446 lines
27 KiB
Java
446 lines
27 KiB
Java
package eu.eudat.logic.managers;
|
|
|
|
import eu.eudat.configurations.dynamicproject.DynamicProjectConfiguration;
|
|
import eu.eudat.configurations.dynamicproject.entities.Property;
|
|
import eu.eudat.data.dao.criteria.DynamicFieldsCriteria;
|
|
import eu.eudat.data.dao.criteria.OrganisationCriteria;
|
|
import eu.eudat.data.dao.criteria.ProjectCriteria;
|
|
import eu.eudat.data.dao.criteria.ResearcherCriteria;
|
|
import eu.eudat.data.dao.entities.*;
|
|
import eu.eudat.data.entities.*;
|
|
import eu.eudat.data.query.items.item.dmp.DataManagementPlanCriteriaRequest;
|
|
import eu.eudat.data.query.items.table.dmp.DataManagementPlanTableRequest;
|
|
import eu.eudat.exceptions.datamanagementplan.DMPWithDatasetsDeleteException;
|
|
import eu.eudat.exceptions.security.UnauthorisedException;
|
|
import eu.eudat.logic.builders.entity.UserInfoBuilder;
|
|
import eu.eudat.logic.services.ApiContext;
|
|
import eu.eudat.logic.services.forms.VisibilityRuleService;
|
|
import eu.eudat.logic.utilities.builders.XmlBuilder;
|
|
import eu.eudat.logic.utilities.documents.helpers.FileEnvelope;
|
|
import eu.eudat.logic.utilities.documents.types.ParagraphStyle;
|
|
import eu.eudat.logic.utilities.documents.word.WordBuilder;
|
|
import eu.eudat.logic.utilities.documents.xml.ExportXmlBuilder;
|
|
import eu.eudat.models.HintedModelFactory;
|
|
import eu.eudat.models.data.datasetwizard.DatasetWizardModel;
|
|
import eu.eudat.models.data.dmp.DataManagementPlan;
|
|
import eu.eudat.models.data.dmp.DataManagementPlanNewVersionModel;
|
|
import eu.eudat.models.data.dynamicfields.DynamicFieldWithValue;
|
|
import eu.eudat.models.data.helpermodels.Tuple;
|
|
import eu.eudat.models.data.helpers.common.DataTableData;
|
|
import eu.eudat.models.data.listingmodels.DataManagementPlanListingModel;
|
|
import eu.eudat.models.data.listingmodels.DatasetListingModel;
|
|
import eu.eudat.models.data.security.Principal;
|
|
import eu.eudat.models.data.user.composite.PagedDatasetProfile;
|
|
import eu.eudat.queryable.QueryableList;
|
|
import org.apache.poi.xwpf.usermodel.XWPFDocument;
|
|
import org.json.JSONObject;
|
|
import org.springframework.core.env.Environment;
|
|
import org.springframework.http.*;
|
|
import org.springframework.stereotype.Component;
|
|
import org.springframework.web.client.RestTemplate;
|
|
import org.w3c.dom.Document;
|
|
import org.w3c.dom.Element;
|
|
|
|
import java.io.*;
|
|
import java.math.BigInteger;
|
|
import java.net.URL;
|
|
import java.nio.file.Paths;
|
|
import java.util.*;
|
|
import java.util.concurrent.CompletableFuture;
|
|
import java.util.stream.Collectors;
|
|
|
|
@Component
|
|
public class DataManagementPlanManager {
|
|
|
|
public DataTableData<DataManagementPlanListingModel> getPaged(ApiContext apiContext, DataManagementPlanTableRequest dataManagementPlanTableRequest, Principal principal, String fieldsGroup) throws Exception {
|
|
UserInfo userInfo = new UserInfo();
|
|
userInfo.setId(principal.getId());
|
|
QueryableList<DMP> items = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().getWithCriteria(dataManagementPlanTableRequest.getCriteria()).withHint(HintedModelFactory.getHint(DataManagementPlanListingModel.class));
|
|
QueryableList<DMP> authItems = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().getAuthenticated(items, userInfo);
|
|
QueryableList<DMP> pagedItems = PaginationManager.applyPaging(authItems, dataManagementPlanTableRequest);
|
|
|
|
DataTableData<DataManagementPlanListingModel> dataTable = new DataTableData<>();
|
|
|
|
CompletableFuture itemsFuture;
|
|
if(fieldsGroup.equals("listing")){
|
|
|
|
itemsFuture = pagedItems.withHint(HintedModelFactory.getHint(DataManagementPlanListingModel.class))
|
|
.selectAsync(item -> {
|
|
item.setDataset(
|
|
item.getDataset().stream()
|
|
.filter(dataset -> dataset.getDmp().getCreator().getId().equals(userInfo.getId())
|
|
|| dataset.isPublic()
|
|
|| dataset.getDmp().getUsers().stream()
|
|
.filter(x -> x.getId().equals(userInfo.getId())).collect(Collectors.toList()).size() > 0).collect(Collectors.toSet()));
|
|
return new DataManagementPlanListingModel().fromDataModelDatasets(item);
|
|
})
|
|
.whenComplete((resultList, throwable) -> dataTable.setData(resultList));
|
|
}
|
|
else{
|
|
itemsFuture = pagedItems
|
|
.selectAsync(item -> new DataManagementPlanListingModel().fromDataModel(item) )
|
|
.whenComplete((resultList, throwable) -> dataTable.setData(resultList));
|
|
}
|
|
|
|
CompletableFuture countFuture = authItems.countAsync().whenComplete((count, throwable) -> {
|
|
dataTable.setTotalCount(count);
|
|
});
|
|
CompletableFuture.allOf(itemsFuture, countFuture).join();
|
|
return dataTable;
|
|
}
|
|
|
|
public void unlock(ApiContext apiContext, UUID uuid) throws Exception {
|
|
apiContext.getOperationsContext().getDatabaseRepository().getDmpDao()
|
|
.asQueryable().where((builder, root) -> builder.equal(root.get("id"), uuid))
|
|
.update(root -> root.get("status"), DMP.DMPStatus.ACTIVE.getValue());
|
|
return;
|
|
}
|
|
|
|
public File getWordDocument(Environment environment, DMPDao dmpRepository, String id, VisibilityRuleService visibilityRuleService) throws InstantiationException, IllegalAccessException, IOException {
|
|
WordBuilder wordBuilder = new WordBuilder();
|
|
DatasetWizardModel dataset = new DatasetWizardModel();
|
|
String fileUrl = environment.getProperty("configuration.h2020template");
|
|
InputStream is = new URL(Paths.get(fileUrl).toUri().toURL().toString()).openStream();
|
|
XWPFDocument document = new XWPFDocument(is);
|
|
|
|
eu.eudat.data.entities.DMP dmpEntity = dmpRepository.find(UUID.fromString(id));
|
|
wordBuilder.addParagraphContent(dmpEntity.getLabel(), document, ParagraphStyle.TITLE, BigInteger.ZERO);
|
|
wordBuilder.addParagraphContent(dmpEntity.getDescription(), document, ParagraphStyle.TEXT, BigInteger.ZERO);
|
|
|
|
wordBuilder.addParagraphContent("Organisations", document, ParagraphStyle.HEADER2, BigInteger.ZERO);
|
|
wordBuilder.addParagraphContent(dmpEntity.getOrganisations().stream().map(x -> x.getLabel()).collect(Collectors.joining(","))
|
|
, document, ParagraphStyle.TEXT, BigInteger.ZERO);
|
|
|
|
wordBuilder.addParagraphContent("Researchers", document, ParagraphStyle.HEADER2, BigInteger.ZERO);
|
|
wordBuilder.addParagraphContent(dmpEntity.getResearchers().stream().map(x -> x.getLabel()).collect(Collectors.joining(","))
|
|
, document, ParagraphStyle.TEXT, BigInteger.ZERO);
|
|
|
|
wordBuilder.addParagraphContent("Datasets", document, ParagraphStyle.TITLE, BigInteger.ZERO);
|
|
dmpEntity.getDataset().stream().forEach(datasetEntity -> {
|
|
Map<String, Object> properties = new HashMap<>();
|
|
if (datasetEntity.getProperties() != null) {
|
|
JSONObject jobject = new JSONObject(datasetEntity.getProperties());
|
|
properties = jobject.toMap();
|
|
}
|
|
wordBuilder.addParagraphContent("Title: " + datasetEntity.getLabel(), document, ParagraphStyle.HEADER1, BigInteger.ZERO);
|
|
wordBuilder.addParagraphContent(datasetEntity.getDescription(), document, ParagraphStyle.TEXT, BigInteger.ZERO);
|
|
wordBuilder.addParagraphContent("Dataset Description", document, ParagraphStyle.HEADER1, BigInteger.ZERO);
|
|
PagedDatasetProfile pagedDatasetProfile = new DatasetManager().getPagedProfile(dataset, datasetEntity);
|
|
visibilityRuleService.setProperties(properties);
|
|
visibilityRuleService.buildVisibilityContext(pagedDatasetProfile.getRules());
|
|
try {
|
|
wordBuilder.build(document, pagedDatasetProfile, visibilityRuleService);
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
});
|
|
File exportFile = new File(dmpEntity.getLabel() + ".docx");
|
|
FileOutputStream out = new FileOutputStream(exportFile);
|
|
document.write(out);
|
|
out.close();
|
|
return exportFile;
|
|
}
|
|
|
|
public eu.eudat.models.data.dmp.DataManagementPlan getSingle(DMPDao dmpsRepository, String id, Principal principal, DynamicProjectConfiguration dynamicProjectConfiguration) 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.data.dmp.DataManagementPlan datamanagementPlan = new eu.eudat.models.data.dmp.DataManagementPlan();
|
|
datamanagementPlan.fromDataModel(dataManagementPlanEntity);
|
|
Map dmpProperties = dataManagementPlanEntity.getDmpProperties() != null ? new org.json.JSONObject(dataManagementPlanEntity.getDmpProperties()).toMap() : null;
|
|
datamanagementPlan.setDynamicFields(dynamicProjectConfiguration.getFields().stream().map(item -> {
|
|
DynamicFieldWithValue fieldWithValue = new DynamicFieldWithValue();
|
|
fieldWithValue.setId(item.getId());
|
|
fieldWithValue.setDependencies(item.getDependencies());
|
|
fieldWithValue.setName(item.getName());
|
|
fieldWithValue.setQueryProperty(item.getQueryProperty());
|
|
fieldWithValue.setRequired(item.getRequired());
|
|
return fieldWithValue;
|
|
}).collect(Collectors.toList()));
|
|
|
|
if (dmpProperties != null && datamanagementPlan.getDynamicFields() != null)
|
|
datamanagementPlan.getDynamicFields().forEach(item -> {
|
|
Map<String, String> properties = (Map<String, String>) dmpProperties.get(item.getId());
|
|
if (properties != null)
|
|
item.setValue(new Tuple<>(properties.get("id"), properties.get("label")));
|
|
});
|
|
return datamanagementPlan;
|
|
}
|
|
|
|
public List<DataManagementPlan> getWithCriteria(DMPDao dmpsRepository, DataManagementPlanCriteriaRequest dataManagementPlanCriteria, Principal principal) throws IllegalAccessException, InstantiationException {
|
|
UserInfo userInfo = new UserInfo();
|
|
userInfo.setId(principal.getId());
|
|
QueryableList<DMP> items = dmpsRepository.getWithCriteria(dataManagementPlanCriteria.getCriteria()).withHint(HintedModelFactory.getHint(DataManagementPlan.class));
|
|
QueryableList<DMP> authenticatedItems = dmpsRepository.getAuthenticated(items, userInfo);
|
|
List<eu.eudat.models.data.dmp.DataManagementPlan> datamanagementPlans = authenticatedItems.select(item -> new DataManagementPlan().fromDataModel(item));
|
|
return datamanagementPlans;
|
|
}
|
|
|
|
public List<Tuple<String, String>> getDynamicFields(String id, DynamicProjectConfiguration dynamicProjectConfiguration, DynamicFieldsCriteria criteria) throws IllegalAccessException, InstantiationException {
|
|
List<Tuple<String, String>> result = new LinkedList<>();
|
|
RestTemplate restTemplate = new RestTemplate();
|
|
HttpHeaders headers = new HttpHeaders();
|
|
headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
|
|
headers.setContentType(MediaType.APPLICATION_JSON);
|
|
HttpEntity<String> entity = new HttpEntity<>("parameters", headers);
|
|
|
|
Property property = dynamicProjectConfiguration.getConfiguration().getConfigurationProperties().stream()
|
|
.filter(item -> item.getId().equals(id)).findFirst().orElse(null);
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
if (criteria.getLike() != null) stringBuilder.append("?search=" + criteria.getLike());
|
|
if (property.getDependencies() != null && !property.getDependencies().isEmpty() && criteria.getDynamicFields() != null && !criteria.getDynamicFields().isEmpty()) {
|
|
property.getDependencies().stream().forEach(item -> {
|
|
DynamicFieldsCriteria.DynamicFieldDependencyCriteria dependencyCriteria = criteria.getDynamicFields().stream().filter(dfield -> dfield.getProperty().equals(item.getId()))
|
|
.findFirst().orElse(null);
|
|
if (dependencyCriteria != null) {
|
|
if (criteria.getLike() != null || property.getDependencies().indexOf(item) > 0)
|
|
stringBuilder.append("&");
|
|
stringBuilder.append(item.getQueryProperty() + "=" + dependencyCriteria.getValue());
|
|
}
|
|
});
|
|
|
|
ResponseEntity<ArrayList> response = restTemplate.exchange(property.getSourceUrl() + stringBuilder.toString(), HttpMethod.GET, entity, ArrayList.class);
|
|
response.getBody().forEach(item -> {
|
|
Tuple<String, String> tuple = new Tuple<>();
|
|
tuple.setId((String) (((Map<String, Object>) item).get(property.getExternalFieldId())));
|
|
tuple.setLabel((String) (((Map<String, Object>) item).get(property.getExternalFieldLabel())));
|
|
result.add(tuple);
|
|
});
|
|
|
|
} else {
|
|
ResponseEntity<ArrayList> response = restTemplate.exchange(property.getSourceUrl() + stringBuilder.toString(), HttpMethod.GET, entity, ArrayList.class);
|
|
response.getBody().forEach(item -> {
|
|
Tuple<String, String> tuple = new Tuple<>();
|
|
tuple.setId((String) (((Map<String, Object>) item).get(property.getExternalFieldId())));
|
|
tuple.setLabel((String) (((Map<String, Object>) item).get(property.getExternalFieldLabel())));
|
|
result.add(tuple);
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public void createOrUpdate(ApiContext apiContext, DataManagementPlan dataManagementPlan, Principal principal) throws Exception {
|
|
DMP newDmp = dataManagementPlan.toDataModel();
|
|
createOrganisationsIfTheyDontExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getOrganisationDao());
|
|
createResearchersIfTheyDontExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getResearcherDao());
|
|
UserInfo user = apiContext.getOperationsContext().getDatabaseRepository().getUserInfoDao().find(principal.getId());
|
|
createProjectIfItDoesntExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getProjectDao(), user);
|
|
newDmp.setCreator(user);
|
|
newDmp = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(newDmp);
|
|
if (dataManagementPlan.getStatus() == DMP.DMPStatus.FINALISED.getValue()) {
|
|
apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao()
|
|
.asQueryable().where((builder, root) -> root.get("id").in(dataManagementPlan.getDatasets()
|
|
.stream().map(x -> UUID.fromString(x.getId())).collect(Collectors.toList())))
|
|
.update(root -> root.<Integer>get("status"), Dataset.Status.FINALISED.getValue());
|
|
}
|
|
if (dataManagementPlan.getAssociatedUsers().stream().filter(item -> item.getId() == principal.getId()).collect(Collectors.toList()).size() == 0)
|
|
assignUser(newDmp, user, apiContext);
|
|
}
|
|
|
|
public void assignUser(DMP dmp, UserInfo userInfo, ApiContext apiContext) {
|
|
UserDMP userDMP = new UserDMP();
|
|
userDMP.setDmp(dmp);
|
|
userDMP.setUser(userInfo);
|
|
userDMP.setRole(UserDMP.UserDMPRoles.OWNER.getValue());
|
|
apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().createOrUpdate(userDMP);
|
|
}
|
|
|
|
public void newVersion(ApiContext apiContext, UUID uuid, DataManagementPlanNewVersionModel dataManagementPlan, Principal principal) throws Exception {
|
|
DMP oldDmp = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(uuid);
|
|
DMP newDmp = dataManagementPlan.toDataModel();
|
|
createOrganisationsIfTheyDontExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getOrganisationDao());
|
|
createResearchersIfTheyDontExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getResearcherDao());
|
|
UserInfo user = apiContext.getOperationsContext().getBuilderFactory().getBuilder(UserInfoBuilder.class).id(principal.getId()).build();
|
|
createProjectIfItDoesntExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getProjectDao(), user);
|
|
newDmp.setCreator(user);
|
|
newDmp.setGroupId(oldDmp.getGroupId());
|
|
newDmp.setVersion(oldDmp.getVersion() + 1);
|
|
newDmp.setId(null);
|
|
newDmp = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(newDmp);
|
|
copyDatasets(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao());
|
|
}
|
|
|
|
public void clone(ApiContext apiContext, UUID uuid, DataManagementPlanNewVersionModel dataManagementPlan, Principal principal) throws Exception {
|
|
DMP newDmp = dataManagementPlan.toDataModel();
|
|
createOrganisationsIfTheyDontExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getOrganisationDao());
|
|
createResearchersIfTheyDontExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getResearcherDao());
|
|
UserInfo user = apiContext.getOperationsContext().getBuilderFactory().getBuilder(UserInfoBuilder.class).id(principal.getId()).build();
|
|
createProjectIfItDoesntExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getProjectDao(), user);
|
|
newDmp.setCreator(user);
|
|
newDmp.setGroupId(UUID.randomUUID());
|
|
newDmp.setVersion(0);
|
|
newDmp.setId(null);
|
|
newDmp = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(newDmp);
|
|
copyDatasets(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao());
|
|
}
|
|
|
|
public void delete(ApiContext apiContext, UUID uuid) throws DMPWithDatasetsDeleteException {
|
|
DMP oldDmp = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(uuid);
|
|
if (oldDmp.getDataset().size() > 0)
|
|
throw new DMPWithDatasetsDeleteException("You cannot Remove Datamanagement Plan with Datasets");
|
|
oldDmp.setStatus(DMP.DMPStatus.DELETED.getValue());
|
|
apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(oldDmp);
|
|
}
|
|
|
|
private void createResearchersIfTheyDontExist(DMP newDmp, ResearcherDao researcherRepository) {
|
|
if (newDmp.getResearchers() != null && !newDmp.getResearchers().isEmpty()) {
|
|
for (eu.eudat.data.entities.Researcher researcher : newDmp.getResearchers()) {
|
|
ResearcherCriteria criteria = new ResearcherCriteria();
|
|
criteria.setLike(researcher.getReference());
|
|
List<eu.eudat.data.entities.Researcher> entries = researcherRepository.getWithCriteria(criteria).toList();
|
|
if (entries != null && !entries.isEmpty()) researcher.setId(entries.get(0).getId());
|
|
else researcher = researcherRepository.createOrUpdate(researcher);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void createOrganisationsIfTheyDontExist(DMP newDmp, OrganisationDao organisationRepository) {
|
|
if (newDmp.getOrganisations() != null && !newDmp.getOrganisations().isEmpty()) {
|
|
for (eu.eudat.data.entities.Organisation organisation : newDmp.getOrganisations()) {
|
|
OrganisationCriteria criteria = new OrganisationCriteria();
|
|
criteria.setLike(organisation.getReference());
|
|
List<eu.eudat.data.entities.Organisation> entries = organisationRepository.getWithCriteria(criteria).toList();
|
|
if (entries != null && !entries.isEmpty()) organisation.setId(entries.get(0).getId());
|
|
else organisation = organisationRepository.createOrUpdate(organisation);
|
|
}
|
|
}
|
|
}
|
|
|
|
private 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.data.entities.Project projectEntity = projectDao.getWithCriteria(criteria).getSingleOrDefault();
|
|
if (projectEntity != null) project.setId(projectEntity.getId());
|
|
else {
|
|
project.setType(Project.ProjectType.EXTERNAL.getValue());
|
|
projectDao.createOrUpdate(project);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private void copyDatasets(DMP newDmp, DatasetDao datasetDao) {
|
|
List<CompletableFuture<Dataset>> futures = new LinkedList<>();
|
|
for (Dataset dataset : newDmp.getDataset()) {
|
|
datasetDao.asQueryable().withHint(HintedModelFactory.getHint(DatasetListingModel.class)).where((builder, root) -> builder.equal(root.get("id"), dataset.getId())).getSingleAsync()
|
|
.thenApplyAsync(entityDataset -> {
|
|
Dataset newDataset = new Dataset();
|
|
newDataset.update(entityDataset);
|
|
newDataset.setDmp(newDmp);
|
|
newDataset.setStatus(Dataset.Status.SAVED.getValue());
|
|
if (newDataset.getDatasetDataRepositories() != null) {
|
|
newDataset.setDatasetDataRepositories(newDataset.getDatasetDataRepositories().stream().map(item -> {
|
|
DataRepository dataRepository = new DataRepository();
|
|
dataRepository.setId(item.getId());
|
|
|
|
DatasetDataRepository datasetDataRepository = new DatasetDataRepository();
|
|
datasetDataRepository.setDataRepository(dataRepository);
|
|
datasetDataRepository.setDataset(newDataset);
|
|
return datasetDataRepository;
|
|
}).collect(Collectors.toSet()));
|
|
}
|
|
|
|
if (newDataset.getDatasetExternalDatasets() != null) {
|
|
newDataset.setDatasetExternalDatasets(newDataset.getDatasetExternalDatasets().stream().map(item -> {
|
|
ExternalDataset externalDataset = new ExternalDataset();
|
|
externalDataset.setId(item.getId());
|
|
DatasetExternalDataset datasetExternalDataset = new DatasetExternalDataset();
|
|
datasetExternalDataset.setExternalDataset(externalDataset);
|
|
datasetExternalDataset.setDataset(newDataset);
|
|
return datasetExternalDataset;
|
|
}).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());
|
|
DatasetService datasetService = new DatasetService();
|
|
datasetService.setService(service);
|
|
datasetService.setDataset(newDataset);
|
|
return datasetService;
|
|
}).collect(Collectors.toSet()));
|
|
}
|
|
newDataset.setCreated(new Date());
|
|
return newDataset;
|
|
}).thenApplyAsync(item -> {
|
|
futures.add(datasetDao.createOrUpdateAsync(item));
|
|
return futures;
|
|
}).join();
|
|
|
|
}
|
|
}
|
|
|
|
public FileEnvelope getXmlDocument(DMPDao dmpRepository, String id, VisibilityRuleService visibilityRuleService) throws InstantiationException, IllegalAccessException, IOException {
|
|
ExportXmlBuilder xmlBuilder = new ExportXmlBuilder();
|
|
eu.eudat.data.entities.DMP dmp = dmpRepository.find(UUID.fromString(id));
|
|
List<Dataset> datasets = dmp.getDataset().stream().collect(Collectors.toList());
|
|
File xmlFile = new File(UUID.randomUUID() + ".xml");
|
|
BufferedWriter writer = new BufferedWriter(new FileWriter(xmlFile, true));
|
|
Document xmlDoc = XmlBuilder.getDocument();
|
|
Element root = xmlDoc.createElement("root");
|
|
Element dmpElement = xmlDoc.createElement("dmp");
|
|
Element dmpName = xmlDoc.createElement("dmpName");
|
|
dmpName.setTextContent(dmp.getLabel());
|
|
dmpElement.appendChild(dmpName);
|
|
Element projectName = xmlDoc.createElement("projectName");
|
|
projectName.setTextContent(dmp.getProject().getLabel());
|
|
dmpElement.appendChild(projectName);
|
|
Element organisationsElement = xmlDoc.createElement("organisations");
|
|
for (Organisation organisation : dmp.getOrganisations()) {
|
|
Element organisationElement = xmlDoc.createElement("organisation");
|
|
organisationElement.setAttribute("name", organisation.getLabel());
|
|
organisationElement.setAttribute("reference", organisation.getReference());
|
|
organisationsElement.appendChild(organisationElement);
|
|
}
|
|
dmpElement.appendChild(organisationsElement);
|
|
|
|
Element researchersElement = xmlDoc.createElement("researchers");
|
|
for (Researcher researcher : dmp.getResearchers()) {
|
|
Element researcherElement = xmlDoc.createElement("organisation");
|
|
researcherElement.setAttribute("name", researcher.getLabel());
|
|
researcherElement.setAttribute("reference", researcher.getReference());
|
|
organisationsElement.appendChild(researcherElement);
|
|
}
|
|
dmpElement.appendChild(researchersElement);
|
|
Element datasetsElement = xmlDoc.createElement("datasets");
|
|
|
|
for (Dataset dataset : datasets) {
|
|
Element datasetElement = xmlDoc.createElement("dataset");
|
|
|
|
DatasetWizardModel datasetWizardModel = new DatasetWizardModel();
|
|
Map<String, Object> properties = new HashMap<>();
|
|
if (dataset.getProperties() != null) {
|
|
JSONObject jobject = new JSONObject(dataset.getProperties());
|
|
properties = jobject.toMap();
|
|
}
|
|
PagedDatasetProfile pagedDatasetProfile = new DatasetManager().getPagedProfile(datasetWizardModel, dataset);
|
|
visibilityRuleService.setProperties(properties);
|
|
visibilityRuleService.buildVisibilityContext(pagedDatasetProfile.getRules());
|
|
datasetElement.appendChild(xmlBuilder.createPages(pagedDatasetProfile.getPages(), visibilityRuleService, xmlDoc));
|
|
datasetsElement.appendChild(datasetElement);
|
|
}
|
|
dmpElement.appendChild(datasetsElement);
|
|
root.appendChild(dmpElement);
|
|
xmlDoc.appendChild(root);
|
|
String xml = XmlBuilder.generateXml(xmlDoc);
|
|
writer.write(xml);
|
|
writer.close();
|
|
FileEnvelope fileEnvelope = new FileEnvelope();
|
|
fileEnvelope.setFile(xmlFile);
|
|
fileEnvelope.setFilename(dmp.getLabel());
|
|
return fileEnvelope;
|
|
}
|
|
|
|
}
|