Merge pull request #1294 from qbicsoftware/development

Release PR

Author: KochTobi

README.md

@@ -70,6 +70,16 @@ ready to be deployed. The file can be found in the `target` folder after the bui
 Once the JAR file is built, you can run it using
 `java -jar target/datamanager-1.0-SNAPSHOT.jar`
 
+## Maven Profiles
+
+To have all beans available for running the datamanager, you need to set a profile during
+compilation.
+If you plan to deploy it in production or with external systems integrated, use the `production`
+profile.
+
+For local development you can use the `development` profile. This profile will disable and mock
+integration with the TIB service, OpenBis and the ROR repository.
+
 ### Configuration
 
 #### Java Version

identity/src/main/java/life/qbic/identity/application/user/IdentityService.java

@@ -274,6 +274,22 @@ private Result<EncryptedPassword, RuntimeException> attemptPasswordEncryption(
     }
   }
 
+  public void setOidc(String userId, String oidcId, String oidcIssuer) throws IssueOidcException {
+    var alreadyConnectedUser = userRepository.findByOidc(oidcId, oidcIssuer);
+    if (alreadyConnectedUser.isPresent()) {
+      throw new IssueOidcException("OpenID already in use.");
+    }
+    var user = userRepository.findById(UserId.from(userId)).orElseThrow(() -> new IssueOidcException("User not found"));
+    user.setOidcEntry(oidcIssuer, oidcId);
+    userRepository.updateUser(user);
+  }
+
+  public static class IssueOidcException extends RuntimeException {
+    public IssueOidcException(String message) {
+      super(message);
+    }
+  }
+
   public static class EmptyUserNameException extends ApplicationException {
 
     @Serial

identity/src/main/java/life/qbic/identity/domain/model/User.java

@@ -102,6 +102,17 @@ public static User create(FullName fullName, EmailAddress emailAddress,
     return user;
   }
 
+  /**
+   * Sets the OIDC issue and identifier for the user. Overwrites existing entries.
+   * @param oidcIssuer the issuer of the OIDC principal
+   * @param oidcId the identifier of the OIDC principal
+   * @since 1.11.0
+   */
+  public void setOidcEntry(String oidcIssuer, String oidcId) {
+    this.oidcIssuer = oidcIssuer;
+    this.oidcId = oidcId;
+  }
+
   public static User createOidc(String fullName, String emailAddress,
       String userName, String oidcIssuer, String oidcId) {
     if (isNull(oidcIssuer) && nonNull(oidcId)) {

project-management-infrastructure/pom.xml

@@ -142,6 +142,10 @@
       <artifactId>poi-ooxml</artifactId>
       <version>5.4.0</version>
     </dependency>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-autoconfigure</artifactId>
+    </dependency>
   </dependencies>
 
 </project>

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

@@ -0,0 +1,43 @@
+package life.qbic.projectmanagement.infrastructure.ontology;
+
+import static life.qbic.logging.service.LoggerFactory.logger;
+
+import java.util.List;
+import java.util.Optional;
+import life.qbic.logging.api.Logger;
+import life.qbic.projectmanagement.application.ontology.LookupException;
+import life.qbic.projectmanagement.application.ontology.OntologyClass;
+import life.qbic.projectmanagement.application.ontology.TerminologySelect;
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Service;
+
+@Service
+@Profile("development")
+public class MockTerminologySelect implements TerminologySelect {
+
+  private static final Logger log = logger(MockTerminologySelect.class);
+
+  private static void logWarning() {
+    log.warn("Using mock implementation. Not suited for production deployment.");
+  }
+
+  @Override
+  public List<OntologyClass> query(String searchTerm, int offset, int limit)
+      throws LookupException {
+    logWarning();
+    return List.of();
+  }
+
+  @Override
+  public Optional<OntologyClass> searchByCurie(String curie) throws LookupException {
+    logWarning();
+    return Optional.empty();
+  }
+
+  @Override
+  public List<OntologyClass> search(String searchTerm, int offset, int limit)
+      throws LookupException {
+    logWarning();
+    return List.of();
+  }
+}

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

@@ -0,0 +1,129 @@
+package life.qbic.projectmanagement.infrastructure.ontology;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * <b>Request cache</b>
+ *
+ * <p>In memory look-up cache for {@link TibTerm}.</p>
+ * <p>
+ * If you need thread-safety, use {@link SynchronizedRequestCache}.
+ *
+ * @since 1.11.0
+ */
+public class RequestCache {
+
+  private final List<TibTerm> cache = new ArrayList<>();
+  private final int limit;
+  private List<CacheEntryStat> accessFrequency = new ArrayList<>();
+
+  RequestCache(int limit) {
+    this.limit = limit;
+  }
+
+  /**
+   * Adds a {@link TibTerm} to the in-memory cache.
+   * <p>
+   * If the cache max size is reached, the oldest entry will be replaced with the one passed to the
+   * function.
+   *
+   * @param term the term to store in the cache
+   * @since 1.9.0
+   */
+  void add(TibTerm term) {
+    if (term == null || cache.contains(term)) return;
+    if (cache.size() >= limit) {
+      addByReplace(term);
+      return;
+    }
+    cache.add(term);
+    addStats(new CacheEntryStat(term));
+  }
+
+  // Puts the term with the time of caching into an own list for tracking
+  private void addStats(CacheEntryStat cacheEntryStat) {
+    if (accessFrequency.contains(cacheEntryStat)) {
+      return;
+    }
+    accessFrequency.add(cacheEntryStat);
+  }
+
+  // A special case of adding by looking for the oldest cache entry and replacing it with
+  // the provided one
+  private void addByReplace(TibTerm term) {
+    // We want to be sure that the access statistic list is in natural order
+    ensureSorted();
+    // We then remove the oldest cache entry
+    if (!cache.isEmpty()) {
+      cache.set(0, term);
+      addStats(new CacheEntryStat(term));
+    }
+  }
+
+  // Ensures the natural order sorting by datetime, when the cache entry has been created
+  // Oldest entry will be the first element, newest the last element of the list
+  private void ensureSorted() {
+    accessFrequency = accessFrequency.stream()
+        .sorted(Comparator.comparing(CacheEntryStat::created, Instant::compareTo))
+        .collect(Collectors.toList());
+  }
+
+  /**
+   * Searches for a matching {@link TibTerm} in the cache.
+   *
+   * @param curie the CURIE to search for
+   * @return the search result, {@link Optional#empty()} if no match was found
+   * @since 1.9.0
+   */
+  Optional<TibTerm> findByCurie(String curie) {
+    return cache.stream().filter(term -> term.oboId.equals(curie)).findFirst();
+  }
+
+
+  /**
+   * A small container for when a cache entry has been created.
+   *
+   * @since 1.9.0
+   */
+  private static class CacheEntryStat {
+
+    private final TibTerm term;
+    private final Instant created;
+
+    CacheEntryStat(TibTerm term) {
+      this.term = term;
+      created = Instant.now();
+    }
+
+    /**
+     * When the cache entry has been created
+     *
+     * @return the instant of creation
+     * @since 1.9.0
+     */
+    Instant created() {
+      return created;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      CacheEntryStat that = (CacheEntryStat) o;
+      return Objects.equals(term, that.term);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(term);
+    }
+  }
+
+}

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

@@ -0,0 +1,56 @@
+package life.qbic.projectmanagement.infrastructure.ontology;
+
+import java.util.Objects;
+import java.util.Optional;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+/**
+ * Thread-safe implementation of {@link RequestCache}.
+ *
+ * @since 1.11.0
+ */
+@Component
+public class SynchronizedRequestCache {
+
+  private final RequestCache cache;
+
+  private final Object lock = new Object();
+
+  public SynchronizedRequestCache(@Value("${terminology.service.cache.size}") String cacheSize) {
+    cache = new RequestCache(Integer.parseInt(cacheSize));
+  }
+
+  /**
+   * Adds a {@link TibTerm} to the in-memory cache.
+   * <p>
+   * If the cache max size is reached, the oldest entry will be replaced with the one passed to the
+   * function.
+   * <p>
+   * This function is thread-safe.
+   *
+   * @param term the term to store in the cache
+   * @since 1.11.0
+   */
+  public void add(TibTerm term) {
+    synchronized (lock) {
+      cache.add(term);
+    }
+  }
+
+  /**
+   * Searches for a matching {@link TibTerm} in the cache.
+   * <p>
+   * This function is thread-safe.
+   *
+   * @param curie the CURIE to search for
+   * @return the search result, {@link Optional#empty()} if no match was found
+   * @since 1.11.0
+   */
+  Optional<TibTerm> findByCurie(String curie) {
+    Objects.requireNonNull(curie);
+    synchronized (lock) {
+      return cache.findByCurie(curie);
+    }
+  }
+}