2018-06-27 12:29:21 +02:00
|
|
|
package eu.eudat.logic.managers;
|
2017-12-15 00:01:26 +01:00
|
|
|
|
2019-06-04 16:04:04 +02:00
|
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
2019-07-31 16:57:34 +02:00
|
|
|
import eu.eudat.configurations.dynamicgrant.DynamicGrantConfiguration;
|
|
|
|
import eu.eudat.configurations.dynamicgrant.entities.Property;
|
2019-02-15 16:11:38 +01:00
|
|
|
import eu.eudat.data.dao.criteria.*;
|
2018-03-21 11:57:56 +01:00
|
|
|
import eu.eudat.data.dao.entities.*;
|
2019-03-05 12:59:34 +01:00
|
|
|
import eu.eudat.data.entities.Organisation;
|
|
|
|
import eu.eudat.data.entities.Researcher;
|
2019-06-04 16:16:12 +02:00
|
|
|
import eu.eudat.data.entities.*;
|
2018-03-28 15:24:47 +02:00
|
|
|
import eu.eudat.data.query.items.item.dmp.DataManagementPlanCriteriaRequest;
|
2019-06-12 11:13:50 +02:00
|
|
|
import eu.eudat.data.query.items.table.datasetprofile.DatasetProfileTableRequestItem;
|
2018-03-28 15:24:47 +02:00
|
|
|
import eu.eudat.data.query.items.table.dmp.DataManagementPlanTableRequest;
|
2019-04-26 16:05:15 +02:00
|
|
|
import eu.eudat.data.query.items.table.dmp.DataManagmentPlanPublicTableRequest;
|
2019-03-26 15:52:19 +01:00
|
|
|
import eu.eudat.exceptions.datamanagementplan.DMPNewVersionException;
|
2018-11-30 15:57:20 +01:00
|
|
|
import eu.eudat.exceptions.datamanagementplan.DMPWithDatasetsDeleteException;
|
2018-02-07 10:56:30 +01:00
|
|
|
import eu.eudat.exceptions.security.UnauthorisedException;
|
2018-07-23 15:09:19 +02:00
|
|
|
import eu.eudat.logic.builders.entity.UserInfoBuilder;
|
|
|
|
import eu.eudat.logic.services.ApiContext;
|
2018-10-08 17:14:27 +02:00
|
|
|
import eu.eudat.logic.services.forms.VisibilityRuleService;
|
2019-03-05 16:33:59 +01:00
|
|
|
import eu.eudat.logic.services.operations.DatabaseRepository;
|
|
|
|
import eu.eudat.logic.services.utilities.UtilitiesService;
|
2018-10-08 17:14:27 +02:00
|
|
|
import eu.eudat.logic.utilities.builders.XmlBuilder;
|
|
|
|
import eu.eudat.logic.utilities.documents.helpers.FileEnvelope;
|
2018-10-18 11:33:13 +02:00
|
|
|
import eu.eudat.logic.utilities.documents.types.ParagraphStyle;
|
|
|
|
import eu.eudat.logic.utilities.documents.word.WordBuilder;
|
2018-10-08 17:14:27 +02:00
|
|
|
import eu.eudat.logic.utilities.documents.xml.ExportXmlBuilder;
|
2018-01-19 10:31:05 +01:00
|
|
|
import eu.eudat.models.HintedModelFactory;
|
2019-06-12 11:13:50 +02:00
|
|
|
import eu.eudat.models.data.datasetprofile.DatasetProfileListingModel;
|
2018-10-08 17:14:27 +02:00
|
|
|
import eu.eudat.models.data.datasetwizard.DatasetWizardModel;
|
2019-06-28 14:58:25 +02:00
|
|
|
import eu.eudat.models.data.datasetwizard.DatasetsToBeFinalized;
|
2019-03-05 12:59:34 +01:00
|
|
|
import eu.eudat.models.data.dmp.*;
|
2018-06-27 12:29:21 +02:00
|
|
|
import eu.eudat.models.data.dynamicfields.DynamicFieldWithValue;
|
2019-03-26 15:52:19 +01:00
|
|
|
import eu.eudat.models.data.entities.xmlmodels.dmpprofiledefinition.DataManagementPlanProfile;
|
|
|
|
import eu.eudat.models.data.entities.xmlmodels.dmpprofiledefinition.Field;
|
2018-06-27 12:29:21 +02:00
|
|
|
import eu.eudat.models.data.helpermodels.Tuple;
|
|
|
|
import eu.eudat.models.data.helpers.common.DataTableData;
|
|
|
|
import eu.eudat.models.data.listingmodels.DataManagementPlanListingModel;
|
2019-05-17 17:21:56 +02:00
|
|
|
import eu.eudat.models.data.listingmodels.DataManagementPlanOverviewModel;
|
2018-06-27 12:29:21 +02:00
|
|
|
import eu.eudat.models.data.listingmodels.DatasetListingModel;
|
2019-05-29 16:58:23 +02:00
|
|
|
import eu.eudat.models.data.listingmodels.UserInfoListingModel;
|
2019-10-15 12:44:45 +02:00
|
|
|
import eu.eudat.models.data.rda.RDAExportModel;
|
2018-06-27 12:29:21 +02:00
|
|
|
import eu.eudat.models.data.security.Principal;
|
2018-10-08 17:14:27 +02:00
|
|
|
import eu.eudat.models.data.user.composite.PagedDatasetProfile;
|
2019-05-10 10:33:48 +02:00
|
|
|
import eu.eudat.models.data.userinfo.UserListingModel;
|
2017-12-17 22:34:24 +01:00
|
|
|
import eu.eudat.queryable.QueryableList;
|
2018-10-18 11:33:13 +02:00
|
|
|
import org.apache.poi.xwpf.usermodel.XWPFDocument;
|
2019-05-22 10:53:30 +02:00
|
|
|
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
|
|
|
|
import org.apache.poi.xwpf.usermodel.XWPFRun;
|
2018-10-08 17:14:27 +02:00
|
|
|
import org.json.JSONObject;
|
2019-03-05 16:33:59 +01:00
|
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
2018-10-18 11:33:13 +02:00
|
|
|
import org.springframework.core.env.Environment;
|
2019-07-04 16:30:15 +02:00
|
|
|
import org.springframework.core.io.FileSystemResource;
|
2018-03-28 15:24:47 +02:00
|
|
|
import org.springframework.http.*;
|
2019-01-29 12:05:36 +01:00
|
|
|
import org.springframework.stereotype.Component;
|
2019-07-04 16:30:15 +02:00
|
|
|
import org.springframework.util.LinkedMultiValueMap;
|
|
|
|
import org.springframework.util.MultiValueMap;
|
2018-03-28 15:24:47 +02:00
|
|
|
import org.springframework.web.client.RestTemplate;
|
2019-03-05 12:59:34 +01:00
|
|
|
import org.springframework.web.multipart.MultipartFile;
|
2018-10-08 17:14:27 +02:00
|
|
|
import org.w3c.dom.Document;
|
|
|
|
import org.w3c.dom.Element;
|
2017-12-15 00:01:26 +01:00
|
|
|
|
2019-09-26 17:33:41 +02:00
|
|
|
import javax.persistence.criteria.Join;
|
|
|
|
import javax.persistence.criteria.JoinType;
|
2019-03-05 12:59:34 +01:00
|
|
|
import javax.xml.bind.JAXBContext;
|
|
|
|
import javax.xml.bind.JAXBException;
|
|
|
|
import javax.xml.bind.Unmarshaller;
|
2018-10-18 11:33:13 +02:00
|
|
|
import java.io.*;
|
|
|
|
import java.math.BigInteger;
|
|
|
|
import java.net.URL;
|
2019-02-06 11:46:14 +01:00
|
|
|
import java.nio.file.Files;
|
2018-10-18 11:33:13 +02:00
|
|
|
import java.nio.file.Paths;
|
2018-03-28 15:24:47 +02:00
|
|
|
import java.util.*;
|
2018-02-16 11:34:02 +01:00
|
|
|
import java.util.concurrent.CompletableFuture;
|
|
|
|
import java.util.stream.Collectors;
|
|
|
|
|
2019-01-29 12:05:36 +01:00
|
|
|
@Component
|
2017-12-15 00:01:26 +01:00
|
|
|
public class DataManagementPlanManager {
|
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
private ApiContext apiContext;
|
|
|
|
private DatasetManager datasetManager;
|
|
|
|
private UtilitiesService utilitiesService;
|
|
|
|
private DatabaseRepository databaseRepository;
|
|
|
|
private Environment environment;
|
|
|
|
|
|
|
|
@Autowired
|
|
|
|
public DataManagementPlanManager(ApiContext apiContext, DatasetManager datasetManager, Environment environment) {
|
|
|
|
this.apiContext = apiContext;
|
|
|
|
this.datasetManager = datasetManager;
|
|
|
|
this.utilitiesService = apiContext.getUtilitiesService();
|
|
|
|
this.databaseRepository = apiContext.getOperationsContext().getDatabaseRepository();
|
|
|
|
this.environment = environment;
|
|
|
|
}
|
|
|
|
|
|
|
|
public DataTableData<DataManagementPlanListingModel> getPaged(DataManagementPlanTableRequest dataManagementPlanTableRequest, Principal principal, String fieldsGroup) throws Exception {
|
2019-05-10 10:33:48 +02:00
|
|
|
UUID principalID = principal.getId();
|
2019-05-31 13:07:12 +02:00
|
|
|
QueryableList<DMP> items = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().getWithCriteria(dataManagementPlanTableRequest.getCriteria());
|
2019-09-26 11:44:39 +02:00
|
|
|
List<Integer> roles = new LinkedList<>();
|
|
|
|
if (dataManagementPlanTableRequest.getCriteria().getRole() != null) roles.add(dataManagementPlanTableRequest.getCriteria().getRole());
|
|
|
|
QueryableList<DMP> authItems = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().getAuthenticated(items, principalID, roles);
|
2018-01-11 17:19:15 +01:00
|
|
|
QueryableList<DMP> pagedItems = PaginationManager.applyPaging(authItems, dataManagementPlanTableRequest);
|
2018-01-08 15:57:21 +01:00
|
|
|
|
2018-07-23 15:09:19 +02:00
|
|
|
DataTableData<DataManagementPlanListingModel> dataTable = new DataTableData<>();
|
2018-02-07 10:56:30 +01:00
|
|
|
|
2019-01-31 14:56:53 +01:00
|
|
|
CompletableFuture itemsFuture;
|
2019-06-21 13:04:29 +02:00
|
|
|
if (fieldsGroup.equals("listing")) {
|
2019-01-31 14:56:53 +01:00
|
|
|
|
|
|
|
itemsFuture = pagedItems.withHint(HintedModelFactory.getHint(DataManagementPlanListingModel.class))
|
|
|
|
.selectAsync(item -> {
|
|
|
|
item.setDataset(
|
|
|
|
item.getDataset().stream()
|
2019-06-19 16:16:05 +02:00
|
|
|
.filter(dataset -> !dataset.getStatus().equals(Dataset.Status.DELETED.getValue()) && !dataset.getStatus().equals(Dataset.Status.CANCELED.getValue())).collect(Collectors.toList()).stream()
|
2019-05-31 10:38:04 +02:00
|
|
|
.filter(dataset -> dataset.getDmp().getUsers().stream().filter(userDMP -> userDMP.getRole().equals(UserDMP.UserDMPRoles.OWNER.getValue())).findFirst().get().getUser().getId().equals(principalID)
|
2019-06-21 13:04:29 +02:00
|
|
|
|| dataset.getDmp().getUsers().stream()
|
|
|
|
.filter(x -> x.getUser().getId().equals(principalID))
|
|
|
|
.collect(Collectors.toList()).size() > 0)
|
2019-05-13 11:20:59 +02:00
|
|
|
.collect(Collectors.toSet()));
|
2019-01-31 14:56:53 +01:00
|
|
|
return new DataManagementPlanListingModel().fromDataModelDatasets(item);
|
|
|
|
})
|
|
|
|
.whenComplete((resultList, throwable) -> dataTable.setData(resultList));
|
2019-06-21 13:04:29 +02:00
|
|
|
} else {
|
2019-01-31 14:56:53 +01:00
|
|
|
itemsFuture = pagedItems
|
2019-06-21 13:04:29 +02:00
|
|
|
.selectAsync(item -> new DataManagementPlanListingModel().fromDataModel(item))
|
2019-01-31 14:56:53 +01:00
|
|
|
.whenComplete((resultList, throwable) -> dataTable.setData(resultList));
|
|
|
|
}
|
2018-02-07 10:56:30 +01:00
|
|
|
|
2018-03-19 13:40:04 +01:00
|
|
|
CompletableFuture countFuture = authItems.countAsync().whenComplete((count, throwable) -> {
|
2018-02-07 10:56:30 +01:00
|
|
|
dataTable.setTotalCount(count);
|
|
|
|
});
|
|
|
|
CompletableFuture.allOf(itemsFuture, countFuture).join();
|
2018-01-11 17:19:15 +01:00
|
|
|
return dataTable;
|
|
|
|
}
|
2017-12-19 09:38:47 +01:00
|
|
|
|
2019-09-26 17:33:41 +02:00
|
|
|
public DataTableData<DataManagementPlanListingModel> getPublicPaged(DataManagmentPlanPublicTableRequest dataManagementPlanPublicTableRequest, String fieldsGroup, Principal principal) throws Exception {
|
2019-04-26 16:05:15 +02:00
|
|
|
dataManagementPlanPublicTableRequest.setQuery(databaseRepository.getDmpDao().asQueryable().withHint(HintedModelFactory.getHint(DataManagementPlanListingModel.class)));
|
|
|
|
QueryableList<DMP> items = dataManagementPlanPublicTableRequest.applyCriteria();
|
2019-09-26 17:33:41 +02:00
|
|
|
|
|
|
|
if (principal.getId() != null && dataManagementPlanPublicTableRequest.getCriteria().getRole() != null) {
|
|
|
|
items.where((builder, root) -> {
|
|
|
|
Join userJoin = root.join("users", JoinType.LEFT);
|
|
|
|
return builder.and(builder.equal(userJoin.join("user", JoinType.LEFT).get("id"), principal.getId()), builder.equal(userJoin.get("role"), dataManagementPlanPublicTableRequest.getCriteria().getRole()));
|
|
|
|
});
|
|
|
|
}
|
2019-04-26 16:05:15 +02:00
|
|
|
QueryableList<DMP> pagedItems = PaginationManager.applyPaging(items, dataManagementPlanPublicTableRequest);
|
|
|
|
|
|
|
|
DataTableData<DataManagementPlanListingModel> dataTable = new DataTableData<>();
|
|
|
|
|
|
|
|
CompletableFuture itemsFuture;
|
2019-06-21 13:04:29 +02:00
|
|
|
if (fieldsGroup.equals("listing")) {
|
2019-04-26 16:05:15 +02:00
|
|
|
itemsFuture = pagedItems.withHint(HintedModelFactory.getHint(DataManagementPlanListingModel.class))
|
|
|
|
.selectAsync(item -> {
|
|
|
|
item.setDataset(
|
|
|
|
item.getDataset().stream()
|
2019-06-07 15:35:49 +02:00
|
|
|
.filter(dataset -> dataset.getStatus().equals(Dataset.Status.FINALISED.getValue())).collect(Collectors.toSet()));
|
2019-04-26 16:05:15 +02:00
|
|
|
return new DataManagementPlanListingModel().fromDataModelDatasets(item);
|
|
|
|
})
|
|
|
|
.whenComplete((resultList, throwable) -> dataTable.setData(resultList));
|
2019-06-21 13:04:29 +02:00
|
|
|
} else {
|
2019-04-26 16:05:15 +02:00
|
|
|
itemsFuture = pagedItems
|
2019-05-28 09:22:58 +02:00
|
|
|
.selectAsync(item -> new DataManagementPlanListingModel().fromDataModel(item))
|
2019-04-26 16:05:15 +02:00
|
|
|
.whenComplete((resultList, throwable) -> dataTable.setData(resultList));
|
|
|
|
}
|
|
|
|
|
|
|
|
CompletableFuture countFuture = items.countAsync().whenComplete((count, throwable) -> {
|
|
|
|
dataTable.setTotalCount(count);
|
|
|
|
});
|
|
|
|
CompletableFuture.allOf(itemsFuture, countFuture).join();
|
|
|
|
return dataTable;
|
|
|
|
}
|
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
public void unlock(UUID uuid) throws Exception {
|
2018-10-12 10:22:23 +02:00
|
|
|
apiContext.getOperationsContext().getDatabaseRepository().getDmpDao()
|
|
|
|
.asQueryable().where((builder, root) -> builder.equal(root.get("id"), uuid))
|
|
|
|
.update(root -> root.get("status"), DMP.DMPStatus.ACTIVE.getValue());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-10-29 12:30:44 +01:00
|
|
|
public File getWordDocument(String id, Principal principal) throws IOException {
|
2018-10-18 11:33:13 +02:00
|
|
|
WordBuilder wordBuilder = new WordBuilder();
|
2019-03-05 16:33:59 +01:00
|
|
|
VisibilityRuleService visibilityRuleService = this.utilitiesService.getVisibilityRuleService();
|
2018-10-18 11:33:13 +02:00
|
|
|
DatasetWizardModel dataset = new DatasetWizardModel();
|
|
|
|
String fileUrl = environment.getProperty("configuration.h2020template");
|
|
|
|
InputStream is = new URL(Paths.get(fileUrl).toUri().toURL().toString()).openStream();
|
2018-10-22 12:34:39 +02:00
|
|
|
XWPFDocument document = new XWPFDocument(is);
|
2018-10-18 11:33:13 +02:00
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
eu.eudat.data.entities.DMP dmpEntity = databaseRepository.getDmpDao().find(UUID.fromString(id));
|
2019-10-29 12:30:44 +01:00
|
|
|
if (!dmpEntity.isPublic() && dmpEntity.getUsers().stream().filter(userInfo -> userInfo.getUser().getId() == principal.getId()).collect(Collectors.toList()).size() == 0)
|
|
|
|
throw new UnauthorisedException();
|
2019-05-22 10:53:30 +02:00
|
|
|
|
|
|
|
// Space above DMP title.
|
2019-10-30 13:30:31 +01:00
|
|
|
/* XWPFParagraph parAboveDmpTitle = document.createParagraph();
|
2019-05-22 10:53:30 +02:00
|
|
|
XWPFParagraph parAboveDmpTitle1 = document.createParagraph();
|
|
|
|
XWPFParagraph parAboveDmpTitle2 = document.createParagraph();
|
2019-10-30 13:30:31 +01:00
|
|
|
XWPFParagraph parAboveDmpTitle3 = document.createParagraph();*/
|
2019-05-22 10:53:30 +02:00
|
|
|
|
|
|
|
// DMP title custom style.
|
2019-10-30 13:30:31 +01:00
|
|
|
wordBuilder.addParagraphContent(dmpEntity.getLabel(), document, ParagraphStyle.HEADER1, BigInteger.ZERO);
|
2019-05-22 10:53:30 +02:00
|
|
|
|
|
|
|
// Space below DMP title.
|
|
|
|
XWPFParagraph parBelowDmpTitle = document.createParagraph();
|
|
|
|
|
2018-10-18 11:33:13 +02:00
|
|
|
wordBuilder.addParagraphContent(dmpEntity.getDescription(), document, ParagraphStyle.TEXT, BigInteger.ZERO);
|
|
|
|
|
|
|
|
wordBuilder.addParagraphContent("Organisations", document, ParagraphStyle.HEADER2, BigInteger.ZERO);
|
2019-03-05 12:59:34 +01:00
|
|
|
if (dmpEntity.getOrganisations().size() > 0) {
|
2019-09-18 12:28:02 +02:00
|
|
|
wordBuilder.addParagraphContent(dmpEntity.getOrganisations().stream().map(Organisation::getLabel).collect(Collectors.joining(", "))
|
2019-03-05 12:59:34 +01:00
|
|
|
, document, ParagraphStyle.TEXT, BigInteger.ZERO);
|
|
|
|
}
|
2018-10-18 11:33:13 +02:00
|
|
|
|
|
|
|
wordBuilder.addParagraphContent("Researchers", document, ParagraphStyle.HEADER2, BigInteger.ZERO);
|
2019-03-05 12:59:34 +01:00
|
|
|
if (dmpEntity.getResearchers().size() > 0) {
|
2019-09-18 12:28:02 +02:00
|
|
|
wordBuilder.addParagraphContent(dmpEntity.getResearchers().stream().map(Researcher::getLabel).collect(Collectors.joining(", "))
|
2019-03-05 12:59:34 +01:00
|
|
|
, document, ParagraphStyle.TEXT, BigInteger.ZERO);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*wordBuilder.addParagraphContent("DMP Profile", document, ParagraphStyle.HEADER2, BigInteger.ZERO);
|
|
|
|
if (dmpEntity.getProfile() != null){
|
|
|
|
wordBuilder.addParagraphContent(dmpEntity.getProfile().getLabel(), document, ParagraphStyle.TEXT, BigInteger.ZERO);
|
|
|
|
}*/
|
2018-10-18 11:33:13 +02:00
|
|
|
|
2019-05-22 10:53:30 +02:00
|
|
|
// Page break at the end of the DMP title.
|
|
|
|
XWPFParagraph parBreakDMP = document.createParagraph();
|
|
|
|
parBreakDMP.setPageBreak(true);
|
|
|
|
|
2018-10-18 11:33:13 +02:00
|
|
|
wordBuilder.addParagraphContent("Datasets", document, ParagraphStyle.TITLE, BigInteger.ZERO);
|
2019-09-18 12:28:02 +02:00
|
|
|
dmpEntity.getDataset().stream()
|
|
|
|
.filter(item -> item.getStatus() != Dataset.Status.CANCELED.getValue())
|
|
|
|
.filter(item -> item.getStatus() != Dataset.Status.DELETED.getValue())
|
|
|
|
.forEach(datasetEntity -> {
|
2018-10-18 11:33:13 +02:00
|
|
|
Map<String, Object> properties = new HashMap<>();
|
|
|
|
if (datasetEntity.getProperties() != null) {
|
|
|
|
JSONObject jobject = new JSONObject(datasetEntity.getProperties());
|
|
|
|
properties = jobject.toMap();
|
|
|
|
}
|
2019-05-22 10:53:30 +02:00
|
|
|
|
|
|
|
// Custom style for the Dataset title.
|
|
|
|
//wordBuilder.addParagraphContent("Title: " + datasetEntity.getLabel(), document, ParagraphStyle.HEADER1, BigInteger.ZERO);
|
|
|
|
XWPFParagraph datasetLabelParagraph = document.createParagraph();
|
2019-10-30 13:30:31 +01:00
|
|
|
datasetLabelParagraph.setStyle("Heading1");
|
2019-05-22 10:53:30 +02:00
|
|
|
XWPFRun runDatasetTitle1 = datasetLabelParagraph.createRun();
|
|
|
|
runDatasetTitle1.setText("Title: ");
|
|
|
|
runDatasetTitle1.setBold(true);
|
|
|
|
runDatasetTitle1.setFontSize(12);
|
|
|
|
XWPFRun runDatasetTitle = datasetLabelParagraph.createRun();
|
|
|
|
runDatasetTitle.setText(datasetEntity.getLabel());
|
|
|
|
runDatasetTitle.setColor("2E75B6");
|
|
|
|
runDatasetTitle.setBold(true);
|
|
|
|
runDatasetTitle.setFontSize(12);
|
|
|
|
|
2019-07-04 16:10:30 +02:00
|
|
|
XWPFParagraph datasetTemplateParagraph = document.createParagraph();
|
2019-10-30 13:30:31 +01:00
|
|
|
datasetTemplateParagraph.setStyle("Heading2");
|
2019-07-04 16:10:30 +02:00
|
|
|
XWPFRun runDatasetTemplate1 = datasetTemplateParagraph.createRun();
|
|
|
|
runDatasetTemplate1.setText("Template: ");
|
|
|
|
runDatasetTemplate1.setBold(true);
|
|
|
|
runDatasetTemplate1.setFontSize(12);
|
|
|
|
XWPFRun runDatasetTemplate = datasetTemplateParagraph.createRun();
|
|
|
|
runDatasetTemplate.setText(datasetEntity.getProfile().getLabel());
|
|
|
|
runDatasetTemplate.setColor("2E75B6");
|
|
|
|
runDatasetTemplate.setBold(true);
|
|
|
|
runDatasetTemplate.setFontSize(12);
|
|
|
|
|
2018-10-18 11:33:13 +02:00
|
|
|
wordBuilder.addParagraphContent(datasetEntity.getDescription(), document, ParagraphStyle.TEXT, BigInteger.ZERO);
|
2019-10-30 13:30:31 +01:00
|
|
|
wordBuilder.addParagraphContent("Dataset Description", document, ParagraphStyle.HEADER2, BigInteger.ZERO);
|
2019-03-05 16:33:59 +01:00
|
|
|
PagedDatasetProfile pagedDatasetProfile = datasetManager.getPagedProfile(dataset, datasetEntity);
|
2018-10-18 11:33:13 +02:00
|
|
|
visibilityRuleService.setProperties(properties);
|
|
|
|
visibilityRuleService.buildVisibilityContext(pagedDatasetProfile.getRules());
|
|
|
|
try {
|
|
|
|
wordBuilder.build(document, pagedDatasetProfile, visibilityRuleService);
|
|
|
|
} catch (IOException e) {
|
|
|
|
e.printStackTrace();
|
|
|
|
}
|
2019-05-22 10:53:30 +02:00
|
|
|
// Page break at the end of the Dataset.
|
|
|
|
XWPFParagraph parBreakDataset = document.createParagraph();
|
2018-10-18 11:33:13 +02:00
|
|
|
});
|
2019-10-30 17:21:04 +01:00
|
|
|
|
|
|
|
// Removes the top empty headings.
|
|
|
|
document.removeBodyElement(0);
|
|
|
|
document.removeBodyElement(0);
|
|
|
|
document.removeBodyElement(0);
|
|
|
|
document.removeBodyElement(0);
|
|
|
|
document.removeBodyElement(0);
|
|
|
|
|
2019-03-05 12:59:34 +01:00
|
|
|
String fileName = dmpEntity.getLabel();
|
|
|
|
fileName = fileName.replaceAll("[^a-zA-Z0-9+ ]", "");
|
2019-07-04 11:43:48 +02:00
|
|
|
File exportFile = new File(fileName + ".docx");
|
2018-10-18 11:33:13 +02:00
|
|
|
FileOutputStream out = new FileOutputStream(exportFile);
|
|
|
|
document.write(out);
|
|
|
|
out.close();
|
2019-04-05 11:20:06 +02:00
|
|
|
|
2018-10-18 11:33:13 +02:00
|
|
|
return exportFile;
|
|
|
|
}
|
|
|
|
|
2019-04-05 11:20:06 +02:00
|
|
|
/*public File getPdfDocument(String id) throws InstantiationException, IllegalAccessException, InterruptedException, IOException {
|
|
|
|
File file = this.getWordDocument(id);
|
|
|
|
String fileName = file.getName();
|
|
|
|
if (fileName.endsWith(".docx")){
|
|
|
|
fileName = fileName.substring(0, fileName.length() - 5);
|
|
|
|
}
|
|
|
|
return this.datasetManager.convertToPDF(file, environment, fileName);
|
|
|
|
}*/
|
|
|
|
|
2019-07-31 16:57:34 +02:00
|
|
|
public eu.eudat.models.data.dmp.DataManagementPlan getSingle(String id, Principal principal, DynamicGrantConfiguration dynamicGrantConfiguration) throws InstantiationException, IllegalAccessException {
|
2019-03-05 16:33:59 +01:00
|
|
|
DMP dataManagementPlanEntity = databaseRepository.getDmpDao().find(UUID.fromString(id));
|
2019-05-31 10:38:04 +02:00
|
|
|
if (dataManagementPlanEntity.getUsers().stream().filter(userInfo -> userInfo.getUser().getId() == principal.getId()).collect(Collectors.toList()).size() == 0)
|
2018-01-11 17:19:15 +01:00
|
|
|
throw new UnauthorisedException();
|
2018-06-27 12:29:21 +02:00
|
|
|
eu.eudat.models.data.dmp.DataManagementPlan datamanagementPlan = new eu.eudat.models.data.dmp.DataManagementPlan();
|
2018-01-11 17:19:15 +01:00
|
|
|
datamanagementPlan.fromDataModel(dataManagementPlanEntity);
|
2018-03-28 15:24:47 +02:00
|
|
|
Map dmpProperties = dataManagementPlanEntity.getDmpProperties() != null ? new org.json.JSONObject(dataManagementPlanEntity.getDmpProperties()).toMap() : null;
|
2019-09-13 12:08:37 +02:00
|
|
|
// datamanagementPlan.setDynamicFields(dynamicGrantConfiguration.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()));
|
2018-03-28 15:24:47 +02:00
|
|
|
|
|
|
|
if (dmpProperties != null && datamanagementPlan.getDynamicFields() != null)
|
|
|
|
datamanagementPlan.getDynamicFields().forEach(item -> {
|
|
|
|
Map<String, String> properties = (Map<String, String>) dmpProperties.get(item.getId());
|
|
|
|
if (properties != null)
|
2018-10-18 11:33:13 +02:00
|
|
|
item.setValue(new Tuple<>(properties.get("id"), properties.get("label")));
|
2018-03-28 15:24:47 +02:00
|
|
|
});
|
2018-01-11 17:19:15 +01:00
|
|
|
return datamanagementPlan;
|
|
|
|
}
|
2017-12-20 15:52:09 +01:00
|
|
|
|
2019-05-17 17:21:56 +02:00
|
|
|
public DataManagementPlanOverviewModel getOverviewSingle(String id, Principal principal) throws InstantiationException, IllegalAccessException {
|
|
|
|
DMP dataManagementPlanEntity = databaseRepository.getDmpDao().find(UUID.fromString(id));
|
2019-05-31 10:38:04 +02:00
|
|
|
if (dataManagementPlanEntity.getUsers()
|
2019-05-17 17:21:56 +02:00
|
|
|
.stream().filter(userInfo -> userInfo.getUser().getId() == principal.getId())
|
|
|
|
.collect(Collectors.toList()).size() == 0)
|
|
|
|
throw new UnauthorisedException();
|
|
|
|
DataManagementPlanOverviewModel datamanagementPlan = new DataManagementPlanOverviewModel();
|
|
|
|
datamanagementPlan.fromDataModelDatasets(dataManagementPlanEntity);
|
|
|
|
|
|
|
|
return datamanagementPlan;
|
|
|
|
}
|
|
|
|
|
2019-07-31 16:57:34 +02:00
|
|
|
public eu.eudat.models.data.dmp.DataManagementPlan getSinglePublic(String id, DynamicGrantConfiguration dynamicGrantConfiguration) throws Exception {
|
2019-04-26 16:05:15 +02:00
|
|
|
DMP dataManagementPlanEntity = databaseRepository.getDmpDao().find(UUID.fromString(id));
|
|
|
|
|
2019-06-21 13:04:29 +02:00
|
|
|
if (dataManagementPlanEntity != null && dataManagementPlanEntity.getStatus() == 1) {
|
2019-04-26 16:05:15 +02:00
|
|
|
eu.eudat.models.data.dmp.DataManagementPlan datamanagementPlan = new eu.eudat.models.data.dmp.DataManagementPlan();
|
|
|
|
datamanagementPlan.fromDataModel(dataManagementPlanEntity);
|
2019-06-07 15:35:49 +02:00
|
|
|
datamanagementPlan.setDatasets(datamanagementPlan.getDatasets().stream().filter(dataset -> dataset.getStatus() == Dataset.Status.FINALISED.getValue()).collect(Collectors.toList()));
|
2019-04-26 16:05:15 +02:00
|
|
|
Map dmpProperties = dataManagementPlanEntity.getDmpProperties() != null ? new org.json.JSONObject(dataManagementPlanEntity.getDmpProperties()).toMap() : null;
|
2019-09-13 12:08:37 +02:00
|
|
|
// datamanagementPlan.setDynamicFields(dynamicGrantConfiguration.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()));
|
2019-04-26 16:05:15 +02:00
|
|
|
|
|
|
|
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;
|
2019-06-21 13:04:29 +02:00
|
|
|
} else {
|
2019-04-26 16:05:15 +02:00
|
|
|
throw new Exception("Selected DMP is not public");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-21 13:04:29 +02:00
|
|
|
public DataManagementPlanOverviewModel getOverviewSinglePublic(String id) throws Exception {
|
2019-06-10 11:27:16 +02:00
|
|
|
DMP dataManagementPlanEntity = databaseRepository.getDmpDao().find(UUID.fromString(id));
|
|
|
|
if (dataManagementPlanEntity != null && dataManagementPlanEntity.getStatus() == 1) {
|
|
|
|
DataManagementPlanOverviewModel datamanagementPlan = new DataManagementPlanOverviewModel();
|
|
|
|
datamanagementPlan.fromDataModelDatasets(dataManagementPlanEntity);
|
|
|
|
datamanagementPlan.setDatasets(datamanagementPlan.getDatasets().stream().filter(dataset -> dataset.getStatus() == Dataset.Status.FINALISED.getValue()).collect(Collectors.toList()));
|
|
|
|
return datamanagementPlan;
|
2019-06-21 13:04:29 +02:00
|
|
|
} else {
|
2019-06-10 11:27:16 +02:00
|
|
|
throw new Exception("Selected DMP is not public");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-24 17:21:02 +02:00
|
|
|
public List<DataManagementPlan> getWithCriteria(DMPDao dmpsRepository, DataManagementPlanCriteriaRequest dataManagementPlanCriteria, Principal principal) throws IllegalAccessException, InstantiationException {
|
2019-05-10 10:33:48 +02:00
|
|
|
UUID principalID = principal.getId();
|
2018-08-24 17:21:02 +02:00
|
|
|
QueryableList<DMP> items = dmpsRepository.getWithCriteria(dataManagementPlanCriteria.getCriteria()).withHint(HintedModelFactory.getHint(DataManagementPlan.class));
|
2019-09-26 11:44:39 +02:00
|
|
|
List<Integer> roles = new LinkedList<>();
|
|
|
|
QueryableList<DMP> authenticatedItems = dmpsRepository.getAuthenticated(items, principalID, roles);
|
2018-08-24 17:21:02 +02:00
|
|
|
List<eu.eudat.models.data.dmp.DataManagementPlan> datamanagementPlans = authenticatedItems.select(item -> new DataManagementPlan().fromDataModel(item));
|
2018-01-11 17:19:15 +01:00
|
|
|
return datamanagementPlans;
|
|
|
|
}
|
2017-12-20 15:52:09 +01:00
|
|
|
|
2019-07-31 16:57:34 +02:00
|
|
|
public List<Tuple<String, String>> getDynamicFields(String id, DynamicGrantConfiguration dynamicGrantConfiguration, DynamicFieldsCriteria criteria) throws IllegalAccessException, InstantiationException {
|
2018-03-28 15:24:47 +02:00
|
|
|
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);
|
|
|
|
|
2019-07-31 16:57:34 +02:00
|
|
|
Property property = dynamicGrantConfiguration.getConfiguration().getConfigurationProperties().stream()
|
2018-03-28 15:24:47 +02:00
|
|
|
.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;
|
|
|
|
}
|
|
|
|
|
2019-07-02 11:36:25 +02:00
|
|
|
public DMP createOrUpdate(ApiContext apiContext, DataManagementPlanEditorModel dataManagementPlan, Principal principal) throws Exception {
|
2019-05-30 14:41:23 +02:00
|
|
|
|
2019-07-19 10:55:08 +02:00
|
|
|
if (dataManagementPlan.getId() != null) {
|
2019-06-24 10:01:28 +02:00
|
|
|
DMP dmp1 = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(dataManagementPlan.getId());
|
2019-07-19 10:55:08 +02:00
|
|
|
|
|
|
|
List<Dataset> datasetList = new ArrayList<>(dmp1.getDataset());
|
|
|
|
for (Dataset dataset : datasetList) {
|
|
|
|
if (dataManagementPlan.getProfiles().stream().filter(associatedProfile -> dataset.getProfile().getId().equals(associatedProfile.getId())).findAny().orElse(null) == null)
|
|
|
|
throw new Exception("Dataset Template for Dataest Description is missing from the DMP.");
|
|
|
|
}
|
|
|
|
if (dataManagementPlan.getStatus() == (int) DMP.DMPStatus.FINALISED.getValue() && dmp1.getStatus().equals(DMP.DMPStatus.FINALISED.getValue()))
|
2019-06-24 10:01:28 +02:00
|
|
|
throw new Exception("DMP is finalized, therefore cannot be edited.");
|
2019-06-21 16:47:06 +02:00
|
|
|
}
|
|
|
|
|
2018-01-11 17:19:15 +01:00
|
|
|
DMP newDmp = dataManagementPlan.toDataModel();
|
2019-08-22 16:15:16 +02:00
|
|
|
if (newDmp.getStatus() == (int) DMP.DMPStatus.FINALISED.getValue()) {
|
|
|
|
checkDmpValidationRules(newDmp);
|
|
|
|
}
|
2019-05-30 14:41:23 +02:00
|
|
|
UserInfo user = apiContext.getOperationsContext().getDatabaseRepository().getUserInfoDao().find(principal.getId());
|
|
|
|
|
2018-03-05 17:18:45 +01:00
|
|
|
createOrganisationsIfTheyDontExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getOrganisationDao());
|
2019-09-30 16:42:01 +02:00
|
|
|
createResearchersIfTheyDontExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getResearcherDao(), user);
|
2019-08-26 15:55:30 +02:00
|
|
|
createFunderIfItDoesntExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getFunderDao());
|
2019-08-28 15:20:55 +02:00
|
|
|
createGrantIfItDoesntExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getGrantDao());
|
2019-08-26 15:55:30 +02:00
|
|
|
if (newDmp.getProject().getLabel() == null || newDmp.getProject().getLabel().trim().isEmpty()) {
|
2019-08-22 13:29:33 +02:00
|
|
|
newDmp.setProject(newDmp.getProject().projectFromGrant(newDmp.getGrant()));
|
|
|
|
}
|
2019-08-02 10:27:12 +02:00
|
|
|
createProjectIfItDoesntExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getProjectDao());
|
2019-06-21 13:04:29 +02:00
|
|
|
|
2019-07-02 11:36:25 +02:00
|
|
|
DMP dmp;
|
|
|
|
if (dataManagementPlan.getId() != null) {
|
|
|
|
dmp = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(dataManagementPlan.getId());
|
|
|
|
} else dmp = new DMP();
|
|
|
|
|
|
|
|
newDmp.setCreated(dmp.getCreated() == null ? new Date() : dmp.getCreated());
|
|
|
|
if (newDmp.getUsers()!= null && newDmp.getUsers().stream().filter(userInfo -> userInfo.getUser().getId() == principal.getId())
|
|
|
|
.collect(Collectors.toList()).size() == 0) {
|
2019-10-30 13:30:31 +01:00
|
|
|
List<UserDMP> userDMPList = new ArrayList<>(newDmp.getUsers());
|
2019-07-02 11:36:25 +02:00
|
|
|
for (UserInfoListingModel userInfoListingModel : dataManagementPlan.getUsers()) {
|
|
|
|
for (UserDMP userDMP : userDMPList) {
|
|
|
|
if (!(userDMP.getUser().getId().equals(userInfoListingModel.getId()))) {
|
|
|
|
apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().delete(userDMP);
|
2019-05-29 16:58:23 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-07-02 11:36:25 +02:00
|
|
|
}
|
2019-08-26 15:52:05 +02:00
|
|
|
|
2019-08-29 16:45:47 +02:00
|
|
|
checkIfUserCanEditGrant(newDmp, user);
|
2019-09-24 16:40:53 +02:00
|
|
|
assignGrandUserIfInternal(newDmp, user);
|
|
|
|
assignFunderUserIfInternal(newDmp, user);
|
|
|
|
assignProjectUserIfInternal(newDmp, user);
|
2019-08-26 15:52:05 +02:00
|
|
|
|
2019-08-27 16:00:09 +02:00
|
|
|
apiContext.getOperationsContext().getDatabaseRepository().getGrantDao().createOrUpdate(newDmp.getGrant());
|
2019-07-02 11:36:25 +02:00
|
|
|
newDmp = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(newDmp);
|
|
|
|
|
|
|
|
// Dataset manipulation for when the DMP is set to be finalized.
|
|
|
|
if (dataManagementPlan.getStatus() == DMP.DMPStatus.FINALISED.getValue()) {
|
|
|
|
if (dataManagementPlan.getDatasetsToBeFinalized() != null && !dataManagementPlan.getDatasetsToBeFinalized().isEmpty()) {
|
|
|
|
apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao()
|
|
|
|
.asQueryable().where((builder, root) -> root.get("id").in(dataManagementPlan.getDatasetsToBeFinalized()))
|
|
|
|
.update(root -> root.<Integer>get("status"), Dataset.Status.FINALISED.getValue());
|
|
|
|
|
|
|
|
List<UUID> datasetsToBeCanceled = new LinkedList<>();
|
|
|
|
for (DatasetListingModel dataset : dataManagementPlan.getDatasets()) {
|
|
|
|
if (!(dataset.getStatus() == (int) Dataset.Status.FINALISED.getValue()) && !dataManagementPlan.getDatasetsToBeFinalized().contains(UUID.fromString(dataset.getId()))) {
|
|
|
|
datasetsToBeCanceled.add(UUID.fromString(dataset.getId()));
|
2019-06-21 16:16:45 +02:00
|
|
|
}
|
|
|
|
}
|
2019-07-02 11:36:25 +02:00
|
|
|
if (!datasetsToBeCanceled.isEmpty())
|
2019-06-21 16:16:45 +02:00
|
|
|
apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao()
|
2019-07-02 11:36:25 +02:00
|
|
|
.asQueryable().where((builder, root) -> root.get("id").in(datasetsToBeCanceled))
|
|
|
|
.update(root -> root.<Integer>get("status"), Dataset.Status.CANCELED.getValue());
|
|
|
|
} else {
|
|
|
|
List<UUID> datasetsToBeCanceled = new LinkedList<>();
|
|
|
|
for (DatasetListingModel dataset : dataManagementPlan.getDatasets()) {
|
|
|
|
if (!(dataset.getStatus() == (int) Dataset.Status.FINALISED.getValue())) {
|
|
|
|
datasetsToBeCanceled.add(UUID.fromString(dataset.getId()));
|
2019-06-21 16:16:45 +02:00
|
|
|
}
|
2019-06-21 13:04:29 +02:00
|
|
|
}
|
2019-07-02 11:36:25 +02:00
|
|
|
if (!datasetsToBeCanceled.isEmpty())
|
|
|
|
apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao()
|
|
|
|
.asQueryable().where((builder, root) -> root.get("id").in(datasetsToBeCanceled))
|
|
|
|
.update(root -> root.<Integer>get("status"), Dataset.Status.CANCELED.getValue());
|
2019-06-21 13:04:29 +02:00
|
|
|
}
|
2018-10-11 13:22:03 +02:00
|
|
|
}
|
2019-05-30 14:41:23 +02:00
|
|
|
|
2019-05-17 12:19:30 +02:00
|
|
|
if (dataManagementPlan.getAssociatedUsers().size() == 0)
|
2019-08-29 16:45:47 +02:00
|
|
|
assignUser(newDmp, user);
|
2019-07-02 11:36:25 +02:00
|
|
|
|
|
|
|
return newDmp;
|
2018-02-08 16:54:31 +01:00
|
|
|
}
|
2017-12-20 15:52:09 +01:00
|
|
|
|
2019-07-02 11:36:25 +02:00
|
|
|
|
2019-08-29 16:45:47 +02:00
|
|
|
public void assignUser(DMP dmp, UserInfo userInfo) {
|
2018-02-08 16:54:31 +01:00
|
|
|
UserDMP userDMP = new UserDMP();
|
|
|
|
userDMP.setDmp(dmp);
|
|
|
|
userDMP.setUser(userInfo);
|
|
|
|
userDMP.setRole(UserDMP.UserDMPRoles.OWNER.getValue());
|
2019-08-29 16:45:47 +02:00
|
|
|
databaseRepository.getUserDmpDao().createOrUpdate(userDMP);
|
2018-01-11 17:19:15 +01:00
|
|
|
}
|
2017-12-20 15:52:09 +01:00
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
public void newVersion(UUID uuid, DataManagementPlanNewVersionModel dataManagementPlan, Principal principal) throws Exception {
|
2019-08-29 16:45:47 +02:00
|
|
|
DMP oldDmp = databaseRepository.getDmpDao().find(uuid);
|
2019-03-26 15:52:19 +01:00
|
|
|
|
|
|
|
DataManagementPlanCriteria criteria = new DataManagementPlanCriteria();
|
|
|
|
LinkedList<UUID> list = new LinkedList<>();
|
|
|
|
list.push(oldDmp.getGroupId());
|
|
|
|
criteria.setGroupIds(list);
|
|
|
|
criteria.setAllVersions(false);
|
2019-08-29 16:45:47 +02:00
|
|
|
QueryableList<DMP> dataManagementPlanQueryableList = databaseRepository.getDmpDao().getWithCriteria(criteria);
|
2019-03-26 15:52:19 +01:00
|
|
|
List<DMP> latestVersionDMP = dataManagementPlanQueryableList.toList();
|
|
|
|
|
2019-06-21 13:04:29 +02:00
|
|
|
if (latestVersionDMP.get(0).getVersion().equals(oldDmp.getVersion())) {
|
2019-03-26 15:52:19 +01:00
|
|
|
DMP newDmp = dataManagementPlan.toDataModel();
|
2019-08-29 16:45:47 +02:00
|
|
|
|
2019-03-26 15:52:19 +01:00
|
|
|
UserInfo user = apiContext.getOperationsContext().getBuilderFactory().getBuilder(UserInfoBuilder.class).id(principal.getId()).build();
|
2019-09-30 16:42:01 +02:00
|
|
|
createOrganisationsIfTheyDontExist(newDmp, databaseRepository.getOrganisationDao());
|
|
|
|
createResearchersIfTheyDontExist(newDmp, databaseRepository.getResearcherDao(), user);
|
2019-08-29 16:45:47 +02:00
|
|
|
|
|
|
|
createFunderIfItDoesntExist(newDmp, databaseRepository.getFunderDao());
|
|
|
|
createGrantIfItDoesntExist(newDmp, databaseRepository.getGrantDao());
|
|
|
|
if (newDmp.getProject().getLabel() == null || newDmp.getProject().getLabel().trim().isEmpty()) {
|
|
|
|
newDmp.setProject(newDmp.getProject().projectFromGrant(newDmp.getGrant()));
|
|
|
|
}
|
|
|
|
createProjectIfItDoesntExist(newDmp, databaseRepository.getProjectDao());
|
2019-05-31 10:38:04 +02:00
|
|
|
|
2019-03-26 15:52:19 +01:00
|
|
|
newDmp.setGroupId(oldDmp.getGroupId());
|
|
|
|
newDmp.setVersion(oldDmp.getVersion() + 1);
|
|
|
|
newDmp.setId(null);
|
2019-08-29 16:45:47 +02:00
|
|
|
|
|
|
|
checkIfUserCanEditGrant(newDmp, user);
|
2019-09-24 16:40:53 +02:00
|
|
|
assignGrandUserIfInternal(newDmp, user);
|
|
|
|
assignFunderUserIfInternal(newDmp, user);
|
|
|
|
assignProjectUserIfInternal(newDmp, user);
|
2019-08-29 16:45:47 +02:00
|
|
|
databaseRepository.getGrantDao().createOrUpdate(newDmp.getGrant());
|
|
|
|
newDmp = databaseRepository.getDmpDao().createOrUpdate(newDmp);
|
2019-05-31 10:38:04 +02:00
|
|
|
|
|
|
|
// Assign creator.
|
2019-08-29 16:45:47 +02:00
|
|
|
assignUser(newDmp, user);
|
2019-05-31 10:38:04 +02:00
|
|
|
|
2019-08-29 16:45:47 +02:00
|
|
|
copyDatasets(newDmp, databaseRepository.getDatasetDao());
|
2019-03-26 15:52:19 +01:00
|
|
|
} else {
|
|
|
|
throw new DMPNewVersionException("Version to update not the latest.");
|
|
|
|
}
|
2018-02-08 09:42:02 +01:00
|
|
|
}
|
2018-02-07 10:56:30 +01:00
|
|
|
|
2019-08-29 16:45:47 +02:00
|
|
|
public void clone(DataManagementPlanNewVersionModel dataManagementPlan, Principal principal) throws Exception {
|
2018-02-08 16:54:31 +01:00
|
|
|
DMP newDmp = dataManagementPlan.toDataModel();
|
2019-09-30 16:42:01 +02:00
|
|
|
|
2018-03-05 17:18:45 +01:00
|
|
|
UserInfo user = apiContext.getOperationsContext().getBuilderFactory().getBuilder(UserInfoBuilder.class).id(principal.getId()).build();
|
2019-09-30 16:42:01 +02:00
|
|
|
createOrganisationsIfTheyDontExist(newDmp, databaseRepository.getOrganisationDao());
|
|
|
|
createResearchersIfTheyDontExist(newDmp, databaseRepository.getResearcherDao(), user);
|
2019-08-29 16:45:47 +02:00
|
|
|
|
|
|
|
createFunderIfItDoesntExist(newDmp, databaseRepository.getFunderDao());
|
|
|
|
createGrantIfItDoesntExist(newDmp, databaseRepository.getGrantDao());
|
|
|
|
if (newDmp.getProject().getLabel() == null || newDmp.getProject().getLabel().trim().isEmpty()) {
|
|
|
|
newDmp.setProject(newDmp.getProject().projectFromGrant(newDmp.getGrant()));
|
|
|
|
}
|
|
|
|
createProjectIfItDoesntExist(newDmp, databaseRepository.getProjectDao());
|
2019-05-31 10:38:04 +02:00
|
|
|
|
2018-02-08 09:42:02 +01:00
|
|
|
newDmp.setGroupId(UUID.randomUUID());
|
|
|
|
newDmp.setVersion(0);
|
|
|
|
newDmp.setId(null);
|
2019-08-29 16:45:47 +02:00
|
|
|
|
|
|
|
checkIfUserCanEditGrant(newDmp, user);
|
2019-09-24 16:40:53 +02:00
|
|
|
assignGrandUserIfInternal(newDmp, user);
|
|
|
|
assignFunderUserIfInternal(newDmp, user);
|
|
|
|
assignProjectUserIfInternal(newDmp, user);
|
2019-08-29 16:45:47 +02:00
|
|
|
databaseRepository.getGrantDao().createOrUpdate(newDmp.getGrant());
|
|
|
|
newDmp = databaseRepository.getDmpDao().createOrUpdate(newDmp);
|
2019-05-31 10:38:04 +02:00
|
|
|
|
|
|
|
// Assign creator.
|
2019-08-29 16:45:47 +02:00
|
|
|
assignUser(newDmp, user);
|
|
|
|
copyDatasets(newDmp, databaseRepository.getDatasetDao());
|
2018-02-07 10:56:30 +01:00
|
|
|
}
|
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
public void delete(UUID uuid) throws DMPWithDatasetsDeleteException {
|
2019-02-15 16:11:38 +01:00
|
|
|
DatasetCriteria criteria = new DatasetCriteria();
|
|
|
|
List<UUID> dmpIds = Collections.singletonList(uuid);
|
|
|
|
criteria.setDmpIds(dmpIds);
|
2019-06-21 13:04:29 +02:00
|
|
|
if (apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao().getWithCriteria(criteria).toList().size() > 0)
|
2018-11-30 15:57:20 +01:00
|
|
|
throw new DMPWithDatasetsDeleteException("You cannot Remove Datamanagement Plan with Datasets");
|
2019-02-15 16:11:38 +01:00
|
|
|
DMP oldDmp = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(uuid);
|
2018-02-07 10:56:30 +01:00
|
|
|
oldDmp.setStatus(DMP.DMPStatus.DELETED.getValue());
|
2018-03-05 17:18:45 +01:00
|
|
|
apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(oldDmp);
|
2018-01-23 16:21:38 +01:00
|
|
|
}
|
|
|
|
|
2019-09-30 16:42:01 +02:00
|
|
|
private void createResearchersIfTheyDontExist(DMP newDmp, ResearcherDao researcherRepository, UserInfo user) {
|
2018-01-11 17:19:15 +01:00
|
|
|
if (newDmp.getResearchers() != null && !newDmp.getResearchers().isEmpty()) {
|
2018-03-21 11:57:56 +01:00
|
|
|
for (eu.eudat.data.entities.Researcher researcher : newDmp.getResearchers()) {
|
2018-01-11 17:19:15 +01:00
|
|
|
ResearcherCriteria criteria = new ResearcherCriteria();
|
|
|
|
criteria.setLike(researcher.getReference());
|
2018-03-21 11:57:56 +01:00
|
|
|
List<eu.eudat.data.entities.Researcher> entries = researcherRepository.getWithCriteria(criteria).toList();
|
2018-03-28 15:24:47 +02:00
|
|
|
if (entries != null && !entries.isEmpty()) researcher.setId(entries.get(0).getId());
|
2019-09-30 16:42:01 +02:00
|
|
|
else {
|
|
|
|
researcher.setCreationUser(user);
|
|
|
|
researcherRepository.createOrUpdate(researcher);
|
|
|
|
}
|
2018-01-11 17:19:15 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-12-22 09:31:05 +01:00
|
|
|
|
2019-01-29 12:05:36 +01:00
|
|
|
private void createOrganisationsIfTheyDontExist(DMP newDmp, OrganisationDao organisationRepository) {
|
2018-01-11 17:19:15 +01:00
|
|
|
if (newDmp.getOrganisations() != null && !newDmp.getOrganisations().isEmpty()) {
|
2018-03-21 11:57:56 +01:00
|
|
|
for (eu.eudat.data.entities.Organisation organisation : newDmp.getOrganisations()) {
|
2018-01-11 17:19:15 +01:00
|
|
|
OrganisationCriteria criteria = new OrganisationCriteria();
|
|
|
|
criteria.setLike(organisation.getReference());
|
2018-03-21 11:57:56 +01:00
|
|
|
List<eu.eudat.data.entities.Organisation> entries = organisationRepository.getWithCriteria(criteria).toList();
|
2018-01-11 17:19:15 +01:00
|
|
|
if (entries != null && !entries.isEmpty()) organisation.setId(entries.get(0).getId());
|
2019-08-26 15:55:30 +02:00
|
|
|
else organisationRepository.createOrUpdate(organisation);
|
2018-01-11 17:19:15 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-26 15:55:30 +02:00
|
|
|
private void createGrantIfItDoesntExist(DMP newDmp, GrantDao grantDao) {
|
2019-07-31 16:57:34 +02:00
|
|
|
if (newDmp.getGrant() != null) {
|
|
|
|
Grant grant = newDmp.getGrant();
|
|
|
|
GrantCriteria criteria = new GrantCriteria();
|
|
|
|
criteria.setReference(grant.getReference());
|
|
|
|
eu.eudat.data.entities.Grant grantEntity = grantDao.getWithCriteria(criteria).getSingleOrDefault();
|
|
|
|
if (grantEntity != null) grant.setId(grantEntity.getId());
|
2018-01-11 17:19:15 +01:00
|
|
|
else {
|
2019-07-31 16:57:34 +02:00
|
|
|
grant.setType(Grant.GrantType.EXTERNAL.getValue());
|
|
|
|
grantDao.createOrUpdate(grant);
|
2018-01-11 17:19:15 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-02-07 10:56:30 +01:00
|
|
|
|
2019-08-26 15:55:30 +02:00
|
|
|
private void createFunderIfItDoesntExist(DMP newDmp, FunderDao funderDao) {
|
|
|
|
if (newDmp.getGrant().getFunder() != null) {
|
|
|
|
Funder funder = newDmp.getGrant().getFunder();
|
|
|
|
FunderCriteria criteria = new FunderCriteria();
|
|
|
|
criteria.setReference(funder.getReference());
|
|
|
|
eu.eudat.data.entities.Funder funderEntity = funderDao.getWithCritetia(criteria).getSingleOrDefault();
|
|
|
|
if (funderEntity != null) funder.setId(funderEntity.getId());
|
|
|
|
else {
|
|
|
|
funderDao.createOrUpdate(funder);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-02 10:27:12 +02:00
|
|
|
private void createProjectIfItDoesntExist(DMP newDmp, ProjectDao projectDao) {
|
|
|
|
if (newDmp.getProject() != null) {
|
|
|
|
Project project = newDmp.getProject();
|
|
|
|
ProjectCriteria criteria = new ProjectCriteria();
|
|
|
|
criteria.setReference(project.getReference());
|
|
|
|
eu.eudat.data.entities.Project projectEntity = projectDao.getWithCritetia(criteria).getSingleOrDefault();
|
|
|
|
if (projectEntity != null) project.setId(projectEntity.getId());
|
|
|
|
else {
|
|
|
|
project.setType(Project.ProjectType.EXTERNAL.getValue());
|
|
|
|
projectDao.createOrUpdate(project);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-29 16:45:47 +02:00
|
|
|
private void checkIfUserCanEditGrant(DMP dmp, UserInfo user) throws Exception{
|
|
|
|
if (dmp.getGrant().getId() != null) {
|
|
|
|
Grant grant = apiContext.getOperationsContext().getDatabaseRepository().getGrantDao().find(dmp.getGrant().getId());
|
|
|
|
if (grant.getFunder() != null && dmp.getGrant().getFunder() != null
|
|
|
|
&& !grant.getFunder().getId().equals(dmp.getGrant().getFunder().getId())) {
|
|
|
|
if (grant.getCreationUser() == null) {
|
|
|
|
throw new Exception("Grant has no user, therefore, cannot be edited.");
|
|
|
|
}
|
|
|
|
if (!grant.getCreationUser().getId().equals(user.getId())) {
|
|
|
|
throw new Exception("User is not the owner of the Grant, therefore, cannot edit it.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-22 15:48:18 +02:00
|
|
|
private void checkDmpValidationRules(DMP dmp) throws Exception {
|
|
|
|
if (dmp.getLabel() == null || dmp.getLabel().trim().isEmpty()) {
|
|
|
|
throw new Exception("DMP has no label.");
|
|
|
|
}
|
|
|
|
if (dmp.getAssociatedDmps().size() == 0) {
|
|
|
|
throw new Exception("DMP does not contain Dataset Templates.");
|
|
|
|
}
|
|
|
|
if (dmp.getGrant() == null) {
|
|
|
|
throw new Exception("DMP has no Grant assigned.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-24 16:40:53 +02:00
|
|
|
private void assignGrandUserIfInternal(DMP dmp, UserInfo user) {
|
|
|
|
if (dmp.getGrant().getCreationUser() == null && dmp.getGrant().getReference().startsWith("dmp:")) {
|
2019-08-29 16:45:47 +02:00
|
|
|
dmp.getGrant().setCreationUser(user);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-24 16:40:53 +02:00
|
|
|
private void assignFunderUserIfInternal(DMP dmp, UserInfo user) {
|
|
|
|
if (dmp.getGrant().getFunder().getCreationUser() == null && dmp.getGrant().getFunder().getReference().startsWith("dmp:")) {
|
|
|
|
dmp.getGrant().getFunder().setCreationUser(user);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private void assignProjectUserIfInternal(DMP dmp, UserInfo user) {
|
|
|
|
if (dmp.getProject().getCreationUser() == null && dmp.getProject().getReference().startsWith("dmp:")) {
|
|
|
|
dmp.getProject().setCreationUser(user);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-29 12:05:36 +01:00
|
|
|
private void copyDatasets(DMP newDmp, DatasetDao datasetDao) {
|
2018-02-07 10:56:30 +01:00
|
|
|
List<CompletableFuture<Dataset>> futures = new LinkedList<>();
|
|
|
|
for (Dataset dataset : newDmp.getDataset()) {
|
2018-02-09 16:54:41 +01:00
|
|
|
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());
|
2018-05-28 11:50:42 +02:00
|
|
|
if (newDataset.getDatasetDataRepositories() != null) {
|
|
|
|
newDataset.setDatasetDataRepositories(newDataset.getDatasetDataRepositories().stream().map(item -> {
|
2018-02-09 16:54:41 +01:00
|
|
|
DataRepository dataRepository = new DataRepository();
|
|
|
|
dataRepository.setId(item.getId());
|
2018-05-28 11:50:42 +02:00
|
|
|
|
|
|
|
DatasetDataRepository datasetDataRepository = new DatasetDataRepository();
|
|
|
|
datasetDataRepository.setDataRepository(dataRepository);
|
|
|
|
datasetDataRepository.setDataset(newDataset);
|
|
|
|
return datasetDataRepository;
|
2018-02-09 16:54:41 +01:00
|
|
|
}).collect(Collectors.toSet()));
|
|
|
|
}
|
|
|
|
|
2018-05-28 11:50:42 +02:00
|
|
|
if (newDataset.getDatasetExternalDatasets() != null) {
|
|
|
|
newDataset.setDatasetExternalDatasets(newDataset.getDatasetExternalDatasets().stream().map(item -> {
|
2018-02-09 16:54:41 +01:00
|
|
|
ExternalDataset externalDataset = new ExternalDataset();
|
|
|
|
externalDataset.setId(item.getId());
|
2018-05-28 11:50:42 +02:00
|
|
|
DatasetExternalDataset datasetExternalDataset = new DatasetExternalDataset();
|
|
|
|
datasetExternalDataset.setExternalDataset(externalDataset);
|
|
|
|
datasetExternalDataset.setDataset(newDataset);
|
|
|
|
return datasetExternalDataset;
|
2018-02-09 16:54:41 +01:00
|
|
|
}).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());
|
2018-05-28 11:50:42 +02:00
|
|
|
DatasetService datasetService = new DatasetService();
|
|
|
|
datasetService.setService(service);
|
|
|
|
datasetService.setDataset(newDataset);
|
|
|
|
return datasetService;
|
2018-02-09 16:54:41 +01:00
|
|
|
}).collect(Collectors.toSet()));
|
|
|
|
}
|
|
|
|
newDataset.setCreated(new Date());
|
|
|
|
return newDataset;
|
|
|
|
}).thenApplyAsync(item -> {
|
2018-02-07 10:56:30 +01:00
|
|
|
futures.add(datasetDao.createOrUpdateAsync(item));
|
|
|
|
return futures;
|
|
|
|
}).join();
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
2018-10-08 17:14:27 +02:00
|
|
|
|
2019-10-29 12:30:44 +01:00
|
|
|
public FileEnvelope getXmlDocument(String id, Principal principal) throws InstantiationException, IllegalAccessException, IOException {
|
2018-10-08 17:14:27 +02:00
|
|
|
ExportXmlBuilder xmlBuilder = new ExportXmlBuilder();
|
2019-03-05 16:33:59 +01:00
|
|
|
VisibilityRuleService visibilityRuleService = utilitiesService.getVisibilityRuleService();
|
|
|
|
eu.eudat.data.entities.DMP dmp = databaseRepository.getDmpDao().find(UUID.fromString(id));
|
2019-10-29 12:30:44 +01:00
|
|
|
if (!dmp.isPublic() && dmp.getUsers().stream().filter(userInfo -> userInfo.getUser().getId() == principal.getId()).collect(Collectors.toList()).size() == 0)
|
|
|
|
throw new UnauthorisedException();
|
2018-10-08 17:14:27 +02:00
|
|
|
List<Dataset> datasets = dmp.getDataset().stream().collect(Collectors.toList());
|
2019-03-05 12:59:34 +01:00
|
|
|
String fileName = dmp.getLabel();
|
|
|
|
fileName = fileName.replaceAll("[^a-zA-Z0-9+ ]", "");
|
|
|
|
File xmlFile = new File(fileName + ".xml");
|
2018-10-08 17:14:27 +02:00
|
|
|
BufferedWriter writer = new BufferedWriter(new FileWriter(xmlFile, true));
|
|
|
|
Document xmlDoc = XmlBuilder.getDocument();
|
|
|
|
Element dmpElement = xmlDoc.createElement("dmp");
|
2019-03-05 12:59:34 +01:00
|
|
|
Element dmpDescription = xmlDoc.createElement("description");
|
|
|
|
dmpDescription.setTextContent(dmp.getDescription());
|
|
|
|
dmpElement.appendChild(dmpDescription);
|
2018-10-09 10:14:29 +02:00
|
|
|
Element dmpName = xmlDoc.createElement("dmpName");
|
|
|
|
dmpName.setTextContent(dmp.getLabel());
|
|
|
|
dmpElement.appendChild(dmpName);
|
2019-03-05 12:59:34 +01:00
|
|
|
|
|
|
|
DMPProfile dmpProfile = dmp.getProfile();
|
|
|
|
Element dmpProfileElement = xmlDoc.createElement("dmpProfile");
|
|
|
|
Element dmpProfileName = xmlDoc.createElement("dmpProfileName");
|
2019-06-21 13:04:29 +02:00
|
|
|
if (!(dmpProfile == null)) {
|
2019-03-05 12:59:34 +01:00
|
|
|
dmpProfileName.setTextContent(dmpProfile.getLabel());
|
|
|
|
dmpProfileElement.appendChild(dmpProfileName);
|
|
|
|
Element dmpProfileId = xmlDoc.createElement("dmpProfileId");
|
|
|
|
dmpProfileId.setTextContent(dmpProfile.getId().toString());
|
|
|
|
dmpProfileElement.appendChild(dmpProfileId);
|
2019-03-26 15:52:19 +01:00
|
|
|
Element values = xmlDoc.createElement("values");
|
|
|
|
values.setTextContent(dmpProfile.getDefinition());
|
|
|
|
dmpProfileElement.appendChild(values);
|
2019-03-05 12:59:34 +01:00
|
|
|
}
|
|
|
|
dmpElement.appendChild(dmpProfileElement);
|
|
|
|
|
2019-07-31 16:57:34 +02:00
|
|
|
Element grant = xmlDoc.createElement("grant");
|
2019-03-05 12:59:34 +01:00
|
|
|
Element label = xmlDoc.createElement("label");
|
2019-07-31 16:57:34 +02:00
|
|
|
label.setTextContent(dmp.getGrant().getLabel());
|
|
|
|
grant.appendChild(label);
|
|
|
|
Element grantId = xmlDoc.createElement("id");
|
|
|
|
grantId.setTextContent(dmp.getGrant().getId().toString());
|
|
|
|
grant.appendChild(grantId);
|
|
|
|
dmpElement.appendChild(grant);
|
2018-10-09 10:14:29 +02:00
|
|
|
Element organisationsElement = xmlDoc.createElement("organisations");
|
2018-10-11 13:22:03 +02:00
|
|
|
for (Organisation organisation : dmp.getOrganisations()) {
|
2018-10-09 10:14:29 +02:00
|
|
|
Element organisationElement = xmlDoc.createElement("organisation");
|
2019-03-05 12:59:34 +01:00
|
|
|
Element organisationNameElement = xmlDoc.createElement("name");
|
|
|
|
organisationNameElement.setTextContent(organisation.getLabel());
|
|
|
|
Element organisationReferenceElement = xmlDoc.createElement("reference");
|
|
|
|
organisationReferenceElement.setTextContent(organisation.getReference());
|
|
|
|
organisationElement.appendChild(organisationNameElement);
|
|
|
|
organisationElement.appendChild(organisationReferenceElement);
|
2018-10-09 10:14:29 +02:00
|
|
|
organisationsElement.appendChild(organisationElement);
|
|
|
|
}
|
|
|
|
dmpElement.appendChild(organisationsElement);
|
|
|
|
|
|
|
|
Element researchersElement = xmlDoc.createElement("researchers");
|
2018-10-11 13:22:03 +02:00
|
|
|
for (Researcher researcher : dmp.getResearchers()) {
|
2019-03-05 12:59:34 +01:00
|
|
|
Element researcherElement = xmlDoc.createElement("researcher");
|
|
|
|
Element researcherNameElement = xmlDoc.createElement("name");
|
|
|
|
researcherNameElement.setTextContent(researcher.getLabel());
|
|
|
|
Element researcherReferenceElement = xmlDoc.createElement("reference");
|
|
|
|
researcherReferenceElement.setTextContent(researcher.getReference());
|
|
|
|
researcherElement.appendChild(researcherNameElement);
|
|
|
|
researcherElement.appendChild(researcherReferenceElement);
|
|
|
|
researchersElement.appendChild(researcherElement);
|
2018-10-09 10:14:29 +02:00
|
|
|
}
|
|
|
|
dmpElement.appendChild(researchersElement);
|
2018-10-08 17:14:27 +02:00
|
|
|
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();
|
|
|
|
}
|
2019-03-05 16:33:59 +01:00
|
|
|
PagedDatasetProfile pagedDatasetProfile = datasetManager.getPagedProfile(datasetWizardModel, dataset);
|
2018-10-08 17:14:27 +02:00
|
|
|
visibilityRuleService.setProperties(properties);
|
|
|
|
visibilityRuleService.buildVisibilityContext(pagedDatasetProfile.getRules());
|
|
|
|
datasetElement.appendChild(xmlBuilder.createPages(pagedDatasetProfile.getPages(), visibilityRuleService, xmlDoc));
|
|
|
|
datasetsElement.appendChild(datasetElement);
|
|
|
|
}
|
2019-03-05 12:59:34 +01:00
|
|
|
Element profiles = xmlDoc.createElement("profiles");
|
2019-05-28 09:22:58 +02:00
|
|
|
|
|
|
|
// Get DatasetProfiles from DMP to add to XML.
|
|
|
|
for (DatasetProfile datasetProfile : dmp.getAssociatedDmps()) {
|
|
|
|
Element profile = xmlDoc.createElement("profile");
|
|
|
|
Element profileLabel = xmlDoc.createElement("profilelabel");
|
|
|
|
profileLabel.setTextContent(datasetProfile.getLabel());
|
|
|
|
profile.appendChild(profileLabel);
|
|
|
|
Element profileId = xmlDoc.createElement("profileId");
|
|
|
|
profileId.setTextContent(datasetProfile.getId().toString());
|
|
|
|
profile.appendChild(profileId);
|
|
|
|
profiles.appendChild(profile);
|
2019-03-05 12:59:34 +01:00
|
|
|
}
|
|
|
|
dmpElement.appendChild(profiles);
|
2018-10-08 17:14:27 +02:00
|
|
|
dmpElement.appendChild(datasetsElement);
|
2019-03-05 12:59:34 +01:00
|
|
|
xmlDoc.appendChild(dmpElement);
|
2018-10-08 17:14:27 +02:00
|
|
|
String xml = XmlBuilder.generateXml(xmlDoc);
|
|
|
|
writer.write(xml);
|
|
|
|
writer.close();
|
|
|
|
FileEnvelope fileEnvelope = new FileEnvelope();
|
|
|
|
fileEnvelope.setFile(xmlFile);
|
|
|
|
fileEnvelope.setFilename(dmp.getLabel());
|
2019-02-06 11:46:14 +01:00
|
|
|
|
2018-10-08 17:14:27 +02:00
|
|
|
return fileEnvelope;
|
|
|
|
}
|
|
|
|
|
2019-10-29 12:30:44 +01:00
|
|
|
public ResponseEntity<byte[]> getRDAJsonDocument(String id, Principal principal) throws IOException {
|
2019-06-04 16:04:04 +02:00
|
|
|
eu.eudat.data.entities.DMP dmp = databaseRepository.getDmpDao().find(UUID.fromString(id));
|
2019-10-29 12:30:44 +01:00
|
|
|
if (!dmp.isPublic() && dmp.getUsers().stream().filter(userInfo -> userInfo.getUser().getId() == principal.getId()).collect(Collectors.toList()).size() == 0)
|
|
|
|
throw new UnauthorisedException();
|
2019-10-11 15:39:29 +02:00
|
|
|
RDAExportModel rdaExportModel = new RDAExportModel().fromDataModel(dmp);
|
2019-06-04 16:04:04 +02:00
|
|
|
|
|
|
|
ObjectMapper mapper = new ObjectMapper();
|
|
|
|
String fileName = dmp.getLabel();
|
|
|
|
fileName = fileName.replaceAll("[^a-zA-Z0-9+ ]", "");
|
|
|
|
File file = new File(fileName);
|
|
|
|
try {
|
|
|
|
mapper.writeValue(file, rdaExportModel);
|
2019-06-21 13:04:29 +02:00
|
|
|
} catch (IOException e) {
|
2019-06-04 16:04:04 +02:00
|
|
|
e.printStackTrace();
|
|
|
|
}
|
|
|
|
|
|
|
|
InputStream resource = new FileInputStream(file);
|
|
|
|
HttpHeaders responseHeaders = new HttpHeaders();
|
|
|
|
responseHeaders.setContentLength(file.length());
|
|
|
|
responseHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
|
|
|
|
responseHeaders.set("Content-Disposition", "attachment;filename=" + file.getName());
|
|
|
|
responseHeaders.set("Access-Control-Expose-Headers", "Content-Disposition");
|
|
|
|
responseHeaders.get("Access-Control-Expose-Headers").add("Content-Type");
|
|
|
|
|
|
|
|
byte[] content = org.apache.poi.util.IOUtils.toByteArray(resource);
|
|
|
|
resource.close();
|
|
|
|
Files.deleteIfExists(file.toPath());
|
|
|
|
return new ResponseEntity<>(content, responseHeaders, HttpStatus.OK);
|
|
|
|
}
|
|
|
|
|
2019-10-29 12:30:44 +01:00
|
|
|
public ResponseEntity<byte[]> getDocument(String id, String contentType, Principal principal) throws InstantiationException, IllegalAccessException, IOException {
|
2019-02-06 11:46:14 +01:00
|
|
|
File file;
|
2019-06-21 13:04:29 +02:00
|
|
|
switch (contentType) {
|
2019-02-06 11:46:14 +01:00
|
|
|
case "application/xml":
|
2019-10-29 12:30:44 +01:00
|
|
|
file = getXmlDocument(id, principal).getFile();
|
2019-02-06 11:46:14 +01:00
|
|
|
break;
|
|
|
|
case "application/msword":
|
2019-10-29 12:30:44 +01:00
|
|
|
file = getWordDocument(id, principal);
|
2019-02-06 11:46:14 +01:00
|
|
|
break;
|
|
|
|
default:
|
2019-10-29 12:30:44 +01:00
|
|
|
file = getXmlDocument(id, principal).getFile();
|
2019-02-06 11:46:14 +01:00
|
|
|
}
|
|
|
|
InputStream resource = new FileInputStream(file);
|
|
|
|
HttpHeaders responseHeaders = new HttpHeaders();
|
|
|
|
responseHeaders.setContentLength(file.length());
|
|
|
|
responseHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
|
|
|
|
responseHeaders.set("Content-Disposition", "attachment;filename=" + file.getName());
|
|
|
|
responseHeaders.set("Access-Control-Expose-Headers", "Content-Disposition");
|
|
|
|
responseHeaders.get("Access-Control-Expose-Headers").add("Content-Type");
|
|
|
|
|
|
|
|
byte[] content = org.apache.poi.util.IOUtils.toByteArray(resource);
|
|
|
|
resource.close();
|
|
|
|
Files.deleteIfExists(file.toPath());
|
|
|
|
return new ResponseEntity<>(content,
|
|
|
|
responseHeaders,
|
|
|
|
HttpStatus.OK);
|
|
|
|
}
|
2019-03-05 12:59:34 +01:00
|
|
|
|
2019-06-21 13:04:29 +02:00
|
|
|
public List<DmpImportModel> createDmpFromXml(ApiContext apiContext, MultipartFile[] files, Principal principal) throws IOException, JAXBException, Exception {
|
2019-03-05 12:59:34 +01:00
|
|
|
List<DmpImportModel> dataManagementPlans = new ArrayList<>();
|
|
|
|
// Jaxb approach.
|
|
|
|
JAXBContext jaxbContext;
|
|
|
|
|
2019-06-21 13:04:29 +02:00
|
|
|
for (MultipartFile multipartFile : Arrays.asList(files)) { // Gets one item from the array.
|
|
|
|
try {
|
2019-03-05 12:59:34 +01:00
|
|
|
InputStream in = multipartFile.getInputStream(); // Transforms item to InputStream.
|
|
|
|
jaxbContext = JAXBContext.newInstance(DmpImportModel.class);
|
|
|
|
Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
|
2019-06-21 13:04:29 +02:00
|
|
|
DmpImportModel dmpImportModel = (DmpImportModel) jaxbUnmarshaller.unmarshal(in);
|
2019-03-05 12:59:34 +01:00
|
|
|
dataManagementPlans.add(dmpImportModel);
|
2019-06-21 13:04:29 +02:00
|
|
|
} catch (IOException | JAXBException ex) {
|
2019-03-05 12:59:34 +01:00
|
|
|
ex.printStackTrace();
|
|
|
|
}
|
2019-10-30 13:30:31 +01:00
|
|
|
// TODO Iterate through the list of dataManagementPlans.
|
|
|
|
// Creates new dataManagementPlan to fill it with the data model that was parsed from the xml.
|
2019-03-05 12:59:34 +01:00
|
|
|
// Creates properties.
|
|
|
|
DataManagementPlan dm = new DataManagementPlan();
|
2019-03-26 15:52:19 +01:00
|
|
|
DataManagementPlanProfile dmpProfile = new DataManagementPlanProfile();
|
|
|
|
|
|
|
|
List<Field> fieldList = new LinkedList<>();
|
|
|
|
Field field = new Field();
|
|
|
|
field.setLabel(dataManagementPlans.get(0).getDmpProfile().getDmpProfileName());
|
|
|
|
field.setId(dataManagementPlans.get(0).getDmpProfile().getDmpProfileId());
|
|
|
|
|
|
|
|
fieldList.add(field);
|
|
|
|
dmpProfile.setFields(fieldList);
|
|
|
|
|
|
|
|
/*Tuple tuple = new Tuple();
|
2019-03-05 12:59:34 +01:00
|
|
|
tuple.setId(dataManagementPlans.get(0).getDmpProfile().getDmpProfileId());
|
2019-03-26 15:52:19 +01:00
|
|
|
tuple.setLabel(dataManagementPlans.get(0).getDmpProfile().getDmpProfileName());*/
|
2019-07-31 16:57:34 +02:00
|
|
|
eu.eudat.models.data.grant.Grant grant = new eu.eudat.models.data.grant.Grant();
|
|
|
|
GrantImportModels grantImport = dataManagementPlans.get(0).getGrantImport();
|
|
|
|
grant.setId(grantImport.getId());
|
|
|
|
grant.setLabel(grantImport.getLabel());
|
|
|
|
grant.setAbbreviation(grantImport.getAbbreviation());
|
|
|
|
grant.setDescription(grantImport.getDescription());
|
2019-03-05 12:59:34 +01:00
|
|
|
List<eu.eudat.models.data.dmp.AssociatedProfile> associatedProfiles = new LinkedList<>();
|
2019-06-21 13:04:29 +02:00
|
|
|
for (AssociatedProfileImportModels a : dataManagementPlans.get(0).getProfilesImportModels()) {
|
2019-03-05 12:59:34 +01:00
|
|
|
AssociatedProfile associatedProfile = new AssociatedProfile();
|
|
|
|
associatedProfile.setId(a.getId());
|
|
|
|
associatedProfile.setLabel(a.getLabel());
|
|
|
|
associatedProfiles.add(associatedProfile);
|
|
|
|
}
|
2019-06-21 13:04:29 +02:00
|
|
|
List<eu.eudat.models.data.dmp.Organisation> organisations = new ArrayList<>();
|
|
|
|
for (OrganisationImportModel org : dataManagementPlans.get(0).getOrganisationImportModels()) {
|
2019-03-06 16:35:56 +01:00
|
|
|
eu.eudat.models.data.dmp.Organisation organisation = new eu.eudat.models.data.dmp.Organisation();
|
|
|
|
organisation.setLabel(org.getOrganaisationNameImport());
|
|
|
|
organisation.setId(org.getOrganaisationReferenceImport());
|
|
|
|
organisations.add(organisation);
|
|
|
|
}
|
2019-03-05 12:59:34 +01:00
|
|
|
List<eu.eudat.models.data.dmp.Researcher> researchers = new LinkedList<>();
|
2019-06-21 13:04:29 +02:00
|
|
|
for (ResearcherImportModels res : dataManagementPlans.get(0).getResearchersImportModels()) {
|
2019-03-06 16:35:56 +01:00
|
|
|
eu.eudat.models.data.dmp.Researcher researcher = new eu.eudat.models.data.dmp.Researcher();
|
|
|
|
researcher.setLabel(res.getResearcherImportName());
|
|
|
|
researcher.setId(res.getResearcherImportReference());
|
|
|
|
researchers.add(researcher);
|
|
|
|
}
|
|
|
|
|
2019-05-10 10:33:48 +02:00
|
|
|
List<UserListingModel> associatedUsers = new LinkedList<>();
|
2019-03-05 12:59:34 +01:00
|
|
|
List<DynamicFieldWithValue> dynamicFields = new LinkedList<>();
|
|
|
|
|
|
|
|
// Sets properties.
|
|
|
|
dm.setLabel(files[0].getOriginalFilename()); // Sets label.
|
2019-07-31 16:57:34 +02:00
|
|
|
dm.setGrant(grant); //Sets grant property.
|
2019-03-05 12:59:34 +01:00
|
|
|
dm.setDescription(dataManagementPlans.get(0).getDescriptionImport()); // Sets description property.
|
|
|
|
dm.setProfiles(associatedProfiles);
|
|
|
|
dm.setOrganisations(organisations); // Sets organisations property.
|
|
|
|
dm.setResearchers(researchers); // Sets researchers property.
|
|
|
|
dm.setAssociatedUsers(associatedUsers); // Sets associatedUsers property.
|
|
|
|
dm.setDynamicFields(dynamicFields); // Sets dynamicFields property.
|
2019-03-26 15:52:19 +01:00
|
|
|
dm.setDefinition(dmpProfile);
|
2019-03-05 12:59:34 +01:00
|
|
|
|
2019-06-13 09:32:45 +02:00
|
|
|
//createOrUpdate(apiContext, dm, principal);
|
2019-03-05 12:59:34 +01:00
|
|
|
|
|
|
|
System.out.println(dm);
|
|
|
|
}
|
|
|
|
|
|
|
|
return dataManagementPlans;
|
|
|
|
}
|
2019-06-12 11:13:50 +02:00
|
|
|
|
|
|
|
public DataTableData<DatasetProfileListingModel> getDatasetProfilesUsedByDMP(DatasetProfileTableRequestItem datasetProfileTableRequestItem, Principal principal) {
|
|
|
|
datasetProfileTableRequestItem.getCriteria().setFilter(DatasetProfileCriteria.DatasetProfileFilter.DMPs.getValue());
|
|
|
|
datasetProfileTableRequestItem.getCriteria().setUserId(principal.getId());
|
|
|
|
|
|
|
|
QueryableList<DatasetProfile> items = apiContext.getOperationsContext().getDatabaseRepository().getDatasetProfileDao().getWithCriteria(datasetProfileTableRequestItem.getCriteria());
|
|
|
|
List<DatasetProfileListingModel> listingModels = items.select(item -> new DatasetProfileListingModel().fromDataModel(item));
|
|
|
|
|
|
|
|
DataTableData<DatasetProfileListingModel> data = new DataTableData<>();
|
|
|
|
data.setData(listingModels);
|
|
|
|
data.setTotalCount((long) listingModels.size());
|
|
|
|
|
|
|
|
return data;
|
|
|
|
}
|
2019-06-20 15:25:49 +02:00
|
|
|
|
|
|
|
public void makePublic(UUID id, Principal principal) throws Exception {
|
|
|
|
DMP dmp = this.apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(id);
|
|
|
|
// Check if dmp is finalized and if user is owner.
|
2019-06-28 14:58:25 +02:00
|
|
|
if (!isUserOwnerOfDmp(dmp, principal))
|
2019-06-20 15:25:49 +02:00
|
|
|
throw new Exception("User does not have the privilege to do this action.");
|
|
|
|
if (!dmp.getStatus().equals(DMP.DMPStatus.FINALISED.getValue()))
|
|
|
|
throw new Exception("DMP is not finalized");
|
|
|
|
dmp.setPublic(true);
|
|
|
|
apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(dmp);
|
|
|
|
}
|
2019-06-28 14:58:25 +02:00
|
|
|
|
|
|
|
public void makeFinalize(UUID id, Principal principal, DatasetsToBeFinalized datasetsToBeFinalized) throws Exception {
|
|
|
|
DMP dmp = this.apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(id);
|
|
|
|
if (!isUserOwnerOfDmp(dmp, principal))
|
|
|
|
throw new Exception("User does not have the privilege to do this action.");
|
|
|
|
if (dmp.getStatus().equals(DMP.DMPStatus.FINALISED.getValue()))
|
|
|
|
throw new Exception("DMP is already finalized");
|
|
|
|
dmp.setStatus(DMP.DMPStatus.FINALISED.getValue());
|
|
|
|
apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(dmp);
|
|
|
|
if (datasetsToBeFinalized != null && datasetsToBeFinalized.getUuids() != null && !datasetsToBeFinalized.getUuids().isEmpty()) {
|
|
|
|
apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao()
|
|
|
|
.asQueryable().where((builder, root) -> root.get("id").in(datasetsToBeFinalized.getUuids()))
|
|
|
|
.update(root -> root.<Integer>get("status"), Dataset.Status.FINALISED.getValue());
|
|
|
|
List<UUID> datasetsToBeCanceled = new LinkedList<>();
|
|
|
|
for (Dataset dataset : dmp.getDataset()) {
|
|
|
|
if (!dataset.getStatus().equals(Dataset.Status.FINALISED.getValue()) && !datasetsToBeFinalized.getUuids().contains(dataset.getId())) {
|
|
|
|
datasetsToBeCanceled.add(dataset.getId());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!datasetsToBeCanceled.isEmpty())
|
|
|
|
apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao()
|
|
|
|
.asQueryable().where((builder, root) -> root.get("id").in(datasetsToBeCanceled))
|
|
|
|
.update(root -> root.<Integer>get("status"), Dataset.Status.CANCELED.getValue());
|
|
|
|
} else {
|
|
|
|
List<UUID> datasetsToBeCanceled = new LinkedList<>();
|
|
|
|
for (Dataset dataset : dmp.getDataset()) {
|
|
|
|
if (!dataset.getStatus().equals(Dataset.Status.FINALISED.getValue())) {
|
|
|
|
datasetsToBeCanceled.add(dataset.getId());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!datasetsToBeCanceled.isEmpty())
|
|
|
|
apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao()
|
|
|
|
.asQueryable().where((builder, root) -> root.get("id").in(datasetsToBeCanceled))
|
|
|
|
.update(root -> root.<Integer>get("status"), Dataset.Status.CANCELED.getValue());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private boolean isUserOwnerOfDmp(DMP dmp, Principal principal) {
|
|
|
|
return (dmp.getUsers().stream().filter(userDMP -> userDMP.getRole().equals(UserDMP.UserDMPRoles.OWNER.getValue())).findFirst().get().getUser().getId()).equals(principal.getId());
|
|
|
|
}
|
2019-07-04 16:30:15 +02:00
|
|
|
|
|
|
|
public String createZenodoDoi(UUID id, Principal principal) throws Exception {
|
|
|
|
DMP dmp = this.apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(id);
|
|
|
|
if (!isUserOwnerOfDmp(dmp, principal))
|
|
|
|
throw new Exception("User is not authorized to invoke this action");
|
|
|
|
if (!dmp.getStatus().equals(DMP.DMPStatus.FINALISED.getValue()))
|
|
|
|
throw new Exception("DMP is not finalized");
|
2019-08-21 16:31:33 +02:00
|
|
|
if (dmp.getDoi() != null)
|
2019-07-05 13:19:43 +02:00
|
|
|
throw new Exception("DMP already has a DOI");
|
2019-07-04 16:30:15 +02:00
|
|
|
|
|
|
|
// First step, post call to Zenodo, to create the entry.
|
|
|
|
RestTemplate restTemplate = new RestTemplate();
|
|
|
|
HttpHeaders headers = new HttpHeaders();
|
|
|
|
headers.set("accept", "application/json");
|
|
|
|
headers.setContentType(MediaType.APPLICATION_JSON);
|
|
|
|
String createData = "{\n" +
|
|
|
|
" \"metadata\": {\n" +
|
|
|
|
" \"title\": \"" + dmp.getLabel() + "\",\n" +
|
|
|
|
" \"upload_type\": \"publication\",\n" +
|
|
|
|
" \"publication_type\": \"datamanagementplan\",\n" +
|
|
|
|
" \"description\": \"" + dmp.getDescription() + "\",\n" +
|
|
|
|
" \"creators\": [{\n" +
|
2019-08-21 16:31:33 +02:00
|
|
|
" \t\t\"name\": \"" + dmp.getUsers().stream().filter(userDMP -> userDMP.getRole().equals(UserDMP.UserDMPRoles.OWNER.getValue())).findFirst().get().getUser().getName() + "\",\n" +
|
2019-07-04 16:30:15 +02:00
|
|
|
" \t\t\"affiliation\": \"OpenDMP\"}]\n" +
|
|
|
|
" }\n" +
|
|
|
|
"}";
|
|
|
|
HttpEntity<String> request = new HttpEntity<>(createData, headers);
|
|
|
|
String createUrl = this.environment.getProperty("zenodo.url") + "deposit/depositions" + "?access_token=" + this.environment.getProperty("zenodo.access_token");
|
|
|
|
Map createResponse = restTemplate.postForObject(createUrl, request, Map.class);
|
|
|
|
|
|
|
|
// Second step, add the file to the entry.
|
|
|
|
HttpHeaders fileHeaders = new HttpHeaders();
|
|
|
|
fileHeaders.setContentType(MediaType.MULTIPART_FORM_DATA);
|
|
|
|
LinkedMultiValueMap<String, Object> addFileMap = new LinkedMultiValueMap<>();
|
|
|
|
|
2019-10-29 12:30:44 +01:00
|
|
|
File file = getWordDocument(id.toString(), principal);
|
2019-07-04 16:30:15 +02:00
|
|
|
addFileMap.add("filename", file.getName());
|
|
|
|
FileSystemResource fileSystemResource = new FileSystemResource(file);
|
|
|
|
addFileMap.add("file", fileSystemResource);
|
|
|
|
HttpEntity<MultiValueMap<String, Object>> addFileMapRequest = new HttpEntity<>(addFileMap, fileHeaders);
|
|
|
|
|
|
|
|
LinkedHashMap<String, String> links = (LinkedHashMap<String, String>) createResponse.get("links");
|
|
|
|
String addFileUrl = links.get("files") + "?access_token=" + this.environment.getProperty("zenodo.access_token");
|
|
|
|
ResponseEntity<String> addFileResponse = restTemplate.postForEntity(addFileUrl, addFileMapRequest, String.class);
|
|
|
|
Files.deleteIfExists(file.toPath());
|
|
|
|
|
|
|
|
// Third post call to Zenodo to publish the entry and return the DOI.
|
|
|
|
String publishUrl = links.get("publish") + "?access_token=" + this.environment.getProperty("zenodo.access_token");
|
|
|
|
Map<String, Object> publishResponce = restTemplate.postForObject(publishUrl, "", Map.class);
|
|
|
|
|
2019-07-05 13:21:33 +02:00
|
|
|
dmp.setDoi((String) publishResponce.get("conceptdoi"));
|
|
|
|
apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(dmp);
|
2019-07-04 16:30:15 +02:00
|
|
|
return (String) publishResponce.get("conceptdoi");
|
|
|
|
}
|
2017-12-15 00:01:26 +01:00
|
|
|
}
|