Merge pull request #502 from qbicsoftware/development

Release PR

Author: KochTobi

application-commons/src/main/java/life/qbic/application/commons/ApplicationException.java

@@ -144,7 +144,8 @@ public enum ErrorCode {
     NO_SPECIES_DEFINED,
     NO_SPECIMEN_DEFINED,
     NO_ANALYTE_DEFINED,
-    DATA_ATTACHED_TO_SAMPLES
+    DATA_ATTACHED_TO_SAMPLES,
+    SAMPLES_ATTACHED_TO_EXPERIMENT
     ;
 
     @Override

finances-infrastructure/pom.xml

@@ -23,6 +23,16 @@
       <version>0.36.0</version>
       <scope>compile</scope>
     </dependency>
+    <dependency>
+      <groupId>org.springframework.security</groupId>
+      <artifactId>spring-security-core</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>life.qbic.identity</groupId>
+      <artifactId>project-management-infrastructure</artifactId>
+      <version>0.34.0</version>
+      <scope>compile</scope>
+    </dependency>
   </dependencies>
 
 </project>

finances-infrastructure/src/main/java/life/qbic/finance/infrastructure/SimpleOfferSearchService.java

@@ -7,6 +7,7 @@
 import life.qbic.finance.domain.model.OfferId;
 import life.qbic.finance.domain.model.OfferPreview;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.stereotype.Service;
 
 /**
@@ -23,20 +24,24 @@ public class SimpleOfferSearchService implements OfferSearchService {
 
   private final OfferRepository offerRepository;
 
+
   @Override
+  @PreAuthorize("hasAnyAuthority('ROLE_PROJECT_MANAGER', 'ROLE_ADMIN')")
   public List<OfferPreview> findByProjectTitleOrOfferId(String projectTitle, String offerId) {
     return offerPreviewRepository.findByProjectTitleContainingIgnoreCaseOrOfferIdContainingIgnoreCase(
         projectTitle, offerId);
   }
 
   @Override
+  @PreAuthorize("hasAnyAuthority('ROLE_PROJECT_MANAGER', 'ROLE_ADMIN')")
   public List<OfferPreview> findByProjectTitleOrOfferId(String projectTitle, String offerId,
       int offset, int limit) {
     return offerPreviewRepository.findByProjectTitleContainingIgnoreCaseOrOfferIdContainingIgnoreCase(
         projectTitle, offerId, new OffsetBasedRequest(offset, limit)).stream().toList();
   }
 
   @Override
+  @PreAuthorize("hasAnyAuthority('ROLE_PROJECT_MANAGER', 'ROLE_ADMIN')")
   public Optional<Offer> findByOfferId(String offerId) {
     return Optional.ofNullable(offerRepository.findByOfferId(OfferId.from(offerId)));
   }

project-management-infrastructure/src/main/java/life/qbic/projectmanagement/infrastructure/project/ProjectRepositoryImpl.java

@@ -52,7 +52,6 @@ public class ProjectRepositoryImpl implements ProjectRepository {
   private static final Logger log = logger(ProjectRepositoryImpl.class);
   private final QbicProjectRepo projectRepo;
   private final QbicProjectDataRepo projectDataRepo;
-
   private final ProjectAccessService projectAccessService;
 
   @Autowired
@@ -75,7 +74,7 @@ public void add(Project project) {
     Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
     QbicUserDetails details = (QbicUserDetails) authentication.getPrincipal();
     projectAccessService.grant(details.getUserId(), project.getId(),
-        List.of(READ, WRITE));
+        List.of(READ, WRITE, ADMINISTRATION));//administration of this project, only
     projectAccessService.grantToAuthority(ADMIN.auth(), project.getId(), ADMIN.permissions());
     projectAccessService.grantToAuthority(PROJECT_MANAGER.auth(), project.getId(),
         PROJECT_MANAGER.permissions());

project-management/src/main/java/life/qbic/projectmanagement/application/DeletionService.java

@@ -75,20 +75,6 @@ public Result<ExperimentId, ResponseCode> deleteAllExperimentalVariables(Experim
     return Result.fromValue(id);
   }
 
-  public Result<ExperimentId, ResponseCode> deleteAllExperimentalGroups(ExperimentId id) {
-    var queryResult = sampleInformationService.retrieveSamplesForExperiment(id);
-    if (queryResult.isError()) {
-      log.debug("experiment (%s) converting %s to %s".formatted(id, queryResult.getError(),
-          ResponseCode.QUERY_FAILED));
-      return Result.fromError(ResponseCode.QUERY_FAILED);
-    }
-    if (queryResult.isValue() && !queryResult.getValue().isEmpty()) {
-      return Result.fromError(ResponseCode.SAMPLES_STILL_ATTACHED_TO_EXPERIMENT);
-    }
-    experimentInformationService.deleteAllExperimentalGroups(id);
-    return Result.fromValue(id);
-  }
-
   @Transactional
   public BatchId deleteBatch(ProjectId projectId, BatchId batchId) {
     var samples = sampleInformationService.retrieveSamplesForBatch(batchId).stream()

project-management/src/main/java/life/qbic/projectmanagement/application/ExperimentInformationService.java

@@ -6,10 +6,16 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.Set;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
 import life.qbic.application.commons.ApplicationException;
+import life.qbic.application.commons.ApplicationException.ErrorCode;
+import life.qbic.application.commons.ApplicationException.ErrorParameters;
 import life.qbic.application.commons.Result;
 import life.qbic.logging.api.Logger;
 import life.qbic.logging.service.LoggerFactory;
+import life.qbic.projectmanagement.application.sample.SampleInformationService;
 import life.qbic.projectmanagement.domain.model.experiment.Experiment;
 import life.qbic.projectmanagement.domain.model.experiment.ExperimentId;
 import life.qbic.projectmanagement.domain.model.experiment.ExperimentalDesign.AddExperimentalGroupResponse.ResponseCode;
@@ -24,6 +30,7 @@
 import life.qbic.projectmanagement.domain.repository.ProjectRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 /**
  * Service that provides an API to query basic experiment information
@@ -36,11 +43,14 @@ public class ExperimentInformationService {
   private static final Logger log = LoggerFactory.logger(ExperimentInformationService.class);
   private final ExperimentRepository experimentRepository;
   private final ProjectRepository projectRepository;
+  private final SampleInformationService sampleInformationService;
 
   public ExperimentInformationService(@Autowired ExperimentRepository experimentRepository,
-      @Autowired ProjectRepository projectRepository) {
+      @Autowired ProjectRepository projectRepository,
+      @Autowired SampleInformationService sampleInformationService) {
     this.experimentRepository = experimentRepository;
     this.projectRepository = projectRepository;
+    this.sampleInformationService = sampleInformationService;
   }
 
   public Optional<Experiment> find(ExperimentId experimentId) {
@@ -64,18 +74,35 @@ private Experiment loadExperimentById(ExperimentId experimentId) {
    * @param experimentId      the Id of the experiment for which to add the species
    * @param experimentalGroup the experimental groups to add
    */
-  public Result<ExperimentalGroup, ResponseCode> addExperimentalGroupToExperiment(
+  private void addExperimentalGroupToExperiment(
       ExperimentId experimentId, ExperimentalGroupDTO experimentalGroup) {
     Objects.requireNonNull(experimentalGroup, "experimental group must not be null");
     Objects.requireNonNull(experimentId, "experiment id must not be null");
 
-    Experiment experiment = loadExperimentById(experimentId);
-    Result<ExperimentalGroup, ResponseCode> result = experiment.addExperimentalGroup(
-        experimentalGroup.levels(), experimentalGroup.replicateCount());
-    if (result.isValue()) {
-      experimentRepository.update(experiment);
+    List<VariableLevel> varLevels = experimentalGroup.levels;
+    if (varLevels.isEmpty()) {
+      throw new ApplicationException("No experimental variable was selected",
+          ErrorCode.NO_CONDITION_SELECTED,
+          ErrorParameters.empty());
     }
-    return result;
+
+      Experiment experiment = loadExperimentById(experimentId);
+      Result<ExperimentalGroup, ResponseCode> result = experiment.addExperimentalGroup(
+          experimentalGroup.name(), experimentalGroup.levels(), experimentalGroup.replicateCount());
+      if (result.isValue()) {
+        experimentRepository.update(experiment);
+      } else {
+        ResponseCode responseCode = result.getError();
+        if (responseCode.equals(ResponseCode.CONDITION_EXISTS)) {
+          throw new ApplicationException("A group with the variable levels %s already exists.".formatted(varLevels.toString()),
+              ErrorCode.DUPLICATE_GROUP_SELECTED,
+              ErrorParameters.empty());
+        } else {
+          throw new ApplicationException(
+              "Could not save one or more experimental groups %s %nReason: %s".formatted(
+                  experimentalGroup.toString(), responseCode));
+        }
+      }
   }
 
   /**
@@ -88,7 +115,7 @@ public Result<ExperimentalGroup, ResponseCode> addExperimentalGroupToExperiment(
   public List<ExperimentalGroupDTO> getExperimentalGroups(ExperimentId experimentId) {
     Experiment experiment = loadExperimentById(experimentId);
     return experiment.getExperimentalGroups().stream()
-        .map(it -> new ExperimentalGroupDTO(it.condition().getVariableLevels(), it.sampleSize()))
+        .map(it -> new ExperimentalGroupDTO(it.id(), it.name(), it.condition().getVariableLevels(), it.sampleSize()))
         .toList();
   }
 
@@ -254,42 +281,80 @@ public List<ExperimentalVariable> getVariablesOfExperiment(ExperimentId experime
 
   /**
    * Deletes all experimental groups in a given experiment.
-   * <p>
-   * This method does not check if samples are already.
    *
    * @param id the experiment identifier of the experiment the experimental groups are going to be
    *           deleted.
    * @since 1.0.0
    */
-  public void deleteAllExperimentalGroups(ExperimentId id) {
+  public void deleteExperimentalGroupsWithIds(ExperimentId id, List<Long> groupIds) {
+    var queryResult = sampleInformationService.retrieveSamplesForExperiment(id);
+    if (queryResult.isError()) {
+      throw new ApplicationException("experiment (%s) converting %s to %s".formatted(id,
+          queryResult.getError(), DeletionService.ResponseCode.QUERY_FAILED),
+          ErrorCode.GENERAL,
+          ErrorParameters.empty());
+    }
+    if (queryResult.isValue() && !queryResult.getValue().isEmpty()) {
+      throw new ApplicationException("Could not edit experimental groups because samples are already registered.",
+          ErrorCode.SAMPLES_ATTACHED_TO_EXPERIMENT,
+          ErrorParameters.empty());
+    }
     Experiment experiment = loadExperimentById(id);
-    experiment.removeAllExperimentalGroups();
+    experiment.removeExperimentalGroups(groupIds);
     experimentRepository.update(experiment);
   }
 
+  @Transactional
   /**
-   * Adds experimental groups to an experiment
+   * Updates experimental groups in a given experiment.
+   *
+   * Compares the provided list of experimental groups of an experiment with the persistent state.
+   * Removes groups from the experiment that are not in the new list, adds groups that are not in
+   * the experiment yet and updates the other groups of the experiment.
    *
-   * @param experimentId          the experiment to add the groups to
-   * @param experimentalGroupDTOS the group information
-   * @return either the collection of added groups or an appropriate response code
+   * @param id                     the experiment identifier of the experiment whose groups should be updated
+   * @param experimentalGroupDTOS  the new list of experimental groups including all updates
+   * @since 1.0.0
    */
-  public Result<Collection<ExperimentalGroup>, ResponseCode> addExperimentalGroupsToExperiment(
-      ExperimentId experimentId, List<ExperimentalGroupDTO> experimentalGroupDTOS) {
-    Experiment experiment = loadExperimentById(experimentId);
-    List<ExperimentalGroup> addedGroups = new ArrayList<>();
-    for (ExperimentalGroupDTO experimentalGroupDTO : experimentalGroupDTOS) {
-      Result<ExperimentalGroup, ResponseCode> result = experiment.addExperimentalGroup(
-          experimentalGroupDTO.levels(),
-          experimentalGroupDTO.replicateCount());
-      if (result.isError()) {
-        return Result.fromError(result.getError());
+  public void updateExperimentalGroupsOfExperiment(ExperimentId experimentId,
+      List<ExperimentalGroupDTO> experimentalGroupDTOS) {
+
+    // check for duplicates
+    List<List<VariableLevel>> distinctLevels = experimentalGroupDTOS.stream()
+        .map(ExperimentalGroupDTO::levels).distinct().toList();
+    if (distinctLevels.size() < experimentalGroupDTOS.size()) {
+      throw new ApplicationException("Duplicate experimental group was selected",
+          ErrorCode.DUPLICATE_GROUP_SELECTED,
+          ErrorParameters.empty());
+    }
+
+    List<ExperimentalGroup> existingGroups = experimentalGroupsFor(experimentId);
+    List<Long> idsToDelete = getGroupIdsToDelete(existingGroups, experimentalGroupDTOS);
+    if(!idsToDelete.isEmpty()) {
+      deleteExperimentalGroupsWithIds(experimentId, idsToDelete);
+    }
+
+    for(ExperimentalGroupDTO group : experimentalGroupDTOS) {
+      if(group.id() == -1) {
+        addExperimentalGroupToExperiment(experimentId, group);
       } else {
-        addedGroups.add(result.getValue());
+        updateExperimentalGroupOfExperiment(experimentId, group);
       }
     }
-    experimentRepository.update(experiment);
-    return Result.fromValue(addedGroups);
+  }
+
+  private void updateExperimentalGroupOfExperiment(ExperimentId experimentId, ExperimentalGroupDTO group) {
+    Experiment experiment = loadExperimentById(experimentId);
+    experiment.updateExperimentalGroup(group.id(), group.name(), group.levels(), group.replicateCount());
+  }
+
+  private List<Long> getGroupIdsToDelete(List<ExperimentalGroup> existingGroups,
+      List<ExperimentalGroupDTO> newGroups) {
+    Set<Long> newIds = newGroups.stream().map(ExperimentalGroupDTO::id).collect(Collectors.toSet());
+    return existingGroups.stream()
+        .map(ExperimentalGroup::id)
+        .filter(Predicate.not(newIds::contains))
+        .toList();
   }
 
   public void editExperimentInformation(ExperimentId experimentId, String experimentName,
@@ -305,10 +370,12 @@ public void editExperimentInformation(ExperimentId experimentId, String experime
   /**
    * Information about an experimental group
    *
+   * @param id             id, -1 for new groups
+   * @param name           the name of the group - can be empty
    * @param levels         the levels in the condition of the group
    * @param replicateCount the number of biological replicates
    */
-  public record ExperimentalGroupDTO(List<VariableLevel> levels, int replicateCount) {
+  public record ExperimentalGroupDTO(long id, String name, List<VariableLevel> levels, int replicateCount) {
 
   }
 }

project-management/src/main/java/life/qbic/projectmanagement/domain/model/experiment/Experiment.java

@@ -171,6 +171,15 @@ public void removeAllExperimentalVariables() {
     experimentalDesign.removeAllExperimentalVariables();
   }
 
+  /**
+   * Removes experimental groups with the provided ids from the experiment .
+   *
+   * @since 1.0.0
+   */
+  public void removeExperimentalGroups(List<Long> ids) {
+    ids.forEach(experimentalDesign::removeExperimentalGroup);
+  }
+
   /**
    * Removes all experimental groups in an experiment.
    *
@@ -247,14 +256,36 @@ public Result<VariableName, Exception> addVariableToDesign(String variableName,
    *   <li>If the sample size is not at least 1, the creation will fail with an {@link IllegalArgumentException}
    * </ul>
    *
+   * @param groupName      the name of this experimental group, which can be empty
+   * @param variableLevels at least one value for a variable defined in this experiment
+   * @param sampleSize     the number of samples that are expected for this experimental group
+   * @return
+   */
+  public Result<ExperimentalGroup, ResponseCode> addExperimentalGroup(String groupName,
+      Collection<VariableLevel> variableLevels,
+      int sampleSize) {
+    return experimentalDesign.addExperimentalGroup(groupName, variableLevels, sampleSize);
+  }
+
+  /**
+   * Updates an experimental group of to the experimental design.
+   * <p>
+   * <ul>
+   *   <li>If an experimental group with the same variable levels already exists, the creation will fail with an {@link ConditionExistsException} and no condition is added to the design.
+   *   <li>If the {@link VariableLevel}s belong to variables not specified in this experiment, the creation will fail with an {@link IllegalArgumentException}
+   *   <li>If the sample size is not at least 1, the creation will fail with an {@link IllegalArgumentException}
+   * </ul>
+   *
+   * @param id             the unique identifier of the experimental group to update
+   * @param groupName      the name of this experimental group, which can be empty
    * @param variableLevels at least one value for a variable defined in this experiment
    * @param sampleSize     the number of samples that are expected for this experimental group
    * @return
    */
-  public Result<ExperimentalGroup, ResponseCode> addExperimentalGroup(
+  public Result<ExperimentalGroup, ResponseCode> updateExperimentalGroup(long id, String groupName,
       Collection<VariableLevel> variableLevels,
       int sampleSize) {
-    return experimentalDesign.addExperimentalGroup(variableLevels, sampleSize);
+    return experimentalDesign.updateExperimentalGroup(id, groupName, variableLevels, sampleSize);
   }
 
   public List<ExperimentalGroup> getExperimentalGroups() {