Merge branch 'Development'

dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/DatasetProfileDao.java

@@ -16,4 +16,6 @@ public interface DatasetProfileDao extends DatabaseAccessLayer<DatasetProfile, U
 
     QueryableList<DatasetProfile> getAuthenticated(QueryableList<DatasetProfile> query, UUID principal, List<Integer> roles);
 
+    List<DatasetProfile> getAllIds();
+
 }

dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/DatasetProfileDaoImpl.java

@@ -15,6 +15,7 @@ import org.springframework.stereotype.Component;
 import javax.persistence.criteria.Join;
 import javax.persistence.criteria.JoinType;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
@@ -86,6 +87,11 @@ public class DatasetProfileDaoImpl extends DatabaseAccess<DatasetProfile> implem
         return getDatabaseService().getQueryable(DatasetProfile.class);
     }
 
+    @Override
+    public List<DatasetProfile> getAllIds(){
+        return getDatabaseService().getQueryable(DatasetProfile.class).withFields(Collections.singletonList("id")).toList();
+    }
+
     @Override
     public void delete(DatasetProfile item) {
         this.getDatabaseService().delete(item);

dmp-backend/data/src/main/java/eu/eudat/data/entities/DMP.java

@@ -25,7 +25,12 @@ import java.util.stream.Collectors;
                 name = "fullyDetailed",
                 attributeNodes = {
                         @NamedAttributeNode("grant"), @NamedAttributeNode("profile"),
-                        @NamedAttributeNode("users"), @NamedAttributeNode("organisations"), @NamedAttributeNode("researchers")}),
+                        @NamedAttributeNode(value = "users", subgraph = "users"), @NamedAttributeNode("organisations"), @NamedAttributeNode("researchers")
+                },
+                subgraphs = {
+                        @NamedSubgraph(name = "users", attributeNodes = {@NamedAttributeNode("user")})
+                }
+        ),
         @NamedEntityGraph(
                 name = "dmpRecentActivity",
                 attributeNodes = {

dmp-backend/web/pom.xml

@@ -34,7 +34,7 @@
         <dependency>
             <groupId>gr.cite.opendmp</groupId>
             <artifactId>repositorydepositbase</artifactId>
-            <version>1.0.1</version>
+            <version>1.0.3</version>
         </dependency>
 
 

dmp-backend/web/src/main/java/eu/eudat/controllers/AboutController.java

@@ -0,0 +1,46 @@
+package eu.eudat.controllers;
+
+import eu.eudat.logic.managers.MaterialManager;
+import eu.eudat.logic.managers.MetricsManager;
+import eu.eudat.types.MetricNames;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.env.Environment;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+@RestController
+@CrossOrigin
+@RequestMapping(value = {"/api/material/about/"})
+public class AboutController {
+
+    private Environment environment;
+    private MaterialManager materialManager;
+    private final MetricsManager metricsManager;
+
+    @Autowired
+    public AboutController(Environment environment, MaterialManager materialManager, MetricsManager metricsManager) {
+        this.environment = environment;
+        this.materialManager = materialManager;
+        this.metricsManager = metricsManager;
+    }
+
+    @RequestMapping(path = "{lang}", method = RequestMethod.GET )
+    public ResponseEntity<byte[]> getAbout(@PathVariable(name = "lang") String lang) throws IOException {
+//        long files = 0;
+//        try (Stream<Path> paths = Files.list(Paths.get(Objects.requireNonNull(this.environment.getProperty("about.path"))))) {
+//            files = paths.count();
+//        }
+//        metricsManager.calculateValue(MetricNames.LANGUAGES, (int) files, null);
+        try (Stream<Path> paths = Files.walk(Paths.get(Objects.requireNonNull(this.environment.getProperty("about.path"))))) {
+            return this.materialManager.getResponseEntity(lang, paths);
+        }
+    }
+
+}

dmp-backend/web/src/main/java/eu/eudat/controllers/Admin.java

@@ -190,8 +190,10 @@ public class Admin extends BaseController {
 				.status(ApiMessageCode.SUCCESS_MESSAGE).message(""));
 	}
 
-	@RequestMapping(method = RequestMethod.GET, value = {"/getRDACommonStandards"}, produces = "application/json")
-	public ResponseEntity getRDACommonStandards(@ClaimedAuthorities(claims = {ADMIN, DATASET_PROFILE_MANAGER}) Principal principal) {
-		return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<List<String>>().status(ApiMessageCode.SUCCESS_MESSAGE).payload(configLoader.getRdaProperties()));
+
+	@RequestMapping(method = RequestMethod.GET, value = {"/getSemantics"}, produces = "application/json")
+	public ResponseEntity<ResponseItem<List<String>>> getSemantics(@RequestParam(value = "query", required = false) String query, @ClaimedAuthorities(claims = {ADMIN, DATASET_PROFILE_MANAGER}) Principal principal) {
+		List<String> semantics = this.datasetProfileManager.getSemantics(query);
+		return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<List<String>>().status(ApiMessageCode.SUCCESS_MESSAGE).payload(semantics));
 	}
 }

dmp-backend/web/src/main/java/eu/eudat/controllers/DMPs.java

@@ -9,12 +9,10 @@ import eu.eudat.data.entities.DMP;
 import eu.eudat.data.entities.Dataset;
 import eu.eudat.data.query.items.table.datasetprofile.DatasetProfileTableRequestItem;
 import eu.eudat.data.query.items.table.dmp.DataManagementPlanTableRequest;
-import eu.eudat.data.query.items.table.dmp.DataManagmentPlanPublicTableRequest;
 import eu.eudat.exceptions.datamanagementplan.DMPNewVersionException;
 import eu.eudat.exceptions.datamanagementplan.DMPWithDatasetsDeleteException;
 import eu.eudat.exceptions.security.UnauthorisedException;
 import eu.eudat.logic.managers.DataManagementPlanManager;
-import eu.eudat.logic.managers.DatasetManager;
 import eu.eudat.logic.proxy.config.configloaders.ConfigLoader;
 import eu.eudat.logic.security.claims.ClaimedAuthorities;
 import eu.eudat.logic.services.ApiContext;
@@ -152,7 +150,7 @@ public class DMPs extends BaseController {
 
     @RequestMapping(method = RequestMethod.GET, value = {"/publicOverview/{id}"})
     public @ResponseBody
-    ResponseEntity getOverviewSinglePublic(@PathVariable String id, @ClaimedAuthorities(claims = {Authorities.ADMIN, Authorities.MANAGER, Authorities.USER, Authorities.ANONYMOUS}) Principal principal) throws Exception {
+    ResponseEntity<ResponseItem<DataManagementPlanOverviewModel>> getOverviewSinglePublic(@PathVariable String id, @ClaimedAuthorities(claims = {Authorities.ADMIN, Authorities.MANAGER, Authorities.USER, Authorities.ANONYMOUS}) Principal principal) throws Exception {
 //        try {
         DataManagementPlanOverviewModel dataManagementPlan = this.dataManagementPlanManager.getOverviewSingle(id, principal, true);
         return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<DataManagementPlanOverviewModel>().status(ApiMessageCode.NO_MESSAGE).payload(dataManagementPlan));
@@ -184,7 +182,21 @@ public class DMPs extends BaseController {
     public @ResponseBody
     ResponseEntity getRDAJsonDocument(@PathVariable String id, @ClaimedAuthorities(claims = {Authorities.ADMIN, Authorities.MANAGER, Authorities.USER, Authorities.ANONYMOUS}) Principal principal) {
     	try {
-        return this.dataManagementPlanManager.getRDAJsonDocument(id, principal);
+            FileEnvelope rdaJsonDocument = this.dataManagementPlanManager.getRDAJsonDocument(id, principal);
+
+            HttpHeaders responseHeaders = new HttpHeaders();
+            responseHeaders.setContentLength(rdaJsonDocument.getFile().length());
+            responseHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
+            responseHeaders.set("Content-Disposition", "attachment;filename=" + rdaJsonDocument.getFilename());
+            responseHeaders.set("Access-Control-Expose-Headers", "Content-Disposition");
+            responseHeaders.get("Access-Control-Expose-Headers").add("Content-Type");
+
+            InputStream resource = new FileInputStream(rdaJsonDocument.getFile());
+            byte[] content = org.apache.poi.util.IOUtils.toByteArray(resource);
+            resource.close();
+            Files.deleteIfExists(rdaJsonDocument.getFile().toPath());
+
+            return new ResponseEntity<>(content, responseHeaders, HttpStatus.OK);
     	} catch (Exception e) {
     		return ResponseEntity.status(HttpStatus.EXPECTATION_FAILED).body(new ResponseItem<>().message(e.getMessage()).status(ApiMessageCode.ERROR_MESSAGE));
     	}
@@ -321,21 +333,6 @@ public class DMPs extends BaseController {
         }
     }
 
-    /*
-    * DOI Generation
-    * */
-
-    @RequestMapping(method = RequestMethod.POST, value = {"/createZenodoDoi/{id}"})
-    public ResponseEntity<ResponseItem<String>> createZenodoDoi(@PathVariable String id, Principal principal) {
-        try {
-            String zenodoDOI = this.dataManagementPlanManager.createZenodoDoi(UUID.fromString(id), principal);
-            return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<String>().status(ApiMessageCode.SUCCESS_MESSAGE).message("Successfully created DOI for Data Datamanagement Plan in question.").payload(zenodoDOI));
-        } catch (Exception e) {
-            logger.error(e.getMessage(), e);
-            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseItem<String>().status(ApiMessageCode.ERROR_MESSAGE).message("Failed to create DOI for the Data Management Plan: " + e.getMessage()));
-        }
-    }
-
     /*
     * Data Index
     * */

dmp-backend/web/src/main/java/eu/eudat/controllers/Datasets.java

@@ -117,7 +117,7 @@ public class Datasets extends BaseController {
 
     @RequestMapping(method = RequestMethod.GET, value = {"/publicOverview/{id}"})
     public @ResponseBody
-    ResponseEntity getOverviewSinglePublic(@PathVariable String id, @ClaimedAuthorities(claims = {Authorities.ADMIN, Authorities.MANAGER, Authorities.USER, Authorities.ANONYMOUS}) Principal principal) throws Exception {
+    ResponseEntity<ResponseItem<DatasetOverviewModel>> getOverviewSinglePublic(@PathVariable String id, @ClaimedAuthorities(claims = {Authorities.ADMIN, Authorities.MANAGER, Authorities.USER, Authorities.ANONYMOUS}) Principal principal) throws Exception {
 //        try {
         DatasetOverviewModel dataset = this.datasetManager.getOverviewSingle(id, principal, true);
         return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<DatasetOverviewModel>().status(ApiMessageCode.NO_MESSAGE).payload(dataset));

dmp-backend/web/src/main/java/eu/eudat/controllers/EmailUnlinkConfirmation.java

@@ -0,0 +1,57 @@
+package eu.eudat.controllers;
+
+import eu.eudat.exceptions.emailconfirmation.HasConfirmedEmailException;
+import eu.eudat.exceptions.emailconfirmation.TokenExpiredException;
+import eu.eudat.logic.managers.UnlinkEmailConfirmationManager;
+import eu.eudat.models.data.helpers.responses.ResponseItem;
+import eu.eudat.models.data.security.Principal;
+import eu.eudat.models.data.userinfo.UserUnlinkRequestModel;
+import eu.eudat.types.ApiMessageCode;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import javax.transaction.Transactional;
+
+@RestController
+@CrossOrigin
+@RequestMapping(value = "api/emailUnlinkConfirmation")
+public class EmailUnlinkConfirmation {
+
+    private UnlinkEmailConfirmationManager unlinkEmailConfirmationManager;
+
+    @Autowired
+    public EmailUnlinkConfirmation(UnlinkEmailConfirmationManager unlinkEmailConfirmationManager){
+        this.unlinkEmailConfirmationManager = unlinkEmailConfirmationManager;
+    }
+
+    @Transactional
+    @RequestMapping(method = RequestMethod.GET, value = {"/{emailToken}"})
+    public @ResponseBody
+    ResponseEntity<ResponseItem> emailConfirmation(@PathVariable(value = "emailToken") String token) {
+        try {
+            this.unlinkEmailConfirmationManager.confirmEmail(token);
+            return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem().status(ApiMessageCode.SUCCESS_MESSAGE));
+        } catch (TokenExpiredException | HasConfirmedEmailException ex) {
+            if (ex instanceof TokenExpiredException) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseItem().status(ApiMessageCode.NO_MESSAGE));
+            }
+            else {
+                return ResponseEntity.status(HttpStatus.FOUND).body(new ResponseItem().status(ApiMessageCode.WARN_MESSAGE));
+            }
+        }
+    }
+
+    @Transactional
+    @RequestMapping(method = RequestMethod.POST, consumes = "application/json", produces = "application/json")
+    public @ResponseBody
+    ResponseEntity<ResponseItem> sendUnlinkConfirmationEmail(@RequestBody UserUnlinkRequestModel requestModel, Principal principal) {
+        try {
+            this.unlinkEmailConfirmationManager.sendConfirmationEmail(requestModel.getEmail(), principal, requestModel.getUserId(), requestModel.getProvider());
+            return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem().status(ApiMessageCode.SUCCESS_MESSAGE));
+        } catch (Exception ex) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseItem().status(ApiMessageCode.NO_MESSAGE).message("Could not send unlink email."));
+        }
+    }
+}

dmp-backend/web/src/main/java/eu/eudat/controllers/FaqController.java

@@ -0,0 +1,45 @@
+package eu.eudat.controllers;
+
+import eu.eudat.logic.managers.MaterialManager;
+import eu.eudat.logic.managers.MetricsManager;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.env.Environment;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+@RestController
+@CrossOrigin
+@RequestMapping(value = {"/api/material/faq/"})
+public class FaqController {
+
+    private Environment environment;
+    private MaterialManager materialManager;
+    private final MetricsManager metricsManager;
+
+    @Autowired
+    public FaqController(Environment environment, MaterialManager materialManager, MetricsManager metricsManager) {
+        this.environment = environment;
+        this.materialManager = materialManager;
+        this.metricsManager = metricsManager;
+    }
+
+    @RequestMapping(path = "{lang}", method = RequestMethod.GET )
+    public ResponseEntity<byte[]> getFaq(@PathVariable(name = "lang") String lang) throws IOException {
+//        long files = 0;
+//        try (Stream<Path> paths = Files.list(Paths.get(Objects.requireNonNull(this.environment.getProperty("faq.path"))))) {
+//            files = paths.count();
+//        }
+//        metricsManager.calculateValue(MetricNames.LANGUAGES, (int) files, null);
+        try (Stream<Path> paths = Files.walk(Paths.get(Objects.requireNonNull(this.environment.getProperty("faq.path"))))) {
+            return this.materialManager.getResponseEntity(lang, paths);
+        }
+    }
+
+}

dmp-backend/web/src/main/java/eu/eudat/controllers/GlossaryController.java

@@ -0,0 +1,45 @@
+package eu.eudat.controllers;
+
+import eu.eudat.logic.managers.MaterialManager;
+import eu.eudat.logic.managers.MetricsManager;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.env.Environment;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+@RestController
+@CrossOrigin
+@RequestMapping(value = {"/api/material/glossary/"})
+public class GlossaryController {
+
+    private Environment environment;
+    private MaterialManager materialManager;
+    private final MetricsManager metricsManager;
+
+    @Autowired
+    public GlossaryController(Environment environment, MaterialManager materialManager, MetricsManager metricsManager) {
+        this.environment = environment;
+        this.materialManager = materialManager;
+        this.metricsManager = metricsManager;
+    }
+
+    @RequestMapping(path = "{lang}", method = RequestMethod.GET )
+    public ResponseEntity<byte[]> getGlossary(@PathVariable(name = "lang") String lang) throws IOException {
+//        long files = 0;
+//        try (Stream<Path> paths = Files.list(Paths.get(Objects.requireNonNull(this.environment.getProperty("glossary.path"))))) {
+//            files = paths.count();
+//        }
+//        metricsManager.calculateValue(MetricNames.LANGUAGES, (int) files, null);
+        try (Stream<Path> paths = Files.walk(Paths.get(Objects.requireNonNull(this.environment.getProperty("glossary.path"))))) {
+            return this.materialManager.getResponseEntity(lang, paths);
+        }
+    }
+
+}

dmp-backend/web/src/main/java/eu/eudat/controllers/ManagementController.java

@@ -0,0 +1,54 @@
+package eu.eudat.controllers;
+
+import eu.eudat.exceptions.datasetprofile.DatasetProfileNewVersionException;
+import eu.eudat.logic.managers.DatasetProfileManager;
+import eu.eudat.logic.security.claims.ClaimedAuthorities;
+import eu.eudat.logic.services.ApiContext;
+import eu.eudat.models.data.admin.composite.DatasetProfile;
+import eu.eudat.models.data.helpers.responses.ResponseItem;
+import eu.eudat.models.data.security.Principal;
+import eu.eudat.types.ApiMessageCode;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import javax.transaction.Transactional;
+
+import static eu.eudat.types.Authorities.ADMIN;
+
+@RestController
+@CrossOrigin
+@RequestMapping(value = {"/api/management/"})
+public class ManagementController extends BaseController {
+
+    private DatasetProfileManager datasetProfileManager;
+
+    @Autowired
+    public ManagementController(ApiContext apiContext, DatasetProfileManager datasetProfileManager){
+        super(apiContext);
+        this.datasetProfileManager = datasetProfileManager;
+    }
+
+    @Transactional
+    @RequestMapping(method = RequestMethod.POST, value = {"/addSemantics"})
+    public ResponseEntity addSemanticsInDatasetProfiles(@ClaimedAuthorities(claims = {ADMIN}) Principal principal) throws Exception {
+        try {
+            this.datasetProfileManager.addSemanticsInDatasetProfiles();
+            return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<Void>().status(ApiMessageCode.SUCCESS_MESSAGE));
+        } catch (Exception exception) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseItem<Void>().status(ApiMessageCode.ERROR_MESSAGE).message(exception.getMessage()));
+        }
+    }
+
+    @Transactional
+    @RequestMapping(method = RequestMethod.POST, value = {"/addRdaInSemantics"})
+    public ResponseEntity addRdaInSemanticsInDatasetProfiles(@ClaimedAuthorities(claims = {ADMIN}) Principal principal) throws Exception {
+        try {
+            this.datasetProfileManager.addRdaInSemanticsInDatasetProfiles();
+            return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<Void>().status(ApiMessageCode.SUCCESS_MESSAGE));
+        } catch (Exception exception) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseItem<Void>().status(ApiMessageCode.ERROR_MESSAGE).message(exception.getMessage()));
+        }
+    }
+}

dmp-backend/web/src/main/java/eu/eudat/controllers/Saml2MetadataController.java

@@ -0,0 +1,78 @@
+package eu.eudat.controllers;
+
+import eu.eudat.logic.proxy.config.configloaders.ConfigLoader;
+import eu.eudat.logic.security.customproviders.ConfigurableProvider.entities.saml2.Saml2ConfigurableProvider;
+import eu.eudat.logic.security.validators.configurableProvider.Saml2SSOUtils;
+import eu.eudat.logic.services.ApiContext;
+import eu.eudat.models.data.helpers.responses.ResponseItem;
+import eu.eudat.types.ApiMessageCode;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.nio.charset.StandardCharsets;
+
+@RestController
+@CrossOrigin
+@RequestMapping(value = {"/api/saml2/"})
+public class Saml2MetadataController extends BaseController {
+
+    private final ConfigLoader configLoader;
+
+    @Autowired
+    public Saml2MetadataController(ApiContext apiContext, ConfigLoader configLoader) {
+        super(apiContext);
+        this.configLoader = configLoader;
+    }
+
+    @RequestMapping(method = RequestMethod.GET, value = {"metadata/{configurableProviderId}"})
+    public @ResponseBody
+    ResponseEntity getMetadata(@PathVariable String configurableProviderId) {
+        Saml2ConfigurableProvider saml2ConfigurableProvider = (Saml2ConfigurableProvider) this.configLoader.getConfigurableProviders().getProviders().stream()
+                .filter(prov -> prov.getConfigurableLoginId().equals(configurableProviderId))
+                .findFirst().orElse(null);
+        if (saml2ConfigurableProvider != null) {
+            try {
+                String metadataXml = Saml2SSOUtils.getMetadata(saml2ConfigurableProvider);
+                HttpHeaders responseHeaders = new HttpHeaders();
+                responseHeaders.setContentLength(metadataXml.length());
+                responseHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
+                responseHeaders.set("Content-Disposition", "attachment;filename=" + configurableProviderId + ".xml");
+                responseHeaders.set("Access-Control-Expose-Headers", "Content-Disposition");
+                responseHeaders.get("Access-Control-Expose-Headers").add("Content-Type");
+                return new ResponseEntity<>(metadataXml.getBytes(StandardCharsets.UTF_8),
+                        responseHeaders,
+                        HttpStatus.OK);
+            } catch (Exception e) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseItem<String>().status(ApiMessageCode.ERROR_MESSAGE).message("Failed to fetch metadata."));
+            }
+        }
+        else {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseItem<String>().status(ApiMessageCode.ERROR_MESSAGE).message("Failed to fetch metadata."));
+        }
+    }
+    @RequestMapping(method = RequestMethod.GET, value = {"authnRequest/{configurableProviderId}"})
+    public @ResponseBody
+    ResponseEntity<ResponseItem<String>> getAuthnRequest(@PathVariable String configurableProviderId) {
+        Saml2ConfigurableProvider saml2ConfigurableProvider = (Saml2ConfigurableProvider) this.configLoader.getConfigurableProviders().getProviders().stream()
+                .filter(prov -> prov.getConfigurableLoginId().equals(configurableProviderId))
+                .findFirst().orElse(null);
+        if (saml2ConfigurableProvider != null) {
+            try {
+                String authnRequestXml = Saml2SSOUtils.getAuthnRequest(saml2ConfigurableProvider);
+                return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<String>().status(ApiMessageCode.SUCCESS_MESSAGE).message("Created").payload(authnRequestXml));
+            }
+            catch (Exception e) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseItem<String>().status(ApiMessageCode.ERROR_MESSAGE).message("Failed to create authentication request."));
+            }
+
+        }
+        else {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseItem<String>().status(ApiMessageCode.ERROR_MESSAGE).message("Unknown provider."));
+        }
+    }
+
+}

dmp-backend/web/src/main/java/eu/eudat/controllers/TermsOfServiceController.java

@@ -0,0 +1,45 @@
+package eu.eudat.controllers;
+
+import eu.eudat.logic.managers.MaterialManager;
+import eu.eudat.logic.managers.MetricsManager;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.env.Environment;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+@RestController
+@CrossOrigin
+@RequestMapping(value = {"/api/material/termsofservice/"})
+public class TermsOfServiceController {
+
+    private Environment environment;
+    private MaterialManager materialManager;
+    private final MetricsManager metricsManager;
+
+    @Autowired
+    public TermsOfServiceController(Environment environment, MaterialManager materialManager, MetricsManager metricsManager) {
+        this.environment = environment;
+        this.materialManager = materialManager;
+        this.metricsManager = metricsManager;
+    }
+
+    @RequestMapping(path = "{lang}", method = RequestMethod.GET )
+    public ResponseEntity<byte[]> getTermsOfService(@PathVariable(name = "lang") String lang) throws IOException {
+//        long files = 0;
+//        try (Stream<Path> paths = Files.list(Paths.get(Objects.requireNonNull(this.environment.getProperty("termsofservice.path"))))) {
+//            files = paths.count();
+//        }
+//        metricsManager.calculateValue(MetricNames.LANGUAGES, (int) files, null);
+        try (Stream<Path> paths = Files.walk(Paths.get(Objects.requireNonNull(this.environment.getProperty("termsofservice.path"))))) {
+            return this.materialManager.getResponseEntity(lang, paths);
+        }
+    }
+
+}

dmp-backend/web/src/main/java/eu/eudat/controllers/UserGuideController.java

@@ -1,5 +1,6 @@
 package eu.eudat.controllers;
 
+import eu.eudat.logic.managers.MaterialManager;
 import eu.eudat.logic.managers.MetricsManager;
 import eu.eudat.logic.security.claims.ClaimedAuthorities;
 import eu.eudat.models.data.helpers.responses.ResponseItem;
@@ -32,47 +33,26 @@ import static eu.eudat.types.Authorities.ADMIN;
 public class UserGuideController {
 
 	private Environment environment;
+	private MaterialManager materialManager;
 	private final MetricsManager metricsManager;
 
 	@Autowired
-	public UserGuideController(Environment environment, MetricsManager metricsManager) {
+	public UserGuideController(Environment environment, MaterialManager materialManager, MetricsManager metricsManager) {
 		this.environment = environment;
+		this.materialManager = materialManager;
 		this.metricsManager = metricsManager;
 	}
 
 	@RequestMapping(path = "{lang}", method = RequestMethod.GET )
-	public ResponseEntity getUserGuide(@PathVariable(name = "lang") String lang) throws IOException {
+	public ResponseEntity<byte[]> getUserGuide(@PathVariable(name = "lang") String lang) throws IOException {
 		long files = 0;
 		try (Stream<Path> paths = Files.list(Paths.get(Objects.requireNonNull(this.environment.getProperty("userguide.path"))))) {
 			files = paths.count();
 		}
-			metricsManager.calculateValue(MetricNames.LANGUAGES, (int) files, null);
+		metricsManager.calculateValue(MetricNames.LANGUAGES, (int) files, null);
 		try (Stream<Path> paths = Files.walk(Paths.get(Objects.requireNonNull(this.environment.getProperty("userguide.path"))))) {
-			List<String> result = paths.filter(Files::isRegularFile)
-					.map(Path::toString).collect(Collectors.toList());
-
-			String fileName = result.stream().filter(guide -> guide.contains("_" + lang)).findFirst().orElse(null);
-			if (fileName == null) {
-				fileName = result.stream().filter(guide -> guide.contains("_en")).findFirst().get();
-			}
-			InputStream is = new FileInputStream(fileName);
-
-			Path path = Paths.get(fileName);
-
-			HttpHeaders responseHeaders = new HttpHeaders();
-			responseHeaders.setContentLength(is.available());
-			responseHeaders.setContentType(MediaType.TEXT_HTML);
-			responseHeaders.set("Content-Disposition", "attachment;filename=" + path.getFileName().toString());
-			responseHeaders.set("Access-Control-Expose-Headers", "Content-Disposition");
-			responseHeaders.get("Access-Control-Expose-Headers").add("Content-Type");
-
-			byte[] content = new byte[is.available()];
-			is.read(content);
-			is.close();
-
-			return new ResponseEntity<>(content, responseHeaders, HttpStatus.OK);
+			return this.materialManager.getResponseEntity(lang, paths);
 		}
-
 	}
 
 	@RequestMapping(value = "current", method = RequestMethod.POST)

dmp-backend/web/src/main/java/eu/eudat/controllers/Users.java

@@ -88,16 +88,6 @@ public class Users extends BaseController {
         return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<DataTableData<UserListingModel>>().payload(dataTable).status(ApiMessageCode.NO_MESSAGE));
     }
 
-    @RequestMapping(method = RequestMethod.GET, value = {"/hasDOIToken"}, consumes = "application/json", produces = "application/json")
-    public @ResponseBody
-    ResponseEntity<ResponseItem<Boolean>> hasDOIToken(Principal principal) throws NullEmailException {
-        try {
-            return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<Boolean>().payload(this.userManager.isDOITokenValid(principal)).status(ApiMessageCode.NO_MESSAGE));
-        } catch (NonValidTokenException | ExpiredTokenException | IOException e) {
-            return ResponseEntity.status(460).body(new ResponseItem<Boolean>().payload(false).status(ApiMessageCode.ERROR_MESSAGE).message(e.getMessage()));
-        }
-    }
-
     @Transactional
     @RequestMapping(method = RequestMethod.POST, value = {"/registerDOIToken"}, consumes = "application/json", produces = "application/json")
     public @ResponseBody

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

@@ -481,6 +481,7 @@ public class DataManagementPlanManager {
             checkDmpValidationRules(newDmp);
         }
         UserInfo user = apiContext.getOperationsContext().getDatabaseRepository().getUserInfoDao().find(principal.getId());
+        newDmp.setCreator(user);
 
         createOrganisationsIfTheyDontExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getOrganisationDao());
         createResearchersIfTheyDontExist(newDmp, apiContext.getOperationsContext().getDatabaseRepository().getResearcherDao(), user);
@@ -645,6 +646,7 @@ public class DataManagementPlanManager {
         if (latestVersionDMP.get(0).getVersion().equals(oldDmp.getVersion())) {
             DMP newDmp = dataManagementPlan.toDataModel();
             UserInfo user = apiContext.getOperationsContext().getBuilderFactory().getBuilder(UserInfoBuilder.class).id(principal.getId()).build();
+            newDmp.setCreator(user);
             createOrganisationsIfTheyDontExist(newDmp, databaseRepository.getOrganisationDao());
             createResearchersIfTheyDontExist(newDmp, databaseRepository.getResearcherDao(), user);
 
@@ -705,6 +707,7 @@ public class DataManagementPlanManager {
         DMP newDmp = dataManagementPlan.toDataModel();
 
         UserInfo user = apiContext.getOperationsContext().getBuilderFactory().getBuilder(UserInfoBuilder.class).id(principal.getId()).build();
+        newDmp.setCreator(user);
         createOrganisationsIfTheyDontExist(newDmp, databaseRepository.getOrganisationDao());
         createResearchersIfTheyDontExist(newDmp, databaseRepository.getResearcherDao(), user);
 
@@ -1064,9 +1067,6 @@ public class DataManagementPlanManager {
         });
         UserInfo user = apiContext.getOperationsContext().getDatabaseRepository().getUserInfoDao().find(principal.getId());
         sendNotification(dmp, user, NotificationType.DMP_PUBLISH);
-//        if (dmp.getDois() != null && !dmp.getDois().isEmpty()) {
-//            this.createZenodoDoi(dmp.getId(), principal, true);
-//        }
     }
 
     @Transactional
@@ -1456,6 +1456,40 @@ public class DataManagementPlanManager {
         }
         dmpElement.appendChild(dmpProfileElement);
 
+        Element dmpContactElement = xmlDoc.createElement("contact");
+        Element dmpContactName = xmlDoc.createElement("name");
+        Element dmpContactEmail = xmlDoc.createElement("email");
+        if(dmp.getCreator() != null){
+            dmpContactName.setTextContent(dmp.getCreator().getName());
+            dmpContactEmail.setTextContent(dmp.getCreator().getEmail());
+        }
+        else{
+            Iterator<UserDMP> users = dmp.getUsers().iterator();
+            if(users.hasNext()){
+                UserDMP creator = users.next();
+                dmpContactName.setTextContent(creator.getUser().getName());
+                dmpContactEmail.setTextContent(creator.getUser().getEmail());
+            }
+        }
+        dmpContactElement.appendChild(dmpContactName);
+        dmpContactElement.appendChild(dmpContactEmail);
+        dmpElement.appendChild(dmpContactElement);
+
+        Element dmpContributorsElement = xmlDoc.createElement("contributors");
+        Iterator<UserDMP> users = dmp.getUsers().iterator();
+        while(users.hasNext()){
+            Element dmpContributorElement = xmlDoc.createElement("contributor");
+            Element dmpContributorName = xmlDoc.createElement("name");
+            Element dmpContributorEmail= xmlDoc.createElement("email");
+            UserDMP contributor = users.next();
+            dmpContributorName.setTextContent(contributor.getUser().getName());
+            dmpContributorEmail.setTextContent(contributor.getUser().getEmail());
+            dmpContributorElement.appendChild(dmpContributorName);
+            dmpContributorElement.appendChild(dmpContributorEmail);
+            dmpContributorsElement.appendChild(dmpContributorElement);
+        }
+        dmpElement.appendChild(dmpContributorsElement);
+
         // Funder.
         Element funder = xmlDoc.createElement("funder");
         Element funderLabel = xmlDoc.createElement("label");
@@ -1464,6 +1498,13 @@ public class DataManagementPlanManager {
         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");
@@ -1473,15 +1514,31 @@ public class DataManagementPlanManager {
         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");
-        Element projectLabel = xmlDoc.createElement("label");
         Element projectId = xmlDoc.createElement("id");
-        projectLabel.setTextContent(dmp.getProject().getLabel());
+        Element projectLabel = xmlDoc.createElement("label");
+        Element projectDescription = xmlDoc.createElement("description");
+        Element projectStartDate = xmlDoc.createElement("start");
+        Element projectEndDate = xmlDoc.createElement("end");
         projectId.setTextContent(dmp.getProject().getId().toString());
-        project.appendChild(projectLabel);
+        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);
 
         Element organisationsElement = xmlDoc.createElement("organisations");
@@ -1513,11 +1570,20 @@ public class DataManagementPlanManager {
 
         for (Dataset dataset : datasets) {
             Element datasetElement = xmlDoc.createElement("dataset");
-            Element datsetProfileElement = xmlDoc.createElement("profile");
             datasetElement.setAttribute("name", dataset.getLabel());
+
+            Element datasetDescriptionElement = xmlDoc.createElement("description");
+            datasetElement.appendChild(datasetDescriptionElement);
+            datasetDescriptionElement.setTextContent(dataset.getDescription());
+
+            Element datsetProfileElement = xmlDoc.createElement("profile-id");
             datasetElement.appendChild(datsetProfileElement);
             datsetProfileElement.setTextContent(dataset.getProfile().getId().toString());
 
+            Element datsetProfileLabelElement = xmlDoc.createElement("profile-label");
+            datasetElement.appendChild(datsetProfileLabelElement);
+            datsetProfileLabelElement.setTextContent(dataset.getProfile().getLabel());
+
             DatasetWizardModel datasetWizardModel = new DatasetWizardModel();
             Map<String, Object> properties = new HashMap<>();
             if (dataset.getProperties() != null) {
@@ -1535,12 +1601,18 @@ public class DataManagementPlanManager {
         // Get DatasetProfiles from DMP to add to XML.
         for (DatasetProfile datasetProfile : dmp.getAssociatedDmps()) {
             Element profile = xmlDoc.createElement("profile");
-            Element profileLabel = xmlDoc.createElement("profilelabel");
-            profileLabel.setTextContent(datasetProfile.getLabel());
-            profile.appendChild(profileLabel);
             Element profileId = xmlDoc.createElement("profileId");
             profileId.setTextContent(datasetProfile.getId().toString());
             profile.appendChild(profileId);
+            Element profileGroupId = xmlDoc.createElement("profileGroupId");
+            profileGroupId.setTextContent(datasetProfile.getGroupId().toString());
+            profile.appendChild(profileGroupId);
+            Element profileLabel = xmlDoc.createElement("profileLabel");
+            profileLabel.setTextContent(datasetProfile.getLabel());
+            profile.appendChild(profileLabel);
+            Element profileVersion = xmlDoc.createElement("profileVersion");
+            profileVersion.setTextContent(String.valueOf(datasetProfile.getVersion()));
+            profile.appendChild(profileVersion);
             profiles.appendChild(profile);
         }
         dmpElement.appendChild(profiles);
@@ -1556,13 +1628,12 @@ public class DataManagementPlanManager {
         return fileEnvelope;
     }
 
-    public ResponseEntity<byte[]> getRDAJsonDocument(String id, Principal principal) throws Exception {
+    public FileEnvelope getRDAJsonDocument(String id, Principal principal) throws Exception {
         eu.eudat.data.entities.DMP dmp = databaseRepository.getDmpDao().find(UUID.fromString(id));
         if (!dmp.isPublic() && dmp.getUsers().stream().noneMatch(userInfo -> userInfo.getUser().getId() == principal.getId()))
             throw new UnauthorisedException();
-//        RDAExportModel rdaExportModel = new RDAExportModel().fromDataModel(dmp, datasetManager, principal);
-        final Boolean isFinalized = dmp.getStatus() == DMP.DMPStatus.FINALISED.getValue();
-        final Boolean isPublic = dmp.isPublic();
+        final boolean isFinalized = dmp.getStatus() == DMP.DMPStatus.FINALISED.getValue();
+        final boolean isPublic = dmp.isPublic();
         dmp.setDataset(dmp.getDataset().stream()
                 .filter(dataset -> dataset.getStatus() != Dataset.Status.DELETED.getValue() &&
                         dataset.getStatus() != Dataset.Status.CANCELED.getValue())
@@ -1570,15 +1641,12 @@ public class DataManagementPlanManager {
                 .collect(Collectors.toSet()));
         String result = rdaManager.convertToRDA(dmp);
 
-        /*ObjectMapper mapper = new ObjectMapper();
-        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);*/
-        String fileName = "DMP_" + dmp.getGrant().getLabel() + "_" + dmp.getVersion();//dmp.getLabel();
+        String fileName = "DMP_" + dmp.getGrant().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 {
-//            mapper.writeValue(file, rdaExportModel);
             output.write(result.getBytes());
             output.flush();
             output.close();
@@ -1586,18 +1654,10 @@ public class DataManagementPlanManager {
             logger.error(e.getMessage(), e);
         }
 
-        InputStream resource = new FileInputStream(file);
-        HttpHeaders responseHeaders = new HttpHeaders();
-        responseHeaders.setContentLength(file.length());
-        responseHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
-        responseHeaders.set("Content-Disposition", "attachment;filename=" + fileName + ".json");
-        responseHeaders.set("Access-Control-Expose-Headers", "Content-Disposition");
-        responseHeaders.get("Access-Control-Expose-Headers").add("Content-Type");
-
-        byte[] content = org.apache.poi.util.IOUtils.toByteArray(resource);
-        resource.close();
-        Files.deleteIfExists(file.toPath());
-        return new ResponseEntity<>(content, responseHeaders, HttpStatus.OK);
+        FileEnvelope rdaJsonDocument = new FileEnvelope();
+        rdaJsonDocument.setFilename(fileName + ".json");
+        rdaJsonDocument.setFile(file);
+        return rdaJsonDocument;
     }
 
     public ResponseEntity<byte[]> getDocument(String id, String contentType, Principal principal, ConfigLoader configLoader) throws InstantiationException, IllegalAccessException, IOException {
@@ -2041,100 +2101,6 @@ public class DataManagementPlanManager {
         return null;
     }
 
-    private String getUnpublishedDOI(String DOI, String token, Integer version) {
-        try {
-            RestTemplate restTemplate = new RestTemplate();
-            HttpHeaders headers = new HttpHeaders();
-            headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
-            headers.setContentType(MediaType.APPLICATION_JSON);
-            Map createResponse = null;
-            LinkedHashMap<String, String> links = null;
-            LinkedHashMap<String, String> metadata = null;
-            String listUrl = this.environment.getProperty("zenodo.url") + "deposit/depositions" + "?q=conceptdoi:\"" + DOI + "\"&access_token=" + token;
-            ResponseEntity<Map[]> listResponses = restTemplate.getForEntity(listUrl, Map[].class);
-            createResponse = listResponses.getBody()[0];
-            metadata = (LinkedHashMap<String, String>) createResponse.get("metadata");
-            links = (LinkedHashMap<String, String>) createResponse.get("links");
-
-            if (metadata.get("version").equals(version.toString())) {
-                return links.get("publish");
-            } else {
-                return null;
-            }
-        }catch (Exception e) {
-            logger.warn(e.getMessage(), e);
-            return null;
-        }
-    }
-
-    public String createZenodoDoi(UUID id, Principal principal) throws Exception {
-        return this.createZenodoDoi(id, principal, false);
-    }
-
-    public String createZenodoDoi(UUID id, Principal principal, boolean update) throws Exception {
-        DMP dmp = this.apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(id);
-        if (!isUserOwnerOfDmp(dmp, principal))
-            throw new Exception("User is not authorized to invoke this action");
-        if (!dmp.getStatus().equals(DMP.DMPStatus.FINALISED.getValue()))
-            throw new Exception("DMP is not finalized");
-        /*if (dmp.getDoi() != null)
-            throw new Exception("DMP already has a DOI");*/
-
-        FileEnvelope file = getWordDocument(id.toString(), principal, configLoader);
-        String name = file.getFilename().substring(0, file.getFilename().length() - 5);
-        File pdfFile = PDFUtils.convertToPDF(file, environment);
-        String fileName = name + ".pdf";
-        ResponseEntity<byte[]> jsonFile;
-        try {
-            jsonFile = getRDAJsonDocument(id.toString(), principal);
-        } catch (Exception e) {
-            throw e;
-        }
-        String previousDOI = this.getPreviousDOI(dmp.getGroupId(), dmp.getId(), "Zenodo");
-
-        File supportingFilesZip = this.createSupportingFilesZip(dmp);
-
-        DMPDepositModel dmpDepositModel = DMPToDepositMapper.fromDMP(dmp, pdfFile, fileName, jsonFile, supportingFilesZip, previousDOI);
-
-        String zenodoToken = "";
-        try {
-            if (this.userManager.isDOITokenValid(principal)) {
-                zenodoToken = principal.getZenodoToken();
-            }
-        } catch (NonValidTokenException e) {
-            zenodoToken = this.environment.getProperty("zenodo.access_token");
-        }
-
-        String finalDoi = null;
-        for(RepositoryDeposit repo: this.repositoriesDeposit) { //temp
-            if(repo.getConfiguration().getRepositoryId().equals("Zenodo")) {
-                finalDoi = repo.deposit(dmpDepositModel, zenodoToken);
-                if (finalDoi != null) {
-                    EntityDoi doiEntity = new EntityDoi();
-                    doiEntity.setId(UUID.randomUUID());
-                    doiEntity.setEntityType(EntityDoi.EntityType.DMP);
-                    doiEntity.setDoi(finalDoi);
-                    doiEntity.setRepositoryId("Zenodo");
-                    Date now = new Date();
-                    doiEntity.setCreatedAt(now);
-                    doiEntity.setUpdatedAt(now);
-                    doiEntity.setEntityId(dmp);
-                    apiContext.getOperationsContext().getDatabaseRepository().getEntityDoiDao().createOrUpdate(doiEntity);
-
-                    dmp.getDois().add(doiEntity);
-                    apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(dmp);
-                }
-            }
-        }
-        if(supportingFilesZip != null) {
-            Files.deleteIfExists(supportingFilesZip.toPath());
-        }
-        Files.deleteIfExists(pdfFile.toPath());
-        Files.deleteIfExists(file.getFile().toPath());
-
-        return finalDoi;
-    }
-
     public Doi createDoi(DepositRequest depositRequest, Principal principal) throws Exception {
         DMP dmp = this.apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().find(UUID.fromString(depositRequest.getDmpId()));
         if (!isUserOwnerOfDmp(dmp, principal))
@@ -2147,18 +2113,22 @@ public class DataManagementPlanManager {
         FileEnvelope file = getWordDocument(depositRequest.getDmpId(), principal, configLoader);
         String name = file.getFilename().substring(0, file.getFilename().length() - 5).replaceAll("[^a-zA-Z0-9_+ ]", "").replace(" ", "_").replace(",", "_");
         File pdfFile = PDFUtils.convertToPDF(file, environment);
-        String fileName = name + ".pdf";
-        ResponseEntity<byte[]> jsonFile;
+        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 {
-            jsonFile = getRDAJsonDocument(depositRequest.getDmpId(), principal);
+              FileEnvelope rdaJsonDocument = getRDAJsonDocument(depositRequest.getDmpId(), principal);
+              rdaJsonFile.setFile(rdaJsonDocument.getFile());
+              rdaJsonFile.setFilename(rdaJsonDocument.getFilename());
         } catch (Exception e) {
-            throw e;
+            logger.error(e.getMessage(), e);
         }
         String previousDOI = this.getPreviousDOI(dmp.getGroupId(), dmp.getId(), depositRequest.getRepositoryId());
 
         File supportingFilesZip = this.createSupportingFilesZip(dmp);
 
-        DMPDepositModel dmpDepositModel = DMPToDepositMapper.fromDMP(dmp, pdfFile, fileName, jsonFile, supportingFilesZip, previousDOI);
+        DMPDepositModel dmpDepositModel = DMPToDepositMapper.fromDMP(dmp, pdfEnvelope, rdaJsonFile, supportingFilesZip, previousDOI);
 
         Optional<RepositoryDeposit> repo = this.repositoriesDeposit.stream().filter(x -> x.getConfiguration().getRepositoryId().equals(depositRequest.getRepositoryId())).findFirst();
         String finalDoi = repo.map(r -> {
@@ -2192,10 +2162,12 @@ public class DataManagementPlanManager {
         if(supportingFilesZip != null) {
             Files.deleteIfExists(supportingFilesZip.toPath());
         }
+        Files.deleteIfExists(rdaJsonFile.getFile().toPath());
         Files.deleteIfExists(pdfFile.toPath());
         Files.deleteIfExists(file.getFile().toPath());
 
         return doiModel;
+
     }
 
     private File createSupportingFilesZip(DMP dmp) throws IOException {

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

@@ -1136,7 +1136,7 @@ public class DatasetManager {
         List<Tag> tags = apiContext.getOperationsContext().getElasticRepository().getDatasetRepository().query(criteria).stream().map(eu.eudat.elastic.entities.Dataset::getTags).flatMap(Collection::stream).filter(StreamDistinctBy.distinctByKey(Tag::getId)).collect(Collectors.toList());
         Set<JsonNode> tagNodes = new HashSet<>();
         tagNodes.addAll(JsonSearcher.findNodes(propertiesJson, "renderStyle", "tags", true));
-        tagNodes.addAll(JsonSearcher.findNodes(propertiesJson, "rdaProperty", "dataset.keyword"));
+        tagNodes.addAll(JsonSearcher.findNodes(propertiesJson, "schematics", "rda.dataset.keyword"));
         if(wizardModel.getTags() == null){
             wizardModel.setTags(new ArrayList<>());
         }

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

@@ -10,13 +10,14 @@ import eu.eudat.data.query.items.item.datasetprofile.DatasetProfileAutocompleteR
 import eu.eudat.data.query.items.table.datasetprofile.DatasetProfileTableRequestItem;
 import eu.eudat.exceptions.datasetprofile.DatasetProfileNewVersionException;
 import eu.eudat.logic.builders.model.models.DataTableDataBuilder;
+import eu.eudat.logic.proxy.config.Semantic;
+import eu.eudat.logic.proxy.config.configloaders.ConfigLoader;
 import eu.eudat.logic.services.ApiContext;
 import eu.eudat.logic.services.operations.DatabaseRepository;
 import eu.eudat.logic.utilities.builders.XmlBuilder;
 import eu.eudat.logic.utilities.documents.helpers.FileEnvelope;
 import eu.eudat.logic.utilities.documents.xml.datasetProfileXml.ExportXmlBuilderDatasetProfile;
 import eu.eudat.logic.utilities.documents.xml.datasetProfileXml.ImportXmlBuilderDatasetProfile;
-import eu.eudat.logic.utilities.helpers.StreamDistinctBy;
 import eu.eudat.models.data.components.commons.datafield.AutoCompleteData;
 import eu.eudat.models.data.datasetprofile.DatasetProfileAutocompleteItem;
 import eu.eudat.models.data.datasetprofile.DatasetProfileListingModel;
@@ -34,23 +35,27 @@ import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.core.env.Environment;
 import org.springframework.http.*;
-import org.springframework.http.client.ClientHttpRequestFactory;
 import org.springframework.http.client.SimpleClientHttpRequestFactory;
-import org.springframework.http.converter.HttpMessageConverter;
-import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
 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 org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
 
 import javax.activation.MimetypesFileTypeMap;
 import javax.transaction.Transactional;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
 import javax.xml.xpath.*;
 import java.io.*;
 import java.nio.file.Files;
 import java.util.*;
-import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
 
 
@@ -62,14 +67,16 @@ public class DatasetProfileManager {
     private ApiContext apiContext;
     private DatabaseRepository databaseRepository;
     private Environment environment;
+    private ConfigLoader configLoader;
 
     private final MetricsManager metricsManager;
 
     @Autowired
-    public DatasetProfileManager(ApiContext apiContext, Environment environment, MetricsManager metricsManager) {
+    public DatasetProfileManager(ApiContext apiContext, Environment environment, ConfigLoader configLoader, MetricsManager metricsManager) {
         this.apiContext = apiContext;
         this.databaseRepository = apiContext.getOperationsContext().getDatabaseRepository();
         this.environment = environment;
+        this.configLoader = configLoader;
         this.metricsManager = metricsManager;
     }
 
@@ -363,4 +370,79 @@ public class DatasetProfileManager {
             }
 
     }
+
+    public List<String> getSemantics(String query) {
+        List<Semantic> semantics = configLoader.getSemantics();
+        List<String> filteredSemantics = semantics.stream().map(Semantic::getName).collect(Collectors.toList());
+        if(query != null && !query.isEmpty()){
+            filteredSemantics = semantics.stream().filter(x -> x.getCategory().contains(query) || x.getName().contains(query)).map(Semantic::getName).collect(Collectors.toList());
+        }
+        return filteredSemantics;
+    }
+
+    public void addSemanticsInDatasetProfiles() throws XPathExpressionException {
+        List<DatasetProfile> ids = this.databaseRepository.getDatasetProfileDao().getAllIds();
+        for(DatasetProfile dp: ids){
+            DatasetProfile datasetProfile = this.databaseRepository.getDatasetProfileDao().find(dp.getId());
+            Document document = XmlBuilder.fromXml(datasetProfile.getDefinition());
+            XPathFactory xpathFactory = XPathFactory.newInstance();
+            XPath xpath = xpathFactory.newXPath();
+            XPathExpression expr = xpath.compile("//rdaCommonStandard");
+            NodeList rdaProperties = (NodeList) expr.evaluate(document, XPathConstants.NODESET);
+            for(int i = 0; i < rdaProperties.getLength(); i++){
+                Node rdaPropertyNode = rdaProperties.item(i);
+                String rdaProperty = rdaPropertyNode.getTextContent();
+                Element schematics = document.createElement("schematics");
+                Node fieldParent = rdaPropertyNode.getParentNode();
+                if(rdaProperty != null && !rdaProperty.isEmpty()){
+                    Element schematic = document.createElement("schematic");
+                    schematic.setTextContent("rda." + rdaProperty);
+                    schematics.appendChild(schematic);
+                }
+                fieldParent.insertBefore(schematics, rdaPropertyNode);
+                fieldParent.removeChild(rdaPropertyNode);
+            }
+            this.updateDatasetProfileXml(document, datasetProfile);
+        }
+    }
+
+    public void addRdaInSemanticsInDatasetProfiles() throws XPathExpressionException {
+        List<DatasetProfile> ids = this.databaseRepository.getDatasetProfileDao().getAllIds();
+        for(DatasetProfile dp: ids){
+            DatasetProfile datasetProfile = this.databaseRepository.getDatasetProfileDao().find(dp.getId());
+            Document document = XmlBuilder.fromXml(datasetProfile.getDefinition());
+            XPathFactory xpathFactory = XPathFactory.newInstance();
+            XPath xpath = xpathFactory.newXPath();
+            XPathExpression expr = xpath.compile("//schematic");
+            NodeList schematics = (NodeList) expr.evaluate(document, XPathConstants.NODESET);
+            for (int i = 0; i < schematics.getLength(); i++) {
+                Node schematicNode = schematics.item(i);
+                String schematicRda = schematicNode.getTextContent();
+                if (schematicRda != null && !schematicRda.isEmpty() && !schematicRda.startsWith("rda.")) {
+                    schematicNode.setTextContent("rda." + schematicRda);
+                }
+            }
+            this.updateDatasetProfileXml(document, datasetProfile);
+        }
+    }
+
+    private void updateDatasetProfileXml(Document document, DatasetProfile datasetProfile) {
+        try {
+            DOMSource domSource = new DOMSource(document);
+            StringWriter writer = new StringWriter();
+            StreamResult result = new StreamResult(writer);
+            TransformerFactory tf = TransformerFactory.newInstance();
+            Transformer transformer = tf.newTransformer();
+            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+            transformer.transform(domSource, result);
+            String newDefinition = writer.toString();
+            if(newDefinition != null){
+                datasetProfile.setDefinition(newDefinition);
+                this.databaseRepository.getDatasetProfileDao().createOrUpdate(datasetProfile);
+            }
+        }
+        catch(TransformerException ex) {
+            logger.error(ex.getMessage(), ex);
+        }
+    }
 }

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

@@ -0,0 +1,51 @@
+package eu.eudat.logic.managers;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Component;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@Component
+public class MaterialManager {
+
+    @Autowired
+    public MaterialManager(){}
+
+    public ResponseEntity<byte[]> getResponseEntity(String lang, Stream<Path> paths) throws IOException {
+        List<String> result = paths.filter(Files::isRegularFile)
+                .map(Path::toString).collect(Collectors.toList());
+
+        String fileName = result.stream().filter(about -> about.contains("_" + lang)).findFirst().orElse(null);
+        if (fileName == null) {
+            fileName = result.stream().filter(about -> about.contains("_en")).findFirst().get();
+        }
+        InputStream is = new FileInputStream(fileName);
+
+        Path path = Paths.get(fileName);
+
+        HttpHeaders responseHeaders = new HttpHeaders();
+        responseHeaders.setContentLength(is.available());
+        responseHeaders.setContentType(MediaType.TEXT_HTML);
+        responseHeaders.set("Content-Disposition", "attachment;filename=" + path.getFileName().toString());
+        responseHeaders.set("Access-Control-Expose-Headers", "Content-Disposition");
+        responseHeaders.get("Access-Control-Expose-Headers").add("Content-Type");
+
+        byte[] content = new byte[is.available()];
+        is.read(content);
+        is.close();
+
+        return new ResponseEntity<>(content, responseHeaders, HttpStatus.OK);
+    }
+}

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

@@ -0,0 +1,106 @@
+package eu.eudat.logic.managers;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import eu.eudat.data.entities.Credential;
+import eu.eudat.data.entities.EmailConfirmation;
+import eu.eudat.data.entities.UserInfo;
+import eu.eudat.data.entities.UserToken;
+import eu.eudat.exceptions.emailconfirmation.HasConfirmedEmailException;
+import eu.eudat.exceptions.emailconfirmation.TokenExpiredException;
+import eu.eudat.logic.builders.entity.UserTokenBuilder;
+import eu.eudat.logic.services.ApiContext;
+import eu.eudat.logic.services.operations.DatabaseRepository;
+import eu.eudat.models.data.security.Principal;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import javax.transaction.Transactional;
+import java.sql.Timestamp;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Component
+public class UnlinkEmailConfirmationManager {
+
+    private static Logger logger = LoggerFactory.getLogger(UnlinkEmailConfirmationManager.class);
+
+    private ApiContext apiContext;
+    private DatabaseRepository databaseRepository;
+
+    @Autowired
+    public UnlinkEmailConfirmationManager(ApiContext apiContext) {
+        this.apiContext = apiContext;
+        this.databaseRepository = apiContext.getOperationsContext().getDatabaseRepository();
+    }
+
+    @Transactional
+    public void confirmEmail(String token) throws TokenExpiredException, HasConfirmedEmailException {
+        EmailConfirmation loginConfirmationEmail = apiContext.getOperationsContext()
+                .getDatabaseRepository().getLoginConfirmationEmailDao().asQueryable()
+                .where((builder, root) -> builder.equal(root.get("token"), UUID.fromString(token))).getSingle();