2018-06-27 12:29:21 +02:00
|
|
|
package eu.eudat.logic.managers;
|
2017-12-15 13:25:21 +01:00
|
|
|
|
2018-07-11 15:47:36 +02:00
|
|
|
import eu.eudat.data.dao.criteria.DataRepositoryCriteria;
|
|
|
|
import eu.eudat.data.dao.criteria.ExternalDatasetCriteria;
|
|
|
|
import eu.eudat.data.dao.criteria.RegistryCriteria;
|
|
|
|
import eu.eudat.data.dao.criteria.ServiceCriteria;
|
2018-03-21 11:57:56 +01:00
|
|
|
import eu.eudat.data.dao.entities.*;
|
2018-05-28 11:50:42 +02:00
|
|
|
import eu.eudat.data.entities.*;
|
2018-10-02 16:33:58 +02:00
|
|
|
import eu.eudat.data.query.items.table.dataset.DatasetPublicTableRequest;
|
2018-07-11 15:47:36 +02:00
|
|
|
import eu.eudat.data.query.items.table.dataset.DatasetTableRequest;
|
|
|
|
import eu.eudat.elastic.criteria.DatasetCriteria;
|
|
|
|
import eu.eudat.elastic.repository.DatasetRepository;
|
2019-03-05 16:33:59 +01:00
|
|
|
import eu.eudat.logic.builders.BuilderFactory;
|
2018-07-11 15:47:36 +02:00
|
|
|
import eu.eudat.logic.builders.entity.UserInfoBuilder;
|
|
|
|
import eu.eudat.logic.services.ApiContext;
|
|
|
|
import eu.eudat.logic.services.forms.VisibilityRuleService;
|
2019-03-05 16:33:59 +01:00
|
|
|
import eu.eudat.logic.services.operations.DatabaseRepository;
|
2018-06-27 12:29:21 +02:00
|
|
|
import eu.eudat.logic.utilities.documents.helpers.FileEnvelope;
|
|
|
|
import eu.eudat.logic.utilities.documents.word.WordBuilder;
|
|
|
|
import eu.eudat.logic.utilities.documents.xml.ExportXmlBuilder;
|
2018-01-19 10:31:05 +01:00
|
|
|
import eu.eudat.models.HintedModelFactory;
|
2018-06-27 12:29:21 +02:00
|
|
|
import eu.eudat.models.data.datasetwizard.DatasetWizardModel;
|
|
|
|
import eu.eudat.models.data.helpers.common.DataTableData;
|
|
|
|
import eu.eudat.models.data.listingmodels.DatasetListingModel;
|
|
|
|
import eu.eudat.models.data.security.Principal;
|
|
|
|
import eu.eudat.models.data.user.composite.PagedDatasetProfile;
|
2017-12-17 22:34:24 +01:00
|
|
|
import eu.eudat.queryable.QueryableList;
|
2018-03-05 17:18:45 +01:00
|
|
|
import org.apache.commons.io.IOUtils;
|
2018-10-18 11:33:13 +02:00
|
|
|
import org.apache.poi.xwpf.usermodel.XWPFDocument;
|
2017-12-22 14:42:47 +01:00
|
|
|
import org.json.JSONObject;
|
2019-03-05 16:33:59 +01:00
|
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
2018-03-05 17:18:45 +01:00
|
|
|
import org.springframework.core.env.Environment;
|
|
|
|
import org.springframework.core.io.FileSystemResource;
|
|
|
|
import org.springframework.http.*;
|
|
|
|
import org.springframework.http.converter.ByteArrayHttpMessageConverter;
|
2019-01-31 16:53:37 +01:00
|
|
|
import org.springframework.stereotype.Component;
|
2018-03-05 17:18:45 +01:00
|
|
|
import org.springframework.util.LinkedMultiValueMap;
|
|
|
|
import org.springframework.web.client.RestTemplate;
|
2017-12-15 13:25:21 +01:00
|
|
|
|
2019-02-06 11:48:05 +01:00
|
|
|
import javax.activation.MimetypesFileTypeMap;
|
2018-10-18 11:33:13 +02:00
|
|
|
import java.io.*;
|
|
|
|
import java.net.URL;
|
2019-02-06 11:48:05 +01:00
|
|
|
import java.nio.file.Files;
|
2018-10-18 11:33:13 +02:00
|
|
|
import java.nio.file.Paths;
|
2018-03-05 17:18:45 +01:00
|
|
|
import java.util.*;
|
2018-02-07 10:56:30 +01:00
|
|
|
import java.util.concurrent.CompletableFuture;
|
2018-07-11 15:47:36 +02:00
|
|
|
import java.util.stream.Collectors;
|
2018-03-05 17:18:45 +01:00
|
|
|
import java.util.zip.ZipEntry;
|
|
|
|
import java.util.zip.ZipInputStream;
|
2017-12-15 13:25:21 +01:00
|
|
|
|
2019-01-31 16:53:37 +01:00
|
|
|
@Component
|
2017-12-15 13:25:21 +01:00
|
|
|
public class DatasetManager {
|
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
private ApiContext apiContext;
|
|
|
|
private DatabaseRepository databaseRepository;
|
|
|
|
private DatasetRepository datasetRepository;
|
|
|
|
private BuilderFactory builderFactory;
|
|
|
|
private UserManager userManager;
|
2019-03-05 17:08:38 +01:00
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
@Autowired
|
|
|
|
public DatasetManager(ApiContext apiContext, UserManager userManager) {
|
|
|
|
this.apiContext = apiContext;
|
|
|
|
this.databaseRepository = apiContext.getOperationsContext().getDatabaseRepository();
|
|
|
|
this.datasetRepository = apiContext.getOperationsContext().getDatasetRepository();
|
|
|
|
this.builderFactory = apiContext.getOperationsContext().getBuilderFactory();
|
|
|
|
this.userManager = userManager;
|
|
|
|
}
|
|
|
|
|
|
|
|
public DataTableData<DatasetListingModel> getPaged(DatasetTableRequest datasetTableRequest, Principal principal) throws Exception {
|
2018-07-11 15:47:36 +02:00
|
|
|
DatasetCriteria datasetCriteria = new DatasetCriteria();
|
|
|
|
datasetCriteria.setTags(datasetTableRequest.getCriteria().getTags());
|
2019-02-04 10:37:42 +01:00
|
|
|
List<eu.eudat.elastic.entities.Dataset> datasets;
|
|
|
|
try {
|
2019-03-05 16:33:59 +01:00
|
|
|
datasets = datasetCriteria.getTags() != null && datasetCriteria.getTags().size() > 0 && datasetRepository.exists() ?
|
|
|
|
datasetRepository.query(datasetCriteria) : new LinkedList<>();
|
2019-02-04 10:37:42 +01:00
|
|
|
}
|
|
|
|
catch (Exception ex){
|
|
|
|
datasets = null;
|
|
|
|
}
|
2018-07-11 15:47:36 +02:00
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
UserInfo userInfo = builderFactory.getBuilder(UserInfoBuilder.class).id(principal.getId()).build();
|
|
|
|
QueryableList<eu.eudat.data.entities.Dataset> items = databaseRepository.getDatasetDao().getWithCriteria(datasetTableRequest.getCriteria()).withHint(HintedModelFactory.getHint(DatasetListingModel.class));
|
2019-02-04 10:37:42 +01:00
|
|
|
if (datasets != null && datasetTableRequest.getCriteria().getTags() != null && !datasetTableRequest.getCriteria().getTags().isEmpty()) {
|
|
|
|
if (!datasets.isEmpty()){
|
|
|
|
List<eu.eudat.elastic.entities.Dataset> finalDatasets = datasets;
|
|
|
|
items.where((builder, root) -> root.get("id").in(finalDatasets.stream().map(x -> UUID.fromString(x.getId())).collect(Collectors.toList())));
|
|
|
|
}
|
2018-07-11 15:47:36 +02:00
|
|
|
else
|
|
|
|
items.where((builder, root) -> root.get("id").in(new UUID[]{UUID.randomUUID()}));
|
|
|
|
}
|
2019-03-05 16:33:59 +01:00
|
|
|
QueryableList<eu.eudat.data.entities.Dataset> authItems = databaseRepository.getDatasetDao().getAuthenticated(items, userInfo);
|
2018-03-21 11:57:56 +01:00
|
|
|
QueryableList<eu.eudat.data.entities.Dataset> pagedItems = PaginationManager.applyPaging(authItems, datasetTableRequest);
|
2017-12-19 17:22:30 +01:00
|
|
|
DataTableData<DatasetListingModel> dataTable = new DataTableData<DatasetListingModel>();
|
2018-02-07 10:56:30 +01:00
|
|
|
|
2018-03-19 13:40:04 +01:00
|
|
|
|
|
|
|
CompletableFuture<List<DatasetListingModel>> itemsFuture = pagedItems.
|
2018-02-21 11:07:31 +01:00
|
|
|
selectAsync(item -> new DatasetListingModel().fromDataModel(item)).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);
|
|
|
|
});
|
|
|
|
|
2018-02-08 16:54:31 +01:00
|
|
|
CompletableFuture.allOf(itemsFuture, countFuture).join();
|
2017-12-15 13:25:21 +01:00
|
|
|
return dataTable;
|
|
|
|
}
|
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
public DataTableData<DatasetListingModel> getPaged(DatasetPublicTableRequest datasetTableRequest, Principal principal) throws Exception {
|
2018-10-15 12:17:54 +02:00
|
|
|
DatasetCriteria datasetCriteria = new DatasetCriteria();
|
|
|
|
datasetCriteria.setTags(datasetTableRequest.getCriteria().getTags());
|
2019-02-04 10:37:42 +01:00
|
|
|
List<eu.eudat.elastic.entities.Dataset> datasets;
|
|
|
|
try{
|
2019-03-05 16:33:59 +01:00
|
|
|
datasets = datasetCriteria.getTags() != null && datasetCriteria.getTags().size() > 0 && datasetRepository.exists() ?
|
|
|
|
datasetRepository.query(datasetCriteria) : new LinkedList<>();
|
2019-02-04 10:37:42 +01:00
|
|
|
}
|
|
|
|
catch (Exception ex){
|
|
|
|
datasets = null;
|
|
|
|
}
|
2019-03-05 16:33:59 +01:00
|
|
|
datasetTableRequest.setQuery(databaseRepository.getDatasetDao().asQueryable().withHint(HintedModelFactory.getHint(DatasetListingModel.class)));
|
2018-10-15 12:17:54 +02:00
|
|
|
QueryableList<Dataset> items = datasetTableRequest.applyCriteria();
|
2019-02-04 10:37:42 +01:00
|
|
|
if (datasets != null && datasetTableRequest.getCriteria().getTags() != null && !datasetTableRequest.getCriteria().getTags().isEmpty()) {
|
|
|
|
if (!datasets.isEmpty()) {
|
|
|
|
List<eu.eudat.elastic.entities.Dataset> finalDatasets = datasets;
|
|
|
|
items.where((builder, root) -> root.get("id").in(finalDatasets.stream().map(x -> UUID.fromString(x.getId())).collect(Collectors.toList())));
|
|
|
|
}
|
2018-10-15 12:17:54 +02:00
|
|
|
else
|
|
|
|
items.where((builder, root) -> root.get("id").in(new UUID[]{UUID.randomUUID()}));
|
|
|
|
}
|
2018-10-18 11:33:13 +02:00
|
|
|
QueryableList<eu.eudat.data.entities.Dataset> pagedItems = PaginationManager.applyPaging(items, datasetTableRequest);
|
2018-10-05 08:56:50 +02:00
|
|
|
DataTableData<DatasetListingModel> dataTable = new DataTableData<>();
|
2018-10-02 16:33:58 +02:00
|
|
|
|
|
|
|
CompletableFuture<List<DatasetListingModel>> itemsFuture = pagedItems.
|
|
|
|
selectAsync(item -> new DatasetListingModel().fromDataModel(item)).whenComplete((resultList, throwable) -> {
|
|
|
|
dataTable.setData(resultList);
|
|
|
|
});
|
|
|
|
|
|
|
|
CompletableFuture countFuture = pagedItems.countAsync().whenComplete((count, throwable) -> {
|
|
|
|
dataTable.setTotalCount(count);
|
|
|
|
});
|
|
|
|
|
|
|
|
CompletableFuture.allOf(itemsFuture, countFuture).join();
|
|
|
|
return dataTable;
|
|
|
|
}
|
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
public DatasetWizardModel getSingle(String id) throws InstantiationException, IllegalAccessException, IOException {
|
2017-12-22 14:42:47 +01:00
|
|
|
DatasetWizardModel dataset = new DatasetWizardModel();
|
2019-03-05 16:33:59 +01:00
|
|
|
eu.eudat.data.entities.Dataset datasetEntity = databaseRepository.getDatasetDao().find(UUID.fromString(id), HintedModelFactory.getHint(DatasetWizardModel.class));
|
2019-02-04 10:37:42 +01:00
|
|
|
eu.eudat.elastic.entities.Dataset datasetElastic;
|
|
|
|
try{
|
2019-03-05 16:33:59 +01:00
|
|
|
datasetElastic = datasetRepository.exists() ?
|
|
|
|
datasetRepository.findDocument(id) : new eu.eudat.elastic.entities.Dataset();
|
2019-02-04 10:37:42 +01:00
|
|
|
}
|
|
|
|
catch (Exception ex){
|
|
|
|
datasetElastic = new eu.eudat.elastic.entities.Dataset();
|
|
|
|
}
|
2018-03-01 10:14:10 +01:00
|
|
|
dataset.setDatasetProfileDefinition(getPagedProfile(dataset, datasetEntity));
|
|
|
|
dataset.fromDataModel(datasetEntity);
|
2018-07-11 15:47:36 +02:00
|
|
|
dataset.setTags(datasetElastic.getTags());
|
2018-03-01 10:14:10 +01:00
|
|
|
return dataset;
|
|
|
|
}
|
|
|
|
|
2018-10-08 17:14:27 +02:00
|
|
|
public PagedDatasetProfile getPagedProfile(DatasetWizardModel dataset, eu.eudat.data.entities.Dataset datasetEntity) {
|
2019-03-05 16:33:59 +01:00
|
|
|
eu.eudat.models.data.user.composite.DatasetProfile datasetprofile = userManager.generateDatasetProfileModel(datasetEntity.getProfile());
|
2017-12-22 14:42:47 +01:00
|
|
|
datasetprofile.setStatus(dataset.getStatus());
|
2018-01-19 12:11:22 +01:00
|
|
|
if (datasetEntity.getProperties() != null) {
|
2018-01-09 12:31:01 +01:00
|
|
|
JSONObject jobject = new JSONObject(datasetEntity.getProperties());
|
2018-07-11 15:47:36 +02:00
|
|
|
Map<String, Object> properties = jobject.toMap();
|
2017-12-22 14:42:47 +01:00
|
|
|
datasetprofile.fromJsonObject(properties);
|
|
|
|
}
|
2018-01-19 10:31:05 +01:00
|
|
|
PagedDatasetProfile pagedDatasetProfile = new PagedDatasetProfile();
|
|
|
|
pagedDatasetProfile.buildPagedDatasetProfile(datasetprofile);
|
2018-03-01 10:14:10 +01:00
|
|
|
return pagedDatasetProfile;
|
|
|
|
}
|
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
public File getWordDocument(Environment environment, String id, VisibilityRuleService visibilityRuleService) throws InstantiationException, IllegalAccessException, IOException {
|
2018-03-01 10:14:10 +01:00
|
|
|
WordBuilder wordBuilder = new WordBuilder();
|
|
|
|
DatasetWizardModel dataset = new DatasetWizardModel();
|
2018-10-18 11:33:13 +02:00
|
|
|
String fileUrl = environment.getProperty("configuration.h2020template");
|
|
|
|
InputStream is = new URL(Paths.get(fileUrl).toUri().toURL().toString()).openStream();
|
|
|
|
XWPFDocument document = new XWPFDocument(is);
|
2019-03-05 16:33:59 +01:00
|
|
|
eu.eudat.data.entities.Dataset datasetEntity = databaseRepository.getDatasetDao().find(UUID.fromString(id), HintedModelFactory.getHint(DatasetWizardModel.class));
|
2018-03-05 17:18:45 +01:00
|
|
|
Map<String, Object> properties = new HashMap<>();
|
|
|
|
if (datasetEntity.getProperties() != null) {
|
|
|
|
JSONObject jobject = new JSONObject(datasetEntity.getProperties());
|
2018-03-06 15:58:38 +01:00
|
|
|
properties = jobject.toMap();
|
2018-03-05 17:18:45 +01:00
|
|
|
}
|
|
|
|
PagedDatasetProfile pagedDatasetProfile = getPagedProfile(dataset, datasetEntity);
|
|
|
|
visibilityRuleService.setProperties(properties);
|
|
|
|
visibilityRuleService.buildVisibilityContext(pagedDatasetProfile.getRules());
|
2018-10-18 11:33:13 +02:00
|
|
|
wordBuilder.build(document, pagedDatasetProfile, visibilityRuleService);
|
|
|
|
File exportFile = new File(datasetEntity.getLabel() + ".docx");
|
|
|
|
FileOutputStream out = new FileOutputStream(exportFile);
|
|
|
|
document.write(out);
|
|
|
|
out.close();
|
|
|
|
return exportFile;
|
2018-03-05 17:18:45 +01:00
|
|
|
}
|
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
public FileEnvelope getXmlDocument(String id, VisibilityRuleService visibilityRuleService) throws InstantiationException, IllegalAccessException, IOException {
|
2018-03-06 15:58:38 +01:00
|
|
|
ExportXmlBuilder xmlBuilder = new ExportXmlBuilder();
|
|
|
|
DatasetWizardModel dataset = new DatasetWizardModel();
|
2019-03-05 16:33:59 +01:00
|
|
|
eu.eudat.data.entities.Dataset datasetEntity = databaseRepository.getDatasetDao().find(UUID.fromString(id), HintedModelFactory.getHint(DatasetWizardModel.class));
|
2018-03-06 15:58:38 +01:00
|
|
|
Map<String, Object> properties = new HashMap<>();
|
|
|
|
if (datasetEntity.getProperties() != null) {
|
|
|
|
JSONObject jobject = new JSONObject(datasetEntity.getProperties());
|
|
|
|
properties = jobject.toMap();
|
|
|
|
}
|
|
|
|
PagedDatasetProfile pagedDatasetProfile = getPagedProfile(dataset, datasetEntity);
|
|
|
|
visibilityRuleService.setProperties(properties);
|
|
|
|
visibilityRuleService.buildVisibilityContext(pagedDatasetProfile.getRules());
|
|
|
|
File file = xmlBuilder.build(pagedDatasetProfile, visibilityRuleService);
|
|
|
|
FileEnvelope fileEnvelope = new FileEnvelope();
|
|
|
|
fileEnvelope.setFile(file);
|
|
|
|
fileEnvelope.setFilename(datasetEntity.getLabel());
|
|
|
|
return fileEnvelope;
|
|
|
|
}
|
|
|
|
|
2018-03-05 17:18:45 +01:00
|
|
|
public File convertToPDF(File file, Environment environment, String label) throws IOException, InterruptedException {
|
|
|
|
LinkedMultiValueMap<String, Object> map = new LinkedMultiValueMap<>();
|
|
|
|
map.add("file", new FileSystemResource(file));
|
|
|
|
HttpHeaders headers = new HttpHeaders();
|
|
|
|
headers.setContentType(MediaType.MULTIPART_FORM_DATA);
|
2018-10-08 17:14:27 +02:00
|
|
|
headers.add("Content-disposition", "attachment; filename=" + label + ".docx");
|
|
|
|
|
|
|
|
headers.add("Content-type", "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
|
2018-03-05 17:18:45 +01:00
|
|
|
|
|
|
|
HttpEntity<LinkedMultiValueMap<String, Object>> requestEntity = new HttpEntity<LinkedMultiValueMap<String, Object>>(
|
|
|
|
map, headers);
|
2018-10-08 17:14:27 +02:00
|
|
|
|
2018-03-05 17:18:45 +01:00
|
|
|
Map queueResult = new RestTemplate().postForObject(
|
|
|
|
environment.getProperty("pdf.converter.url") +
|
|
|
|
"api/v1/", requestEntity, Map.class);
|
|
|
|
|
|
|
|
Map mediaResult = new RestTemplate().getForObject(environment.getProperty("pdf.converter.url") +
|
|
|
|
"/api/v1/" + queueResult.get("id"), Map.class);
|
|
|
|
System.out.println("Status: " + mediaResult.get("status"));
|
|
|
|
while (!mediaResult.get("status").equals("finished")) {
|
|
|
|
Thread.sleep(500);
|
|
|
|
mediaResult = new RestTemplate().getForObject(environment.getProperty("pdf.converter.url") +
|
|
|
|
"api/v1/" + queueResult.get("id"), Map.class);
|
|
|
|
System.out.println("Polling");
|
|
|
|
}
|
|
|
|
RestTemplate restTemplate = new RestTemplate();
|
|
|
|
restTemplate.getMessageConverters().add(new ByteArrayHttpMessageConverter());
|
|
|
|
HttpHeaders headers2 = new HttpHeaders();
|
|
|
|
headers.setAccept(Arrays.asList(MediaType.APPLICATION_OCTET_STREAM));
|
|
|
|
HttpEntity<String> entity = new HttpEntity<String>(headers2);
|
|
|
|
|
|
|
|
ResponseEntity<byte[]> response = restTemplate.exchange(environment.getProperty("pdf.converter.url") +
|
|
|
|
mediaResult.get("result_url"), HttpMethod.GET, entity, byte[].class, "1");
|
|
|
|
|
|
|
|
UUID uuid = UUID.randomUUID();
|
|
|
|
File zip = new File(uuid + ".zip");
|
|
|
|
if (response.getStatusCode().equals(HttpStatus.OK)) {
|
|
|
|
FileOutputStream output = new FileOutputStream(zip);
|
|
|
|
IOUtils.write(response.getBody(), output);
|
|
|
|
}
|
|
|
|
return extractFromZip(zip, label + ".pdf");
|
|
|
|
}
|
|
|
|
|
|
|
|
private File extractFromZip(File file, String filename) throws IOException {
|
|
|
|
byte[] buffer = new byte[1024];
|
|
|
|
File newFile = new File(filename);
|
|
|
|
ZipInputStream zis = new ZipInputStream(new FileInputStream(file));
|
|
|
|
ZipEntry zipEntry = zis.getNextEntry();
|
|
|
|
while (zipEntry != null) {
|
|
|
|
String zippedFileName = zipEntry.getName();
|
|
|
|
if (zippedFileName.equals("pdf")) {
|
|
|
|
|
|
|
|
FileOutputStream fos = new FileOutputStream(newFile);
|
|
|
|
int len;
|
|
|
|
while ((len = zis.read(buffer)) > 0) {
|
|
|
|
fos.write(buffer, 0, len);
|
|
|
|
}
|
|
|
|
fos.close();
|
|
|
|
zipEntry = zis.getNextEntry();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
zis.closeEntry();
|
|
|
|
zis.close();
|
|
|
|
return newFile;
|
2017-12-15 13:25:21 +01:00
|
|
|
}
|
2017-12-20 15:52:09 +01:00
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
public eu.eudat.data.entities.Dataset createOrUpdate(DatasetWizardModel datasetWizardModel, Principal principal) throws Exception {
|
2018-07-11 15:47:36 +02:00
|
|
|
eu.eudat.data.entities.Dataset dataset = datasetWizardModel.toDataModel();
|
|
|
|
propertiesModelToString(datasetWizardModel, dataset);
|
2018-03-05 17:18:45 +01:00
|
|
|
UserInfo userInfo = apiContext.getOperationsContext().getBuilderFactory().getBuilder(UserInfoBuilder.class).id(principal.getId()).build();
|
2018-02-08 16:54:31 +01:00
|
|
|
dataset.setCreator(userInfo);
|
2018-07-11 15:47:36 +02:00
|
|
|
updateTags(apiContext.getOperationsContext().getDatasetRepository(), datasetWizardModel);
|
2018-03-05 17:18:45 +01:00
|
|
|
createRegistriesIfTheyDontExist(apiContext.getOperationsContext().getDatabaseRepository().getRegistryDao(), dataset);
|
|
|
|
createDataRepositoriesIfTheyDontExist(apiContext.getOperationsContext().getDatabaseRepository().getDataRepositoryDao(), dataset);
|
2019-03-05 16:33:59 +01:00
|
|
|
createServicesIfTheyDontExist(dataset);
|
|
|
|
createExternalDatasetsIfTheyDontExist(dataset);
|
2018-03-05 17:18:45 +01:00
|
|
|
return apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao().createOrUpdate(dataset);
|
2017-12-21 11:38:18 +01:00
|
|
|
}
|
|
|
|
|
2019-01-31 16:53:37 +01:00
|
|
|
private void propertiesModelToString(DatasetWizardModel datasetWizardModel, eu.eudat.data.entities.Dataset dataset) {
|
2018-02-08 16:54:31 +01:00
|
|
|
Map<String, Object> values = new HashMap();
|
2018-01-30 12:07:51 +01:00
|
|
|
PagedDatasetProfile properties = datasetWizardModel.getDatasetProfileDefinition();
|
2018-01-25 09:14:43 +01:00
|
|
|
properties.toMap(values);
|
|
|
|
JSONObject jobject = new JSONObject(values);
|
|
|
|
dataset.setProperties(jobject.toString());
|
|
|
|
}
|
|
|
|
|
2019-01-31 16:53:37 +01:00
|
|
|
private void updateTags(DatasetRepository datasetRepository, DatasetWizardModel datasetWizardModel) throws IOException {
|
2018-07-11 15:47:36 +02:00
|
|
|
if (datasetWizardModel.getTags() != null && !datasetWizardModel.getTags().isEmpty()) {
|
|
|
|
eu.eudat.elastic.entities.Dataset dataset = new eu.eudat.elastic.entities.Dataset();
|
|
|
|
dataset.setId(datasetWizardModel.getId().toString());
|
|
|
|
dataset.setTags(datasetWizardModel.getTags());
|
|
|
|
datasetRepository.createOrUpdate(dataset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-31 16:53:37 +01:00
|
|
|
private void createRegistriesIfTheyDontExist(RegistryDao registryDao, eu.eudat.data.entities.Dataset dataset) {
|
2018-01-19 12:11:22 +01:00
|
|
|
if (dataset.getRegistries() != null && !dataset.getRegistries().isEmpty()) {
|
2018-03-21 11:57:56 +01:00
|
|
|
for (eu.eudat.data.entities.Registry registry : dataset.getRegistries()) {
|
2018-01-19 12:11:22 +01:00
|
|
|
RegistryCriteria criteria = new RegistryCriteria();
|
|
|
|
criteria.setLike(registry.getReference());
|
2018-03-21 11:57:56 +01:00
|
|
|
List<eu.eudat.data.entities.Registry> entries = registryDao.getWithCriteria(criteria).toList();
|
2018-01-19 12:11:22 +01:00
|
|
|
if (entries != null && !entries.isEmpty()) registry.setId(entries.get(0).getId());
|
2018-01-25 16:24:21 +01:00
|
|
|
else registry = registryDao.createOrUpdate(registry);
|
2018-01-19 12:11:22 +01:00
|
|
|
}
|
|
|
|
}
|
2017-12-21 11:38:18 +01:00
|
|
|
}
|
|
|
|
|
2019-01-31 16:53:37 +01:00
|
|
|
private void createDataRepositoriesIfTheyDontExist(DataRepositoryDao dataRepositoryDao, eu.eudat.data.entities.Dataset dataset) {
|
2018-05-28 11:50:42 +02:00
|
|
|
Set<DatasetDataRepository> datasetDataRepositories = dataset.getDatasetDataRepositories();
|
|
|
|
dataset.setDatasetDataRepositories(new HashSet<>());
|
|
|
|
|
|
|
|
if (datasetDataRepositories != null && !datasetDataRepositories.isEmpty()) {
|
|
|
|
for (eu.eudat.data.entities.DatasetDataRepository datasetDataRepository : datasetDataRepositories) {
|
|
|
|
DataRepositoryCriteria criteria = new DataRepositoryCriteria();
|
|
|
|
criteria.setLike(datasetDataRepository.getDataRepository().getReference());
|
|
|
|
List<eu.eudat.data.entities.DataRepository> entries = dataRepositoryDao.getWithCriteria(criteria).toList();
|
|
|
|
if (entries != null && !entries.isEmpty()) {
|
|
|
|
datasetDataRepository.getDataRepository().setId(entries.get(0).getId());
|
|
|
|
datasetDataRepository.setDataset(dataset);
|
|
|
|
dataset.getDatasetDataRepositories().add(datasetDataRepository);
|
2018-07-11 15:47:36 +02:00
|
|
|
} else {
|
2018-09-18 14:41:24 +02:00
|
|
|
//datasetDataRepository.getDataRepository().setId(UUID.randomUUID());
|
2018-05-28 11:50:42 +02:00
|
|
|
DataRepository dataRepository = dataRepositoryDao.createOrUpdate(datasetDataRepository.getDataRepository());
|
|
|
|
datasetDataRepository.setDataRepository(dataRepository);
|
|
|
|
dataset.getDatasetDataRepositories().add(datasetDataRepository);
|
|
|
|
}
|
2018-01-19 12:11:22 +01:00
|
|
|
}
|
|
|
|
}
|
2017-12-21 11:38:18 +01:00
|
|
|
}
|
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
private void createServicesIfTheyDontExist(eu.eudat.data.entities.Dataset dataset) {
|
2018-05-28 11:50:42 +02:00
|
|
|
Set<DatasetService> services = dataset.getServices();
|
|
|
|
dataset.setServices(new HashSet<>());
|
|
|
|
if (services != null && !services.isEmpty()) {
|
|
|
|
for (eu.eudat.data.entities.DatasetService datasetService : services) {
|
|
|
|
ServiceCriteria criteria = new ServiceCriteria();
|
|
|
|
criteria.setLike(datasetService.getService().getLabel());
|
2019-03-05 16:33:59 +01:00
|
|
|
List<eu.eudat.data.entities.Service> entries = databaseRepository.getServiceDao().getWithCriteria(criteria).toList();
|
2018-07-11 15:47:36 +02:00
|
|
|
if (entries != null && !entries.isEmpty()) {
|
2018-05-28 11:50:42 +02:00
|
|
|
datasetService.getService().setId(entries.get(0).getId());
|
|
|
|
datasetService.setDataset(dataset);
|
|
|
|
dataset.getServices().add(datasetService);
|
2018-07-11 15:47:36 +02:00
|
|
|
} else {
|
2019-03-05 16:33:59 +01:00
|
|
|
Service service = databaseRepository.getServiceDao().createOrUpdate(datasetService.getService());
|
2018-07-11 15:47:36 +02:00
|
|
|
datasetService.setService(service);
|
2018-05-28 11:50:42 +02:00
|
|
|
dataset.getServices().add(datasetService);
|
|
|
|
}
|
2018-01-19 12:11:22 +01:00
|
|
|
}
|
|
|
|
}
|
2017-12-21 11:38:18 +01:00
|
|
|
}
|
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
private void createExternalDatasetsIfTheyDontExist(eu.eudat.data.entities.Dataset dataset) {
|
2018-05-28 11:50:42 +02:00
|
|
|
Set<DatasetExternalDataset> externalDatasets = dataset.getDatasetExternalDatasets();
|
|
|
|
dataset.setDatasetExternalDatasets(new HashSet<>());
|
|
|
|
if (externalDatasets != null && !externalDatasets.isEmpty()) {
|
|
|
|
for (eu.eudat.data.entities.DatasetExternalDataset datasetExternalDataset : externalDatasets) {
|
2018-01-19 15:19:14 +01:00
|
|
|
ExternalDatasetCriteria criteria = new ExternalDatasetCriteria();
|
2018-05-28 11:50:42 +02:00
|
|
|
criteria.setLike(datasetExternalDataset.getExternalDataset().getLabel());
|
2019-03-05 16:33:59 +01:00
|
|
|
List<eu.eudat.data.entities.ExternalDataset> entries = databaseRepository.getExternalDatasetDao().getWithCriteria(criteria).toList();
|
2018-05-28 11:50:42 +02:00
|
|
|
if (entries != null && !entries.isEmpty()) {
|
|
|
|
datasetExternalDataset.getExternalDataset().setId(entries.get(0).getId());
|
|
|
|
datasetExternalDataset.setDataset(dataset);
|
|
|
|
dataset.getDatasetExternalDatasets().add(datasetExternalDataset);
|
2018-07-11 15:47:36 +02:00
|
|
|
} else {
|
2019-03-05 16:33:59 +01:00
|
|
|
ExternalDataset externalDataset = databaseRepository.getExternalDatasetDao().createOrUpdate(datasetExternalDataset.getExternalDataset());
|
2018-05-28 11:50:42 +02:00
|
|
|
datasetExternalDataset.setExternalDataset(externalDataset);
|
|
|
|
dataset.getDatasetExternalDatasets().add(datasetExternalDataset);
|
|
|
|
}
|
2018-01-19 15:19:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-31 16:53:37 +01:00
|
|
|
public void makePublic(DatasetDao datasetDao, UUID id) throws Exception {
|
2018-03-21 11:57:56 +01:00
|
|
|
eu.eudat.data.entities.Dataset dataset = datasetDao.find(id);
|
|
|
|
if (dataset.getStatus() != eu.eudat.data.entities.Dataset.Status.FINALISED.getValue())
|
2018-01-19 12:11:22 +01:00
|
|
|
throw new Exception("You cannot make public a Dataset That Has not Been Finalised");
|
|
|
|
datasetDao.createOrUpdate(dataset);
|
|
|
|
}
|
2017-12-21 11:38:18 +01:00
|
|
|
|
2019-03-05 16:33:59 +01:00
|
|
|
public ResponseEntity<byte[]> getDocument(String id, VisibilityRuleService visibilityRuleService, String contentType) throws IllegalAccessException, IOException, InstantiationException {
|
|
|
|
FileEnvelope envelope = getXmlDocument(id, visibilityRuleService);
|
2019-02-06 11:48:05 +01:00
|
|
|
InputStream resource = new FileInputStream(envelope.getFile());
|
|
|
|
System.out.println("Mime Type of " + envelope.getFilename() + " is " +
|
|
|
|
new MimetypesFileTypeMap().getContentType(envelope.getFile()));
|
|
|
|
HttpHeaders responseHeaders = new HttpHeaders();
|
|
|
|
responseHeaders.setContentLength(envelope.getFile().length());
|
|
|
|
responseHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
|
|
|
|
responseHeaders.set("Content-Disposition", "attachment;filename=" + envelope.getFilename() + ".xml");
|
|
|
|
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(envelope.getFile().toPath());
|
|
|
|
|
|
|
|
return new ResponseEntity<>(content,
|
|
|
|
responseHeaders,
|
|
|
|
HttpStatus.OK);
|
|
|
|
}
|
|
|
|
|
2017-12-15 13:25:21 +01:00
|
|
|
}
|