D-Net

package eu.dnetlib.data.claims.handler;

import eu.dnetlib.data.claims.utils.ClaimValidation;

import eu.dnetlib.data.claims.utils.ClaimValidationException;

import eu.dnetlib.data.claims.entity.Claim;

import eu.dnetlib.data.claims.entity.OpenaireEntity;

import eu.dnetlib.data.claims.entity.Project;

import eu.dnetlib.data.claims.entity.Result;

import eu.dnetlib.data.claims.utils.ClaimUtils;

import eu.dnetlib.data.claims.utils.ContextUtils;

import eu.dnetlib.data.claims.utils.QueryGenerator;

import eu.dnetlib.data.claims.sql.SQLStoreException;

import eu.dnetlib.data.claims.sql.SqlDAO;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

/**

 * Created by kiatrop on 5/2/2016.

 */

public class ClaimHandler {

    SqlDAO sqlDAO = null;

    QueryGenerator queryGenerator = null;

    ResultHandler resultHandler = null;

    ProjectHandler projectHandler = null;

    ClaimValidation claimValidation = null;

    @Autowired

    IndexResultHandler indexResultHandler;

    ContextUtils contextUtils;

    ExternalRecordHandler externalRecordHandler;

    private static final Logger logger = Logger.getLogger(ClaimHandler.class);

    /**

     * Saves a list of claims in DB

     * @param claims

     */

    public void saveClaims(List<Claim> claims){

        for(Claim claim:claims){

            try {

                saveClaim(claim);

            } catch (SQLStoreException e) {

                logger.error("Claim couldn't be saved : " + claim.getId() + "\n" + claim.toString(), e);

            } catch (SQLException e) {

                logger.error("Claim couldn't be saved : " + claim.getId() + "\n" + claim.toString(), e);

            }

        }

    }

   public String  generateSaveQueryForClaim(Claim claim, ArrayList<Object> params){

       String query= null;

       query = queryGenerator.generateInsertFullClaimQuery(claim, params);

       return query;

   }

    /**

     * saves a claim in DB

     * @param claim

     * @throws Exception

     */

    //TODO make private - used in Migration

    public String saveClaim(Claim claim) throws SQLStoreException, SQLException {

        logger.info("Saving claim...");

        String id = null;

        ArrayList<Object> params = new ArrayList<>();

        String query = generateSaveQueryForClaim(claim, params);

        ResultSet rs=sqlDAO.executePreparedQuery(query, params);

        if(rs.next()) {

            id = rs.getString(1);

        }

        rs.close();

        return id;

    }

    // - used in Migration

    public void saveOrphanClaimId(String id) throws SQLStoreException, Exception {

        logger.info("Saving orphan claim id...");

        String query = queryGenerator.generateInsertQueryForClaimsOrphanIds(id);

        sqlDAO.executeUpdateQuery(query);

    }

    /**

     * Gets the main information for a claim relation - builds a claim object

     * exports metadata

     * and saves the claim relations in the DB

     * @param user

     * @param sourceType

     * @param sourceId

     * @param sourceCollectedFrom

     * @param targetType

     * @param targetId

     * @param targetCollectedFrom

     * @throws Exception

     */

    public String buildAndInsertClaim(String user, String sourceType, String sourceId, String sourceCollectedFrom, String sourceAccessRights, String sourceEmbargoDate, String targetType, String targetId, String targetCollectedFrom, String targetAccessRights, String targetEmbargoDate, String claimedInDashboard ) throws Exception, SQLStoreException {

        String id = null;

        claimValidation.validateCollectedFrom(targetCollectedFrom);

        claimValidation.validateCollectedFrom(sourceCollectedFrom);

        logger.info("Trying to create a claim {user:"+user+", sourceType:"+sourceType+", sourceId:"+sourceId+", sourceCollectedFrom:"+sourceCollectedFrom+", sourceAccessRights:"+sourceAccessRights

                +", sourceEmbargoDate:"+sourceEmbargoDate +", targetType:"+targetType +", targetId:"+targetId +", targetCollectedFrom:"+targetCollectedFrom +", targetAccessRights:"+targetAccessRights

                +", targetEmbargoDate:"+targetEmbargoDate+"}");

        Claim claim = buildClaim(user,sourceType,sourceId,sourceCollectedFrom, sourceAccessRights, sourceEmbargoDate, targetType, targetId, targetCollectedFrom, targetAccessRights, targetEmbargoDate, claimedInDashboard);

        if(claimValidation.validateClaim(claim)) {

            claim = exportMedatataForClaim(claim);

            id = saveClaim(claim);

        }else{

            logger.info("claim is not valid");

        }

        return id;

    }

    /**

     * Gets the main information of a relation claim and

     * builds a claim object

     * @param user

     * @param sourceType publication, dataset, project, context

     * @param sourceId openaireId, doi or orcid workid

     * @param sourceCollectedFrom only for source with type publication, dataset

     * @param targetType publication, dataset, project, context

     * @param targetId openaireId, doi or orcid workid

     * @param targetCollectedFrom only for target with type publication, dataset

     * @return a claim object

     * @throws Exception

     */

    public Claim buildClaim(String user, String sourceType, String sourceId,String sourceCollectedFrom, String sourceAccessRights, String sourceEmbargoDate, String targetType,String targetId,String targetCollectedFrom, String targetAccessRights, String targetEmbargoDate, String claimedInDashboard ) throws Exception {

        Claim claim = new Claim();

        claim.setUserMail(user);

        claim.setClaimedInDashboard(claimedInDashboard);

        claim.setDate(new Date());

        //date

        claim.setSourceType(sourceType);

        claim.setTargetType(targetType);

        claim.setSource(buildOpenaireEntity(sourceId,sourceType,sourceCollectedFrom,sourceAccessRights, sourceEmbargoDate));

        claim.setTarget(buildOpenaireEntity(targetId,targetType,targetCollectedFrom, targetAccessRights, targetEmbargoDate));

        if (claim.getSource() == null) {

           throw new ClaimValidationException("The source id is invalid.");

        }

        if (claim.getTarget() == null) {

            throw new ClaimValidationException("The target id is invalid.");

        }

        //TODO from external sources need an OPenaireID

        return claim;

    }

    public boolean updateClaimCurationInfo(String curatedBy, String claimId, boolean approved) throws SQLStoreException, SQLException, Exception {

        logger.info("Updating claim curation info...");

        ArrayList<Object> params = new ArrayList<>();

        String query = queryGenerator.generateUpdateClaimCuration(curatedBy, claimId, approved, params);

        //ResultSet rs = sqlDAO.executeUpdateQuery(query, params);

        return sqlDAO.executeUpdateQuery(query, params);

        /*

        boolean success = false;

        while (rs.next())

        {

            success = true;

        }

        rs.close();

        return success;

        */

    }

    /**

     * Gets the main information of an openaire entityinfrastruct_::openaire

     * and returns a full  object

     * @param id

     * @param type

     * @param collectedFrom

     * @return openaire Entity (Context, Result, Project)

     * @throws Exception

     */

    public OpenaireEntity buildOpenaireEntity(String id, String type, String collectedFrom, String accessRights, String embargoDate) throws Exception {

        logger.debug(id+" "+ type+" "+collectedFrom);

        if(type==null){

            return null;

        }

        else if(type.equals(ClaimUtils.CONTEXT)){

            return contextUtils.fetchContextById(id);

        }else if (type.equals(ClaimUtils.PROJECT)){

            Project project = projectHandler.fetchProjectByID(id);

//            if(project == null){

//                project = projectHandler.fetchProjectByID(id);

//            }

            if(project == null){

                logger.error("Project with id:"+id + " couldn't be fetched.");

            }

            return project;

        }else if (type.equals(ClaimUtils.PUBLICATION)||type.equals(ClaimUtils.DATASET)||type.equals(ClaimUtils.SOFTWARE) ||type.equals(ClaimUtils.OTHER) ){

            if(collectedFrom == null){

                return null;

            }else if(collectedFrom.equals(ClaimUtils.CROSSREF)){

                Result result = externalRecordHandler.fetchResultfromCrossref(id);

                if(result == null){

                    logger.error("Record with id: " + id + " couldn't be fetched from crossref.");

                }

                result.setAccessRights(accessRights);

                result.setEmbargoEndDate(embargoDate);

                result.setResultType(type);

                return result;

            }else if (collectedFrom.equals(ClaimUtils.DATACITE)){

                Result result = externalRecordHandler.fetchResultfromDatacite(id);

                if(result == null){

                    logger.error("Record with id:"+id + " couldn't be fetched from datacite.");

                }else {

                    result.setAccessRights(accessRights);

                    result.setEmbargoEndDate(embargoDate);

                    result.setResultType(type);

                }

                return result;

            }else if (collectedFrom.equals(ClaimUtils.ORCID)){

                Result result = externalRecordHandler.fetchResultfromOrcid(id);

                if(result == null){

                    logger.error("Record with id:"+id + " couldn't be fetched from ORCID.");

                }else {

                    result.setAccessRights(accessRights);

                    result.setEmbargoEndDate(embargoDate);

                    result.setResultType(type);

                }

                return result;

            }else if (collectedFrom.equals(ClaimUtils.OPENAIRE)){

                Result result = null;

                if(type.equals(ClaimUtils.PUBLICATION)){

                    result = indexResultHandler.fetchPublicationById(id);

                }else if(type.equals(ClaimUtils.DATASET)){

                    result = indexResultHandler.fetchDatasetById(id);

                }else if(type.equals(ClaimUtils.SOFTWARE)){

                    result = indexResultHandler.fetchSoftwareById(id);

                }else if(type.equals(ClaimUtils.OTHER)){

                    result = indexResultHandler.fetchOtherById(id);

                }

                if(result == null){

                    logger.error("Record with id:"+id + " and type " + type + " couldn't be fetched from openaire.");

                }

                return result;

            }

        }

        return null;

    }

    /**

     * Exports the metadata for the source and the target of a claim and sets the proper field

     * @param claim

     * @return claim with the proper metadata path of the result of source and target

     */

    public Claim exportMedatataForClaim(Claim claim){

        if(claim.getTargetType().equals(ClaimUtils.DATASET)||claim.getTargetType().equals(ClaimUtils.PUBLICATION)){

            String path = resultHandler.exportMetadataFileForResult((Result)claim.getTarget());

            ((Result) claim.getTarget()).setRecordPath(path);

        }

        if(claim.getSourceType().equals(ClaimUtils.DATASET)||claim.getSourceType().equals(ClaimUtils.PUBLICATION)){

            String path = resultHandler.exportMetadataFileForResult((Result)claim.getSource());

            ((Result) claim.getSource()).setRecordPath(path);

        }

        return claim;

    }

    public void deleteClaim(String user, String claimId) throws SQLStoreException, Exception {

        ArrayList<Object> params = new ArrayList<>();

        String query = queryGenerator.generateSelectClaimQuery(claimId,user, params);

        ResultSet rs = sqlDAO.executePreparedQuery(query, params);

        if(rs.next()) {

            String sourceType =rs.getString(2);

            String sourceId =rs.getString(3);

            String targetType =rs.getString(4);

            String targetId =rs.getString(5);

            this.checkRecordFile(sourceType, sourceId);

            this.checkRecordFile(targetType, targetId);

            ArrayList<Object> params2 = new ArrayList<>();

            String query2 = queryGenerator.generateDeleteFullClaimQuery(claimId,user,sourceType,sourceId,targetType,targetId, params2);

            sqlDAO.executeUpdateQuery(query2, params2);

        }else{

            logger.error("Claim with id : "+ claimId+" user:  "+user+" couldn't be deleted." );

        }

        rs.close();

    }

    public void checkRecordFile(String type, String id) throws SQLStoreException, SQLException {

        if(type.equals("publication") || type.equals("dataset")|| type.equals("other")|| type.equals("software")){

            this.resultHandler.deleteRecordFile(type,id);

        }

    }

    public boolean deleteClaim(String claimId) throws Exception, SQLStoreException {

        ArrayList<Object> params = new ArrayList<>();

        String query = queryGenerator.generateSelectClaimQuery(claimId, params);

        ResultSet rs = sqlDAO.executePreparedQuery(query, params);

        if(rs.next()) {

            String sourceType =rs.getString(2);

            String sourceId =rs.getString(3);

            String targetType =rs.getString(4);

            String targetId =rs.getString(5);

            String user =rs.getString(6);

            this.checkRecordFile(sourceType, sourceId);

            this.checkRecordFile(targetType, targetId);

            ArrayList<Object> params2 = new ArrayList<>();

            String query2 = queryGenerator.generateDeleteFullClaimQuery(claimId,user,sourceType,sourceId,targetType,targetId, params2);

            sqlDAO.executeUpdateQuery(query2, params2);

            rs.close();

            return  true;

        }

        rs.close();

        logger.error("Couldn't delete claim with id : " + claimId +". It doesn't not exist.");

        return false;

    }

    public SqlDAO getSqlDAO() {

        return sqlDAO;

    }

    public void setSqlDAO(SqlDAO sqlDAO) {

        this.sqlDAO = sqlDAO;

    }

    public QueryGenerator getQueryGenerator() {

        return queryGenerator;

    }

    public void setQueryGenerator(QueryGenerator queryGenerator) {

        this.queryGenerator = queryGenerator;

    }

    public ResultHandler getResultHandler() {

        return resultHandler;

    }

    public void setResultHandler(ResultHandler resultHandler) {

        this.resultHandler = resultHandler;

    }

    public ProjectHandler getProjectHandler() {

        return projectHandler;

    }

    public void setProjectHandler(ProjectHandler projectHandler) {

        this.projectHandler = projectHandler;

    }

    public ClaimValidation getClaimValidation() {

        return claimValidation;

    }

    public void setClaimValidation(ClaimValidation claimValidation) {

        this.claimValidation = claimValidation;

    }

    public ContextUtils getContextUtils() {

        return contextUtils;

    }

    public void setContextUtils(ContextUtils contextUtils) {

        this.contextUtils = contextUtils;

    }

    public IndexResultHandler getIndexResultHandler() {

        return indexResultHandler;

    }

    public void setIndexResultHandler(IndexResultHandler indexResultHandler) {

        this.indexResultHandler = indexResultHandler;

    }

    public ExternalRecordHandler getExternalRecordHandler() {

        return externalRecordHandler;

    }

    public void setExternalRecordHandler(ExternalRecordHandler externalRecordHandler) {

        this.externalRecordHandler = externalRecordHandler;

    }

}