190 lines
11 KiB
Java
190 lines
11 KiB
Java
package eu.eudat.managers;
|
|
|
|
import java.util.*;
|
|
import java.util.concurrent.CompletableFuture;
|
|
import java.util.stream.Collectors;
|
|
|
|
import eu.eudat.dao.entities.*;
|
|
import eu.eudat.entities.*;
|
|
import eu.eudat.exceptions.datamanagementplan.DMPWithDatasetsException;
|
|
import eu.eudat.exceptions.security.UnauthorisedException;
|
|
import eu.eudat.models.HintedModelFactory;
|
|
import eu.eudat.models.criteria.OrganisationCriteria;
|
|
import eu.eudat.models.criteria.ProjectCriteria;
|
|
import eu.eudat.models.criteria.ResearcherCriteria;
|
|
import eu.eudat.models.dmp.DataManagementPlan;
|
|
import eu.eudat.models.dmp.DataManagementPlanCriteriaRequest;
|
|
import eu.eudat.models.dmp.DataManagementPlanNewVersionModel;
|
|
import eu.eudat.models.dmp.DataManagementPlanTableRequest;
|
|
import eu.eudat.models.helpers.common.DataTableData;
|
|
import eu.eudat.models.listingmodels.DataManagementPlanListingModel;
|
|
import eu.eudat.models.listingmodels.DatasetListingModel;
|
|
import eu.eudat.models.security.Principal;
|
|
import eu.eudat.queryable.QueryableList;
|
|
import eu.eudat.services.ApiContext;
|
|
import eu.eudat.utilities.builders.DomainModelConverter;
|
|
import org.springframework.scheduling.annotation.Async;
|
|
|
|
public class DataManagementPlanManager {
|
|
|
|
public DataTableData<DataManagementPlanListingModel> getPaged(ApiContext apiContext, DataManagementPlanTableRequest dataManagementPlanTableRequest, Principal principal) throws Exception {
|
|
UserInfo userInfo = new UserInfo();
|
|
userInfo.setId(principal.getId());
|
|
QueryableList<DMP> items = apiContext.getDatabaseRepository().getDmpDao().getWithCriteria(dataManagementPlanTableRequest.getCriteria());
|
|
QueryableList<DMP> authItems = apiContext.getDatabaseRepository().getDmpDao().getAuthenticated(items, userInfo);
|
|
QueryableList<DMP> pagedItems = PaginationManager.applyPaging(authItems, dataManagementPlanTableRequest);
|
|
|
|
DataTableData<DataManagementPlanListingModel> dataTable = new DataTableData<DataManagementPlanListingModel>();
|
|
|
|
CompletableFuture itemsFuture = pagedItems.withHint(HintedModelFactory.getHint(DataManagementPlanListingModel.class)).toListAsync().whenComplete((resultList, throwable) -> {
|
|
List<DataManagementPlanListingModel> datamanagementPlans = new DomainModelConverter<DMP, DataManagementPlanListingModel>().fromDataModel(resultList, DataManagementPlanListingModel.class);
|
|
dataTable.setData(datamanagementPlans);
|
|
});
|
|
|
|
CompletableFuture countFuture = items.countAsync().whenComplete((count, throwable) -> {
|
|
dataTable.setTotalCount(count);
|
|
});
|
|
CompletableFuture.allOf(itemsFuture, countFuture).join();
|
|
return dataTable;
|
|
}
|
|
|
|
public eu.eudat.models.dmp.DataManagementPlan getSingle(DMPDao dmpsRepository, String id, Principal principal) throws InstantiationException, IllegalAccessException {
|
|
DMP dataManagementPlanEntity = dmpsRepository.find(UUID.fromString(id));
|
|
if (dataManagementPlanEntity.getCreator().getId() != principal.getId() && dataManagementPlanEntity.getUsers().stream().filter(userInfo -> userInfo.getId() == principal.getId()).collect(Collectors.toList()).size() == 0)
|
|
throw new UnauthorisedException();
|
|
eu.eudat.models.dmp.DataManagementPlan datamanagementPlan = new eu.eudat.models.dmp.DataManagementPlan();
|
|
datamanagementPlan.fromDataModel(dataManagementPlanEntity);
|
|
return datamanagementPlan;
|
|
}
|
|
|
|
public List<DataManagementPlan> getWithCriteria(DMPDao dmpsRepository, DataManagementPlanCriteriaRequest dataManagementPlanCriteria) throws IllegalAccessException, InstantiationException {
|
|
QueryableList<DMP> items = dmpsRepository.getWithCriteria(dataManagementPlanCriteria.getCriteria());
|
|
List<eu.eudat.models.dmp.DataManagementPlan> datamanagementPlans = new DomainModelConverter<eu.eudat.entities.DMP, eu.eudat.models.dmp.DataManagementPlan>().fromDataModel(items.toList(), eu.eudat.models.dmp.DataManagementPlan.class);
|
|
return datamanagementPlans;
|
|
}
|
|
|
|
public static void createOrUpdate(ApiContext apiContext, DataManagementPlan dataManagementPlan, Principal principal) throws Exception {
|
|
DMP newDmp = dataManagementPlan.toDataModel();
|
|
createOrganisationsIfTheyDontExist(newDmp, apiContext.getDatabaseRepository().getOrganisationDao());
|
|
createResearchersIfTheyDontExist(newDmp, apiContext.getDatabaseRepository().getResearcherDao());
|
|
UserInfo user = apiContext.getDatabaseRepository().getUserInfoDao().find(principal.getId());
|
|
createProjectIfItDoesntExist(newDmp, apiContext.getDatabaseRepository().getProjectDao(), user);
|
|
newDmp.setCreator(user);
|
|
apiContext.getDatabaseRepository().getDmpDao().createOrUpdate(newDmp);
|
|
|
|
}
|
|
|
|
public static void newVersion(ApiContext apiContext, UUID uuid, DataManagementPlanNewVersionModel dataManagementPlan, Principal principal) throws Exception {
|
|
DMP oldDmp = apiContext.getDatabaseRepository().getDmpDao().find(uuid);
|
|
DMP newDmp = dataManagementPlan.toDataModel();
|
|
createOrganisationsIfTheyDontExist(newDmp, apiContext.getDatabaseRepository().getOrganisationDao());
|
|
createResearchersIfTheyDontExist(newDmp, apiContext.getDatabaseRepository().getResearcherDao());
|
|
UserInfo user = new UserInfo();
|
|
user.setId(principal.getId());
|
|
createProjectIfItDoesntExist(newDmp, apiContext.getDatabaseRepository().getProjectDao(), user);
|
|
newDmp.setCreator(user);
|
|
newDmp.setPrevious(oldDmp);
|
|
newDmp.setVersion(oldDmp.getVersion() + 1);
|
|
newDmp.setId(null);
|
|
newDmp = apiContext.getDatabaseRepository().getDmpDao().createOrUpdate(newDmp);
|
|
copyDatasets(newDmp, apiContext.getDatabaseRepository().getDatasetDao());
|
|
|
|
}
|
|
|
|
public static void delete(ApiContext apiContext, UUID uuid) throws DMPWithDatasetsException {
|
|
DMP oldDmp = apiContext.getDatabaseRepository().getDmpDao().find(uuid);
|
|
if (oldDmp.getDataset().size() > 0)
|
|
throw new DMPWithDatasetsException("You cannot Remove Datamanagement Plan with Datasets");
|
|
oldDmp.setStatus(DMP.DMPStatus.DELETED.getValue());
|
|
apiContext.getDatabaseRepository().getDmpDao().createOrUpdate(oldDmp);
|
|
}
|
|
|
|
private static void createResearchersIfTheyDontExist(DMP newDmp, ResearcherDao researcherRepository) {
|
|
if (newDmp.getResearchers() != null && !newDmp.getResearchers().isEmpty()) {
|
|
for (eu.eudat.entities.Researcher researcher : newDmp.getResearchers()) {
|
|
ResearcherCriteria criteria = new ResearcherCriteria();
|
|
criteria.setLike(researcher.getReference());
|
|
List<eu.eudat.entities.Researcher> entries = researcherRepository.getWithCriteria(criteria).toList();
|
|
if (entries != null && !entries.isEmpty()) researcher.setId(entries.get(0).getId());
|
|
else researcher = researcherRepository.createOrUpdate(researcher);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void createOrganisationsIfTheyDontExist(DMP newDmp, OrganisationDao organisationRepository) {
|
|
if (newDmp.getOrganisations() != null && !newDmp.getOrganisations().isEmpty()) {
|
|
for (eu.eudat.entities.Organisation organisation : newDmp.getOrganisations()) {
|
|
OrganisationCriteria criteria = new OrganisationCriteria();
|
|
criteria.setLike(organisation.getReference());
|
|
List<eu.eudat.entities.Organisation> entries = organisationRepository.getWithCriteria(criteria).toList();
|
|
if (entries != null && !entries.isEmpty()) organisation.setId(entries.get(0).getId());
|
|
else organisation = organisationRepository.createOrUpdate(organisation);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void createProjectIfItDoesntExist(DMP newDmp, ProjectDao projectDao, UserInfo userInfo) {
|
|
if (newDmp.getProject() != null) {
|
|
Project project = newDmp.getProject();
|
|
ProjectCriteria criteria = new ProjectCriteria();
|
|
criteria.setReference(project.getReference());
|
|
eu.eudat.entities.Project projectEntity = projectDao.getWithCriteria(criteria).getSingleOrDefault();
|
|
if (projectEntity != null) project.setId(projectEntity.getId());
|
|
else {
|
|
project.setCreationUser(userInfo);
|
|
projectDao.createOrUpdate(project);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Async
|
|
private static void copyDatasets(DMP newDmp, DatasetDao datasetDao) {
|
|
List<CompletableFuture<Dataset>> futures = new LinkedList<>();
|
|
for (Dataset dataset : newDmp.getDataset()) {
|
|
CompletableFuture.supplyAsync(() -> {
|
|
Dataset entityDataset = datasetDao.find(dataset.getId(), HintedModelFactory.getHint(DatasetListingModel.class));
|
|
Dataset newDataset = new Dataset();
|
|
newDataset.update(entityDataset);
|
|
newDataset.setDmp(newDmp);
|
|
if (newDataset.getDataRepositories() != null) {
|
|
newDataset.setDataRepositories(newDataset.getDataRepositories().stream().map(item -> {
|
|
DataRepository dataRepository = new DataRepository();
|
|
dataRepository.setId(item.getId());
|
|
return dataRepository;
|
|
}).collect(Collectors.toSet()));
|
|
}
|
|
|
|
if (newDataset.getExternalDatasets() != null) {
|
|
newDataset.setExternalDatasets(newDataset.getExternalDatasets().stream().map(item -> {
|
|
ExternalDataset externalDataset = new ExternalDataset();
|
|
externalDataset.setId(item.getId());
|
|
return externalDataset;
|
|
}).collect(Collectors.toSet()));
|
|
}
|
|
|
|
if (newDataset.getRegistries() != null) {
|
|
newDataset.setRegistries(newDataset.getRegistries().stream().map(item -> {
|
|
Registry registry = new Registry();
|
|
registry.setId(item.getId());
|
|
return registry;
|
|
}).collect(Collectors.toSet()));
|
|
}
|
|
|
|
if (newDataset.getServices() != null) {
|
|
newDataset.setServices(newDataset.getServices().stream().map(item -> {
|
|
Service service = new Service();
|
|
service.setId(item.getId());
|
|
return service;
|
|
}).collect(Collectors.toSet()));
|
|
}
|
|
newDataset.setCreated(new Date());
|
|
return newDataset;
|
|
}).thenApplyAsync(item -> {
|
|
futures.add(datasetDao.createOrUpdateAsync(item));
|
|
return futures;
|
|
}).join();
|
|
|
|
}
|
|
}
|
|
}
|