package eu.eudat.logic.managers;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import eu.eudat.commons.XmlHandlingService;
import eu.eudat.commons.enums.*;
import eu.eudat.commons.scope.user.UserScope;
import eu.eudat.commons.types.dmpblueprint.*;
import eu.eudat.data.*;
import eu.eudat.data.dao.criteria.*;
import eu.eudat.data.dao.entities.*;
import eu.eudat.data.old.*;
import eu.eudat.data.query.items.table.dataset.DatasetTableRequest;
import eu.eudat.data.query.items.table.datasetprofile.DatasetProfileTableRequestItem;
import eu.eudat.data.query.items.table.dmp.DataManagementPlanTableRequest;
//import eu.eudat.depositinterface.models.DmpDepositModel;
import eu.eudat.exceptions.datamanagementplan.DMPNewVersionException;
import eu.eudat.exceptions.datamanagementplan.DMPWithDatasetsDeleteException;
import eu.eudat.exceptions.security.ForbiddenException;
import eu.eudat.exceptions.security.UnauthorisedException;
import eu.eudat.logic.builders.entity.UserInfoBuilder;
import eu.eudat.logic.proxy.config.configloaders.ConfigLoader;
import eu.eudat.model.DmpUser;
import eu.eudat.logic.services.ApiContext;
import eu.eudat.logic.services.forms.VisibilityRuleService;
import eu.eudat.logic.services.forms.VisibilityRuleServiceImpl;
import eu.eudat.logic.services.operations.DatabaseRepository;
import eu.eudat.commons.types.xml.XmlBuilder;
import eu.eudat.model.EntityDoi;
import eu.eudat.model.file.FileEnvelope;
import eu.eudat.query.*;
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.model.persist.deposit.DepositRequest;
import eu.eudat.models.HintedModelFactory;
import eu.eudat.models.data.dataset.DatasetOverviewModel;
import eu.eudat.models.data.datasetprofile.DatasetProfileListingModel;
import eu.eudat.models.data.datasetwizard.DatasetWizardModel;
import eu.eudat.models.data.datasetwizard.DatasetsToBeFinalized;
import eu.eudat.models.data.dmp.*;
import eu.eudat.models.data.dynamicfields.DynamicFieldWithValue;
import eu.eudat.models.data.helpermodels.Tuple;
import eu.eudat.models.data.helpers.common.DataTableData;
import eu.eudat.models.data.listingmodels.*;
import eu.eudat.models.data.user.composite.PagedDatasetProfile;
import eu.eudat.queryable.QueryableList;
import eu.eudat.service.deposit.DepositService;
import eu.eudat.service.dmpblueprint.DmpBlueprintService;
import eu.eudat.types.MetricNames;
import gr.cite.commons.web.authz.service.AuthorizationService;
import gr.cite.tools.data.query.QueryFactory;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.apache.poi.xwpf.usermodel.XWPFRun;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.http.*;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.multipart.MultipartFile;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import jakarta.transaction.Transactional;
import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.JAXBException;
import jakarta.xml.bind.Unmarshaller;

import javax.management.InvalidApplicationException;
import java.io.*;
import java.math.BigInteger;
import java.nio.file.Files;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
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.ZipOutputStream;

@Component
public class DataManagementPlanManager {
    private static final Logger logger = LoggerFactory.getLogger(DataManagementPlanManager.class);
    private final ObjectMapper objectMapper;

//    private final Map<NotificationType, String> notificationPaths = Stream.of(new Object[][] {
//            {NotificationType.DMP_MODIFIED, "/plans/edit"},
//            {NotificationType.DMP_PUBLISH, "/plans/publicEdit"},
//            {NotificationType.DMP_FINALISED, "/plans/edit"},
//            {NotificationType.DMP_MODIFIED_FINALISED, "/plans/edit"}
//    }).collect(Collectors.toMap(data -> (NotificationType) data[0], data -> (String) data[1]));

    private ApiContext apiContext;
    private DatasetManager datasetManager;
    private DatabaseRepository databaseRepository;
    private Environment environment;
    private RDAManager rdaManager;
    private final MetricsManager metricsManager;
    private final ConfigLoader configLoader;
    private DepositService repositoriesDeposit;
    private final UserScope userScope;
    private final AuthorizationService authorizationService;
    private final DmpBlueprintService dmpBlueprintService;
    private final QueryFactory queryFactory;
    private final XmlHandlingService xmlHandlingService;

    @Autowired
    public DataManagementPlanManager(XmlHandlingService xmlHandlingService, ApiContext apiContext, DatasetManager datasetManager, Environment environment, RDAManager rdaManager, 
                                     MetricsManager metricsManager, ConfigLoader configLoader, DepositService repositoriesDeposit, UserScope userScope, AuthorizationService authorizationService, DmpBlueprintService dmpBlueprintService, QueryFactory queryFactory) {
        this.xmlHandlingService = xmlHandlingService;
        this.apiContext = apiContext;
        this.datasetManager = datasetManager;
        this.databaseRepository = apiContext.getOperationsContext().getDatabaseRepository();
        this.environment = environment;
        this.rdaManager = rdaManager;
        this.metricsManager = metricsManager;
        this.configLoader = configLoader;
        this.userScope = userScope;
        this.authorizationService = authorizationService;
        this.dmpBlueprintService = dmpBlueprintService;
        this.queryFactory = queryFactory;
        this.objectMapper = new ObjectMapper();
        this.repositoriesDeposit = repositoriesDeposit;
    }

    /*
    * Data Retrieval
    * */

    public DataTableData<DataManagementPlanListingModel> getPaged(DataManagementPlanTableRequest dataManagementPlanTableRequest, String fieldsGroup) throws Exception {
        UUID principalID = userScope.getUserIdSafe();
//        List<Dmp> dmps = null;
        QueryableList<DmpEntity> items = null;
        QueryableList<DmpEntity> authItems = null;
        Long totalData = 0L;
//        if (apiContext.getOperationsContext().getElasticRepository().getDmpRepository() != null) { //TODO
//            try {
//                DmpCriteria criteria = DmpCriteriaMapper.toElasticCriteria(dataManagementPlanTableRequest.getCriteria(), principalID);
//                criteria.setOffset(dataManagementPlanTableRequest.getOffset());
//                criteria.setSize(dataManagementPlanTableRequest.getLength());
//                criteria.setSortCriteria(DmpCriteriaMapper.toElasticSorting(dataManagementPlanTableRequest.getOrderings()));
//
//                dmps = apiContext.getOperationsContext().getElasticRepository().getDmpRepository().query(criteria);
//                if (dmps != null && !dmps.isEmpty()) {
//                    List<Dmp> finalDmps = dmps;
//                    items = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().asQueryable().where((builder, root) -> root.get("id").in(finalDmps.stream().map(Dmp::getId).collect(Collectors.toList())));
//                    PaginationManager.applyOrder(items, dataManagementPlanTableRequest);
//                    totalData = apiContext.getOperationsContext().getElasticRepository().getDmpRepository().count(criteria);
//                }
//            } catch (Exception ex) {
//                logger.warn(ex.getMessage(), ex);
//                items = null;
//            }
//        }

        if (items == null) {
            items = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().getWithCriteria(dataManagementPlanTableRequest.getCriteria());
        }
            List<Integer> roles = new LinkedList<>();
            if (!dataManagementPlanTableRequest.getCriteria().isOnlyPublic()) {
                if (dataManagementPlanTableRequest.getCriteria().getRole() != null)
                    roles.add(dataManagementPlanTableRequest.getCriteria().getRole());
                authItems = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().getAuthenticated(items, principalID, roles);
            } else {
                authItems = items;
            }
//        if (dmps == null) {
            totalData = authItems.count();
            items = PaginationManager.applyPaging(authItems, dataManagementPlanTableRequest);
//        } else {
//            items = authItems;
//        }



        DataTableData<DataManagementPlanListingModel> dataTable = new DataTableData<>();

        if (fieldsGroup.equals("listing")) {
            if (!dataManagementPlanTableRequest.getCriteria().isOnlyPublic()) {
                List<DmpEntity> dmps1 = items.withHint(HintedModelFactory.getHint(DataManagementPlanListingModel.class))
                                        .distinct().toList();
                dataTable.setData(dmps1.stream().map(dmp -> {
                    DatasetCriteria datasetCriteria = new DatasetCriteria();
                    datasetCriteria.setDmpIds(Collections.singletonList(dmp.getId()));
                    datasetCriteria.setAllVersions(dataManagementPlanTableRequest.getCriteria().getAllVersions());
                    datasetCriteria.setIsPublic(dataManagementPlanTableRequest.getCriteria().getIsPublic());
                    datasetCriteria.setGroupIds(Collections.singletonList(dmp.getGroupId()));
//                    try { //TODO
//                        dmp.setDataset(retrieveRelevantDatasets(datasetCriteria, principalID));
//                    } catch (InvalidApplicationException e) {
//                        throw new RuntimeException(e);
//                    }


                    return new DataManagementPlanListingModel().fromDataModelDatasets(dmp);
                }).collect(Collectors.toList()));
                /*.selectAsync(item -> {
                                            item.setDataset(
                                                    item.getDataset().stream()
                                                        .filter(dataset -> !dataset.getStatus().equals(Dataset.Status.DELETED.getValue()) && !dataset.getStatus().equals(Dataset.Status.CANCELED.getValue())).collect(Collectors.toList()).stream()
                                                        *//*.filter(dataset ->  dataset.getDmp().getUsers().stream()
                                                                          .filter(x -> x.getUser().getId().equals(principalID))
                                                                          .collect(Collectors.toList()).size() > 0)*//*
                                                        .collect(Collectors.toSet()));
                                            return new DataManagementPlanListingModel().fromDataModelDatasets(item);
                                        })
                                        .whenComplete((resultList, throwable) -> dataTable.setData(resultList));*/
            } else {
                List<DmpEntity> dmps1 = items.withHint(HintedModelFactory.getHint(DataManagementPlanListingModel.class))
                                        .distinct().toList();
                dataTable.setData(dmps1.stream().map(dmp -> {
                    DatasetCriteria datasetCriteria = new DatasetCriteria();
                    datasetCriteria.setDmpIds(Collections.singletonList(dmp.getId()));
                    datasetCriteria.setIsPublic(true);
                    datasetCriteria.setAllVersions(dataManagementPlanTableRequest.getCriteria().getAllVersions());
                    datasetCriteria.setGroupIds(Collections.singletonList(dmp.getGroupId()));
//                    try { //TODO
//                        dmp.setDataset(retrieveRelevantDatasets(datasetCriteria));
//                    } catch (InvalidApplicationException e) {
//                        throw new RuntimeException(e);
//                    }


                    return new DataManagementPlanListingModel().fromDataModelDatasets(dmp);
                }).collect(Collectors.toList()));
                                        /*.selectAsync(item -> {
                                            item.setDataset(
                                                    item.getDataset().stream()
                                                        .filter(dataset -> dataset.getStatus().equals(Dataset.Status.FINALISED.getValue())).collect(Collectors.toSet()));
                                            return new DataManagementPlanListingModel().fromDataModelDatasets(item);
                                        })
                                        .whenComplete((resultList, throwable) -> dataTable.setData(resultList));*/
            }
        } else if (fieldsGroup.equals("autocomplete")) {
            dataTable.setData(items
                    .distinct()
                    .select(item -> new DataManagementPlanListingModel().fromDataModelAutoComplete(item)));
        } else {
            dataTable.setData(items
                    .distinct()
                    .select(item -> new DataManagementPlanListingModel().fromDataModelAssociatedProfiles(item)));
        }

        //CompletableFuture countFuture = authItems.distinct().countAsync().whenComplete((count, throwable) -> dataTable.setTotalCount(count));
        dataTable.setTotalCount(totalData);
        //CompletableFuture.allOf(itemsFuture).join();
        return dataTable;
    }

    private Set<DescriptionEntity> retrieveRelevantDatasets(DatasetCriteria datasetCriteria) throws InvalidApplicationException {
        return retrieveRelevantDatasets(datasetCriteria, null);
    }

    private Set<DescriptionEntity> retrieveRelevantDatasets (DatasetCriteria datasetCriteria, UUID principal) throws InvalidApplicationException {
        QueryableList<DescriptionEntity> datasetItems = apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao().getWithCriteria(datasetCriteria)
                .orderBy((builder, root) -> builder.desc(root.get("modified")));
        if (principal != null) {
            UserEntity userInfo = this.queryFactory.query(UserQuery.class).ids(principal).first();
            List<Integer> roles = new ArrayList<>();
            roles.add(0);
            roles.add(1);
            datasetItems = apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao().getAuthenticated(datasetItems, userInfo, roles);
        }
        Long maxDatasets = datasetItems.distinct().count();
        DatasetTableRequest datasetTableRequest = new DatasetTableRequest();
        datasetTableRequest.setOffset(0);
        datasetTableRequest.setLength(3);
        Set<DescriptionEntity> datasetsSet = new LinkedHashSet<>();
        try {
            datasetItems = PaginationManager.applyPaging(datasetItems, datasetTableRequest);
            List<DescriptionEntity> descriptionEntities = datasetItems.distinct().toList();
            datasetsSet.addAll(descriptionEntities);
            for (int i = 0; i < maxDatasets - descriptionEntities.size(); i++) {
                DescriptionEntity fakedataset = new DescriptionEntity();
                fakedataset.setId(UUID.randomUUID());
                datasetsSet.add(fakedataset);
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }

        return datasetsSet;
    }

    public eu.eudat.models.data.dmp.DataManagementPlan getSingle(String id, boolean isPublic, boolean includeDatasets) throws Exception {
        eu.eudat.models.data.dmp.DataManagementPlan dataManagementPlan = new eu.eudat.models.data.dmp.DataManagementPlan();
        DmpEntity dataManagementPlanEntity = databaseRepository.getDmpDao().find(UUID.fromString(id));
        if (!isPublic && !this.userScope.isSet()) {
            throw new UnauthorisedException();
            //TODO
        } else if (!isPublic /*&& (dataManagementPlanEntity.getUsers().stream().noneMatch(userInfo -> this.userScope.getUserIdSafe().equals(userInfo.getUser().getId())))*/ ) {
            if (!dataManagementPlanEntity.getAccessType().equals(DmpAccessType.Public)) {
                throw new UnauthorisedException();
            }
        } else if (isPublic && !dataManagementPlanEntity.getAccessType().equals(DmpAccessType.Public)) {
            throw new ForbiddenException("Selected DMP is not public");
        }
        if (includeDatasets) {
            dataManagementPlan.fromDataModel(dataManagementPlanEntity);
            dataManagementPlan.getDatasets().forEach(datasetWizardModel -> datasetWizardModel.setDescription(null));
            dataManagementPlan.setDatasets(dataManagementPlan.getDatasets().stream().sorted(Comparator.comparing(DatasetWizardModel::getCreated).reversed()).collect(Collectors.toList()));
            //List<Dataset> datasetEnities = new ArrayList<>(dataManagementPlanEntity.getDataset());
        /*for (int i = 0; i < datasetEnities.size(); i++) {
            for (int j = i; j < dataManagementPlan.getDatasets().size(); j++) {
                if (dataManagementPlan.getDatasets().get(j).getId().equals(datasetEnities.get(i).getId())) {
                    dataManagementPlan.getDatasets().get(j).setDatasetProfileDefinition(datasetManager.getPagedProfile(dataManagementPlan.getDatasets().get(j), datasetEnities.get(i)));
                    break;
                }
            }
        }*/
            /*datasetEnities.stream()
                    .filter(dataset -> !dataset.getStatus().equals(Dataset.Status.DELETED) && !dataset.getStatus().equals(Dataset.Status.CANCELED))
                    .forEach(dataset -> {
                        dataManagementPlan.getDatasets().stream().filter(datasetWizardModel -> datasetWizardModel.getId().equals(dataset.getId())).forEach(datasetWizardModel -> {
                            DatasetWizardModel wizardModel = datasetManager.getSingle(datasetWizardModel.getId().toString(), principal);
                            datasetWizardModel.setDatasetProfileDefinition(wizardModel.getDatasetProfileDefinition());
                            datasetWizardModel.setTags(wizardModel.getTags());
                        });
                    });*/
            if (isPublic) {
                dataManagementPlan.setDatasets(dataManagementPlan.getDatasets().stream().filter(dataset -> dataset.getStatus() == DescriptionStatus.Finalized).collect(Collectors.toList()));
            }
        } else {
            dataManagementPlan.fromDataModelNoDatasets(dataManagementPlanEntity);
        }
        Map dmpProperties = new HashMap();//TODO dataManagementPlanEntity.getDmpProperties() != null ? new org.json.JSONObject(dataManagementPlanEntity.getDmpProperties()).toMap() : null;

        if (dmpProperties != null && dataManagementPlan.getDynamicFields() != null)
            dataManagementPlan.getDynamicFields().forEach(item -> {
                Map<String, String> properties = (Map<String, String>) dmpProperties.get(item.getId());
                if (properties != null)
                    item.setValue(new Tuple<>(properties.get("id"), properties.get("label")));
            });
        return dataManagementPlan;
    }

    public DataManagementPlanOverviewModel getOverviewSingle(String id, boolean isPublic) throws Exception {
        DmpEntity dataManagementPlanEntity = databaseRepository.getDmpDao().find(UUID.fromString(id));
        if (dataManagementPlanEntity.getIsActive().equals(IsActive.Inactive)) {
            throw new Exception("DMP is deleted.");
        }
        if (!isPublic && !this.userScope.isSet()) {
            throw new UnauthorisedException();
        } else
        if (!isPublic //&& dataManagementPlanEntity.getUsers() //TODO
                      //              .stream().noneMatch(userInfo -> userInfo.getUser().getId().equals(this.userScope.getUserIdSafe()))
        ) {
            throw new UnauthorisedException();
        } else if (isPublic && !dataManagementPlanEntity.getAccessType().equals(DmpAccessType.Public)) {
            throw new ForbiddenException("Selected DMP is not public");
        }
        DataManagementPlanOverviewModel datamanagementPlan = new DataManagementPlanOverviewModel();
        datamanagementPlan.fromDataModelDatasets(dataManagementPlanEntity);
        datamanagementPlan.setDatasets(datamanagementPlan.getDatasets().stream().sorted(Comparator.comparing(DatasetOverviewModel::getCreated).reversed()).collect(Collectors.toList()));
        if (isPublic) {
            datamanagementPlan.setDatasets(datamanagementPlan.getDatasets().stream().filter(dataset -> dataset.getStatus() == DescriptionStatus.Finalized).collect(Collectors.toList()));
        }

        return datamanagementPlan;
    }

//    public List<Tuple<String, String>> getDynamicFields(String id, DynamicGrantConfiguration dynamicGrantConfiguration, DynamicFieldsCriteria criteria) throws IllegalAccessException, InstantiationException {
//        List<Tuple<String, String>> result = new LinkedList<>();
//        RestTemplate restTemplate = new RestTemplate();
//        HttpHeaders headers = new HttpHeaders();
//        headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
//        headers.setContentType(MediaType.APPLICATION_JSON);
//        HttpEntity<String> entity = new HttpEntity<>("parameters", headers);
//
//        Property property = dynamicGrantConfiguration.getConfiguration().getConfigurationProperties().stream()
//                                                     .filter(item -> item.getId().equals(id)).findFirst().orElse(null);
//        StringBuilder stringBuilder = new StringBuilder();
//        if (criteria.getLike() != null) stringBuilder.append("?search=" + criteria.getLike());
//        if (property.getDependencies() != null && !property.getDependencies().isEmpty() && criteria.getDynamicFields() != null && !criteria.getDynamicFields().isEmpty()) {
//            property.getDependencies().stream().forEach(item -> {
//                DynamicFieldsCriteria.DynamicFieldDependencyCriteria dependencyCriteria = criteria.getDynamicFields().stream().filter(dfield -> dfield.getProperty().equals(item.getId()))
//                                                                                                  .findFirst().orElse(null);
//                if (dependencyCriteria != null) {
//                    if (criteria.getLike() != null || property.getDependencies().indexOf(item) > 0)
//                        stringBuilder.append("&");
//                    stringBuilder.append(item.getQueryProperty() + "=" + dependencyCriteria.getValue());
//                }
//            });
//
//            ResponseEntity<ArrayList> response = restTemplate.exchange(property.getSourceUrl() + stringBuilder.toString(), HttpMethod.GET, entity, ArrayList.class);
//            response.getBody().forEach(item -> {
//                Tuple<String, String> tuple = new Tuple<>();
//                tuple.setId((String) (((Map<String, Object>) item).get(property.getExternalFieldId())));
//                tuple.setLabel((String) (((Map<String, Object>) item).get(property.getExternalFieldLabel())));
//                result.add(tuple);
//            });
//
//        } else {
//            ResponseEntity<ArrayList> response = restTemplate.exchange(property.getSourceUrl() + stringBuilder.toString(), HttpMethod.GET, entity, ArrayList.class);
//            response.getBody().forEach(item -> {
//                Tuple<String, String> tuple = new Tuple<>();
//                tuple.setId((String) (((Map<String, Object>) item).get(property.getExternalFieldId())));
//                tuple.setLabel((String) (((Map<String, Object>) item).get(property.getExternalFieldLabel())));
//                result.add(tuple);
//            });
//        }
//        return result;
//    }

    public DataTableData<DatasetProfileListingModel> getDatasetProfilesUsedByDMP(DatasetProfileTableRequestItem datasetProfileTableRequestItem) throws InvalidApplicationException {
        datasetProfileTableRequestItem.getCriteria().setFilter(DatasetProfileCriteria.DatasetProfileFilter.DMPs.getValue());
        datasetProfileTableRequestItem.getCriteria().setUserId(this.userScope.getUserId());

        QueryableList<eu.eudat.data.DescriptionTemplateEntity> 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;
    }

    public List<VersionListingModel> getAllVersions(String groupId, Boolean isPublic) throws InvalidApplicationException {
        UUID principalId = this.userScope.getUserIdSafe();
        List<VersionListingModel> versions = new ArrayList<>();
        QueryableList<DmpEntity> items = null;
        QueryableList<DmpEntity> authItems = null;
        List<Integer> roles = new LinkedList<>();
        DataManagementPlanCriteria criteria = new DataManagementPlanCriteria();
        criteria.setGroupIds(Collections.singletonList(UUID.fromString(groupId)));
        criteria.setAllVersions(true);
        criteria.setIsPublic(isPublic);
        criteria.setOnlyPublic(isPublic);
        items = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().getWithCriteria(criteria);
        if (!isPublic) {
            authItems = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().getAuthenticated(items, principalId, roles);
        } else {
            authItems = items;
        }
        CompletableFuture<List<VersionListingModel>> versionFuture = authItems.withHint(HintedModelFactory.getHint(VersionListingModel.class))
                 .orderBy(((builder, root) -> builder.desc(root.get("version"))))
                 .selectAsync(item -> new VersionListingModel().fromDataModel(item))
                 .whenComplete(((versionListingModels, throwable) -> versions.addAll(versionListingModels)));

        CompletableFuture.allOf(versionFuture).join();

        return versions;
    }

    /*
    * Data Management
    * */

    @Transactional
    public DmpEntity createOrUpdate(DataManagementPlanEditorModel dataManagementPlan) throws Exception {
        boolean setNotification = false;
        if (dataManagementPlan.getId() != null) {
            DmpEntity dmp1 = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(dataManagementPlan.getId());
            
            Instant dbTime = dmp1.getUpdatedAt().truncatedTo(ChronoUnit.SECONDS);
            Instant modelTime = dmp1.getUpdatedAt().truncatedTo(ChronoUnit.SECONDS);

            if (!isUserOwnerOfDmp(dmp1)) {
                throw new Exception("User not being the creator is not authorized to edit this DMP.");
            }
            if (dbTime.toEpochMilli() != modelTime.toEpochMilli()) {
                throw new Exception("Another user have already edit that DMP.");
            }
            DatasetCriteria datasetCriteria = new DatasetCriteria();
            datasetCriteria.setDmpIds(List.of(dmp1.getId()));
            
            List<DescriptionEntity> descriptionEntityList = this.databaseRepository.getDatasetDao().getWithCriteria(datasetCriteria).toList().stream().filter(dataset -> dataset.getIsActive() != IsActive.Inactive).collect(Collectors.toList());
            for (DescriptionEntity descriptionEntity : descriptionEntityList) {
                if (dataManagementPlan.getProfiles().stream().filter(associatedProfile -> descriptionEntity.getDescriptionTemplateId().equals(associatedProfile.getDescriptionTemplateId())).findAny().orElse(null) == null)
                    throw new Exception("Dataset Template for Dataset Description is missing from the DMP.");
            }
            if (dataManagementPlan.getStatus() == DmpStatus.Finalized.getValue() && dmp1.getStatus().equals(DmpStatus.Finalized.getValue() ))
                throw new Exception("DMP is finalized, therefore cannot be edited.");

            setNotification = true;
        } else {
            metricsManager.increaseValue(MetricNames.DMP, 1, MetricNames.DRAFT);
        }

        DmpEntity newDmp = dataManagementPlan.toDataModel();
        if(dataManagementPlan.getProfile() != null){
            newDmp.setBlueprintId(dataManagementPlan.getProfile().getId());
        }
        if (newDmp.getStatus().equals(DmpStatus.Finalized)) {
            checkDmpValidationRules(newDmp);
        }
        UserEntity user = this.queryFactory.query(UserQuery.class).ids(this.userScope.getUserId()).first();
        newDmp.setCreatorId(user.getId());
        DmpBlueprintEntity dmpBlueprint = this.queryFactory.query(DmpBlueprintQuery.class).ids(newDmp.getBlueprintId()).first();

//        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Organizations)) {
//            createOrganisationsIfTheyDontExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getOrganisationDao());
//        }
//        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Researchers)) {
//            createResearchersIfTheyDontExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getResearcherDao(), user);
//        } //TODO
//        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Funder)) {
//            createFunderIfItDoesntExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getFunderDao());
//        }/TODO
//        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Grant)) {
//            createGrantIfItDoesntExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getGrantDao());
//            if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Project)) {
////                if (newDmp.getProject() != null && newDmp.getGrant() != null && (newDmp.getProject().getLabel() == null || newDmp.getProject().getLabel().trim().isEmpty())) { //TODO
////                    newDmp.setProject(newDmp.getProject().projectFromGrant(newDmp.getGrant()));
////                }
////                createProjectIfItDoesntExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getProjectDao()); //TODO
//            }
//        }

        DmpEntity dmp;
        if (dataManagementPlan.getId() != null) {
            dmp = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(dataManagementPlan.getId());
        } else dmp = new DmpEntity();

        newDmp.setCreatedAt(dmp.getCreatedAt() == null ? Instant.now() : dmp.getCreatedAt());
        DmpEntity finalNewDmp = newDmp;
        if (this.queryFactory.query(DmpUserQuery.class).dmpIds(finalNewDmp.getId()).collect() != null &&
                this.queryFactory.query(DmpUserQuery.class).dmpIds(finalNewDmp.getId()).collect().stream().filter(userInfo -> this.userScope.getUserIdSafe().equals(userInfo.getUserId()))
                                              .collect(Collectors.toList()).size() == 0) {
            List<DmpUserEntity> userDMPList = new ArrayList<>(this.queryFactory.query(DmpUserQuery.class).dmpIds(finalNewDmp.getId()).collect());
            for (DmpUser userInfoListingModel : dataManagementPlan.getUsers()) {
                for (DmpUserEntity userDMP : userDMPList) {
                    if (!(userDMP.getUserId().equals(userInfoListingModel.getId()))) {
//                        apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().delete(userDMP);
                    }
                }
            }
        }

        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Grant)) {
//            if (newDmp.getGrant() != null && newDmp.getGrant().getType().equals(Grant.GrantType.INTERNAL.getValue())) {
//                checkIfUserCanEditGrant(newDmp, user);
//            }//TODO
            assignGrandUserIfInternal(newDmp, user);
        }
        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Funder)) {
            assignFunderUserIfInternal(newDmp, user);
        }
        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Project)) {
            assignProjectUserIfInternal(newDmp, user);
        }

        if(newDmp.getId() != null){
//            for(DMPDatasetProfile dmpDatasetProfile : newDmp.getAssociatedDmps()){ //TODO
//                apiContext.getOperationsContext().getDatabaseRepository().getDmpDatasetProfileDao().createOrUpdate(dmpDatasetProfile);
//            }
        }

        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Grant)) {
//            if (newDmp.getGrant() != null) { //TODO
//                apiContext.getOperationsContext().getDatabaseRepository().getGrantDao().createOrUpdate(newDmp.getGrant());
//            }
        }
        newDmp = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(newDmp);

//        for(DMPDatasetProfile dmpDatasetProfile : newDmp.getAssociatedDmps()){ //TODO
//            apiContext.getOperationsContext().getDatabaseRepository().getDmpDatasetProfileDao().createOrUpdate(dmpDatasetProfile);
//        }

        if (dataManagementPlan.getUsers() != null && !dataManagementPlan.getUsers().isEmpty()) {
            clearUsers(newDmp);
            for (DmpUser userListing : dataManagementPlan.getUsers()) {
                UserEntity tempUser = this.queryFactory.query(UserQuery.class).ids(userListing.getId()).first();
                assignUser(dmp, tempUser, userListing.getRole());
            }
        }

        // Dataset manipulation for when the DMP is set to be finalized.
        if (dataManagementPlan.getStatus() == DmpStatus.Finalized.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"), DescriptionStatus.Finalized);
                apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao()
                          .asQueryable().where((builder, root) -> root.get("id").in(dataManagementPlan.getDatasetsToBeFinalized()))
                          .update(root -> root.<Date>get("finalizedat"), new Date());

                List<UUID> datasetsToBeCanceled = new LinkedList<>();
                for (DatasetWizardModel dataset : dataManagementPlan.getDatasets()) {
                    if (!(dataset.getStatus() == DescriptionStatus.Finalized) && !dataManagementPlan.getDatasetsToBeFinalized().contains(dataset.getId())) {
                        datasetsToBeCanceled.add(UUID.fromString(dataset.getId().toString()));
                    }
                }
                if (!datasetsToBeCanceled.isEmpty())
                    apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao()
                              .asQueryable().where((builder, root) -> root.get("id").in(datasetsToBeCanceled))
                              .update(root -> root.<Integer>get("status"), DescriptionStatus.Canceled);
            } else {
                List<UUID> datasetsToBeCanceled = new LinkedList<>();
                for (DatasetWizardModel dataset : dataManagementPlan.getDatasets()) {
                    if (!(dataset.getStatus() == DescriptionStatus.Finalized)) {
                        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"), DescriptionStatus.Canceled);
            }
        }

//        if (dataManagementPlan.getAssociatedUsers().size() == 0)
//            assignUser(newDmp, user);

        UUID dmpId = newDmp.getId();
        //TODO
//        newDmp.setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), dmpId)).toList()));

        //this.updateIndex(newDmp); //TODO

        if (setNotification) {
            if (newDmp.getStatus().equals(DmpStatus.Finalized.getValue())) {
                this.sendNotification(newDmp, user/*, NotificationType.DMP_MODIFIED*/);
            } else {
                this.sendNotification(newDmp, user/*, , NotificationType.DMP_MODIFIED_FINALISED*/);
            }
        }

        return newDmp;
    }

    public DmpEntity createOrUpdateWithDatasets(DataManagementPlanEditorModel dataManagementPlan) throws Exception {
        if (dataManagementPlan.getId() != null) {
            DmpEntity dmp1 = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(dataManagementPlan.getId());
            
            Instant dbTime = dmp1.getUpdatedAt().truncatedTo(ChronoUnit.SECONDS);
            Instant modelTime = Instant.ofEpochMilli(dataManagementPlan.getModified().getTime()).truncatedTo(ChronoUnit.SECONDS);

            if (!isUserOwnerOfDmp(dmp1)) {
                throw new Exception("User not being the creator is not authorized to edit this DMP.");
            }
            if (dbTime.toEpochMilli() != modelTime.toEpochMilli()) {
                throw new Exception("Another user have already edit that DMP.");
            }
            for (DatasetWizardModel dataset : dataManagementPlan.getDatasets()) {
                if (dataManagementPlan.getProfiles().stream().filter(associatedProfile -> dataset.getProfile().getId().equals(associatedProfile.getDescriptionTemplateId())).findAny().orElse(null) == null)
                    throw new Exception("Dataset Template for Dataset Description is missing from the DMP.");
            }
            if (dataManagementPlan.getStatus() == (int) DmpStatus.Finalized.getValue() && dmp1.getStatus().equals(DmpStatus.Finalized.getValue()))
                throw new Exception("DMP is finalized, therefore cannot be edited.");
        } else {
            metricsManager.increaseValue(MetricNames.DMP, 1, MetricNames.DRAFT);
        }
        List<DescriptionEntity> descriptionEntities = new ArrayList<>();
        DmpEntity tempDMP = dataManagementPlan.toDataModel();
        if (tempDMP.getStatus().equals(DmpStatus.Finalized)) {
            checkDmpValidationRules(tempDMP);
        }
        UserEntity user = this.queryFactory.query(UserQuery.class).ids(this.userScope.getUserId()).first();
        DmpBlueprintEntity dmpBlueprint = this.queryFactory.query(DmpBlueprintQuery.class).ids(tempDMP.getBlueprintId()).first();
        
//        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Organizations)) {
//            createOrganisationsIfTheyDontExist(tempDMP, apiContext.getOperationsContext().getDatabaseRepository().getOrganisationDao());
//        }
//        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Researchers)) {
//            createResearchersIfTheyDontExist(tempDMP, apiContext.getOperationsContext().getDatabaseRepository().getResearcherDao(), user);
//        }
//        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Funder)) {
//            createFunderIfItDoesntExist(tempDMP, apiContext.getOperationsContext().getDatabaseRepository().getFunderDao());
//        }
//        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Grant)) {
//            createGrantIfItDoesntExist(tempDMP, apiContext.getOperationsContext().getDatabaseRepository().getGrantDao());
//        }//TODO

        DmpEntity result = createOrUpdate(dataManagementPlan);

        for (DatasetWizardModel datasetWizardModel: dataManagementPlan.getDatasets()) {
            datasetWizardModel.setDmp(new DataManagementPlan().fromDataModel(result));
            DescriptionEntity descriptionEntity = datasetManager.createOrUpdate(datasetWizardModel);
            descriptionEntities.add(descriptionEntity);
        }

        UUID dmpId = result.getId();
        //result.setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), dmpId)).toList())); //TODO

        //this.updateIndex(result); //TODO

        return result;
    }

    public UUID newVersion(UUID uuid, DataManagementPlanNewVersionModel dataManagementPlan) throws Exception {
        DmpEntity oldDmp = databaseRepository.getDmpDao().find(uuid);
        if (!isUserOwnerOfDmp(oldDmp)) {
            throw new Exception("User not being the creator is not authorized to perform this action.");
        }
        DataManagementPlanCriteria criteria = new DataManagementPlanCriteria();
        LinkedList<UUID> list = new LinkedList<>();
        list.push(oldDmp.getGroupId());
        criteria.setGroupIds(list);
        criteria.setAllVersions(false);
        QueryableList<DmpEntity> dataManagementPlanQueryableList = databaseRepository.getDmpDao().getWithCriteria(criteria);
        List<DmpEntity> latestVersionDMP = dataManagementPlanQueryableList.toList();

        if (latestVersionDMP.get(0).getVersion().equals(oldDmp.getVersion())) {
            DmpEntity newDmp = dataManagementPlan.toDataModel();
            newDmp.setBlueprintId(oldDmp.getBlueprintId());
            newDmp.setProperties(oldDmp.getProperties());
            newDmp.setProperties(oldDmp.getProperties());
            UserEntity user = apiContext.getOperationsContext().getBuilderFactory().getBuilder(UserInfoBuilder.class).id(this.userScope.getUserId()).build();
            newDmp.setCreatorId(user.getId());
            DmpBlueprintEntity dmpBlueprint = this.queryFactory.query(DmpBlueprintQuery.class).ids(newDmp.getBlueprintId()).first();
//            if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Organizations)) {
//                createOrganisationsIfTheyDontExist(newDmp, databaseRepository.getOrganisationDao());
//            }
//            if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Researchers)) {
//                createResearchersIfTheyDontExist(newDmp, databaseRepository.getResearcherDao(), user);
//            }//TODO
//            if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Funder)) {
//                createFunderIfItDoesntExist(newDmp, databaseRepository.getFunderDao());
//            }//TODO
//            if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Grant)) {
//                createGrantIfItDoesntExist(newDmp, databaseRepository.getGrantDao());
//                if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Project)) {
//                    //TODO
////                    if (newDmp.getProject() != null && newDmp.getGrant() != null && (newDmp.getProject().getLabel() == null || newDmp.getProject().getLabel().trim().isEmpty())) {
////                        newDmp.setProject(newDmp.getProject().projectFromGrant(newDmp.getGrant()));
////                    }
////                    createProjectIfItDoesntExist(newDmp, databaseRepository.getProjectDao()); //TODO
//                }
//            }//TODO

            newDmp.setGroupId(oldDmp.getGroupId());
            newDmp.setVersion((short)(oldDmp.getVersion() + 1));
            newDmp.setId(null);

            if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Grant)) {
                //TODO
//                if (newDmp.getGrant() != null && newDmp.getGrant().getType().equals(Grant.GrantType.INTERNAL.getValue())) {
//                    checkIfUserCanEditGrant(newDmp, user);
//                }
                assignGrandUserIfInternal(newDmp, user);
            }
            if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Funder)) {
                assignFunderUserIfInternal(newDmp, user);
            }
            if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Project)) {
                assignProjectUserIfInternal(newDmp, user);
            }
            if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Grant)) {
                //TODO
//                if (newDmp.getGrant() != null) {
//                    if (newDmp.getGrant().getStartdate() == null) {
//                        newDmp.getGrant().setStartdate(new Date());
//                    }
//                    if (newDmp.getGrant().getEnddate() == null) {
//                        newDmp.getGrant().setEnddate(Date.from(Instant.now().plus(365, ChronoUnit.DAYS)));
//                    }
//                    databaseRepository.getGrantDao().createOrUpdate(newDmp.getGrant());
//                }
            }
            DmpEntity tempDmp = databaseRepository.getDmpDao().createOrUpdate(newDmp);
            newDmp.setId(tempDmp.getId());
            //TODO
//            for(DMPDatasetProfile dmpDatasetProfile : newDmp.getAssociatedDmps()){
//                apiContext.getOperationsContext().getDatabaseRepository().getDmpDatasetProfileDao().createOrUpdate(dmpDatasetProfile);
//            }

            // Assign creator.
            //assignUser(newDmp, user);

            copyDatasets(newDmp, databaseRepository.getDatasetDao());

            this.queryFactory.query(DmpUserQuery.class).dmpIds(oldDmp.getId()).collect()
                    .stream().forEach(userDMP -> {
                        DmpUserEntity temp = new DmpUserEntity();
                        temp.setUserId(userDMP.getUserId());
                        temp.setRole(userDMP.getRole());
                        temp.setDmpId(newDmp.getId());
//                        apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().createOrUpdate(temp);
                    });

           //TODO
            //newDmp.setUsers(new HashSet<>(databaseRepository.getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), newDmp.getId())).toList()));

            DatasetCriteria criteria1 = new DatasetCriteria();
            criteria1.setDmpIds(Collections.singletonList(newDmp.getId()));
            //TODO
            //newDmp.setDataset(new HashSet<>(databaseRepository.getDatasetDao().getWithCriteria(criteria1).toList()));

            this.updateGroupIndex(newDmp.getGroupId());
            return newDmp.getId();
        } else {
            throw new DMPNewVersionException("Version to update not the latest.");
        }
    }

    public UUID clone(UUID uuid, DataManagementPlanNewVersionModel dataManagementPlan) throws Exception {
        DmpEntity oldDmp = databaseRepository.getDmpDao().find(uuid);
        DmpEntity newDmp = dataManagementPlan.toDataModel();
        newDmp.setBlueprintId(oldDmp.getBlueprintId());
        newDmp.setProperties(oldDmp.getProperties());
        newDmp.setProperties(oldDmp.getProperties());

        UserEntity user = apiContext.getOperationsContext().getBuilderFactory().getBuilder(UserInfoBuilder.class).id(this.userScope.getUserId()).build();
        newDmp.setCreatorId(user.getId());
        DmpBlueprintEntity dmpBlueprint = this.queryFactory.query(DmpBlueprintQuery.class).ids(newDmp.getBlueprintId()).first();
//        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Organizations)) {
//            createOrganisationsIfTheyDontExist(newDmp, databaseRepository.getOrganisationDao());
//        }
//        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Researchers)) {
//            createResearchersIfTheyDontExist(newDmp, databaseRepository.getResearcherDao(), user);
//        } 
//        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Funder)) {
//            createFunderIfItDoesntExist(newDmp, databaseRepository.getFunderDao());
//        }
//        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Grant)) {
//            createGrantIfItDoesntExist(newDmp, databaseRepository.getGrantDao());
//            //TODO
////            if(this.dmpBlueprintService.fieldInBlueprint(newDmp.getProfile(), DmpBlueprintSystemFieldType.Project)) {
////                if (newDmp.getProject() != null && newDmp.getGrant() != null && (newDmp.getProject().getLabel() == null || newDmp.getProject().getLabel().trim().isEmpty())) {
////                    newDmp.setProject(newDmp.getProject().projectFromGrant(newDmp.getGrant()));
////                }
////                createProjectIfItDoesntExist(newDmp, databaseRepository.getProjectDao());
////            }
//        }//TODO

        newDmp.setGroupId(UUID.randomUUID());
        newDmp.setVersion((short)0);
        newDmp.setId(null);

        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Grant)) {
            //TODO
//            if (newDmp.getGrant() != null && newDmp.getGrant().getType().equals(Grant.GrantType.INTERNAL.getValue())) {
//                checkIfUserCanEditGrant(newDmp, user);
//            }
            assignGrandUserIfInternal(newDmp, user);
        }
        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Funder)) {
            assignFunderUserIfInternal(newDmp, user);
        }
        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Project)) {
            assignProjectUserIfInternal(newDmp, user);
        }
        if(this.dmpBlueprintService.fieldInBlueprint(dmpBlueprint, DmpBlueprintSystemFieldType.Grant)) {
            //TODO
//            if (newDmp.getGrant() != null) {
//                databaseRepository.getGrantDao().createOrUpdate(newDmp.getGrant());
//            }
        }
        DmpEntity tempDmp = databaseRepository.getDmpDao().createOrUpdate(newDmp);
        newDmp.setId(tempDmp.getId());
        //TODO
//        for(DMPDatasetProfile dmpDatasetProfile : newDmp.getAssociatedDmps()){
//            apiContext.getOperationsContext().getDatabaseRepository().getDmpDatasetProfileDao().createOrUpdate(dmpDatasetProfile);
//        }

        assignUser(newDmp, user);
        copyDatasets(newDmp, databaseRepository.getDatasetDao());

        //TODO
//        newDmp.setUsers(new HashSet<>(databaseRepository.getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), newDmp.getId())).toList()));

        DatasetCriteria criteria1 = new DatasetCriteria();
        criteria1.setDmpIds(Collections.singletonList(newDmp.getId()));
        //TODO
//        newDmp.setDataset(new HashSet<>(databaseRepository.getDatasetDao().getWithCriteria(criteria1).toList()));
        UUID dmpId = newDmp.getId();
        //TODO
//        newDmp.setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), dmpId)).toList()));

        //this.updateIndex(newDmp); //TODO
        metricsManager.increaseValue(MetricNames.DMP, 1, MetricNames.DRAFT);

        return newDmp.getId();
    }

    public void delete(UUID uuid) throws DMPWithDatasetsDeleteException, IOException, InvalidApplicationException {
        DatasetCriteria criteria = new DatasetCriteria();
        List<UUID> dmpIds = Collections.singletonList(uuid);
        criteria.setDmpIds(dmpIds);
        if (apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao().getWithCriteria(criteria).toList().size() > 0)
            throw new DMPWithDatasetsDeleteException("You cannot Remove Datamanagement Plan with Datasets");
        DmpEntity oldDmp = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(uuid);
        switch (oldDmp.getStatus()) {
            case Draft:
                metricsManager.decreaseValue(MetricNames.DMP, 1, MetricNames.DRAFT);
                break;
            case Finalized:
                //TODO
//                if (oldDmp.getDois() != null && !oldDmp.getDois().isEmpty()) {
//                    metricsManager.decreaseValue(MetricNames.DMP, 1, MetricNames.DOIED);
//                }
//                if (oldDmp.isPublic()) {
//                    metricsManager.decreaseValue(MetricNames.DMP, 1, MetricNames.PUBLISHED);
//                }
                metricsManager.decreaseValue(MetricNames.DMP, 1, MetricNames.FINALIZED);
                break;
        }
        oldDmp.setIsActive(IsActive.Inactive);
        apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(oldDmp);
        UUID dmpId = oldDmp.getId();
//        oldDmp.setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), dmpId)).toList())); //TODO
//        this.updateIndex(oldDmp); //TODO
        DataManagementPlanCriteria criteria1 = new DataManagementPlanCriteria();
        criteria1.setAllVersions(true);
        criteria1.setGroupIds(Collections.singletonList(oldDmp.getGroupId()));
        apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().getWithCriteria(criteria1).toList().forEach(dmp -> {
            //TODO
//            try {
//                UUID tdmpId = dmp.getId();
//                //TODO
//                //dmp.setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), tdmpId)).toList()));
//                //this.updateIndex(dmp); //TODO
//            } catch (InvalidApplicationException e) {
//                logger.error(e.getMessage(), e);
//            }
//            for (DescriptionEntity descriptionEntity : dmp.getDataset()) {
//
//                try {
//                    List<Tag> tags = new ArrayList<>();
//                    eu.eudat.elastic.entities.Dataset elastic = apiContext.getOperationsContext().getElasticRepository().getDatasetRepository().findDocument(descriptionEntity.getId().toString());
//                    if (elastic != null) {
//                        tags = elastic.getTags();
//                    }
//                    //descriptionEntity.setDmpId(dmp.getId()); //TODO
//                    this.datasetManager.updateTags(descriptionEntity, tags);
//                } catch (Exception e) {
//                    logger.error(e.getMessage(), e);
//                }
//            }
        });
    }

//    private void createResearchersIfTheyDontExist(DmpEntity newDmp, ResearcherDao researcherRepository, UserEntity user) throws InvalidApplicationException {
//        if (newDmp.getResearchers() != null && !newDmp.getResearchers().isEmpty()) { //TODO
//            for (eu.eudat.data.old.Researcher researcher : newDmp.getResearchers()) {
//                ResearcherCriteria criteria = new ResearcherCriteria();
//                criteria.setReference(researcher.getReference());
//                List<eu.eudat.data.old.Researcher> entries = researcherRepository.getWithCriteria(criteria).toList();
//                if (entries != null && !entries.isEmpty()) researcher.setId(entries.get(0).getId());
//                else {
//                    researcher.setCreationUser(user);
//                    researcherRepository.createOrUpdate(researcher);
//                    metricsManager.increaseValue(MetricNames.RESEARCHER, 1, null);
//                }
//            }
//        }
//    }

//    private void createOrganisationsIfTheyDontExist(DmpEntity newDmp, OrganisationDao organisationRepository) throws InvalidApplicationException {
//        if (newDmp.getOrganisations() != null && !newDmp.getOrganisations().isEmpty()) { //TODO
//            for (Organisation organisation : newDmp.getOrganisations()) {
//                boolean createNew = false;
//                if (organisation.getReference() != null) {
//                    OrganisationCriteria criteria = new OrganisationCriteria();
//                    criteria.setLike(organisation.getReference());
//                    List<eu.eudat.data.old.Organisation> entries = organisationRepository.getWithCriteria(criteria).toList();
//                    if (entries != null && !entries.isEmpty()) organisation.setId(entries.get(0).getId());
//                    else createNew = true;
//                } else {
//                    createNew = true;
//                }
//
//                if (createNew) {
//                    if (organisation.getReference() == null) {
//                        organisation.setReference("Internal:" + UUID.randomUUID().toString());
//                    }
//                    organisationRepository.createOrUpdate(organisation);
//                }
//            }
//        }
//    }

//    private void createGrantIfItDoesntExist(DmpEntity newDmp, GrantDao grantDao) throws InvalidApplicationException {
//        if (newDmp.getGrant() != null) { //TODO
//            Grant grant = newDmp.getGrant();
//            GrantCriteria criteria = new GrantCriteria();
//            if (grant.getReference() != null) {
//                criteria.setReference(grant.getReference());
//                Grant grantEntity = grantDao.getWithCriteria(criteria).toList().stream().max(Comparator.comparing(grant1 -> grant1.getModified().getTime())).orElse(null);
//                if (grantEntity != null) grant.setId(grantEntity.getId());
//                else {
//                    grant.setType(Grant.GrantType.EXTERNAL.getValue());
//                    grant.setCreationUser(null);
//                    if (grant.getStartdate() == null) {
//                        grant.setStartdate(new Date());
//                    }
//                    if (grant.getEnddate() == null) {
//                        grant.setEnddate(Date.from(Instant.now().plus(365, ChronoUnit.DAYS)));
//                    }
//                    grantDao.createOrUpdate(grant);
//                }
//            }
//            else {
//                grant.setType(Grant.GrantType.EXTERNAL.getValue());
//                grant.setCreationUser(null);
//                grantDao.createOrUpdate(grant);
//            }
//        }
//    }

//    private void createFunderIfItDoesntExist(DmpEntity newDmp, FunderDao funderDao) throws InvalidApplicationException {
//        if (newDmp.getGrant() != null && newDmp.getGrant().getFunder() != null) { //TODO
//            Funder funder = newDmp.getGrant().getFunder();
//            FunderCriteria criteria = new FunderCriteria();
//            if (funder.getReference() != null) {
//                criteria.setReference(funder.getReference());
//                Funder funderEntity = funderDao.getWithCritetia(criteria).toList().stream().max(Comparator.comparing(funder1 -> funder1.getModified().getTime())).orElse(null);
//                if (funderEntity != null) funder.setId(funderEntity.getId());
//                else {
//                    funderDao.createOrUpdate(funder);
//                }
//            }
//            else {
//                funderDao.createOrUpdate(funder);
//            }
//        }
//    }

//    private void createProjectIfItDoesntExist(DmpEntity newDmp, ProjectDao projectDao) throws InvalidApplicationException { //TODO
//        if (newDmp.getProject() != null) {
//            Project project = newDmp.getProject();
//            ProjectCriteria criteria = new ProjectCriteria();
//            if (project.getReference() != null) {
//                criteria.setReference(project.getReference());
//                Project projectEntity = projectDao.getWithCritetia(criteria).toList().stream().max(Comparator.comparing(project1 -> project1.getModified().getTime())).orElse(null);
//                if (projectEntity != null) project.setId(projectEntity.getId());
//                else {
//                    createExternalProject(project, projectDao);
//                }
//            }
//            else {
//                createExternalProject(project, projectDao);
//            }
//        }
//    }
//
//    private void createExternalProject(Project project, ProjectDao projectDao) {
//        if (project.getStartdate() == null) project.setStartdate(new Date());
//        if (project.getEnddate() == null) project.setEnddate(new Date());
//        project.setType(Project.ProjectType.EXTERNAL.getValue());
//        if (project.getId() == null) project.setId(UUID.randomUUID());
//        projectDao.createOrUpdate(project);
//        metricsManager.increaseValue(MetricNames.PROJECT, 1, null);
//    }

    private void copyDatasets(DmpEntity newDmp, DatasetDao datasetDao) throws InvalidApplicationException {
        List<CompletableFuture<DescriptionEntity>> futures = new LinkedList<>();
        DatasetCriteria datasetCriteria = new DatasetCriteria();
        datasetCriteria.setDmpIds(List.of(newDmp.getId()));
        for (DescriptionEntity descriptionEntity : this.databaseRepository.getDatasetDao().getWithCriteria(datasetCriteria).toList()) {
            DescriptionEntity tempDescriptionEntity = datasetDao.find(descriptionEntity.getId());
            //TODO
//            try {
//                List<Tag> tags = new ArrayList<>();
//                eu.eudat.elastic.entities.Dataset elastic = apiContext.getOperationsContext().getElasticRepository().getDatasetRepository().findDocument(descriptionEntity.getId().toString());
//                if (elastic != null) {
//                    tags = elastic.getTags();
//                }
//                //TODO
//                //UUID dmpId = tempDescriptionEntity.getDmpId();
//                //tempDescriptionEntity.getDmp().setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), dmpId)).toList()));
//                this.datasetManager.updateTags(tempDescriptionEntity, tags);
//            } catch (Exception e) {
//                logger.error(e.getMessage(), e);
//            }
            datasetDao.asQueryable().withHint(HintedModelFactory.getHint(DatasetListingModel.class)).where((builder, root) -> builder.equal(root.get("id"), descriptionEntity.getId())).getSingleAsync()
                      .thenApplyAsync(entityDataset -> {
                          DescriptionEntity newDescriptionEntity = new DescriptionEntity();
                          newDescriptionEntity.update(entityDataset);
                          newDescriptionEntity.setStatus(DescriptionStatus.Draft);
                          //TODO
                          //newDescriptionEntity.setDmpId(newDmp.getId());
                          
//                          if (newDescriptionEntity.getDatasetDataRepositories() != null) {
//                              newDescriptionEntity.setDatasetDataRepositories(newDescriptionEntity.getDatasetDataRepositories().stream().map(item -> {
//                                  DataRepository dataRepository = new DataRepository();
//                                  dataRepository.setId(item.getDataRepository().getId());
//
//                                  DatasetDataRepository datasetDataRepository = new DatasetDataRepository();
//                                  datasetDataRepository.setDataRepository(dataRepository);
//                                  datasetDataRepository.setDataset(newDescriptionEntity);
//                                  datasetDataRepository.setData(item.getData());
//                                  return datasetDataRepository;
//                              }).collect(Collectors.toSet()));
//                          }
//
//                          if (newDescriptionEntity.getDatasetExternalDatasets() != null) {
//                              newDescriptionEntity.setDatasetExternalDatasets(newDescriptionEntity.getDatasetExternalDatasets().stream().map(item -> {
//                                  ExternalDataset externalDataset = new ExternalDataset();
//                                  externalDataset.setId(item.getExternalDataset().getId());
//                                  DatasetExternalDataset datasetExternalDataset = new DatasetExternalDataset();
//                                  datasetExternalDataset.setExternalDataset(externalDataset);
//                                  datasetExternalDataset.setDataset(newDescriptionEntity);
//                                  datasetExternalDataset.setData(item.getData());
//                                  return datasetExternalDataset;
//                              }).collect(Collectors.toSet()));
//                          }
//
//                          if (newDescriptionEntity.getRegistries() != null) {
//                              newDescriptionEntity.setRegistries(newDescriptionEntity.getRegistries().stream().map(item -> {
//                                  Registry registry = new Registry();
//                                  registry.setId(item.getId());
//                                  return registry;
//                              }).collect(Collectors.toSet()));
//                          }
//
//                          if (newDescriptionEntity.getServices() != null) {
//                              newDescriptionEntity.setServices(newDescriptionEntity.getServices().stream().map(item -> {
//                                  Service service = new Service();
//                                  service.setId(item.getId());
//                                  DatasetService datasetService = new DatasetService();
//                                  datasetService.setService(service);
//                                  datasetService.setDataset(newDescriptionEntity);
//                                  datasetService.setData(item.getData());
//                                  return datasetService;
//                              }).collect(Collectors.toSet()));
//                          }
                          newDescriptionEntity.setCreatedAt(Instant.now());
                          return newDescriptionEntity;
                      }).thenApplyAsync(item -> {
                futures.add(datasetDao.createOrUpdateAsync(item).whenComplete(((dataset1, throwable) -> {
                    DmpEntity dmp = null;
                    try {
                        dmp = this.apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(this.queryFactory.query(DmpDescriptionTemplateQuery.class).ids(dataset1.getDmpDescriptionTemplateId()).isActive(IsActive.Active).first().getDmpId());
                    } catch (InvalidApplicationException e) {
                        throw new RuntimeException(e);
                    }
                    metricsManager.increaseValue(MetricNames.DATASET, 1, MetricNames.DRAFT);
                    //TODO
//                    eu.eudat.elastic.entities.Dataset datasetElastic = new eu.eudat.elastic.entities.Dataset();
//                    datasetElastic.setId(dataset1.getId().toString());
//                    datasetElastic.setLabel(dataset1.getLabel());
//                    datasetElastic.setDescription(dataset1.getDescription());
//                    datasetElastic.setTemplate(this.queryFactory.query(DmpDescriptionTemplateQuery.class).ids(dataset1.getDmpDescriptionTemplateId()).isActive(IsActive.Active).first().getDescriptionTemplateId());
//                    datasetElastic.setDmp(dmp.getId());
//                    datasetElastic.setStatus(dataset1.getStatus().getValue());
//                    datasetElastic.setGroup(dmp.getGroupId());
//                    if(this.dmpBlueprintService.fieldInBlueprint(dmp.getProfile(), DmpBlueprintSystemFieldType.Grant)) {
//                        datasetElastic.setGrant(dmp.getGrant().getId());
//                    }
//                    if (dmp.getUsers() != null) {
//                        datasetElastic.setCollaborators(dmp.getUsers().stream().map(user -> {
//                            Collaborator collaborator = new Collaborator();
//                            collaborator.setId(user.getId().toString());
//                            collaborator.setRole(user.getRole());
//                            //  collaborator.setName(user.getUser().getName());
//                            return collaborator;
//                        }).collect(Collectors.toList()));
//                    }
//                    datasetElastic.setLastVersion(true);
//                    datasetElastic.setLastPublicVersion(false);
//                    if (dmp.getOrganisations() != null) {
//                        datasetElastic.setOrganizations(dmp.getOrganisations().stream().map(org -> {
//                            Organization organization = new Organization();
//                            organization.setId(org.getId().toString());
//                            organization.setName(org.getLabel());
//                            return organization;
//                        }).collect(Collectors.toList()));
//                    }
//                    datasetElastic.setPublic(dmp.isPublic());
//                    if(this.dmpBlueprintService.fieldInBlueprint(dmp.getProfile(), DmpBlueprintSystemFieldType.Grant)) {
//                        datasetElastic.setGrantStatus(dmp.getGrant().getStatus());
//                    }
//
//                    try {
//                        eu.eudat.elastic.entities.Dataset oldDatasetElastic = apiContext.getOperationsContext().getElasticRepository().getDatasetRepository().findDocument(descriptionEntity.getId().toString());
//                        if (oldDatasetElastic != null) {
//                            datasetElastic.setTags(oldDatasetElastic.getTags());
//                        }
//                        datasetElastic.setFormData(this.datasetManager.getWordDocumentText(dataset1));
//                        apiContext.getOperationsContext().getElasticRepository().getDatasetRepository().createOrUpdate(datasetElastic);
//                    } catch (Exception e) {
//                        logger.error(e.getMessage(), e);
//                    }
                })));
                return futures;
            }).join();

        }
    }

    public void makePublic(UUID id) throws Exception {
        DmpEntity dmp = this.apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(id);
        // Check if dmp is finalized and if user is owner.
        if (!isUserOwnerOfDmp(dmp))
            throw new Exception("User does not have the privilege to do this action.");
        if (!dmp.getStatus().equals(DmpStatus.Finalized))
            throw new Exception("DMP is not finalized");
        dmp.setAccessType(DmpAccessType.Public);
        apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(dmp);
        UUID dmpId = dmp.getId();
        
//        dmp.setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), dmpId)).toList())); //TODO
        //this.updateIndex(dmp); //TODO
        metricsManager.increaseValue(MetricNames.DMP, 1, MetricNames.PUBLISHED);
        DataManagementPlanCriteria criteria = new DataManagementPlanCriteria();
        criteria.setGroupIds(Collections.singletonList(dmp.getGroupId()));
        criteria.setAllVersions(true);

        apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().getWithCriteria(criteria).toList().stream().forEach(dmp1 -> {
//            dmp1.getDataset().forEach(dataset -> {
                //TODO
//                try {
//                    List<Tag> tags = new ArrayList<>();
//                    eu.eudat.elastic.entities.Dataset elastic = apiContext.getOperationsContext().getElasticRepository().getDatasetRepository().findDocument(dataset.getId().toString());
//                    if (elastic != null) {
//                        tags = elastic.getTags();
//                    }
//                    //TODO
//                    //UUID tmdmpId = dataset.getDmpId();
//                    //dataset.getDmp().setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), tmdmpId)).toList()));
//                    this.datasetManager.updateTags(dataset, tags);
//                    metricsManager.increaseValue(MetricNames.DATASET, 1, MetricNames.PUBLISHED);
//                } catch (Exception e) {
//                    logger.error(e.getMessage(), e);
//                }
//            });
        });
        UserEntity user = this.queryFactory.query(UserQuery.class).ids(this.userScope.getUserId()).first(); 
        sendNotification(dmp, user/*, , NotificationType.DMP_PUBLISH*/);
    }

    @Transactional
    public void makeFinalize(UUID id, DatasetsToBeFinalized datasetsToBeFinalized) throws Exception {
        DmpEntity dmp = this.apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(id);
        if (!isUserOwnerOfDmp(dmp))
            throw new Exception("User does not have the privilege to do this action.");
        if (dmp.getStatus().equals(DmpStatus.Finalized))
            throw new Exception("DMP is already finalized");
        List<DescriptionEntity> indexDescriptionEntities = new ArrayList<>();
        if (datasetsToBeFinalized != null && datasetsToBeFinalized.getUuids() != null && !datasetsToBeFinalized.getUuids().isEmpty()) {
            List<DescriptionEntity> finalizedDescriptionEntities = apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao()
                      .asQueryable().where((builder, root) -> root.get("id").in(datasetsToBeFinalized.getUuids()))
                      .toList();
            for (DescriptionEntity descriptionEntity : finalizedDescriptionEntities) {
                DescriptionStatus status = descriptionEntity.getStatus();
                Instant finalizedDate = descriptionEntity.getFinalizedAt();
                descriptionEntity.setStatus(DescriptionStatus.Finalized);
                descriptionEntity.setFinalizedAt(Instant.now());
                DatasetWizardModel wizardModel = new DatasetWizardModel();
                wizardModel = wizardModel.fromDataModel(descriptionEntity);
                wizardModel.setDatasetProfileDefinition(this.datasetManager.getPagedProfile(wizardModel, descriptionEntity));
                try {
                    datasetManager.createOrUpdate(wizardModel);
                } catch (Exception e) {
                    descriptionEntity.setStatus(status);
                    descriptionEntity.setFinalizedAt(finalizedDate);
                    throw e;
                }
                descriptionEntity.setUpdatedAt(Instant.now());
            }
            /*apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao()
                      .asQueryable().where((builder, root) -> root.get("id").in(datasetsToBeFinalized.getUuids()))
                      .update(root -> root.<Date>get("finalizedAt"), new Date());*/
            //List<Dataset> finalizedDatasets = dmp.getDataset().stream().filter(dataset -> datasetsToBeFinalized.getUuids().contains(dataset.getId())).collect(Collectors.toList());
/*            finalizedDatasets.forEach(dataset ->{
                dataset.setStatus(Dataset.Status.FINALISED.getValue());
                dataset.setFinalizedAt(new Date());
                dataset.setModified(new Date());
            } );*/
            indexDescriptionEntities.addAll(finalizedDescriptionEntities);
            List<UUID> datasetsToBeCanceled = new LinkedList<>();
            DatasetCriteria datasetCriteria = new DatasetCriteria();
            datasetCriteria.setDmpIds(List.of(dmp.getId()));

            List<DescriptionEntity> descriptionEntityList = this.databaseRepository.getDatasetDao().getWithCriteria(datasetCriteria).toList().stream().collect(Collectors.toList());

            for (DescriptionEntity descriptionEntity : descriptionEntityList) {
                if (!descriptionEntity.getStatus().equals(DescriptionStatus.Finalized) && !datasetsToBeFinalized.getUuids().contains(descriptionEntity.getId())) {
                    datasetsToBeCanceled.add(descriptionEntity.getId());
                }
            }
            if (!datasetsToBeCanceled.isEmpty()) {
                apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao()
                          .asQueryable().where((builder, root) -> root.get("id").in(datasetsToBeCanceled))
                          .update(root -> root.<Integer>get("status"), DescriptionStatus.Canceled);
                List<DescriptionEntity> cancelledDescriptionEntities = descriptionEntityList.stream().filter(dataset -> datasetsToBeCanceled.contains(dataset.getId())).collect(Collectors.toList());
                cancelledDescriptionEntities.forEach(dataset -> dataset.setStatus(DescriptionStatus.Canceled));
                indexDescriptionEntities.addAll(cancelledDescriptionEntities);
            }
        } else {
            List<UUID> datasetsToBeCanceled = new LinkedList<>();
            DatasetCriteria datasetCriteria = new DatasetCriteria();
            datasetCriteria.setDmpIds(List.of(dmp.getId()));
            List<DescriptionEntity> descriptionEntityList = this.databaseRepository.getDatasetDao().getWithCriteria(datasetCriteria).toList().stream().collect(Collectors.toList());
            for (DescriptionEntity descriptionEntity : descriptionEntityList) {
                if (!descriptionEntity.getStatus().equals(DescriptionStatus.Finalized)) {
                    datasetsToBeCanceled.add(descriptionEntity.getId());
                }
            }
            if (!datasetsToBeCanceled.isEmpty()) {
                apiContext.getOperationsContext().getDatabaseRepository().getDatasetDao()
                          .asQueryable().where((builder, root) -> root.get("id").in(datasetsToBeCanceled))
                          .update(root -> root.<Integer>get("status"), DescriptionStatus.Canceled);
                List<DescriptionEntity> cancelledDescriptionEntities = descriptionEntityList.stream().filter(dataset -> datasetsToBeCanceled.contains(dataset.getId())).collect(Collectors.toList());
                cancelledDescriptionEntities.forEach(dataset -> dataset.setStatus(DescriptionStatus.Canceled));
                indexDescriptionEntities.addAll(cancelledDescriptionEntities);
            }
        }
        dmp.setStatus(DmpStatus.Finalized);
        apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(dmp);
        UUID dmpId = dmp.getId();
//        dmp.setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), dmpId)).toList())); //TODO
        //this.updateIndex(dmp); //TODO
        UserEntity user = this.queryFactory.query(UserQuery.class).ids(this.userScope.getUserId()).first();
        sendNotification(dmp, user/*, , NotificationType.DMP_FINALISED*/);
        metricsManager.decreaseValue(MetricNames.DMP, 1, MetricNames.DRAFT);
        metricsManager.increaseValue(MetricNames.DMP, 1, MetricNames.FINALIZED);
        //this.updateDatasetsIndex(indexDescriptionEntities); //TODO
        metricsManager.decreaseValue(MetricNames.DATASET, indexDescriptionEntities.size(), MetricNames.DRAFT);
        metricsManager.increaseValue(MetricNames.DATASET, indexDescriptionEntities.size(), MetricNames.FINALIZED);
    }

    public void undoFinalize(UUID id) throws Exception {
        DmpEntity dmp = this.apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(id);
        if (!isUserOwnerOfDmp(dmp))
            throw new Exception("User does not have the privilege to do this action.");
        if (dmp.getIsActive().equals(IsActive.Inactive))
            throw new Exception("DMP is already Active");
        if (dmp.getAccessType().equals(DmpAccessType.Public))
            throw new Exception("DMP is publicly available");
//        if (!dmp.getDois().isEmpty())//TODO
//            throw new Exception("DMP is deposited");
        dmp.setStatus(DmpStatus.Draft);
        apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(dmp);
        UUID dmpId = dmp.getId();
//        dmp.setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), dmpId)).toList())); //TODO
        //this.updateIndex(dmp); //TODO
        metricsManager.decreaseValue(MetricNames.DMP, 1, MetricNames.FINALIZED);
        metricsManager.increaseValue(MetricNames.DMP, 1, MetricNames.DRAFT);
    }

    public void updateUsers(UUID id, List<DmpUser> users) throws Exception {
        DmpEntity dmp = this.apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(id);
        if (!isUserOwnerOfDmp(dmp))
            throw new Exception("User does not have the privilege to do this action.");
        clearUsers(dmp);
        for (DmpUser userListing : users) {
            UserEntity tempUser = this.queryFactory.query(UserQuery.class).ids(userListing.getId()).first();
            assignUser(dmp, tempUser, userListing.getRole());
        }

    }

    /*
    * Export Data
    * */

    public FileEnvelope getWordDocument(String id, ConfigLoader configLoader) throws IOException, InvalidApplicationException {
        return this.getWordDocument(id, configLoader, true);
    }

    public FileEnvelope getWordDocument(String id, ConfigLoader configLoader, Boolean versioned) throws IOException, InvalidApplicationException {
        WordBuilder wordBuilder = new WordBuilder(this.environment, configLoader);
        VisibilityRuleService visibilityRuleService = new VisibilityRuleServiceImpl();
        DatasetWizardModel dataset = new DatasetWizardModel();
        XWPFDocument document = configLoader.getDocument();

        DmpEntity dmpEntity = databaseRepository.getDmpDao().find(UUID.fromString(id));
        if (!dmpEntity.getAccessType().equals(DmpAccessType.Public) 
        //TODO        && dmpEntity.getUsers().stream().filter(userInfo -> userInfo.getUser().getId().equals(this.userScope.getUserIdSafe())).collect(Collectors.toList()).size() == 0
        )
            throw new UnauthorisedException();

        wordBuilder.fillFirstPage(dmpEntity, null, document, false);

//        int powered_pos = document.getParagraphs().size() - 3;
        int powered_pos = wordBuilder.findPosOfPoweredBy(document);
        XWPFParagraph powered_par = null;
        XWPFParagraph argos_img_par = null;
        if(powered_pos != -1) {
            powered_par = document.getParagraphArray(powered_pos);
            argos_img_par = document.getParagraphArray(powered_pos + 1);
        }


//        // DMP info on top of the document.
//        wordBuilder.addParagraphContent("Data Management Plan Information", document, ParagraphStyle.HEADER1, BigInteger.ZERO);
//        // DMP title custom style.
//        wordBuilder.addParagraphContent(dmpEntity.getLabel(), document, ParagraphStyle.HEADER2, BigInteger.ZERO);
//        wordBuilder.addParagraphContent(dmpEntity.getDescription(), document, ParagraphStyle.HTML, BigInteger.ZERO);
//
//        wordBuilder.addParagraphContent("Funder", document, ParagraphStyle.HEADER3, BigInteger.ZERO);
//        if (dmpEntity.getGrant().getFunder() != null)
//            wordBuilder.addParagraphContent(dmpEntity.getGrant().getFunder().getLabel(), document, ParagraphStyle.TEXT, BigInteger.ZERO);
//
//        wordBuilder.addParagraphContent("Grant", document, ParagraphStyle.HEADER3, BigInteger.ZERO);
//        wordBuilder.addParagraphContent(dmpEntity.getGrant().getLabel(), document, ParagraphStyle.TEXT, BigInteger.ZERO);
//
//        wordBuilder.addParagraphContent("Organisations", document, ParagraphStyle.HEADER3, BigInteger.ZERO);
//        if (dmpEntity.getOrganisations().size() > 0) {
//            wordBuilder.addParagraphContent(dmpEntity.getOrganisations().stream().map(Organisation::getLabel).collect(Collectors.joining(", "))
//                    , document, ParagraphStyle.TEXT, BigInteger.ZERO);
//        }
//
//        wordBuilder.addParagraphContent("Researchers", document, ParagraphStyle.HEADER3, BigInteger.ZERO);
//        if (dmpEntity.getResearchers().size() > 0) {
//            wordBuilder.addParagraphContent(dmpEntity.getResearchers().stream().map(Researcher::getLabel).collect(Collectors.joining(", "))
//                    , 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);
//        }*/
//
//        // Page break at the end of the DMP title.
//        XWPFParagraph parBreakDMP = document.createParagraph();
//        parBreakDMP.setPageBreak(true);
//
//        wordBuilder.addParagraphContent("Datasets", document, ParagraphStyle.HEADER1, BigInteger.ZERO);
//        // Space below Datasets.
//        XWPFParagraph parBreakDatasets = document.createParagraph();

        DefinitionEntity dmpBlueprint = this.xmlHandlingService.fromXmlSafe(DefinitionEntity.class, this.queryFactory.query(DmpBlueprintQuery.class).ids(dmpEntity.getBlueprintId()).first().getDefinition());
        for(SectionEntity section: dmpBlueprint.getSections()){
            wordBuilder.addParagraphContent("Section " + section.getOrdinal(), document, ParagraphStyle.HEADER1, BigInteger.ZERO, 0);
            XWPFParagraph sectionInfoParagraph = document.createParagraph();
            sectionInfoParagraph.setSpacingBetween(1.0);
            XWPFRun runSectionTitle = sectionInfoParagraph.createRun();
            runSectionTitle.setText("Title: ");
            runSectionTitle.setColor("000000");
            XWPFRun runSectionTitleText = sectionInfoParagraph.createRun();
            runSectionTitleText.setText(section.getLabel());
            runSectionTitleText.setColor("116a78");
            XWPFParagraph sectionDescriptionParagraph = document.createParagraph();
            XWPFRun runSectionDescription = sectionDescriptionParagraph.createRun();
            runSectionDescription.setText("Description: ");
            runSectionDescription.setColor("000000");
            XWPFRun runSectionDescriptionText = sectionDescriptionParagraph.createRun();
            runSectionDescriptionText.setText(section.getDescription());
            runSectionDescriptionText.setColor("116a78");

            wordBuilder.addParagraphContent("Section Fields", document, ParagraphStyle.HEADER2, BigInteger.ZERO, 0);
            section.getFields().sort(Comparator.comparingInt(FieldEntity::getOrdinal));
            for(FieldEntity field: section.getFields()){
                if(field.getCategory() == DmpBlueprintFieldCategory.System){
                    SystemFieldEntity systemField = (SystemFieldEntity) field;
                    XWPFParagraph systemFieldParagraph = document.createParagraph();
                    systemFieldParagraph.setSpacingBetween(1.0);
                    XWPFRun runSyStemFieldTitle = systemFieldParagraph.createRun();
                    runSyStemFieldTitle.setText("Title: ");
                    runSyStemFieldTitle.setColor("000000");
                    XWPFRun runSystemFieldTitleText = systemFieldParagraph.createRun();
                    runSystemFieldTitleText.setText(systemField.getLabel());
                    runSystemFieldTitleText.setColor("116a78");
                    if(systemField.getDescription() != null && !systemField.getDescription().isEmpty()){
                        XWPFParagraph systemFieldDescription = document.createParagraph();
                        systemFieldDescription.setSpacingBetween(1.0);
                        XWPFRun runSyStemFieldDescription = systemFieldDescription.createRun();
                        runSyStemFieldDescription.setText("Description: ");
                        runSyStemFieldDescription.setColor("000000");
                        XWPFRun runSystemFieldDescriptionText = systemFieldDescription.createRun();
                        runSystemFieldDescriptionText.setText(systemField.getDescription());
                        runSystemFieldDescriptionText.setColor("116a78");
                    }
                    XWPFParagraph systemFieldInput = document.createParagraph();
                    systemFieldInput.setSpacingBetween(1.0);
                    XWPFRun runInput = systemFieldInput.createRun();
                    runInput.setText("Input: ");
                    runInput.setColor("000000");
                    switch (systemField.getType()) {
                        case Text:
                            XWPFRun runTitle = systemFieldInput.createRun();
                            runTitle.setText(dmpEntity.getLabel());
                            runTitle.setColor("116a78");
                            break;
                        case HtmlText:
                            XWPFRun runDescription = systemFieldInput.createRun();
                            runDescription.setText(dmpEntity.getDescription());
                            runDescription.setColor("116a78");
                            break;
                        case Researchers:
                            //TODO
//                            for(Researcher researcher: dmpEntity.getResearchers()){
//                                XWPFRun runResearcher = systemFieldInput.createRun();
//                                runResearcher.setText("• " + researcher.getLabel());
//                                runResearcher.setColor("116a78");
//                            }
                            break;
                        //TODO
//                      case Organizations:
//                            
//                            for(Organisation organisation: dmpEntity.getOrganisations()){
//                                XWPFRun runOrganisation = systemFieldInput.createRun();
//                                runOrganisation.setText("• " + organisation.getLabel());
//                                runOrganisation.setColor("116a78");
//                            }
//                            break;
//                        case Language:
//                            XWPFRun runLanguage = systemFieldInput.createRun();
//                            runLanguage.setText(objectMapper.readValue(dmpEntity.getExtraProperties(), HashMap.class).get("language").toString());
//                            runLanguage.setColor("116a78");
//                            break;
//                        case Contact:
//                            XWPFRun runContact = systemFieldInput.createRun();
//                            runContact.setText(dmpEntity.getCreator().getName());
//                            runContact.setColor("116a78");
//                            break;
//                        case Funder:
//                            if (dmpEntity.getGrant() != null && dmpEntity.getGrant().getFunder() != null) {
//                                XWPFRun runFunder = systemFieldInput.createRun();
//                                runFunder.setText(dmpEntity.getGrant().getFunder().getLabel());
//                                runFunder.setColor("116a78");
//                            }
//                            break;
//                        case Grant:
//                            if (dmpEntity.getGrant() != null) {
//                                XWPFRun runGrant = systemFieldInput.createRun();
//                                runGrant.setText(dmpEntity.getGrant().getLabel());
//                                runGrant.setColor("116a78");
//                            }
//                            break;
//                        case Project:
//                            if (dmpEntity.getProject() != null ) {
//                                XWPFRun runProject = systemFieldInput.createRun();
//                                runProject.setText(dmpEntity.getProject().getLabel());
//                                runProject.setColor("116a78");
//                            }
//                            break;
//                        case License:
//                            Map extraProperties = objectMapper.readValue(dmpEntity.getExtraProperties(), HashMap.class);
//                            if (extraProperties.containsKey("license")) {
//                                XWPFRun runLicense = systemFieldInput.createRun();
//                                runLicense.setText(extraProperties.get("license").toString());
//                                runLicense.setColor("116a78");
//                            }
//                            break;
//                        case AccessRights:
//                            Map extraPropertiesMap = objectMapper.readValue(dmpEntity.getExtraProperties(), HashMap.class);
//                            if (extraPropertiesMap.containsKey("visible")) {
//                                XWPFRun runAccessRights = systemFieldInput.createRun();
//                                runAccessRights.setText(extraPropertiesMap.get("visible").toString());
//                                runAccessRights.setColor("116a78");
//                            }
//                            break;
                    }
                    document.createParagraph();
                }
                else if(field.getCategory() == DmpBlueprintFieldCategory.Extra){
                    ExtraFieldEntity extraField = (ExtraFieldEntity)field;
                    XWPFParagraph extraFieldParagraph = document.createParagraph();
                    extraFieldParagraph.setSpacingBetween(1.0);
                    XWPFRun runExtraFieldLabel = extraFieldParagraph.createRun();
                    runExtraFieldLabel.setText(extraField.getLabel());
                    runExtraFieldLabel.setColor("116a78");
                    if(extraField.getDescription() != null && !extraField.getDescription().isEmpty()){
                        XWPFRun runExtraFieldDescription = extraFieldParagraph.createRun();
                        runExtraFieldDescription.setText(extraField.getDescription());
                        runExtraFieldDescription.setColor("116a78");
                    }
                    XWPFRun runExtraFieldInput = extraFieldParagraph.createRun();
                    Map dmpProperties = objectMapper.readValue(dmpEntity.getProperties(), HashMap.class);
                    if (dmpProperties.containsKey(field.getId()) && dmpProperties.get(field.getId()) != null) {
                        runExtraFieldInput.setText((String) dmpProperties.get(field.getId()));
                    }
                    runExtraFieldInput.setColor("116a78");
                }
            }

            if(!section.getDescriptionTemplates().isEmpty()){
                wordBuilder.addParagraphContent("Section descriptions", document, ParagraphStyle.HEADER2, BigInteger.ZERO, 0);
                wordBuilder.addParagraphContent("Description Templates", document, ParagraphStyle.HEADER4, BigInteger.ZERO, 0);
                for(eu.eudat.commons.types.dmpblueprint.DescriptionTemplateEntity descriptionTemplateEntity : section.getDescriptionTemplates()){
                    XWPFParagraph templateParagraph = document.createParagraph();
                    XWPFRun runTemplateLabel = templateParagraph.createRun();
                    runTemplateLabel.setText("• " + descriptionTemplateEntity.getLabel());
                    runTemplateLabel.setColor("116a78");
                }

                final Boolean isFinalized = dmpEntity.getStatus().equals(DmpStatus.Finalized);
                final Boolean isPublic = dmpEntity.getAccessType().equals(DmpAccessType.Public);

                DatasetCriteria datasetCriteria = new DatasetCriteria();
                datasetCriteria.setDmpIds(Collections.singletonList(dmpEntity.getId()));
                List<DescriptionEntity> descriptionEntityList = this.databaseRepository.getDatasetDao().getWithCriteria(datasetCriteria).toList().stream().collect(Collectors.toList());
                descriptionEntityList.stream()
                        .filter(item -> item.getStatus() != DescriptionStatus.Canceled)
                        .filter(item -> item.getIsActive() != IsActive.Inactive)
                        .filter(item -> !isPublic && !isFinalized || item.getStatus() == DescriptionStatus.Finalized)
                        //.filter(item -> item.getDmpSectionIndex().equals(section.getOrdinal() - 1)) //TODO
                        .sorted(Comparator.comparing(DescriptionEntity::getCreatedAt))
                        .forEach(datasetEntity -> {
                            Map<String, Object> properties = new HashMap<>();
                            if (datasetEntity.getProperties() != null) {
                                //ObjectMapper objectMapper = new ObjectMapper();
                                try {
                                    properties = objectMapper.readValue(datasetEntity.getProperties(), LinkedHashMap.class);
                                } catch (IOException e) {
                                    logger.error(e.getLocalizedMessage(), e);
                                }
                                 /*JSONObject jObject = new JSONObject(datasetEntity.getProperties());
                                 properties = jObject.toMap();*/
                            }


                            // Dataset Description custom style.
                            XWPFParagraph datasetDescriptionParagraph = document.createParagraph();
                            datasetDescriptionParagraph.setStyle("Heading4");
                            datasetDescriptionParagraph.setSpacingBetween(1.5);
                            XWPFRun datasetDescriptionRun = datasetDescriptionParagraph.createRun();
                            datasetDescriptionRun.setText("Dataset Description");
                            //datasetDescriptionRun.setColor("2E75B6");
                            //datasetDescriptionRun.setBold(true);
                            datasetDescriptionRun.setFontSize(15);


                            // Custom style for the Dataset title.
                            //wordBuilder.addParagraphContent("Title: " + datasetEntity.getLabel(), document, ParagraphStyle.HEADER1, BigInteger.ZERO);
                            XWPFParagraph datasetLabelParagraph = document.createParagraph();
//                          datasetLabelParagraph.setStyle("Heading2");
                            datasetLabelParagraph.setSpacingBetween(1.0);
                            XWPFRun runDatasetTitle1 = datasetLabelParagraph.createRun();
                            runDatasetTitle1.setText("Title: ");
                            runDatasetTitle1.setColor("000000");
                            //runDatasetTitle1.setBold(true);
                            //runDatasetTitle1.setFontSize(12);
                            XWPFRun runDatasetTitle = datasetLabelParagraph.createRun();
                            runDatasetTitle.setText(datasetEntity.getLabel());
                            runDatasetTitle.setColor("116a78");
                            //runDatasetTitle.setBold(true);
                            //runDatasetTitle.setFontSize(12);

                            XWPFParagraph datasetTemplateParagraph = document.createParagraph();
//                          datasetTemplateParagraph.setStyle("Heading3");
                            XWPFRun runDatasetTemplate1 = datasetTemplateParagraph.createRun();
                            runDatasetTemplate1.setText("Template: ");
                            runDatasetTemplate1.setColor("000000");
                            //runDatasetTemplate1.setBold(true);
                            //runDatasetTemplate1.setFontSize(12);
                            XWPFRun runDatasetTemplate = datasetTemplateParagraph.createRun();
                            runDatasetTemplate.setText(this.queryFactory.query(DescriptionTemplateQuery.class).ids(datasetEntity.getDescriptionTemplateId()).first().getLabel());
                            runDatasetTemplate.setColor("116a78");
                            //runDatasetTemplate.setBold(true);
                            //runDatasetTemplate.setFontSize(12);

//                          /*XWPFParagraph externalReferencesParagraph = document.createParagraph();
//                          externalReferencesParagraph.setStyle("Heading3");
//                          XWPFRun externalReferencesRun = externalReferencesParagraph.createRun();
//                          externalReferencesRun.setText("External References");
//                          externalReferencesRun.setColor("2E75B6");
//                          externalReferencesRun.setBold(true);
//                          externalReferencesRun.setFontSize(12);
//
//                          wordBuilder.addParagraphContent("Data Repositories", document, ParagraphStyle.HEADER4, BigInteger.ZERO);
//                          if (datasetEntity.getDatasetDataRepositories().size() > 0) {
//                                wordBuilder.addParagraphContent(datasetEntity.getDatasetDataRepositories().stream().map(DatasetDataRepository::getDataRepository).map(DataRepository::getLabel).collect(Collectors.joining(", "))
//                                        , document, ParagraphStyle.TEXT, BigInteger.ZERO);
//                          }
//                          wordBuilder.addParagraphContent("External Datasets", document, ParagraphStyle.HEADER4, BigInteger.ZERO);
//                          if (datasetEntity.getDatasetExternalDatasets().size() > 0) {
//                                wordBuilder.addParagraphContent(datasetEntity.getDatasetExternalDatasets().stream().map(DatasetExternalDataset::getExternalDataset).map(ExternalDataset::getLabel).collect(Collectors.joining(", "))
//                                       , document, ParagraphStyle.TEXT, BigInteger.ZERO);
//                          }
//                          wordBuilder.addParagraphContent("Registries", document, ParagraphStyle.HEADER4, BigInteger.ZERO);
//                          if (datasetEntity.getRegistries().size() > 0) {
//                              wordBuilder.addParagraphContent(datasetEntity.getRegistries().stream().map(Registry::getLabel).collect(Collectors.joining(", "))
//                                         , document, ParagraphStyle.TEXT, BigInteger.ZERO);
//                          }
//                          wordBuilder.addParagraphContent("Services", document, ParagraphStyle.HEADER4, BigInteger.ZERO);
//                          if (datasetEntity.getServices().size() > 0) {
//                                 wordBuilder.addParagraphContent(datasetEntity.getServices().stream().map(DatasetService::getService).map(Service::getLabel).collect(Collectors.joining(", "))
//                                         , document, ParagraphStyle.TEXT, BigInteger.ZERO);
//                          }
//                          *//*wordBuilder.addParagraphContent("Tags", document, ParagraphStyle.HEADER3, BigInteger.ZERO);
//                          if (datasetEntity.().size() > 0) {
//                              wordBuilder.addParagraphContent(datasetEntity.getServices().stream().map(DatasetService::getService).map(Service::getLabel).collect(Collectors.joining(", "))
//                                          , document, ParagraphStyle.HEADER4, BigInteger.ZERO);
//                          }*/
//
//

                            XWPFParagraph datasetDescParagraph = document.createParagraph();
                            XWPFRun runDatasetDescription1 = datasetDescParagraph.createRun();
                            runDatasetDescription1.setText("Description: ");
                            runDatasetDescription1.setColor("000000");
                            XWPFRun runDatasetDescription = datasetDescParagraph.createRun();
                            runDatasetDescription.setText(this.queryFactory.query(DescriptionTemplateQuery.class).ids(datasetEntity.getDescriptionTemplateId()).first().getLabel());
                            runDatasetDescription.setColor("116a78");
                            //wordBuilder.addParagraphContent(datasetEntity.getDescription(), document, ParagraphStyle.HTML, BigInteger.ZERO, 0);

                            document.createParagraph();

                            PagedDatasetProfile pagedDatasetProfile = datasetManager.getPagedProfile(dataset, datasetEntity);
                            visibilityRuleService.setProperties(properties);
                            visibilityRuleService.buildVisibilityContext(pagedDatasetProfile.getRules());
                            try {
                                wordBuilder.build(document, pagedDatasetProfile, visibilityRuleService);
                            } catch (IOException e) {
                                logger.error(e.getMessage(), e);
                            }
                            // Page break at the end of the Dataset.
                            XWPFParagraph parBreakDataset = document.createParagraph();
                            parBreakDataset.setPageBreak(true);
                        });
            }
        }

//        // Removes the top empty headings.
//        for (int i = 0; i < 6; i++) {
//            document.removeBodyElement(0);
//        }


        if(powered_pos != -1) {
            document.getLastParagraph().setPageBreak(false);
            document.createParagraph();
            document.setParagraph(powered_par, document.getParagraphs().size() - 1);

            document.createParagraph();
            document.setParagraph(argos_img_par, document.getParagraphs().size() - 1);

            document.removeBodyElement(powered_pos + 1);
            document.removeBodyElement(powered_pos + 1);
        }

        wordBuilder.fillFooter(dmpEntity, null, document, false);

        String fileName ="";
        //TODO
//        if (dmpEntity.getGrant() !=  null && dmpEntity.getGrant().getLabel() != null) {
//            fileName = "DMP_" + dmpEntity.getGrant().getLabel();
//        }
//        else {
//            fileName = "DMP_" + dmpEntity.getLabel();
//        }
//        if (versioned) {
//            fileName += "_" + dmpEntity.getVersion();
//        }
       // fileName = fileName.replaceAll("[^a-zA-Z0-9+ ]", "");
        FileEnvelope exportEnvelope = new FileEnvelope();
        exportEnvelope.setFilename(fileName + ".docx");
        String uuid = UUID.randomUUID().toString();
        File exportFile = new File(this.environment.getProperty("temp.temp") + uuid + ".docx");
        FileOutputStream out = new FileOutputStream(exportFile);
        document.write(out);
        out.close();
        exportEnvelope.setFile(exportFile);

        return exportEnvelope;
    }

    private FileEnvelope getXmlDocument(String id) throws IOException, InvalidApplicationException {
        ExportXmlBuilder xmlBuilder = new ExportXmlBuilder();
        VisibilityRuleService visibilityRuleService = new VisibilityRuleServiceImpl();
        DmpEntity dmp = databaseRepository.getDmpDao().find(UUID.fromString(id));
        if (!dmp.getAccessType().equals(DmpAccessType.Public) 
        //TODO        && dmp.getUsers().stream().filter(userInfo -> this.userScope.getUserIdSafe().equals(userInfo.getUser().getId())).collect(Collectors.toList()).size() == 0
        )
            throw new UnauthorisedException();
        final Boolean isFinalized = dmp.getStatus().equals(DmpStatus.Finalized);
        final Boolean isPublic = dmp.getAccessType().equals(DmpAccessType.Public);
        DatasetCriteria datasetCriteria = new DatasetCriteria();
        datasetCriteria.setDmpIds(List.of(dmp.getId()));

        List<DescriptionEntity> descriptionEntityList = this.databaseRepository.getDatasetDao().getWithCriteria(datasetCriteria).toList().stream().filter(dataset -> dataset.getIsActive() != IsActive.Inactive).collect(Collectors.toList());

        List<DescriptionEntity> descriptionEntities = descriptionEntityList.stream()
                .filter(dataset -> dataset.getIsActive() != IsActive.Inactive &&
                        dataset.getStatus() != DescriptionStatus.Canceled)
                .filter(dataset -> !isPublic && !isFinalized || dataset.getStatus() == DescriptionStatus.Finalized)
                .collect(Collectors.toList());
        /*String fileName = dmp.getLabel();
        fileName = fileName.replaceAll("[^a-zA-Z0-9+ ]", "");*/
        String uuid = UUID.randomUUID().toString();
        File xmlFile = new File(this.environment.getProperty("temp.temp") + uuid + ".xml");
        BufferedWriter writer = new BufferedWriter(new FileWriter(xmlFile, true));
        Document xmlDoc = XmlBuilder.getDocument();
        Element dmpElement = xmlDoc.createElement("dmp");
        Element dmpDescription = xmlDoc.createElement("description");
        dmpDescription.setTextContent(dmp.getDescription());
        dmpElement.appendChild(dmpDescription);
        Element dmpName = xmlDoc.createElement("dmpName");
        dmpName.setTextContent(dmp.getLabel());
        dmpElement.appendChild(dmpName);

        //TODO
//        if (dmp.getExtraProperties() != null && !dmp.getExtraProperties().isEmpty()) {
//            Map<String, Object> extraProperties = new ObjectMapper().readValue(dmp.getExtraProperties(), HashMap.class);
//            Element language = xmlDoc.createElement("language");
//            language.setTextContent(extraProperties.get("language") != null ? extraProperties.get("language").toString() : null);
//            dmpElement.appendChild(language);
//            Element visibility = xmlDoc.createElement("visibility");
//            visibility.setTextContent(extraProperties.get("visible") != null ? extraProperties.get("visible").toString() : null);
//            dmpElement.appendChild(visibility);
//            Element publicDate = xmlDoc.createElement("publicDate");
//            publicDate.setTextContent(extraProperties.get("publicDate") != null ? extraProperties.get("publicDate").toString() : null);
//            dmpElement.appendChild(publicDate);
//            Element costs = xmlDoc.createElement("costs");
//            costs.setTextContent(extraProperties.get("costs") != null ? extraProperties.get("costs").toString() : null);
//            dmpElement.appendChild(costs);
//        }

        DmpBlueprintEntity dmpBlueprint = this.queryFactory.query(DmpBlueprintQuery.class).ids(dmp.getBlueprintId()).first();
        Element dmpProfileElement = xmlDoc.createElement("dmpProfile");
        Element dmpProfileName = xmlDoc.createElement("dmpProfileName");
        if (!(dmpBlueprint == null)) {
            dmpProfileName.setTextContent(dmpBlueprint.getLabel());
            dmpProfileElement.appendChild(dmpProfileName);
            Element dmpProfileId = xmlDoc.createElement("dmpProfileId");
            dmpProfileId.setTextContent(dmpBlueprint.getId().toString());
            dmpProfileElement.appendChild(dmpProfileId);
//            Element values = xmlDoc.createElement("values");
//            values.setTextContent(dmpProfile.getDefinition());
//            dmpProfileElement.appendChild(values);
        }
        dmpElement.appendChild(dmpProfileElement);

        Element dmpContactElement = xmlDoc.createElement("contact");
        Element dmpContactName = xmlDoc.createElement("name");
        Element dmpContactEmail = xmlDoc.createElement("email");
        if(dmp.getCreatorId() != null){
            dmpContactName.setTextContent(this.queryFactory.query(UserQuery.class).ids(dmp.getCreatorId()).first().getName());
            //TODO dmpContactEmail.setTextContent(this.databaseRepository.getUserInfoDao().find(dmp.getCreator()).getEmail());
        }
        else{
            Iterator<DmpUserEntity> users = new ArrayList<DmpUserEntity>().iterator(); //TODO dmp.getUsers().iterator();
            if(users.hasNext()){
                DmpUserEntity creator = users.next();
                dmpContactName.setTextContent(this.queryFactory.query(UserQuery.class).ids(creator.getUserId()).first().getName());
//TODO .setTextContent(this.databaseRepository.getUserInfoDao().find(creator.getUser()).getEmail());
            }
        }
        dmpContactElement.appendChild(dmpContactName);
        dmpContactElement.appendChild(dmpContactEmail);
        dmpElement.appendChild(dmpContactElement);

        Element dmpContributorsElement = xmlDoc.createElement("contributors");
        Iterator<DmpUserEntity> users = new ArrayList<DmpUserEntity>().iterator(); //TODO dmp.getUsers().iterator();
        while(users.hasNext()){
            Element dmpContributorElement = xmlDoc.createElement("contributor");
            Element dmpContributorName = xmlDoc.createElement("name");
            Element dmpContributorEmail= xmlDoc.createElement("email");
            DmpUserEntity contributor = users.next();
            dmpContributorName.setTextContent(this.queryFactory.query(UserQuery.class).ids(contributor.getUserId()).first().getName());
            //TODO dmpContributorEmail.setTextContent(this.databaseRepository.getUserInfoDao().find(contributor.getUser()).getEmail());
            dmpContributorElement.appendChild(dmpContributorName);
            dmpContributorElement.appendChild(dmpContributorEmail);
            dmpContributorsElement.appendChild(dmpContributorElement);
        }
        dmpElement.appendChild(dmpContributorsElement);

        // Funder.
        Element funder = xmlDoc.createElement("funder");
        if (this.dmpBlueprintService.fieldInBlueprint(this.queryFactory.query(DmpBlueprintQuery.class).ids(dmp.getBlueprintId()).first(), DmpBlueprintSystemFieldType.Grant) && this.dmpBlueprintService.fieldInBlueprint(this.queryFactory.query(DmpBlueprintQuery.class).ids(dmp.getBlueprintId()).first(), DmpBlueprintSystemFieldType.Funder)) {
            Element funderLabel = xmlDoc.createElement("label");
            Element funderId = xmlDoc.createElement("id");
            //TODO
//            funderLabel.setTextContent(dmp.getGrant().getFunder().getLabel());
//            funderId.setTextContent(dmp.getGrant().getFunder().getId().toString());
//            funder.appendChild(funderLabel);
//            funder.appendChild(funderId);
//            if (dmp.getGrant().getFunder().getReference() != null) {
//                String referencePrefix = dmp.getGrant().getFunder().getReference().split(":")[0];
//                String shortReference = dmp.getGrant().getFunder().getReference().substring(referencePrefix.length() + 1);
//                Element funderReference = xmlDoc.createElement("reference");
//                funderReference.setTextContent(shortReference);
//                funder.appendChild(funderReference);
//            }
        }
        dmpElement.appendChild(funder);
        // Grant.
        Element grant = xmlDoc.createElement("grant");
        if (this.dmpBlueprintService.fieldInBlueprint(this.queryFactory.query(DmpBlueprintQuery.class).ids(dmp.getBlueprintId()).first(), DmpBlueprintSystemFieldType.Grant)) {
            Element grantLabel = xmlDoc.createElement("label");
            Element grantId = xmlDoc.createElement("id");
            //TODO
//            grantLabel.setTextContent(dmp.getGrant().getLabel());
//            grantId.setTextContent(dmp.getGrant().getId().toString());
//            grant.appendChild(grantLabel);
//            grant.appendChild(grantId);
//            if (dmp.getGrant().getReference() != null) {
//                String referencePrefix = dmp.getGrant().getReference().split(":")[0];
//                String shortReference = dmp.getGrant().getReference().substring(referencePrefix.length() + 1);
//                Element grantReference = xmlDoc.createElement("reference");
//                grantReference.setTextContent(shortReference);
//                grant.appendChild(grantReference);
//            }
        }
        dmpElement.appendChild(grant);
        // Project.
        Element project = xmlDoc.createElement("project");
        if (this.dmpBlueprintService.fieldInBlueprint(this.queryFactory.query(DmpBlueprintQuery.class).ids(dmp.getBlueprintId()).first(), DmpBlueprintSystemFieldType.Project)) {
            Element projectId = xmlDoc.createElement("id");
            Element projectLabel = xmlDoc.createElement("label");
            Element projectDescription = xmlDoc.createElement("description");
            Element projectStartDate = xmlDoc.createElement("start");
            Element projectEndDate = xmlDoc.createElement("end");
            
            //TODO
//            projectId.setTextContent(dmp.getProject().getId().toString());
//            projectLabel.setTextContent(dmp.getProject().getLabel());
//            projectDescription.setTextContent(dmp.getProject().getDescription());
//            projectStartDate.setTextContent(dmp.getProject().getStartdate().toString());
//            projectEndDate.setTextContent(dmp.getProject().getEnddate().toString());
            project.appendChild(projectId);
            project.appendChild(projectLabel);
            project.appendChild(projectDescription);
            project.appendChild(projectStartDate);
            project.appendChild(projectEndDate);
        }
        dmpElement.appendChild(project);

        //TODO
//        Element organisationsElement = xmlDoc.createElement("organisations");
//        for (Organisation organisation : dmp.getOrganisations()) {
//            Element organisationElement = xmlDoc.createElement("organisation");
//            Element organisationNameElement = xmlDoc.createElement("name");
//            organisationNameElement.setTextContent(organisation.getLabel());
//            Element organisationReferenceElement = xmlDoc.createElement("reference");
//            organisationReferenceElement.setTextContent(organisation.getReference());
//            organisationElement.appendChild(organisationNameElement);
//            organisationElement.appendChild(organisationReferenceElement);
//            organisationsElement.appendChild(organisationElement);
//        }
//        dmpElement.appendChild(organisationsElement);
//
//        Element researchersElement = xmlDoc.createElement("researchers");
//        for (Researcher researcher : dmp.getResearchers()) {
//            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);
//        }
//        dmpElement.appendChild(researchersElement);

        Element extraFields = xmlDoc.createElement("extraFields");
        Map<String, Object> dmpProperties = new ObjectMapper().readValue(dmp.getProperties(), new TypeReference<Map<String, Object>>() {});

        DefinitionEntity blueprint = new DefinitionEntity(); //new DefinitionEntity().fromXml(XmlBuilder.fromXml(this.queryFactory.query(DmpBlueprintQuery.class).ids(dmp.getBlueprintId()).first().getDefinition()).getDocumentElement());

        blueprint.getSections().forEach(section -> {
            section.getFields().forEach(fieldModel -> {
                if (fieldModel.getCategory() == DmpBlueprintFieldCategory.Extra) {
                    Element extraField = xmlDoc.createElement("extraField");
                    Element extraFieldId = xmlDoc.createElement("id");
                    extraFieldId.setTextContent(fieldModel.getId().toString());
                    Element extraFieldLabel = xmlDoc.createElement("label");
                    extraFieldLabel.setTextContent(fieldModel.getLabel());
                    Element extraFieldValue = xmlDoc.createElement("value");
                    Object value = dmpProperties.get(fieldModel.getId().toString());
                    if (value != null) {
                        extraFieldValue.setTextContent((String) value);
                    }
                    extraField.appendChild(extraFieldId);
                    extraField.appendChild(extraFieldLabel);
                    extraField.appendChild(extraFieldValue);
                    extraFields.appendChild(extraField);
                }
            });
        });
        dmpElement.appendChild(extraFields);

        Element datasetsElement = xmlDoc.createElement("datasets");
        for (DescriptionEntity descriptionEntity : descriptionEntities) {
            Element datasetElement = xmlDoc.createElement("dataset");
            datasetElement.setAttribute("name", descriptionEntity.getLabel());

            Element datasetDescriptionElement = xmlDoc.createElement("description");
            datasetElement.appendChild(datasetDescriptionElement);
            datasetDescriptionElement.setTextContent(descriptionEntity.getDescription());

            //TODO
//            Element datasetDmpSectionIndex = xmlDoc.createElement("dmpSectionIndex");
//            datasetElement.appendChild(datasetDmpSectionIndex);
//            datasetDmpSectionIndex.setTextContent(String.valueOf(descriptionEntity.getDmpSectionIndex()));

            Element datsetProfileElement = xmlDoc.createElement("profile-id");
            datasetElement.appendChild(datsetProfileElement);
            datsetProfileElement.setTextContent(descriptionEntity.getDescriptionTemplateId().toString());

            Element datsetProfileLabelElement = xmlDoc.createElement("profile-label");
            datasetElement.appendChild(datsetProfileLabelElement);
            datsetProfileLabelElement.setTextContent(this.queryFactory.query(DescriptionTemplateQuery.class).ids(descriptionEntity.getDescriptionTemplateId()).first().getLabel());

            DatasetWizardModel datasetWizardModel = new DatasetWizardModel();
            Map<String, Object> properties = new HashMap<>();
            if (descriptionEntity.getProperties() != null) {
                JSONObject jobject = new JSONObject(descriptionEntity.getProperties());
                properties = jobject.toMap();
            }
            PagedDatasetProfile pagedDatasetProfile = datasetManager.getPagedProfile(datasetWizardModel, descriptionEntity);
            visibilityRuleService.setProperties(properties);
            visibilityRuleService.buildVisibilityContext(pagedDatasetProfile.getRules());
            datasetElement.appendChild(xmlBuilder.createPages(pagedDatasetProfile.getPages(), visibilityRuleService, xmlDoc));
            datasetsElement.appendChild(datasetElement);
        }

        Element profiles = xmlDoc.createElement("profiles");
        // Get DatasetProfiles from DMP to add to XML.
        //TODO
//        for (DMPDatasetProfile dmpDescriptionProfile : dmp.getAssociatedDmps()) {
//            DescriptionTemplateEntity descriptionTemplateEntity = dmpDescriptionProfile.getDatasetprofile();
//            Element profile = xmlDoc.createElement("profile");
//            Element profileId = xmlDoc.createElement("profileId");
//            profileId.setTextContent(descriptionTemplateEntity.getId().toString());
//            profile.appendChild(profileId);
//            Element profileGroupId = xmlDoc.createElement("profileGroupId");
//            profileGroupId.setTextContent(descriptionTemplateEntity.getGroupId().toString());
//            profile.appendChild(profileGroupId);
//            Element profileLabel = xmlDoc.createElement("profileLabel");
//            profileLabel.setTextContent(descriptionTemplateEntity.getLabel());
//            profile.appendChild(profileLabel);
//            Element profileVersion = xmlDoc.createElement("profileVersion");
//            profileVersion.setTextContent(String.valueOf(descriptionTemplateEntity.getVersion()));
//            profile.appendChild(profileVersion);
//            Element profileInSections = xmlDoc.createElement("profileInSections");
//            Map<String, Object> data = new ObjectMapper().readValue(dmpDescriptionProfile.getData(), new TypeReference<Map<String, Object>>() {});
//            List<Integer> sections = (List<Integer>) data.get("dmpSectionIndex");
//            for(int section: sections) {
//                Element profileInSection = xmlDoc.createElement("section");
//                profileInSection.setTextContent(String.valueOf(section));
//                profileInSections.appendChild(profileInSection);
//            }
//            profile.appendChild(profileInSections);
//            profiles.appendChild(profile);
//        }
        dmpElement.appendChild(profiles);
        dmpElement.appendChild(datasetsElement);
        xmlDoc.appendChild(dmpElement);
        String xml = XmlBuilder.generateXml(xmlDoc);
        writer.write(xml);
        writer.close();
        FileEnvelope fileEnvelope = new FileEnvelope();
        fileEnvelope.setFile(xmlFile);
        //TODO
//        if (dmp.getGrant() !=  null && dmp.getGrant().getLabel() != null) {
//            fileEnvelope.setFilename("DMP_" + dmp.getGrant().getLabel() + "_" + dmp.getVersion() + ".xml");
//        }
//        else {
//            fileEnvelope.setFilename("DMP_" + dmp.getLabel() + "_" + dmp.getVersion() + ".xml");
//        }

        return fileEnvelope;
    }

    @Transactional
    public FileEnvelope getRDAJsonDocument(String id) throws Exception {
        DmpEntity dmp = databaseRepository.getDmpDao().find(UUID.fromString(id));
        if (!dmp.getAccessType().equals(DmpAccessType.Public) 
        //TODO        && dmp.getUsers().stream().noneMatch(userInfo -> this.userScope.getUserIdSafe().equals(userInfo.getUser().getId()))
        )
            throw new UnauthorisedException();
        final boolean isFinalized = dmp.getStatus() == DmpStatus.Finalized;
        final boolean isPublic = dmp.getAccessType().equals(DmpAccessType.Public);
        //TODO   
//        dmp.setDataset(dmp.getDataset().stream()
//                .filter(dataset -> dataset.getIsActive() != IsActive.Inactive &&
//                        dataset.getStatus() != DescriptionStatus.Canceled)
//                .filter(dataset -> !isPublic && !isFinalized || dataset.getStatus() == DescriptionStatus.Finalized)
//                .collect(Collectors.toSet()));
        String result = rdaManager.convertToRDA(dmp);

        String fileName = "";
        //TODO   
//        if (dmp.getGrant() !=  null && dmp.getGrant().getLabel() != null) {
//            fileName = "DMP_" + dmp.getGrant().getLabel() + "_" + dmp.getVersion();
//        }
//        else {
//            fileName = "DMP_" + dmp.getLabel() + "_" + dmp.getVersion();
//        }
        fileName = fileName.replaceAll("[^a-zA-Z0-9+ ]", "").replace(" ", "_").replace(",", "_");
        String uuid = UUID.randomUUID().toString();
        File file = new File(this.environment.getProperty("temp.temp") + uuid + ".json");
        OutputStream output = new FileOutputStream(file);
        try {
            output.write(result.getBytes());
            output.flush();
            output.close();
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }

        FileEnvelope rdaJsonDocument = new FileEnvelope();
        rdaJsonDocument.setFilename(fileName + ".json");
        rdaJsonDocument.setFile(file);
        return rdaJsonDocument;
    }

    public ResponseEntity<byte[]> getDocument(String id, String contentType, ConfigLoader configLoader) throws InstantiationException, IllegalAccessException, IOException, InvalidApplicationException {
        FileEnvelope file;
        switch (contentType) {
            case "application/xml":
                file = getXmlDocument(id);
                break;
            case "application/msword":
                file = getWordDocument(id, configLoader);
                break;
            default:
                file = getXmlDocument(id);
        }
        String fileName = file.getFilename().replace(" ", "_").replace(",", "_");
        InputStream resource = new FileInputStream(file.getFile());
        HttpHeaders responseHeaders = new HttpHeaders();
        responseHeaders.setContentLength(file.getFile().length());
        responseHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
        responseHeaders.set("Content-Disposition", "attachment;filename=" + fileName);
        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.getFile().toPath());
        return new ResponseEntity<>(content,
                responseHeaders,
                HttpStatus.OK);
    }

    /*
    * Data Import
    * */

    public List<DmpImportModel> createDmpFromXml(MultipartFile[] files, String[] profiles) throws IOException, JAXBException, Exception {
        List<DmpImportModel> dataManagementPlans = new ArrayList<>();
        // Jaxb approach.
        JAXBContext jaxbContext;

        for (MultipartFile multipartFile : Arrays.asList(files)) {  // Gets one item from the array.
            try {
                InputStream in = multipartFile.getInputStream();  // Transforms item to InputStream.
                jaxbContext = JAXBContext.newInstance(DmpImportModel.class);
                Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
                DmpImportModel dmpImportModel = (DmpImportModel) jaxbUnmarshaller.unmarshal(in);
                dataManagementPlans.add(dmpImportModel);
            } catch (IOException | JAXBException ex) {
                logger.error(ex.getMessage(), ex);
            }
            // TODO Iterate through the list of dataManagementPlans.
            // Creates new dataManagementPlan to fill it with the data model that was parsed from the xml.
            // Creates properties.
            DataManagementPlanEditorModel dm = new DataManagementPlanEditorModel();

            DmpProfileImportModel dmpProfileImportModel = dataManagementPlans.get(0).getDmpProfile();
            Tuple<UUID, String> tupleProfile = new Tuple<>();
            if (dmpProfileImportModel != null) {
                tupleProfile.setId(dmpProfileImportModel.getDmpProfileId());
                tupleProfile.setLabel(dmpProfileImportModel.getDmpProfileName());
            }
            else {
                tupleProfile.setId(UUID.fromString("86635178-36a6-484f-9057-a934e4eeecd5"));
                tupleProfile.setLabel("Dmp Default Blueprint");
            }
            dm.setProfile(tupleProfile);


            Map<String, Object> dmpPropertiesMap = new HashMap<>();
            if (dataManagementPlans.get(0).getExtraFieldsImportModels() != null) {
                for (ExtraFieldsImportModels extraField: dataManagementPlans.get(0).getExtraFieldsImportModels()) {
                    dmpPropertiesMap.put(extraField.getId(), extraField.getValue());
                }
            }
            dm.setProperties(dmpPropertiesMap);
//TODO
//            if (this.dmpBlueprintService.fieldInBlueprint(dmpProfileImportModel.getDmpProfileId(), DmpBlueprintSystemFieldType.Funder)) {
//                eu.eudat.models.data.funder.Funder funder = new eu.eudat.models.data.funder.Funder();
//                FunderImportModels funderImport = dataManagementPlans.get(0).getFunderImportModels();
//                funder.setId(funderImport.getId());
//                funder.setLabel(funderImport.getLabel());
//                FunderDMPEditorModel funderEditor = new FunderDMPEditorModel();
//                funderEditor.setExistFunder(funder);
//
//                dm.setFunder(funderEditor);
//            }
            //TODO
//            if (this.dmpBlueprintService.fieldInBlueprint(dmpProfileImportModel.getDmpProfileId(), DmpBlueprintSystemFieldType.Grant)) {
//                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());
//                GrantDMPEditorModel grantEditor = new GrantDMPEditorModel();
//                grantEditor.setExistGrant(grant);
//
//                dm.setGrant(grantEditor);
//            }

            //TODO
//            if (this.dmpBlueprintService.fieldInBlueprint(dmpProfileImportModel.getDmpProfileId(), DmpBlueprintSystemFieldType.Project)) {
//                eu.eudat.models.data.project.Project project = new eu.eudat.models.data.project.Project();
//                ProjectImportModels projectImport = dataManagementPlans.get(0).getProjectImportModels();
//                project.setId(projectImport.getId());
//                project.setLabel(projectImport.getLabel());
//                ProjectDMPEditorModel projectEditor = new ProjectDMPEditorModel();
//                projectEditor.setExistProject(project);
//
//                dm.setProject(projectEditor);
//            }

            List<eu.eudat.models.data.dmp.AssociatedProfile> associatedProfiles = new LinkedList<>();
//            if (profiles != null && profiles.length > 0) {
//                for (String profile : profiles) {
//                    DescriptionTemplate exProfile = apiContext.getOperationsContext().getDatabaseRepository().getDatasetProfileDao().find(UUID.fromString(profile));
//                    AssociatedProfile associatedProfile = new AssociatedProfile().fromData(exProfile);
//                    associatedProfiles.add(associatedProfile);
//                }
//            }

            for (AssociatedProfileImportModels a : dataManagementPlans.get(0).getProfilesImportModels()) {
                try {
                    eu.eudat.data.DescriptionTemplateEntity exProfile = apiContext.getOperationsContext().getDatabaseRepository().getDatasetProfileDao().find(a.getId());
                    AssociatedProfile associatedProfile = new AssociatedProfile().fromData(exProfile);
                    Map<String, Object> data = new HashMap<>();
                    List<Integer> sections = new ArrayList<>(a.getSection());
                    data.put("dmpSectionIndex", sections);
                    associatedProfile.setData(data);
                    associatedProfiles.add(associatedProfile);
                } catch (Exception ignored) {
                }
            }

//            List<eu.eudat.models.data.dmp.Organisation> organisations = new ArrayList<>();
//            for (OrganisationImportModel org : dataManagementPlans.get(0).getOrganisationImportModels()) {
//                eu.eudat.models.data.dmp.Organisation organisation = new eu.eudat.models.data.dmp.Organisation();
//                organisation.setName(org.getOrganaisationNameImport());
//                organisation.setReference(org.getOrganaisationReferenceImport());
//                organisation.setKey(organisation.getReference().split(":")[0]);
//                organisations.add(organisation);
//            }//TODO

//            List<eu.eudat.models.data.dmp.Researcher> researchers = new LinkedList<>();
//            for (ResearcherImportModels res : dataManagementPlans.get(0).getResearchersImportModels()) {
//                eu.eudat.models.data.dmp.Researcher researcher = new eu.eudat.models.data.dmp.Researcher();
//                researcher.setLabel(res.getResearcherImportName());
//                researcher.setName(res.getResearcherImportName());
//                researcher.setReference(res.getResearcherImportReference());
//                researcher.setKey(researcher.getReference().split(":")[0]);
//                researchers.add(researcher);
//            } //TODO

            //List<UserListingModel> associatedUsers = new LinkedList<>();
            List<DynamicFieldWithValue> dynamicFields = new LinkedList<>();

            // Sets properties.
            dm.setLabel(files[0].getOriginalFilename());  // Sets label.
            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.
            //dm.setDefinition(dmpProfile);
            //ObjectMapper mapper = new ObjectMapper();
            Map<String, Object> extraPropertiesMap = new HashMap<>();
            if (dataManagementPlans.get(0).getLanguage() != null) {
                extraPropertiesMap.put("language", dataManagementPlans.get(0).getLanguage());
            }
            if (dataManagementPlans.get(0).getVisibility() != null) {
                extraPropertiesMap.put("visible", dataManagementPlans.get(0).getVisibility());
            }
            if (dataManagementPlans.get(0).getPublicDate() != null) {
                extraPropertiesMap.put("publicDate", dataManagementPlans.get(0).getPublicDate());
            }
            if (dataManagementPlans.get(0).getCosts() != null && !dataManagementPlans.get(0).getCosts().isEmpty()) {
                extraPropertiesMap.put("costs", objectMapper.readValue(dataManagementPlans.get(0).getCosts(), ArrayList.class));
            }
            dm.setExtraProperties(extraPropertiesMap);

            //createOrUpdate(apiContext, dm, principal);
            DmpEntity dmp = this.createOrUpdate(dm);
//            if (dmp.getOrganisations() == null) { //TODO
//                dmp.setOrganisations(new HashSet<>());
//            }
//            if (dmp.getResearchers() == null) {
//                dmp.setResearchers(new HashSet<>());
//            }
//            if (dmp.getDataset() == null) {
//                dmp.setDataset(new HashSet<>());
//            }
//            if (dmp.getUsers() == null) {
//                dmp.setUsers(new HashSet<>());
//            }
//            if (dmp.getAssociatedDmps() == null) {
//                dmp.setAssociatedDmps(new HashSet<>());
//            }

            List<DatasetListingModel> datasets = new LinkedList<>();
            for (DatasetImportModels das: dataManagementPlans.get(0).getDatasetImportModels()) {
                DescriptionEntity descriptionEntity = new DescriptionEntity();
                descriptionEntity.setLabel(das.getName());
                //TODO
//                descriptionEntity.setDmpSectionIndex(das.getDmpSectionIndex());
//                try {
//                    descriptionEntity.setDescriptionTemplateId(das.getProfile());
//                } catch (Exception ignored) {
//                    descriptionEntity.setDescriptionTemplateId(associatedProfiles.get(0).getDescriptionTemplateId());
//                }
//                descriptionEntity.setDmpId(dmp.getId());
                descriptionEntity.setProperties(objectMapper.writeValueAsString(das.getFieldImportModels()));
                descriptionEntity.setStatus(DescriptionStatus.Draft);
//                descriptionEntity.setRegistries(new HashSet<>());
//                descriptionEntity.setDatasetDataRepositories(new HashSet<>());
//                descriptionEntity.setServices(new HashSet<>());
//                descriptionEntity.setDatasetExternalDatasets(new HashSet<>());
                DatasetWizardModel datasetWizard = new DatasetWizardModel();
                datasetWizard.setDatasetProfileDefinition(this.datasetManager.getPagedProfile(datasetWizard, descriptionEntity));
                datasetWizard.fromDataModel(descriptionEntity);
                this.datasetManager.createOrUpdate(datasetWizard);
                // datasets.add(new DatasetListingModel().fromDataModel(dataset));
            }
        }

        return dataManagementPlans;
    }

    public List<DmpEntity> createFromRDA(MultipartFile[] files, String[] profiles) throws IOException, InvalidApplicationException {
        if (!this.userScope.isSet()) {
            throw new UnauthorisedException("No user is logged in");
        }
        List<DmpEntity> result = new ArrayList<>();
        for (MultipartFile file: files) {
            DmpEntity dmp = rdaManager.convertToEntity(new String(file.getBytes(), "UTF-8"), profiles);
            dmp.setLabel(file.getOriginalFilename());
            UserEntity me = this.queryFactory.query(UserQuery.class).ids(dmp.getCreatorId()).first();
            dmp.setUpdatedAt(Instant.now());
            dmp.setCreatorId(me.getId());
            //TODO
//            Map<String, String> extraProperties = objectMapper.readValue(dmp.getExtraProperties(), HashMap.class);
//            extraProperties.put("contact", me.getId().toString());
//            dmp.setExtraProperties(objectMapper.writeValueAsString(extraProperties));
//            dmp.setVersion(0);
//            dmp.setStatus((short)0);
//            dmp.setGroupId(UUID.randomUUID());
//            if (dmp.getResearchers() != null && !dmp.getResearchers().isEmpty()) {
//                dmp.getResearchers().stream().filter(Objects::nonNull).forEach(researcher -> {
//                    researcher.setId(UUID.randomUUID());
//                    researcher.setCreated(new Date());
//                    researcher.setModified(new Date());
//                    researcher.setStatus((short) 0);
//                    apiContext.getOperationsContext().getDatabaseRepository().getResearcherDao().createOrUpdate(researcher);
//                });
//            }
//            databaseRepository.getDmpDao().createOrUpdate(dmp);
//            assignUser(dmp, me);
//            //TODO
////            if (this.apiContext.getOperationsContext().getElasticRepository().getDmpRepository().getClient() != null) {
////                UUID dmpId = dmp.getId();
////                dmp.setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), dmpId)).toList()));
////                this.updateIndex(dmp);
////            }
//            dmp.getDataset().forEach(dataset -> {
//                dataset.setStatus(DescriptionStatus.Draft);
//                dataset.setCreatedAt(Instant.now());
//                dataset.setUpdatedAt(Instant.now());
//                //dataset.setDmpId(dmp.getId()); //TODO
//                dataset = databaseRepository.getDatasetDao().createOrUpdate(dataset);
////                dataset.setRegistries(new HashSet<>());
////                dataset.setDatasetDataRepositories(new HashSet<>());
////                dataset.setDatasetExternalDatasets(new HashSet<>());
////                dataset.setServices(new HashSet<>());
//                if (dmp.getOrganisations() == null) {
//                    dmp.setOrganisations(new HashSet<>());
//                }
//                if (dmp.getResearchers() == null) {
//                    dmp.setResearchers(new HashSet<>());
//                }
//                try {
//                    dmp.setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), dmp.getId())).toList()));
//                } catch (InvalidApplicationException e) {
//                    throw new RuntimeException(e);
//                }
                //TODO
//                try {
//                    List<Tag> tags = new ArrayList<>();
//                    eu.eudat.elastic.entities.Dataset elastic = apiContext.getOperationsContext().getElasticRepository().getDatasetRepository().findDocument(dataset.getId().toString());
//                    DatasetWizardModel datasetWizardModel = new DatasetWizardModel().fromDataModel(dataset);
//                    if (elastic != null) {
//                        tags = elastic.getTags();
//                        datasetWizardModel.setTags(tags);
//                    }
//                    datasetManager.getTagsFromProfile(datasetWizardModel, dataset);
//                    datasetManager.updateTags(dataset, datasetWizardModel.getTags());
//                } catch (Exception e) {
//                    logger.error(e.getMessage(), e);
//                }
//            });
            result.add(dmp);
        }

        return result;
    }

    /*
    * Data assignments
    * */

    private void assignUser(DmpEntity dmp, UserEntity userInfo) {
        this.assignUser(dmp, userInfo, DmpUserRole.Owner);
    }

    private void assignUser(DmpEntity dmp, UserEntity userInfo, DmpUserRole role) {
        DmpUserEntity userDMP = new DmpUserEntity();
        userDMP.setDmpId(dmp.getId());
        userDMP.setUserId(userInfo.getId());
        userDMP.setRole(role);
//        databaseRepository.getUserDmpDao().createOrUpdate(userDMP);
    }

    private void clearUsers(DmpEntity dmp) throws InvalidApplicationException {
        List<DmpUserEntity> userDMPs = this.queryFactory.query(DmpUserQuery.class).dmpIds(dmp.getId()).collect();
//        userDMPs.forEach(userDMP -> apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().delete(userDMP));
    }

    private void assignGrandUserIfInternal(DmpEntity dmp, UserEntity user) {
        //TODO
//        if (dmp.getGrant() != null && dmp.getGrant().getCreationUser() == null && (dmp.getGrant().getReference() != null && dmp.getGrant().getReference().startsWith("dmp:"))) {
//            dmp.getGrant().setCreationUser(user);
//        }
    }

    private void assignFunderUserIfInternal(DmpEntity dmp, UserEntity user) {
        //TODO
//        if (dmp.getGrant() != null && dmp.getGrant().getFunder() != null && dmp.getGrant().getFunder().getCreationUser() == null && ( dmp.getGrant().getFunder().getReference() != null && dmp.getGrant().getFunder().getReference().startsWith("dmp:"))) {
//            dmp.getGrant().getFunder().setCreationUser(user);
//        }
    }

    private void assignProjectUserIfInternal(DmpEntity dmp, UserEntity user) {
        //TODO
//        if (dmp.getProject() != null && dmp.getProject().getCreationUser() == null && (dmp.getProject().getReference() != null && dmp.getProject().getReference().startsWith("dmp:"))) {
//            dmp.getProject().setCreationUser(user);
//        }
    }

    /*
    * Data Index
    * */

    private void updateGroupIndex(UUID groupId) throws InvalidApplicationException {
        DataManagementPlanCriteria criteria = new DataManagementPlanCriteria();
        criteria.setGroupIds(Collections.singletonList(groupId));
        criteria.setAllVersions(true);
        List<DmpEntity> dmps = databaseRepository.getDmpDao().getWithCriteria(criteria).toList();
        for (DmpEntity dmp: dmps) {
//            try { //TODO
//                if (dmp.getUsers() == null) {
//                    UUID dmpId = dmp.getId();
//                    dmp.setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), dmpId)).toList()));
//                }
////                this.updateIndex(dmp); //TODO
//            } catch (InvalidApplicationException e) {
//                logger.error(e.getMessage(), e);
//            }
        }
    }

//    private void updateDatasetsIndex(List<DescriptionEntity> descriptionEntities) {
//        descriptionEntities.forEach(dataset -> {
//            List<Tag> tags = new ArrayList<>();
//            eu.eudat.elastic.entities.Dataset elastic = null;
//            try {
//                elastic = apiContext.getOperationsContext().getElasticRepository().getDatasetRepository().findDocument(dataset.getId().toString());
//                if (elastic != null) {
//                    tags = elastic.getTags();
//                }
//                //TODO
//                //UUID dmpId = dataset.getDmpId();
//                //dataset.getDmp().setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), dmpId)).toList()));
//                this.datasetManager.updateTags(dataset, tags);
//            } catch (Exception e) {
//                logger.error(e.getMessage(), e);
//            }
//
//        });
//    }

//    public void updateIndex(DMP dmp) throws IOException, InvalidApplicationException {
//        DmpMapper mapper = new DmpMapper(apiContext, datasetManager);
//        Dmp elastic = mapper.toElastic(dmp);
//        apiContext.getOperationsContext().getElasticRepository().getDmpRepository().createOrUpdate(elastic);
//    }
//
//    public void generateIndex() throws InvalidApplicationException {
//        if (this.authorizationService.authorize(Permission.AdminRole)) {
//            if (apiContext.getOperationsContext().getElasticRepository().getDmpRepository().createIndex()) {
//                List<DMP> dmps = apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().asQueryable().toList();
//                dmps.forEach(dmp -> {
//                    try {
//                        UUID dmpId = dmp.getId();
//                        dmp.setUsers(new HashSet<>(apiContext.getOperationsContext().getDatabaseRepository().getUserDmpDao().asQueryable().where((builder, root) -> builder.equal(root.get("dmp").get("id"), dmpId)).toList()));
//                        this.updateIndex(dmp);
//                    } catch (IOException | InvalidApplicationException e) {
//                        logger.error(e.getMessage(), e);
//                    }
//                });
//            }
//        }
//    }

//    public void clearIndex() throws IOException {
//        if (this.authorizationService.authorize(Permission.AdminRole)) {
//            apiContext.getOperationsContext().getElasticRepository().getDmpRepository().clear();
//        }
//    }

    /*
    * Data Checkup
    * */

    private void checkIfUserCanEditGrant(DmpEntity dmp, UserEntity user) throws Exception{
//        if (dmp.getGrant() != null && dmp.getGrant().getId() != null) { //TODO
//            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.");
//                }
//            }
//        }
    }

    private void checkDmpValidationRules(DmpEntity dmp) throws Exception {
        if (dmp.getLabel() == null || dmp.getLabel().trim().isEmpty()) {
            throw new Exception("DMP has no label.");
        }
        //TODO
//        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.");
//        }
    }

    private boolean isUserOwnerOfDmp(DmpEntity dmp) throws InvalidApplicationException {
        return this.userScope.isSet() ;
               //TODO && (dmp.getUsers().stream().filter(userDMP -> userDMP.getRole().equals(UserDMP.UserDMPRoles.OWNER.getValue())).map(userDMP -> userDMP.getUser().getId())).collect(Collectors.toList()).contains(this.userScope.getUserId();
    }

    /*
    * DOI Generation
    * */

    private String getPreviousDOI(UUID groupId, UUID selfId, String repositoryId) throws InvalidApplicationException {
        DataManagementPlanCriteria criteria = new DataManagementPlanCriteria();
        List<UUID> groupIds = new ArrayList<>();
        groupIds.add(groupId);
        criteria.setGroupIds(groupIds);
        criteria.setAllVersions(true);
        List<DmpEntity> dmps = this.databaseRepository.getDmpDao().getWithCriteria(criteria).toList();
        dmps.sort((DmpEntity d1, DmpEntity d2) -> d2.getVersion() - d1.getVersion());
        for (DmpEntity dmp: dmps) {
            if (!dmp.getId().equals(selfId)) {
//                if (dmp.getDois() != null && !dmp.getDois().isEmpty()) { //TODO
//                    for (Iterator<EntityDoiEntity> it = dmp.getDois().iterator(); it.hasNext(); ) {
//                        EntityDoiEntity entityDoi = it.next();
//                        if(entityDoi.getRepositoryId().equals(repositoryId)){
//                            return entityDoi.getDoi();
//                        }
//                    }
//                }
            }
        }

        return null;
    }


    @Transactional
    public EntityDoi createDoi(DepositRequest depositRequest) throws Exception {
        DmpEntity dmp = this.apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(depositRequest.getDmpId());
        if (!isUserOwnerOfDmp(dmp))
            throw new Exception("User is not authorized to invoke this action");
        if (!dmp.getStatus().equals(DmpStatus.Finalized))
            throw new Exception("DMP is not finalized");
        /*if (dmp.getDoi() != null)
            throw new Exception("DMP already has a DOI");*/

        FileEnvelope file = getWordDocument(depositRequest.getDmpId().toString(), configLoader);
        String name = file.getFilename().substring(0, file.getFilename().length() - 5).replaceAll("[^a-zA-Z0-9_+ ]", "").replace(" ", "_").replace(",", "_");
        byte[] pdfFile = null; //PDFUtils.convertToPDF(file, environment); //TODO 
//        eu.eudat.depositinterface.models.FileEnvelope pdfEnvelope = new eu.eudat.depositinterface.models.FileEnvelope();
//        pdfEnvelope.setFile(pdfFile);
//        pdfEnvelope.setFilename(name + ".pdf");
//        eu.eudat.depositinterface.models.FileEnvelope rdaJsonFile = new eu.eudat.depositinterface.models.FileEnvelope();
        try {
              FileEnvelope rdaJsonDocument = getRDAJsonDocument(depositRequest.getDmpId().toString());
              //rdaJsonFile.setFile(rdaJsonDocument.getFile()); //TODO
//              rdaJsonFile.setFilename(rdaJsonDocument.getFilename());
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        String previousDOI = this.getPreviousDOI(dmp.getGroupId(), dmp.getId(), depositRequest.getRepositoryId());

        File supportingFilesZip = this.createSupportingFilesZip(dmp);

//        DmpDepositModel dmpDepositModel = new DmpDepositModel(); // DMPToDepositMapper.fromDMP(dmp, pdfEnvelope, rdaJsonFile, supportingFilesZip, previousDOI);//TODO

        String finalDoi = null;
        try {
            finalDoi =  this.repositoriesDeposit.deposit(depositRequest).getDoi();
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            return null;
        }
        EntityDoi doiModel = null;
        if (finalDoi != null) {

            EntityDoiEntity doiEntity = new EntityDoiEntity();
            doiEntity.setId(UUID.randomUUID());
            doiEntity.setEntityType(EntityType.DMP);
            doiEntity.setDoi(finalDoi);
            doiEntity.setRepositoryId(depositRequest.getRepositoryId());
            doiEntity.setCreatedAt(Instant.now());
            doiEntity.setUpdatedAt(Instant.now());
            doiEntity.setEntityId(dmp.getId());
            //TODO: Save doi
//            apiContext.getOperationsContext().getDatabaseRepository().getEntityDoiDao().createOrUpdate(doiEntity);

//            dmp.getDois().add(doiEntity);
            apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(dmp);

            doiModel = new EntityDoi();//.fromDataModel(doiEntity); //TODO

        }
        if(supportingFilesZip != null) {
            Files.deleteIfExists(supportingFilesZip.toPath());
        }
//        Files.deleteIfExists(rdaJsonFile.getFile().toPath()); //TODO
//        Files.deleteIfExists(pdfFile.toPath());
//        Files.deleteIfExists(file.getFile().toPath());

        return doiModel;

    }

    private File createSupportingFilesZip(DmpEntity dmp) throws IOException, InvalidApplicationException {
        FileOutputStream fout = new FileOutputStream(this.environment.getProperty("temp.temp") + "supportingFiles.zip");
        ZipOutputStream zout = new ZipOutputStream(fout);

        boolean hasFileUploaded = false;
        Set<DescriptionEntity> descriptionEntities = new HashSet<>(); //TODO dmp.getDataset();
        for (DescriptionEntity descriptionEntity : descriptionEntities) {
            List<FileUpload> files = this.apiContext.getOperationsContext().getDatabaseRepository().getFileUploadDao().getFileUploads(descriptionEntity.getId());
            for (FileUpload f : files) {
                if(!f.getIsDeleted()){
                    File exportFile = new File(this.environment.getProperty("file.storage") + f.getId());
                    String filename = f.getName().replace(" ", "_").replace(",", "_");
                    byte[] content = Files.readAllBytes(exportFile.toPath());
                    ZipEntry ze = new ZipEntry(filename);
                    zout.putNextEntry(ze);
                    zout.write(content, 0, content.length);
                    zout.closeEntry();
                    hasFileUploaded = true;
                }
            }
        }
        zout.close();
        if(!hasFileUploaded){
            Files.deleteIfExists(new File(this.environment.getProperty("temp.temp") + "supportingFiles.zip").toPath());
        }
        return hasFileUploaded ? new File(this.environment.getProperty("temp.temp") + "supportingFiles.zip") : null;
    }

    /*
    * Misc
    * */

    private void sendNotification(DmpEntity dmp, UserEntity user/*, NotificationType notificationType*/) throws InvalidApplicationException {
        List<DmpUserEntity> userDMPS = this.queryFactory.query(DmpUserQuery.class).dmpIds(dmp.getId()).collect();
        for (DmpUserEntity userDMP : userDMPS) {
            if (!userDMP.getUserId().equals(user.getId())) {
//                Notification notification = new Notification(); //TODO
//                notification.setUserId(user);
//                notification.setType(notificationType);
//                notification.setNotifyState(NotifyState.PENDING);
//                notification.setIsActive(ActiveStatus.ACTIVE);
//                notification.setData("{" +
//                        "\"userId\": \"" + userDMP.getId() + "\"" +
////                        ", \"id\": \"" + userDMP.getDmp().getId() + "\"" + //TODO
////                        ", \"name\": \"" + userDMP.getDmp().getLabel() + "\"" +
//                        ", \"path\": \"" + notificationPaths.get(notificationType) +"\"" +
//                        "}");
//                notification.setCreatedAt(new Date());
//                notification.setUpdatedAt(notification.getCreatedAt());
//                notification.setContactTypeHint(ContactType.EMAIL);
//                //notification.setContactHint(userDMP.getUser().getEmail()); //TODO
//                databaseRepository.getNotificationDao().createOrUpdate(notification);
            }
        }

    }

    /*public DataTableData<DataManagementPlanListingModel> getPublicPaged(DataManagmentPlanPublicTableRequest dataManagementPlanPublicTableRequest, String fieldsGroup, Principal principal) throws Exception {
        dataManagementPlanPublicTableRequest.setQuery(databaseRepository.getDmpDao().asQueryable().withHint(HintedModelFactory.getHint(DataManagementPlanListingModel.class)));
        QueryableList<DMP> items = dataManagementPlanPublicTableRequest.applyCriteria();

        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()));
            });
        }
        QueryableList<DMP> pagedItems = PaginationManager.applyPaging(items, dataManagementPlanPublicTableRequest);

        DataTableData<DataManagementPlanListingModel> dataTable = new DataTableData<>();

        CompletableFuture itemsFuture;
        if (fieldsGroup.equals("listing")) {
            itemsFuture = pagedItems.withHint(HintedModelFactory.getHint(DataManagementPlanListingModel.class))
                    .selectAsync(item -> {
                        item.setDataset(
                                item.getDataset().stream()
                                        .filter(dataset -> dataset.getStatus().equals(Dataset.Status.FINALISED.getValue())).collect(Collectors.toSet()));
                        return new DataManagementPlanListingModel().fromDataModelDatasets(item);
                    })
                    .whenComplete((resultList, throwable) -> dataTable.setData(resultList));
        } else {
            itemsFuture = pagedItems
                    .selectAsync(item -> new DataManagementPlanListingModel().fromDataModel(item))
                    .whenComplete((resultList, throwable) -> dataTable.setData(resultList));
        }

        CompletableFuture countFuture = items.countAsync().whenComplete((count, throwable) -> {
            dataTable.setTotalCount(count);
        });
        CompletableFuture.allOf(itemsFuture, countFuture).join();
        return dataTable;
    }
*/
    /*public void unlock(UUID uuid) throws Exception {
        apiContext.getOperationsContext().getDatabaseRepository().getDmpDao()
                .asQueryable().where((builder, root) -> builder.equal(root.get("id"), uuid))
                .update(root -> root.get("status"), DMP.DMPStatus.ACTIVE.getValue());
        return;
    }*/
    /*public File 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);
    }*/
    /*public eu.eudat.models.data.dmp.DataManagementPlan getSinglePublic(String id, DynamicGrantConfiguration dynamicGrantConfiguration) throws Exception {
        DMP dataManagementPlanEntity = databaseRepository.getDmpDao().find(UUID.fromString(id));

        if (dataManagementPlanEntity != null && dataManagementPlanEntity.getStatus() == 1) {
            eu.eudat.models.data.dmp.DataManagementPlan datamanagementPlan = new eu.eudat.models.data.dmp.DataManagementPlan();
            datamanagementPlan.fromDataModel(dataManagementPlanEntity);
            datamanagementPlan.setDatasets(datamanagementPlan.getDatasets().stream().filter(dataset -> dataset.getStatus() == Dataset.Status.FINALISED.getValue()).collect(Collectors.toList()));
            Map dmpProperties = dataManagementPlanEntity.getDmpProperties() != null ? new org.json.JSONObject(dataManagementPlanEntity.getDmpProperties()).toMap() : null;
//            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()));

            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;
        } else {
            throw new Exception("Selected DMP is not public");
        }
    }

    public DataManagementPlanOverviewModel getOverviewSinglePublic(String id) throws Exception {
        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;
        } else {
            throw new Exception("Selected DMP is not public");
        }
    }*/
    /*public List<DataManagementPlan> getWithCriteria(DMPDao dmpsRepository, DataManagementPlanCriteriaRequest dataManagementPlanCriteria, Principal principal) throws IllegalAccessException, InstantiationException {
        UUID principalID = principal.getId();
        QueryableList<DMP> items = dmpsRepository.getWithCriteria(dataManagementPlanCriteria.getCriteria()).withHint(HintedModelFactory.getHint(DataManagementPlan.class));
        List<Integer> roles = new LinkedList<>();
        QueryableList<DMP> authenticatedItems = dmpsRepository.getAuthenticated(items, principalID, roles);
        List<eu.eudat.models.data.dmp.DataManagementPlan> datamanagementPlans = authenticatedItems.select(item -> new DataManagementPlan().fromDataModel(item));
        return datamanagementPlans;
    }*/
}