Merge branch 'dmp-refactoring' of code-repo.d4science.org:MaDgiK-CITE/argos into dmp-refactoring

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

dmp-backend/core/src/main/java/eu/eudat/configurations/deposit/DepositProperties.java

@@ -22,14 +22,16 @@ public class DepositProperties {
     public static class DepositSource {
 
         private final String url;
+        private final List<String> codes;
         private final String issuerUrl;
         private final String clientId;
         private final String clientSecret;
         private final String scope;
 
         @ConstructorBinding
-        public DepositSource(String url, String issuerUrl, String clientId, String clientSecret, String scope) {
+        public DepositSource(String url, List<String> codes, String issuerUrl, String clientId, String clientSecret, String scope) {
             this.url = url;
+            this.codes = codes;
             this.issuerUrl = issuerUrl;
             this.clientId = clientId;
             this.clientSecret = clientSecret;
@@ -55,5 +57,9 @@ public class DepositProperties {
         public String getScope() {
             return scope;
         }
+
+        public List<String> getCodes() {
+            return codes;
+        }
     }
 }

dmp-backend/core/src/main/java/eu/eudat/query/EntityDoiQuery.java

@@ -34,6 +34,8 @@ public class EntityDoiQuery extends QueryBase<EntityDoiEntity> {
 
     private Collection<String> dois;
 
+    private Collection<UUID> entityIds;
+
     private EnumSet<AuthorizationFlags> authorize = EnumSet.of(AuthorizationFlags.None);
 
     public EntityDoiQuery ids(UUID value) {
@@ -111,6 +113,21 @@ public class EntityDoiQuery extends QueryBase<EntityDoiEntity> {
         return this;
     }
 
+    public EntityDoiQuery entityIds(Collection<UUID> values) {
+        this.entityIds = values;
+        return this;
+    }
+
+    public EntityDoiQuery entityIds(UUID value) {
+        this.entityIds = List.of(value);
+        return this;
+    }
+
+    public EntityDoiQuery entityIds(UUID... value) {
+        this.entityIds = Arrays.asList(value);
+        return this;
+    }
+
     public EntityDoiQuery authorize(EnumSet<AuthorizationFlags> values) {
         this.authorize = values;
         return this;

dmp-backend/core/src/main/java/eu/eudat/repository/DepositRepository.java

@@ -12,11 +12,9 @@ import java.util.List;
 public class DepositRepository implements RepositoryDeposit {
 
     private final WebClient depositClient;
-    private final List<String> configurationIds;
 
     public DepositRepository(WebClient depositClient) {
         this.depositClient = depositClient;
-        this.configurationIds = new ArrayList<>();
     }
 
 
@@ -39,8 +37,4 @@ public class DepositRepository implements RepositoryDeposit {
     public String getLogo(String repositoryId) {
         return depositClient.get().uri("/logo/" + repositoryId).exchangeToMono(mono -> mono.bodyToMono(String.class)).block();
     }
-
-    public List<String> getConfigurationIds() {
-        return configurationIds;
-    }
 }

dmp-backend/core/src/main/java/eu/eudat/service/deposit/RepositoryDepositService.java

@@ -2,76 +2,94 @@ package eu.eudat.service.deposit;
 
 import eu.eudat.authorization.Permission;
 import eu.eudat.cache.deposit.RepositoryDepositConfigurationCache;
-import eu.eudat.commons.enums.EntityType;
 import eu.eudat.commons.enums.IsActive;
 import eu.eudat.configurations.deposit.DepositProperties;
 import eu.eudat.convention.ConventionService;
 import eu.eudat.data.DmpEntity;
 import eu.eudat.data.EntityDoiEntity;
-import eu.eudat.data.old.DMP;
 import eu.eudat.depositinterface.models.DMPDepositModel;
 import eu.eudat.depositinterface.models.FileEnvelope;
 import eu.eudat.depositinterface.repository.RepositoryDepositConfiguration;
+import eu.eudat.model.EntityDoi;
 import eu.eudat.model.doi.DepositRequest;
-import eu.eudat.model.doi.Doi;
 import eu.eudat.model.doi.RepositoryConfig;
 import eu.eudat.model.doi.RepositoryConfigs;
 import eu.eudat.model.mapper.deposit.DmpEntityDepositMapper;
+import eu.eudat.model.persist.EntityDoiPersist;
+import eu.eudat.query.DmpQuery;
+import eu.eudat.query.EntityDoiQuery;
 import eu.eudat.repository.DepositRepository;
+import eu.eudat.service.entitydoi.EntityDoiService;
 import eu.eudat.utilities.pdf.PDFUtils;
 import gr.cite.commons.web.authz.service.AuthorizationService;
 import gr.cite.commons.web.oidc.apikey.ApiKeyCacheService;
 import gr.cite.commons.web.oidc.apikey.webflux.ApiKeyExchangeFilterFunction;
 import gr.cite.commons.web.oidc.apikey.webflux.ApiKeyWebfluxModel;
+import gr.cite.tools.data.query.Ordering;
+import gr.cite.tools.fieldset.BaseFieldSet;
+import gr.cite.tools.fieldset.FieldSet;
 import jakarta.persistence.EntityManager;
-import jakarta.persistence.NoResultException;
-import jakarta.persistence.criteria.CriteriaBuilder;
-import jakarta.persistence.criteria.CriteriaQuery;
-import jakarta.persistence.criteria.Join;
-import jakarta.persistence.criteria.Root;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
 import org.springframework.core.env.Environment;
 import org.springframework.stereotype.Service;
 import org.springframework.util.ResourceUtils;
 import org.springframework.web.reactive.function.client.WebClient;
 
+import javax.management.InvalidApplicationException;
 import java.io.File;
 import java.io.IOException;
 import java.net.URI;
-import java.time.Instant;
+import java.util.*;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.UUID;
 
 @Service
 public class RepositoryDepositService {
     private static final Logger logger = LoggerFactory.getLogger(RepositoryDepositService.class);
 
     private final DepositProperties depositProperties;
-    private final List<DepositRepository> clients;
+    private final Map<String, DepositRepository> clients;
     private final ApiKeyCacheService apiKeyCacheService;
     private final RepositoryDepositConfigurationCache repositoryDepositConfigurationCache;
-    private final EntityManager entityManager;
     private final AuthorizationService authorizationService;
     private final ConventionService conventionService;
     private final Environment environment;
     private final DmpEntityDepositMapper depositMapper;
+    private final WebClient.Builder webClientBuilder;
+    private final EntityDoiService doiService;
+    private final ApplicationContext applicationContext;
+
 
     @Autowired
-    public RepositoryDepositService(DepositProperties depositProperties, ApiKeyCacheService apiKeyCacheService, RepositoryDepositConfigurationCache repositoryDepositConfigurationCache, WebClient.Builder builder, EntityManager entityManager, AuthorizationService authorizationService, ConventionService conventionService, Environment environment, DmpEntityDepositMapper depositMapper) {
+    public RepositoryDepositService(DepositProperties depositProperties, ApiKeyCacheService apiKeyCacheService, RepositoryDepositConfigurationCache repositoryDepositConfigurationCache, WebClient.Builder builder, EntityManager entityManager, AuthorizationService authorizationService, ConventionService conventionService, Environment environment, DmpEntityDepositMapper depositMapper, DmpQuery dmpQuery, EntityDoiQuery doiQuery, EntityDoiService doiService, ApplicationContext applicationContext) {
         this.depositProperties = depositProperties;
         this.apiKeyCacheService = apiKeyCacheService;
         this.repositoryDepositConfigurationCache = repositoryDepositConfigurationCache;
-        this.clients = depositRepositories(builder);
-        this.entityManager = entityManager;
         this.authorizationService = authorizationService;
         this.conventionService = conventionService;
         this.environment = environment;
         this.depositMapper = depositMapper;
-        //GK: I don't like this but that way you can both cache the available configurations and set Configuration Ids for each client
+        this.webClientBuilder = builder;
-        getAvailableConfigurations();
+        this.doiService = doiService;
+        this.applicationContext = applicationContext;
+        this.clients = new HashMap<>();
+    }
+
+    private DepositRepository getRepository(String repoId) {
+        if (this.clients.containsKey(repoId)) return this.clients.get(repoId);
+
+        //GK: It's register time
+        DepositProperties.DepositSource source = depositProperties.getSources().stream().filter(depositSource -> depositSource.getCodes().contains(repoId)).findFirst().orElse(null);
+        if (source != null) {
+            String host = URI.create(source.getUrl()).getHost();
+            ApiKeyWebfluxModel apiKeyWebfluxModel = new ApiKeyWebfluxModel(host + "_" + source.getClientId(), source.getIssuerUrl(), source.getClientId(), source.getClientSecret(), source.getScope());
+            ApiKeyExchangeFilterFunction apiKeyExchangeFilterFunction = new ApiKeyExchangeFilterFunction(this.apiKeyCacheService, apiKeyWebfluxModel);
+            DepositRepository repository = new DepositRepository(webClientBuilder.baseUrl(source.getUrl() + "/api/deposit").filters(exchangeFilterFunctions -> exchangeFilterFunctions.add(apiKeyExchangeFilterFunction)).build());
+            source.getCodes().forEach(code -> this.clients.put(code, repository));
+            return repository;
+        }
+        return null;
     }
 
 
@@ -79,11 +97,12 @@ public class RepositoryDepositService {
         RepositoryConfigs configs = repositoryDepositConfigurationCache.lookup("base");
         if (configs == null) {
             List<RepositoryConfig> configurations = new ArrayList<>();
+            //GK: So much for lazy loading
+            List<DepositRepository> repositories = depositProperties.getSources().stream().map(depositSource -> getRepository(depositSource.getCodes().get(0))).toList();
 
-            clients.forEach((client) -> {
+            repositories.forEach((client) -> {
                 List<RepositoryDepositConfiguration> repositoryConfigs = client.getConfiguration();
                 if (repositoryConfigs != null && !repositoryConfigs.isEmpty()) {
-                    client.getConfigurationIds().addAll(repositoryConfigs.stream().map(RepositoryDepositConfiguration::getRepositoryId).toList());
                     configurations.addAll(repositoryConfigs.stream().map(RepositoryConfig::toModel).toList());
                 }
             });
@@ -95,14 +114,15 @@ public class RepositoryDepositService {
         return configs.getRepositoryConfigs();
     }
 
-    public Doi deposit(DepositRequest dmpDepositModel) {
+    public EntityDoi deposit(DepositRequest dmpDepositModel) throws InvalidApplicationException {
         this.authorizationService.authorize(Permission.EditDmp);
         //GK: Why it is in that service, and why it's not static?
         this.conventionService.isValidGuid(UUID.fromString(dmpDepositModel.getDmpId()));
         //GK: First get the right client
-        DepositRepository repository = clients.stream().filter(client -> client.getConfigurationIds().contains(dmpDepositModel.getRepositoryId())).findFirst().orElseThrow();
+        DepositRepository repository = getRepository(dmpDepositModel.getRepositoryId());
         //GK: Second get the Target Data Management Plan
-        DmpEntity dmpEntity = this.entityManager.find(DmpEntity.class, UUID.fromString(dmpDepositModel.getDmpId()));
+        DmpQuery dmpQuery = applicationContext.getBean(DmpQuery.class);
+        DmpEntity dmpEntity = dmpQuery.ids(UUID.fromString(dmpDepositModel.getDmpId())).first();
 
         //GK: Third get the DOI from the previous Data Management Plan (if it exists)
         String previousDOI = null;
@@ -117,7 +137,7 @@ public class RepositoryDepositService {
         FileEnvelope jsonEnvelope = new FileEnvelope();
         File zip = new File(environment.getProperty("temp.temp") + UUID.randomUUID() + ".zip");
         try {
-            File documentFile = ResourceUtils.getFile(this.environment.getProperty("coniguration.h2020template"));
+            File documentFile = ResourceUtils.getFile(this.environment.getProperty("configuration.h2020template"));
             docEnvelope.setFilename("test.docx");
             docEnvelope.setFile(documentFile);
             File pdfFile = PDFUtils.convertToPDF(docEnvelope, environment);
@@ -145,52 +165,38 @@ public class RepositoryDepositService {
         if (doi.isEmpty())
             return null;
         //GK: doi is fine store it in database
-        EntityDoiEntity doiEntity = new EntityDoiEntity();
+        EntityDoiPersist doiPersist = new EntityDoiPersist();
-        doiEntity.setId(UUID.randomUUID());
+        doiPersist.setRepositoryId(dmpDepositModel.getRepositoryId());
-        doiEntity.setDoi(doi);
+        doiPersist.setDoi(doi);
-        doiEntity.setEntityType(EntityType.DMP);
+        doiPersist.setEntityId(dmpEntity.getId());
-        DMP dmp = new DMP();
+        FieldSet fieldSet = new BaseFieldSet();
-        dmp.setId(dmpEntity.getId());
+        return doiService.persist(doiPersist, fieldSet);
-        doiEntity.setEntityId(dmp);
-        doiEntity.setCreatedAt(Instant.now());
-        doiEntity.setIsActive(IsActive.Active);
-        entityManager.persist(doiEntity);
-
-
-        return Doi.fromDataModel(doiEntity);
     }
 
-    private List<DepositRepository> depositRepositories(WebClient.Builder builder) {
+    public String getLogo(String repoId) {
-        List<DepositRepository> tclients = new ArrayList<>();
+        //GK: First get the right client
-        for (DepositProperties.DepositSource source: depositProperties.getSources()) {
+        DepositRepository repository = getRepository(repoId);
-
+        if (repository != null) {
-            String host = URI.create(source.getUrl()).getHost();
+            return repository.getLogo(repoId);
-            ApiKeyWebfluxModel apiKeyWebfluxModel = new ApiKeyWebfluxModel(host + "_" + source.getClientId(), source.getIssuerUrl(), source.getClientId(), source.getClientSecret(), source.getScope());
-            ApiKeyExchangeFilterFunction apiKeyExchangeFilterFunction = new ApiKeyExchangeFilterFunction(this.apiKeyCacheService, apiKeyWebfluxModel);
-
-            tclients.add(new DepositRepository(builder.baseUrl(source.getUrl() + "/api/deposit").filters(exchangeFilterFunctions -> exchangeFilterFunctions.add(apiKeyExchangeFilterFunction)).build()));
         }
-        return tclients;
+        return null;
     }
 
     private String getPreviousDOI(UUID groupId, UUID currentId, String repoId) {
-        CriteriaBuilder builder = this.entityManager.getCriteriaBuilder();
         EntityDoiEntity doiEntity = null;
 
         //GK: Step one get the previous version of the Data management plan
-        CriteriaQuery<DmpEntity> query = builder.createQuery(DmpEntity.class);
+        DmpQuery dmpQuery = this.applicationContext.getBean(DmpQuery.class);
-        Root<DmpEntity> root = query.from(DmpEntity.class);
+        Ordering ordering = new Ordering();
-        query = query.select(root.get("id"));
+        ordering.setItems(List.of("-version"));
-        query = query.where(builder.and(builder.equal(root.get("groupId"), groupId), builder.equal(root.get("isActive"), IsActive.Active)));
+        dmpQuery.setOrder(ordering);
-        query = query.orderBy(builder.desc(root.get("version")));
+        FieldSet fieldSet = new BaseFieldSet();
-        List<UUID> dmpIds = this.entityManager.createQuery(query).getResultList().stream().map(DmpEntity::getId).toList();
+        fieldSet.ensure("id");
+        List<UUID> dmpIds = dmpQuery.groupIds(groupId).isActive(IsActive.Active).collectAs(fieldSet).stream().map(DmpEntity::getId).toList();
 
         //GK: Step two get it's doiEntity
-        CriteriaQuery<EntityDoiEntity> doiQuery = builder.createQuery(EntityDoiEntity.class);
+        EntityDoiQuery doiQuery = this.applicationContext.getBean(EntityDoiQuery.class);
-        Root<EntityDoiEntity> doiRoot = doiQuery.from(EntityDoiEntity.class);
+        List<EntityDoiEntity> dois = doiQuery.entityIds(dmpIds).isActive(IsActive.Active).collect();
-        doiQuery = doiQuery.multiselect(doiRoot.get("entityId").get("id"), doiRoot.get("doi"));
-        doiQuery = doiQuery.where(builder.and(doiRoot.get("entityId").get("id").in(dmpIds), builder.equal(doiRoot.get("isActive"), IsActive.Active), builder.equal(doiRoot.get("repositoryId"), repoId)));
-        List<EntityDoiEntity> dois = this.entityManager.createQuery(doiQuery).getResultList();
 
         for(UUID uuid: dmpIds)
         {

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

@@ -3,11 +3,13 @@ package eu.eudat.controllers;
 import eu.eudat.authorization.Permission;
 import eu.eudat.logic.managers.DepositManager;
 import eu.eudat.logic.services.ApiContext;
+import eu.eudat.model.EntityDoi;
 import eu.eudat.model.doi.DepositCode;
 import eu.eudat.model.doi.DepositRequest;
 import eu.eudat.model.doi.Doi;
 import eu.eudat.model.doi.RepositoryConfig;
 import eu.eudat.models.data.helpers.responses.ResponseItem;
+import eu.eudat.service.deposit.RepositoryDepositService;
 import eu.eudat.types.ApiMessageCode;
 import gr.cite.commons.web.authz.service.AuthorizationService;
 import org.slf4j.Logger;
@@ -27,12 +29,14 @@ public class DepositController extends BaseController {
 
     private final DepositManager depositManager;
     private final AuthorizationService authorizationService;
+    private final RepositoryDepositService repositoryDepositService;
 
     @Autowired
-    public DepositController(ApiContext apiContext, DepositManager depositManager, AuthorizationService authorizationService){
+    public DepositController(ApiContext apiContext, DepositManager depositManager, AuthorizationService authorizationService, RepositoryDepositService repositoryDepositService){
         super(apiContext);
         this.depositManager = depositManager;
         this.authorizationService = authorizationService;
+        this.repositoryDepositService = repositoryDepositService;
     }
 
     @RequestMapping(method = RequestMethod.GET, value = {"/repos"})
@@ -40,7 +44,7 @@ public class DepositController extends BaseController {
     ResponseEntity<ResponseItem<List<RepositoryConfig>>> getAvailableRepos() {
         this.authorizationService.authorizeForce(Permission.AdminRole, Permission.ManagerRole, Permission.UserRole, Permission.AnonymousRole);
         
-        List<RepositoryConfig> ids = this.depositManager.getAvailableRepos();
+        List<RepositoryConfig> ids = this.repositoryDepositService.getAvailableConfigurations();
         return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<List<RepositoryConfig>>().status(ApiMessageCode.NO_MESSAGE).payload(ids));
     }
 
@@ -55,19 +59,19 @@ public class DepositController extends BaseController {
 
     @RequestMapping(method = RequestMethod.POST, value = {"/createDoi"})
     public @ResponseBody
-    ResponseEntity<ResponseItem<Doi>> createDoi(@RequestBody DepositRequest depositRequest) {
+    ResponseEntity<ResponseItem<EntityDoi>> createDoi(@RequestBody DepositRequest depositRequest) {
         this.authorizationService.authorizeForce(Permission.AdminRole, Permission.ManagerRole, Permission.UserRole, Permission.AnonymousRole);
         try {
-            Doi doi = this.depositManager.deposit(depositRequest);
+            EntityDoi doi = this.repositoryDepositService.deposit(depositRequest);
             if(doi != null){
-                return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<Doi>().status(ApiMessageCode.SUCCESS_MESSAGE).message("Successfully created DOI for Data Datamanagement Plan in question.").payload(doi));
+                return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<EntityDoi>().status(ApiMessageCode.SUCCESS_MESSAGE).message("Successfully created DOI for Data Datamanagement Plan in question.").payload(doi));
             }
             else{
-                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseItem<Doi>().status(ApiMessageCode.ERROR_MESSAGE).message("Failed to create DOI for the Data Management Plan"));
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseItem<EntityDoi>().status(ApiMessageCode.ERROR_MESSAGE).message("Failed to create DOI for the Data Management Plan"));
             }
         } catch (Exception e) {
             logger.error(e.getMessage(), e);
-            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseItem<Doi>().status(ApiMessageCode.ERROR_MESSAGE).message("Failed to create DOI for the Data Management Plan: " + e.getMessage()));
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseItem<EntityDoi>().status(ApiMessageCode.ERROR_MESSAGE).message("Failed to create DOI for the Data Management Plan: " + e.getMessage()));
         }
     }
 
@@ -76,7 +80,7 @@ public class DepositController extends BaseController {
     ResponseEntity<ResponseItem<String>> getLogo(@PathVariable("repositoryId") String repositoryId) {
         this.authorizationService.authorizeForce(Permission.AdminRole, Permission.ManagerRole, Permission.UserRole, Permission.AnonymousRole);
         try {
-            String encodedLogo = this.depositManager.getRepositoryLogo(repositoryId);
+            String encodedLogo = this.repositoryDepositService.getLogo(repositoryId);
             if(encodedLogo != null){
                 return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<String>().status(ApiMessageCode.SUCCESS_MESSAGE).message("Successfully loaded " + repositoryId + "'s logo.").payload(encodedLogo));
             }

dmp-backend/web/src/main/resources/config/deposit.yml

@@ -1,6 +1,7 @@
 deposit:
   sources:
     - url: http://localhost:8082
+      codes: [ zenodo ]
       issuer-url: ${ZENODO_ISSUER_URI:IDP_APIKEY_ISSUER_URI}
       client-id: ${ZENODO_DEPOSIT_CLIENT_ID:}
       client-secret: ${ZENODO_DEPOSIT_CLIENT_SECRET:}