argos/dmp-backend/web/src/main/java/eu/eudat/logic/managers/QuickWizardManager.java

package eu.eudat.logic.managers;

import eu.eudat.commons.enums.DmpUserRole;
import eu.eudat.commons.scope.user.UserScope;
import eu.eudat.data.DmpEntity;
import eu.eudat.data.DmpUserEntity;
import eu.eudat.data.UserEntity;
import eu.eudat.data.old.*;
import eu.eudat.logic.services.ApiContext;
import eu.eudat.logic.services.operations.DatabaseRepository;
import eu.eudat.models.data.dmp.DataManagementPlan;
import eu.eudat.query.UserQuery;
import gr.cite.tools.data.query.QueryFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.management.InvalidApplicationException;
import java.io.IOException;
import java.text.ParseException;

@Component
public class QuickWizardManager {

    private ApiContext apiContext;
    private DatabaseRepository databaseRepository;
    private DatasetManager datasetManager;
    
    private final QueryFactory queryFactory;

    private final UserScope userScope;
    @Autowired
    public QuickWizardManager(ApiContext apiContext, DatasetManager datasetManager, QueryFactory queryFactory, UserScope userScope) {
        this.apiContext = apiContext;
        this.databaseRepository = apiContext.getOperationsContext().getDatabaseRepository();
        this.datasetManager = datasetManager;
        this.queryFactory = queryFactory;
        this.userScope = userScope;
    }

    public Funder createOrUpdate(eu.eudat.models.data.funder.Funder funder) {
        Funder funderEntity = funder.toDataModel();
        return databaseRepository.getFunderDao().createOrUpdate(funderEntity);
    }

    public Grant createOrUpdate(eu.eudat.models.data.grant.Grant grant) throws ParseException, IOException, InvalidApplicationException {
        Grant grantEntity = grant.toDataModel();
        grantEntity.setType(Grant.GrantType.INTERNAL.getValue());
        grantEntity.setCreationUser(this.queryFactory.query(UserQuery.class).ids(this.userScope.getUserId()).first());
        return databaseRepository.getGrantDao().createOrUpdate(grantEntity);
    }

    public Project createOrUpdate(eu.eudat.models.data.project.Project project) throws InvalidApplicationException {
        Project projectEntity = project.toDataModel();
        projectEntity.setCreationUser(this.queryFactory.query(UserQuery.class).ids(this.userScope.getUserId()).first());
        return databaseRepository.getProjectDao().createOrUpdate(projectEntity);
    }

    public DmpEntity createOrUpdate(DataManagementPlan dataManagementPlan, Funder funderEntity) throws Exception {
        DmpEntity newDmp = dataManagementPlan.toDataModel();
        if (funderEntity != null) {
            //TODO
            //newDmp.getGrant().setFunder(funderEntity);
        }
        UserEntity user = this.queryFactory.query(UserQuery.class).ids(this.userScope.getUserId()).first();
        createFunderIfItDoesntExist(newDmp, user);
        createGrantIfItDoesntExist(newDmp, user);
        //TODO
//        if (newDmp.getProject() == null) {
//            newDmp.setProject(new Project());
//            newDmp.setProject(newDmp.getProject().projectFromGrant(newDmp.getGrant()));
//        }
        createProjectIfItDoesntExist(newDmp, user);

        //TODO
        //apiContext.getOperationsContext().getDatabaseRepository().getGrantDao().createOrUpdate(newDmp.getGrant());
        DmpEntity dmpret = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(newDmp);
//        if (dataManagementPlan.getAssociatedUsers().size() == 0)
//            assignUser(newDmp, user, apiContext);

//        this.updateIndex(dmpret);

        return dmpret;
    }

//    private void updateIndex(DMP dmp) throws IOException, InvalidApplicationException {
//        DmpMapper mapper = new DmpMapper(apiContext, datasetManager);
//        Dmp elastic = mapper.toElastic(dmp);
//        apiContext.getOperationsContext().getElasticRepository().getDmpRepository().createOrUpdate(elastic);
//    }

    private void assignUser(DmpEntity dmp, UserEntity userInfo, ApiContext apiContext) {
        DmpUserEntity userDMP = new DmpUserEntity();
        userDMP.setDmpId(dmp.getId());
        userDMP.setUserId(userInfo.getId());
        userDMP.setRole(DmpUserRole.User);
        //apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().createOrUpdate(userDMP);
    }

    private void createGrantIfItDoesntExist(DmpEntity newDmp, UserEntity userInfo) throws InvalidApplicationException {
//        if (newDmp.getGrant() != null) {
//            Grant grant = newDmp.getGrant();
//            GrantCriteria criteria = new GrantCriteria();
//            criteria.setReference(grant.getReference());
//            Grant grantEntity = databaseRepository.getGrantDao().getWithCriteria(criteria).getSingleOrDefault();
//            if (grantEntity != null) grant.setId(grantEntity.getId());
//            else {
//                grant.setType(Grant.GrantType.EXTERNAL.getValue());
//                databaseRepository.getGrantDao().createOrUpdate(grant);
//            }
//        }
    }

    private void createFunderIfItDoesntExist(DmpEntity newDmp, UserEntity userInfo) throws InvalidApplicationException {
//        if (newDmp.getGrant().getFunder() != null) { //TODO
//            Funder funder = newDmp.getGrant().getFunder();
//            FunderCriteria criteria = new FunderCriteria();
//            criteria.setReference(funder.getReference());
//            Funder funderEntity = databaseRepository.getFunderDao().getWithCritetia(criteria).getSingleOrDefault();
//            if (funderEntity != null) funder.setId(funderEntity.getId());
//            else {
//                funder.setType(Funder.FunderType.EXTERNAL.getValue());
//                databaseRepository.getFunderDao().createOrUpdate(funder);
//            }
//        }
    }

    private void createProjectIfItDoesntExist(DmpEntity newDmp, UserEntity userInfo) throws InvalidApplicationException {
//        if (newDmp.getProject() != null) { //TODO
//            Project project = newDmp.getProject();
//            ProjectCriteria criteria = new ProjectCriteria();
//            criteria.setReference(project.getReference());
//            Project projectEntity = databaseRepository.getProjectDao().getWithCritetia(criteria).getSingleOrDefault();
//            if (projectEntity != null) project.setId(projectEntity.getId());
//            else {
//                if (project.getId() == null) project.setId(UUID.randomUUID());
//                project.setType(Project.ProjectType.EXTERNAL.getValue());
//                databaseRepository.getProjectDao().createOrUpdate(project);
//            }
//        }
    }
}