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

package eu.eudat.logic.managers;

import eu.eudat.data.dao.criteria.*;
import eu.eudat.data.dao.entities.DataRepositoryDao;
import eu.eudat.data.dao.entities.DatasetDao;
import eu.eudat.data.dao.entities.RegistryDao;
import eu.eudat.data.entities.*;
import eu.eudat.data.query.items.table.dataset.DatasetPublicTableRequest;
import eu.eudat.data.query.items.table.dataset.DatasetTableRequest;
import eu.eudat.elastic.criteria.DatasetCriteria;
import eu.eudat.elastic.repository.DatasetRepository;
import eu.eudat.logic.builders.BuilderFactory;
import eu.eudat.logic.builders.entity.UserInfoBuilder;
import eu.eudat.logic.services.ApiContext;
import eu.eudat.logic.services.forms.VisibilityRuleService;
import eu.eudat.logic.services.operations.DatabaseRepository;
import eu.eudat.logic.utilities.documents.helpers.FileEnvelope;
import eu.eudat.logic.utilities.documents.types.ParagraphStyle;
import eu.eudat.logic.utilities.documents.word.WordBuilder;
import eu.eudat.logic.utilities.documents.xml.ExportXmlBuilder;
import eu.eudat.models.HintedModelFactory;
import eu.eudat.models.data.datasetImport.DatasetImportField;
import eu.eudat.models.data.datasetImport.DatasetImportPagedDatasetProfile;
import eu.eudat.models.data.datasetwizard.DatasetWizardModel;
import eu.eudat.models.data.dmp.AssociatedProfile;
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;
import eu.eudat.queryable.QueryableList;
import org.apache.commons.io.IOUtils;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.core.io.FileSystemResource;
import org.springframework.http.*;
import org.springframework.stereotype.Component;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.multipart.MultipartFile;

import javax.activation.MimetypesFileTypeMap;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import java.io.*;
import java.math.BigInteger;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

@Component
public class DatasetManager {

    private ApiContext apiContext;
    private DatabaseRepository databaseRepository;
    private DatasetRepository datasetRepository;
    private BuilderFactory builderFactory;
    private UserManager userManager;

    @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 {
        DatasetCriteria datasetCriteria = new DatasetCriteria();
        datasetCriteria.setTags(datasetTableRequest.getCriteria().getTags());
        List<eu.eudat.elastic.entities.Dataset> datasets;
        try {
            datasets = datasetCriteria.getTags() != null && datasetCriteria.getTags().size() > 0 && datasetRepository.exists() ?
                    datasetRepository.query(datasetCriteria) : new LinkedList<>();
        } catch (Exception ex) {
            datasets = null;
        }

        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));
        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())));
            } else
                items.where((builder, root) -> root.get("id").in(new UUID[]{UUID.randomUUID()}));
        }
        QueryableList<eu.eudat.data.entities.Dataset> authItems = databaseRepository.getDatasetDao().getAuthenticated(items, userInfo);
        QueryableList<eu.eudat.data.entities.Dataset> pagedItems = PaginationManager.applyPaging(authItems, datasetTableRequest);
        DataTableData<DatasetListingModel> dataTable = new DataTableData<DatasetListingModel>();


        CompletableFuture<List<DatasetListingModel>> itemsFuture = pagedItems.
                selectAsync(item -> new DatasetListingModel().fromDataModel(item)).whenComplete((resultList, throwable) -> {
            dataTable.setData(resultList);
        });

        CompletableFuture countFuture = authItems.countAsync().whenComplete((count, throwable) -> {
            dataTable.setTotalCount(count);
        });

        CompletableFuture.allOf(itemsFuture, countFuture).join();
        return dataTable;
    }

    public DataTableData<DatasetListingModel> getPaged(DatasetPublicTableRequest datasetTableRequest, Principal principal) throws Exception {
        DatasetCriteria datasetCriteria = new DatasetCriteria();
        datasetCriteria.setTags(datasetTableRequest.getCriteria().getTags());
        List<eu.eudat.elastic.entities.Dataset> datasets;
        try {
            datasets = datasetCriteria.getTags() != null && datasetCriteria.getTags().size() > 0 && datasetRepository.exists() ?
                    datasetRepository.query(datasetCriteria) : new LinkedList<>();
        } catch (Exception ex) {
            datasets = null;
        }
        datasetTableRequest.setQuery(databaseRepository.getDatasetDao().asQueryable().withHint(HintedModelFactory.getHint(DatasetListingModel.class)));
        QueryableList<Dataset> items = datasetTableRequest.applyCriteria();
        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())));
            } else
                items.where((builder, root) -> root.get("id").in(new UUID[]{UUID.randomUUID()}));
        }
        QueryableList<eu.eudat.data.entities.Dataset> pagedItems = PaginationManager.applyPaging(items, datasetTableRequest);
        DataTableData<DatasetListingModel> dataTable = new DataTableData<>();

        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;
    }

    public DatasetWizardModel getSingle(String id) throws InstantiationException, IllegalAccessException, IOException {
        DatasetWizardModel dataset = new DatasetWizardModel();
        eu.eudat.data.entities.Dataset datasetEntity = databaseRepository.getDatasetDao().find(UUID.fromString(id), HintedModelFactory.getHint(DatasetWizardModel.class));
        eu.eudat.elastic.entities.Dataset datasetElastic;
        try {
            datasetElastic = datasetRepository.exists() ?
                    datasetRepository.findDocument(id) : new eu.eudat.elastic.entities.Dataset();
        } catch (Exception ex) {
            datasetElastic = new eu.eudat.elastic.entities.Dataset();
        }
        dataset.setDatasetProfileDefinition(getPagedProfile(dataset, datasetEntity));
        dataset.fromDataModel(datasetEntity);

        // Creates the Criteria to get all version of DatasetProfile in question.
        DatasetProfileCriteria profileCriteria = new DatasetProfileCriteria();
        UUID profileId = datasetEntity.getProfile().getGroupId();
        List<UUID> uuidList = new LinkedList<>();
        uuidList.add(profileId);
        profileCriteria.setGroupIds(uuidList);
        profileCriteria.setAllVersions(true);

        List<eu.eudat.data.entities.DatasetProfile> profileVersions = databaseRepository.getDatasetProfileDao().getWithCriteria(profileCriteria)
                .orderBy(((builder, root) -> builder.desc(root.get("version"))))
                .toList();
        List<DatasetProfile> profileVersionsIncluded = new LinkedList<>();

        // Iterate through the versions and remove those that are not included in the DMP of the dataset in question.
        for (DatasetProfile version : profileVersions) {
            for (AssociatedProfile p : dataset.getDmp().getProfiles()) {
                if (version.getId().toString().equals(p.getId().toString())) {
                    profileVersionsIncluded.add(version);
                }
            }
        }

        // Sort the list with the included Versions.
        Stream<DatasetProfile> sorted = profileVersionsIncluded.stream().sorted(Comparator.comparing(DatasetProfile::getVersion).reversed());

        // Make the Stream into List and get the first item.
        DatasetProfile profile = sorted.collect(Collectors.toList()).iterator().next();

        // Check if the dataset is on the latest Version.
        boolean latestVersion = profile.getVersion().toString().equals(datasetEntity.getProfile().getVersion().toString());
        dataset.setIsProfileLatestVersion(latestVersion);

        dataset.setTags(datasetElastic.getTags());
        return dataset;
    }

    public DatasetWizardModel getSinglePublic(String id) throws Exception {
        DatasetWizardModel dataset = new DatasetWizardModel();
        eu.eudat.data.entities.Dataset datasetEntity = databaseRepository.getDatasetDao().isPublicDataset(UUID.fromString(id));

        if (datasetEntity != null && datasetEntity.getStatus() == 1 && datasetEntity.getDmp().getStatus() == 1) {
            dataset.setDatasetProfileDefinition(getPagedProfile(dataset, datasetEntity));
            dataset.fromDataModel(datasetEntity);
            return dataset;
        } else {
            throw new Exception("Selected dataset is not public");
        }
    }

    public PagedDatasetProfile getPagedProfile(DatasetWizardModel dataset, eu.eudat.data.entities.Dataset datasetEntity) {
        eu.eudat.models.data.user.composite.DatasetProfile datasetprofile = userManager.generateDatasetProfileModel(datasetEntity.getProfile());
        datasetprofile.setStatus(dataset.getStatus());
        if (datasetEntity.getProperties() != null) {
            JSONObject jobject = new JSONObject(datasetEntity.getProperties());
            Map<String, Object> properties = jobject.toMap();
            datasetprofile.fromJsonObject(properties);
        }
        PagedDatasetProfile pagedDatasetProfile = new PagedDatasetProfile();
        pagedDatasetProfile.buildPagedDatasetProfile(datasetprofile);
        return pagedDatasetProfile;
    }

    public File getWordDocument(Environment environment, String id, VisibilityRuleService visibilityRuleService) throws InstantiationException, IllegalAccessException, IOException {
        WordBuilder wordBuilder = new WordBuilder();
        DatasetWizardModel dataset = new DatasetWizardModel();
        String fileUrl = environment.getProperty("configuration.h2020template");
        InputStream is = new URL(Paths.get(fileUrl).toUri().toURL().toString()).openStream();
        XWPFDocument document = new XWPFDocument(is);
        eu.eudat.data.entities.Dataset datasetEntity = databaseRepository.getDatasetDao().find(UUID.fromString(id), HintedModelFactory.getHint(DatasetWizardModel.class));
        wordBuilder.addParagraphContent(datasetEntity.getLabel(), document, ParagraphStyle.TITLE, BigInteger.ZERO);
        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());
        wordBuilder.build(document, pagedDatasetProfile, visibilityRuleService);
        String label = datasetEntity.getLabel().replaceAll("[^a-zA-Z0-9+ ]", "");
        File exportFile = new File(environment.getProperty("configuration.exportUrl") + label + ".docx");
        FileOutputStream out = new FileOutputStream(exportFile);
        document.write(out);
        out.close();
        return exportFile;
    }

    public FileEnvelope getXmlDocument(String id, VisibilityRuleService visibilityRuleService) throws InstantiationException, IllegalAccessException, IOException {
        ExportXmlBuilder xmlBuilder = new ExportXmlBuilder();
        DatasetWizardModel dataset = new DatasetWizardModel();
        eu.eudat.data.entities.Dataset datasetEntity = databaseRepository.getDatasetDao().find(UUID.fromString(id), HintedModelFactory.getHint(DatasetWizardModel.class));
        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, datasetEntity.getProfile().getId(), visibilityRuleService);
        FileEnvelope fileEnvelope = new FileEnvelope();
        fileEnvelope.setFile(file);
        fileEnvelope.setFilename(datasetEntity.getLabel());
        return fileEnvelope;
    }

    public File convertToPDF(File file, Environment environment, String label) throws IOException, InterruptedException {
        LinkedMultiValueMap<String, Object> map = new LinkedMultiValueMap<>();
        map.add("files", new FileSystemResource(file));
        map.add("filename", label + ".pdf");
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.MULTIPART_FORM_DATA);
        headers.add("Content-disposition", "attachment; filename=" + label + ".pdf");
        headers.add("Content-type", "application/pdf");

        HttpEntity<LinkedMultiValueMap<String, Object>> requestEntity = new HttpEntity<LinkedMultiValueMap<String, Object>>(
                map, headers);

        byte[] queueResult = new RestTemplate().postForObject(environment.getProperty("pdf.converter.url") + "convert/office"
                , requestEntity, byte[].class);

        File resultPdf = new File(environment.getProperty("configuration.exportUrl") + label + ".pdf");
        FileOutputStream output = new FileOutputStream(resultPdf);
        IOUtils.write(queueResult, output);
        output.close();
        Files.deleteIfExists(file.toPath());

        return resultPdf;
    }

    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;
    }

    public eu.eudat.data.entities.Dataset createOrUpdate(DatasetWizardModel datasetWizardModel, Principal principal) throws Exception {
        eu.eudat.data.entities.Dataset dataset = datasetWizardModel.toDataModel();
        dataset.setDmp(apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(datasetWizardModel.getDmp().getId()));
        propertiesModelToString(datasetWizardModel, dataset);
        UserInfo userInfo = apiContext.getOperationsContext().getBuilderFactory().getBuilder(UserInfoBuilder.class).id(principal.getId()).build();
        dataset.setCreator(userInfo);
        updateTags(apiContext.getOperationsContext().getDatasetRepository(), datasetWizardModel);
        createRegistriesIfTheyDontExist(apiContext.getOperationsContext().getDatabaseRepository().getRegistryDao(), dataset);
        createDataRepositoriesIfTheyDontExist(apiContext.getOperationsContext().getDatabaseRepository().getDataRepositoryDao(), dataset);
        createServicesIfTheyDontExist(dataset);
        createExternalDatasetsIfTheyDontExist(dataset);
        return apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao().createOrUpdate(dataset);
    }

    private void propertiesModelToString(DatasetWizardModel datasetWizardModel, eu.eudat.data.entities.Dataset dataset) {
        Map<String, Object> values = new HashMap();
        PagedDatasetProfile properties = datasetWizardModel.getDatasetProfileDefinition();
        properties.toMap(values);
        JSONObject jobject = new JSONObject(values);
        dataset.setProperties(jobject.toString());
    }

    private void updateTags(DatasetRepository datasetRepository, DatasetWizardModel datasetWizardModel) throws IOException {
        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);
        }
    }

    private void createRegistriesIfTheyDontExist(RegistryDao registryDao, eu.eudat.data.entities.Dataset dataset) {
        if (dataset.getRegistries() != null && !dataset.getRegistries().isEmpty()) {
            for (eu.eudat.data.entities.Registry registry : dataset.getRegistries()) {
                RegistryCriteria criteria = new RegistryCriteria();
                criteria.setLike(registry.getReference());
                List<eu.eudat.data.entities.Registry> entries = registryDao.getWithCriteria(criteria).toList();
                if (entries != null && !entries.isEmpty()) registry.setId(entries.get(0).getId());
                else registry = registryDao.createOrUpdate(registry);
            }
        }
    }

    private void createDataRepositoriesIfTheyDontExist(DataRepositoryDao dataRepositoryDao, eu.eudat.data.entities.Dataset dataset) {
        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);
                } else {
                    //datasetDataRepository.getDataRepository().setId(UUID.randomUUID());
                    DataRepository dataRepository = dataRepositoryDao.createOrUpdate(datasetDataRepository.getDataRepository());
                    datasetDataRepository.setDataRepository(dataRepository);
                    dataset.getDatasetDataRepositories().add(datasetDataRepository);
                }
            }
        }
    }

    private void createServicesIfTheyDontExist(eu.eudat.data.entities.Dataset dataset) {
        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());
                List<eu.eudat.data.entities.Service> entries = databaseRepository.getServiceDao().getWithCriteria(criteria).toList();
                if (entries != null && !entries.isEmpty()) {
                    datasetService.getService().setId(entries.get(0).getId());
                    datasetService.setDataset(dataset);
                    dataset.getServices().add(datasetService);
                } else {
                    Service service = databaseRepository.getServiceDao().createOrUpdate(datasetService.getService());
                    datasetService.setService(service);
                    dataset.getServices().add(datasetService);
                }
            }
        }
    }

    private void createExternalDatasetsIfTheyDontExist(eu.eudat.data.entities.Dataset dataset) {
        Set<DatasetExternalDataset> externalDatasets = dataset.getDatasetExternalDatasets();
        dataset.setDatasetExternalDatasets(new HashSet<>());
        if (externalDatasets != null && !externalDatasets.isEmpty()) {
            for (eu.eudat.data.entities.DatasetExternalDataset datasetExternalDataset : externalDatasets) {
                ExternalDatasetCriteria criteria = new ExternalDatasetCriteria();
                criteria.setLike(datasetExternalDataset.getExternalDataset().getLabel());
                List<eu.eudat.data.entities.ExternalDataset> entries = databaseRepository.getExternalDatasetDao().getWithCriteria(criteria).toList();
                if (entries != null && !entries.isEmpty()) {
                    datasetExternalDataset.getExternalDataset().setId(entries.get(0).getId());
                    datasetExternalDataset.setDataset(dataset);
                    dataset.getDatasetExternalDatasets().add(datasetExternalDataset);
                } else {
                    ExternalDataset externalDataset = databaseRepository.getExternalDatasetDao().createOrUpdate(datasetExternalDataset.getExternalDataset());
                    datasetExternalDataset.setExternalDataset(externalDataset);
                    dataset.getDatasetExternalDatasets().add(datasetExternalDataset);
                }
            }
        }
    }

    public void makePublic(DatasetDao datasetDao, UUID id) throws Exception {
        eu.eudat.data.entities.Dataset dataset = datasetDao.find(id);
        if (dataset.getStatus() != eu.eudat.data.entities.Dataset.Status.FINALISED.getValue())
            throw new Exception("You cannot make public a Dataset That Has not Been Finalised");
        datasetDao.createOrUpdate(dataset);
    }

    public ResponseEntity<byte[]> getDocument(String id, VisibilityRuleService visibilityRuleService, String contentType) throws IllegalAccessException, IOException, InstantiationException {
        FileEnvelope envelope = getXmlDocument(id, visibilityRuleService);
        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);
    }

    public eu.eudat.data.entities.Dataset createDatasetFromXml(MultipartFile importFile, String dmpId, String datasetProfileId, Principal principal) throws JAXBException, IOException {
        DatasetImportPagedDatasetProfile importModel = new DatasetImportPagedDatasetProfile();
        JAXBContext jaxbContext;

        // Parses XML into DatasetImport Model.
        try {
            InputStream in = importFile.getInputStream();
            jaxbContext = JAXBContext.newInstance(DatasetImportPagedDatasetProfile.class);
            Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
            DatasetImportPagedDatasetProfile datasetImport = (DatasetImportPagedDatasetProfile) jaxbUnmarshaller.unmarshal(in);
            importModel = datasetImport;
        } catch (IOException e) {
            e.printStackTrace();
        }

        // Checks if XML datasetProfileId GroupId matches the one selected.
        try {
            eu.eudat.data.entities.DatasetProfile importDatasetProfile = databaseRepository.getDatasetProfileDao().find(UUID.fromString(importModel.getDatasetProfileId()));
            eu.eudat.data.entities.DatasetProfile latestVersionDatasetProfile = databaseRepository.getDatasetProfileDao().find(UUID.fromString(datasetProfileId));
            if (latestVersionDatasetProfile.getGroupId() != importDatasetProfile.getGroupId()) {
                throw new Exception();
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

        // Creates the Hash Map to place the values of the data set.
        Map<String, String> importMap = importModel.getPages().stream()
                .flatMap(s -> s.getSections().getSection().stream()
                        .flatMap(cFields -> cFields.getCompositeFields().stream()
                                .flatMap(cField -> cField.getCompositeField().stream()
                                        .filter(Objects::nonNull)
                                        .flatMap(fields -> fields.getFields().stream()
                                                .flatMap(field -> field.getField().stream()
                                                        .filter(f -> f.getValue() != null)
                                                )))))
                .collect(Collectors.toMap(DatasetImportField::getId, DatasetImportField::getValue));

        // Transforms map into json file.
        JSONObject jsonDatasetProperties = new JSONObject(importMap);

        // Creates the entity data set to save.
        eu.eudat.data.entities.Dataset entity = new Dataset();
        entity.setProperties(jsonDatasetProperties.toString());
        entity.setLabel(importFile.getOriginalFilename());
        DMP dmp = new DMP();
        dmp.setId(UUID.fromString(dmpId));
        entity.setDmp(dmp);
        entity.setStatus((short) 0);
        entity.setPublic(false);
        entity.setCreated(new Date());
        entity.setModified(new Date());
        DatasetProfile profile = new DatasetProfile();
        profile.setId(UUID.fromString(datasetProfileId));
        entity.setProfile(profile);

        UserInfo userInfo = apiContext.getOperationsContext().getBuilderFactory().getBuilder(UserInfoBuilder.class).id(principal.getId()).build();
        entity.setCreator(userInfo);

        updateTagsXmlImportDataset(apiContext.getOperationsContext().getDatasetRepository(), entity);
        createRegistriesIfTheyDontExist(apiContext.getOperationsContext().getDatabaseRepository().getRegistryDao(), entity);
        createDataRepositoriesIfTheyDontExist(apiContext.getOperationsContext().getDatabaseRepository().getDataRepositoryDao(), entity);
        createServicesIfTheyDontExist(entity);
        createExternalDatasetsIfTheyDontExist(entity);

        return apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao().createOrUpdate(entity);
    }

    public void updateTagsXmlImportDataset(DatasetRepository datasetRepository, Dataset dataset) throws IOException {
        // TODO: When tags functionality return.
    }

    public DatasetWizardModel datasetUpdateProfile(String id) {
        DatasetWizardModel dataset = new DatasetWizardModel();
        eu.eudat.data.entities.Dataset datasetEntity = databaseRepository.getDatasetDao().find(UUID.fromString(id), HintedModelFactory.getHint(DatasetWizardModel.class));
        eu.eudat.elastic.entities.Dataset datasetElastic;
        try {
            datasetElastic = datasetRepository.exists() ?
                    datasetRepository.findDocument(id) : new eu.eudat.elastic.entities.Dataset();
        } catch (Exception ex) {
            datasetElastic = new eu.eudat.elastic.entities.Dataset();
        }
        dataset.setDatasetProfileDefinition(getPagedProfile(dataset, datasetEntity));
        dataset.fromDataModel(datasetEntity);

        // Creates the Criteria to get all version of DatasetProfile in question.
        DatasetProfileCriteria profileCriteria = new DatasetProfileCriteria();
        UUID profileId = datasetEntity.getProfile().getGroupId();
        List<UUID> uuidList = new LinkedList<>();
        uuidList.add(profileId);
        profileCriteria.setGroupIds(uuidList);

        // Gets the latest version of the datasetProfile.
        eu.eudat.data.entities.DatasetProfile item = databaseRepository.getDatasetProfileDao().getWithCriteria(profileCriteria).getSingle();

        // Sets the latest version of dataet Profile to the Dataset in question.
        dataset.setDatasetProfileDefinition(getLatestDatasetProfile(datasetEntity, item));
        dataset.setProfile(item.getId());

        // Now at latest version.
        dataset.setIsProfileLatestVersion(true);

        dataset.setTags(datasetElastic.getTags());
        return dataset;
    }

    public PagedDatasetProfile getLatestDatasetProfile(Dataset datasetEntity, DatasetProfile profile) {
        eu.eudat.models.data.user.composite.DatasetProfile datasetprofile = userManager.generateDatasetProfileModel(profile);
        datasetprofile.setStatus(datasetEntity.getStatus());
        if (datasetEntity.getProperties() != null) {
            JSONObject jobject = new JSONObject(datasetEntity.getProperties());
            Map<String, Object> properties = jobject.toMap();
            datasetprofile.fromJsonObject(properties);
        }
        PagedDatasetProfile pagedDatasetProfile = new PagedDatasetProfile();
        pagedDatasetProfile.buildPagedDatasetProfile(datasetprofile);
        return pagedDatasetProfile;
    }
}