Merge pull request #540 from qbicsoftware/development

Release 0.39.0

Author: Steffengreiner

application-commons/pom.xml

@@ -15,5 +15,9 @@
       <artifactId>spock-core</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.springframework.data</groupId>
+      <artifactId>spring-data-commons</artifactId>
+    </dependency>
   </dependencies>
 </project>

project-management-infrastructure/src/main/java/life/qbic/projectmanagement/infrastructure/OffsetBasedRequest.java application-commons/src/main/java/life/qbic/application/commons/OffsetBasedRequest.java

@@ -1,4 +1,4 @@
-package life.qbic.projectmanagement.infrastructure;
+package life.qbic.application.commons;
 
 import java.util.Objects;
 import org.springframework.data.domain.Pageable;

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

@@ -1,4 +1,4 @@
-package life.qbic.projectmanagement.application;
+package life.qbic.application.commons;
 
 /**
  * A sort order to be consumed by a data providing service.

identity-api/pom.xml

@@ -17,5 +17,13 @@
     <maven.compiler.target>17</maven.compiler.target>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>
+  <dependencies>
+    <dependency>
+      <groupId>life.qbic</groupId>
+      <artifactId>application-commons</artifactId>
+      <version>0.38.2</version>
+      <scope>compile</scope>
+    </dependency>
+  </dependencies>
 
 </project>

identity-api/src/main/java/life/qbic/identity/api/PersonalAccessTokenService.java

@@ -31,7 +31,7 @@ RawToken create(String userId, String description, Duration duration)
    * @return a collection of personal access token entries associated with a user id
    * @since 1.0.0
    */
-  Collection<PersonalAccessToken> find(String userId);
+  Collection<PersonalAccessToken> findAll(String userId);
 
   /**
    * Deletes a personal access token with a given token id for a user

identity-api/src/main/java/life/qbic/identity/api/UserInformationService.java

@@ -1,6 +1,8 @@
 package life.qbic.identity.api;
 
+import java.util.List;
 import java.util.Optional;
+import life.qbic.application.commons.SortOrder;
 
 /**
  * <b>User information service</b>
@@ -42,4 +44,5 @@ public interface UserInformationService {
    */
   boolean userNameAvailable(String userName);
 
+  List<UserInfo> findAllActive(String filter, int offset, int limit, List<SortOrder> sortOrders);
 }

identity-infrastructure/src/main/java/life/qbic/identity/infrastructure/QbicUserRepo.java

@@ -5,6 +5,8 @@
 import life.qbic.identity.domain.model.EmailAddress;
 import life.qbic.identity.domain.model.User;
 import life.qbic.identity.domain.model.UserId;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.repository.CrudRepository;
 
 /**
@@ -18,7 +20,7 @@
  *
  * @since 1.0.0
  */
-public interface QbicUserRepo extends CrudRepository<User, UserId> {
+public interface QbicUserRepo extends JpaRepository<User, UserId> {
 
   /**
    * Find users by mail address in the persistent data storage
@@ -46,4 +48,6 @@ public interface QbicUserRepo extends CrudRepository<User, UserId> {
   List<User> findUsersByActiveTrue();
 
   User findUserByUserName(String userName);
+
+  List<User> findAllByUserNameContainingIgnoreCaseAndActiveTrue(String username, Pageable pageable);
 }

identity-infrastructure/src/main/java/life/qbic/identity/infrastructure/UserJpaRepository.java

@@ -7,6 +7,7 @@
 import life.qbic.identity.domain.model.UserId;
 import life.qbic.identity.domain.repository.UserDataStorage;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Component;
 
 
@@ -57,4 +58,10 @@ public List<User> findAllActiveUsers() {
   public Optional<User> findUserByUserName(String userName) {
     return Optional.ofNullable(userRepo.findUserByUserName(userName));
   }
+
+  @Override
+  public List<User> findByUserNameContainingIgnoreCaseAndActiveTrue(String userName,
+      Pageable pageable) {
+    return userRepo.findAllByUserNameContainingIgnoreCaseAndActiveTrue(userName, pageable);
+  }
 }

identity/src/main/java/life/qbic/identity/application/service/BasicUserInformationService.java

@@ -2,8 +2,11 @@
 
 import static life.qbic.logging.service.LoggerFactory.logger;
 
+import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
+import life.qbic.application.commons.OffsetBasedRequest;
+import life.qbic.application.commons.SortOrder;
 import life.qbic.identity.api.UserInfo;
 import life.qbic.identity.api.UserInformationService;
 import life.qbic.identity.domain.model.EmailAddress;
@@ -12,6 +15,8 @@
 import life.qbic.identity.domain.model.UserId;
 import life.qbic.identity.domain.repository.UserRepository;
 import life.qbic.logging.api.Logger;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.domain.Sort.Order;
 
 /**
  * <b>Basic user information service</b>
@@ -58,6 +63,26 @@ public boolean userNameAvailable(String userName) {
     return userRepository.findByUserName(userName).isEmpty();
   }
 
+  @Override
+  public List<UserInfo> findAllActive(String filter, int offset, int limit,
+      List<SortOrder> sortOrders) {
+    List<Order> orders = sortOrders.stream().map(it -> {
+      Order order;
+      if (it.isDescending()) {
+        order = Order.desc(it.propertyName());
+      } else {
+        order = Order.asc(it.propertyName());
+      }
+      return order;
+    }).toList();
+    return userRepository.findByUserNameContainingIgnoreCaseAndActiveTrue(
+            filter, new OffsetBasedRequest(offset, limit, Sort.by(orders)))
+        .stream()
+        .map(user -> new UserInfo(user.id().get(), user.fullName().get(), user.emailAddress().get(),
+            user.userName(), user.getEncryptedPassword().get(), user.isActive()))
+        .toList();
+  }
+
   private UserInfo convert(User user) {
     return new UserInfo(user.id().get(), user.fullName().get(), user.emailAddress().get(),
         user.userName(),

identity/src/main/java/life/qbic/identity/application/token/PersonalAccessTokenServiceImpl.java

@@ -1,12 +1,15 @@
 package life.qbic.identity.application.token;
 
+import static java.util.Objects.requireNonNull;
+
 import java.time.Duration;
 import java.util.Collection;
 import life.qbic.identity.api.PersonalAccessToken;
 import life.qbic.identity.api.PersonalAccessTokenService;
 import life.qbic.identity.api.RawToken;
 import life.qbic.identity.api.UnknownUserIdException;
 import life.qbic.identity.api.UserInformationService;
+import life.qbic.identity.domain.model.token.TokenEncoder;
 import life.qbic.identity.domain.model.token.TokenGenerator;
 import life.qbic.identity.domain.model.token.TokenRepository;
 import org.springframework.stereotype.Service;
@@ -22,13 +25,16 @@
 public class PersonalAccessTokenServiceImpl implements PersonalAccessTokenService {
 
   private final UserInformationService userInformationService;
-
   private final TokenRepository tokenRepository;
+  private final TokenEncoder tokenEncoder;
 
   public PersonalAccessTokenServiceImpl(UserInformationService basicUserInformationService,
-      TokenRepository tokenRepository) {
-    this.userInformationService = basicUserInformationService;
-    this.tokenRepository = tokenRepository;
+      TokenRepository tokenRepository,
+      TokenEncoder tokenEncoder) {
+    this.userInformationService = requireNonNull(basicUserInformationService,
+        "basicUserInformationService must not be null");
+    this.tokenRepository = requireNonNull(tokenRepository, "tokenRepository must not be null");
+    this.tokenEncoder = requireNonNull(tokenEncoder, "tokenEncoder must not be null");
   }
 
   private static PersonalAccessToken convert(
@@ -49,16 +55,16 @@ public RawToken create(String userId, String description, Duration duration)
   }
 
   private RawToken processTokenRequest(String userId, String description, Duration duration) {
-    TokenGenerator tokenGenerator = new TokenGenerator();
-    String rawToken = tokenGenerator.token();
-    var token = life.qbic.identity.domain.model.token.PersonalAccessToken.create(userId,
-        description, duration, rawToken);
+    String rawToken = TokenGenerator.token();
+    String encodedToken = tokenEncoder.encode(rawToken.toCharArray());
+    var token = new life.qbic.identity.domain.model.token.PersonalAccessToken(userId, description,
+        duration, encodedToken);
     tokenRepository.save(token);
     return new RawToken(rawToken);
   }
 
   @Override
-  public Collection<PersonalAccessToken> find(String userId) {
+  public Collection<PersonalAccessToken> findAll(String userId) {
     return tokenRepository.findAllByUserId(userId).stream()
         .map(PersonalAccessTokenServiceImpl::convert).toList();
   }

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

@@ -1,5 +1,7 @@
 package life.qbic.identity.application.user;
 
+import static java.util.Objects.isNull;
+
 import java.io.Serial;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -55,7 +57,7 @@ public IdentityService(UserRepository userRepository) {
   public ApplicationResponse registerUser(final String fullName, String userName, final String email,
       final char[] rawPassword) {
 
-    var registrationResponse = validateInput(fullName, email, rawPassword);
+    var registrationResponse = validateInput(fullName, userName, email, rawPassword);
     if (registrationResponse.hasFailures()) {
       return registrationResponse;
     }
@@ -86,7 +88,8 @@ public ApplicationResponse registerUser(final String fullName, String userName,
     return ApplicationResponse.successResponse();
   }
 
-  private ApplicationResponse validateInput(String fullName, String email, char[] rawPassword) {
+  private ApplicationResponse validateInput(String fullName, String userName, String email,
+      char[] rawPassword) {
     List<RuntimeException> failures = new ArrayList<>();
 
     try {
@@ -99,6 +102,9 @@ private ApplicationResponse validateInput(String fullName, String email, char[]
     } catch (FullNameValidationException e) {
       failures.add(e);
     }
+    if (isNull(userName) || userName.isBlank()) {
+      failures.add(new EmptyUserNameException());
+    }
     try {
       EncryptedPassword.from(rawPassword);
     } catch (PasswordValidationException e) {
@@ -185,6 +191,16 @@ private Result<EncryptedPassword, RuntimeException> attemptPasswordEncryption(
     }
   }
 
+  public static class EmptyUserNameException extends ApplicationException {
+
+    @Serial
+    private static final long serialVersionUID = -150902871229730428L;
+
+    public EmptyUserNameException() {
+      super();
+    }
+  }
+
   public static class UserExistsException extends ApplicationException {
 
     @Serial

identity/src/main/java/life/qbic/identity/application/user/registration/Registration.java

@@ -2,6 +2,7 @@
 
 import life.qbic.application.commons.ApplicationResponse;
 import life.qbic.identity.application.user.IdentityService;
+import life.qbic.identity.application.user.IdentityService.EmptyUserNameException;
 import life.qbic.identity.application.user.IdentityService.UserExistsException;
 import life.qbic.identity.application.user.IdentityService.UserNameNotAvailableException;
 import life.qbic.identity.domain.model.EmailAddress.EmailValidationException;
@@ -83,16 +84,19 @@ private UserRegistrationException build(ApplicationResponse applicationResponse)
     var builder = UserRegistrationException.builder();
 
     for (RuntimeException e : applicationResponse.failures()) {
-      if (e instanceof EmailValidationException) {
-        builder.withEmailFormatException((EmailValidationException) e);
-      } else if (e instanceof PasswordValidationException) {
-        builder.withInvalidPasswordException((PasswordValidationException) e);
-      } else if (e instanceof FullNameValidationException) {
-        builder.withFullNameException((FullNameValidationException) e);
-      } else if (e instanceof UserExistsException) {
-        builder.withUserExistsException((UserExistsException) e);
-      } else if (e instanceof UserNameNotAvailableException) {
-        builder.withUserNameNotAvailableException((UserNameNotAvailableException) e);
+
+      if (e instanceof EmailValidationException emailValidationException) {
+        builder.withEmailFormatException(emailValidationException);
+      } else if (e instanceof PasswordValidationException passwordValidationException) {
+        builder.withInvalidPasswordException(passwordValidationException);
+      } else if (e instanceof FullNameValidationException fullNameValidationException) {
+        builder.withFullNameException(fullNameValidationException);
+      } else if (e instanceof UserExistsException userExistsException) {
+        builder.withUserExistsException(userExistsException);
+      } else if (e instanceof UserNameNotAvailableException userNameNotAvailableException) {
+        builder.withUserNameNotAvailableException(userNameNotAvailableException);
+      } else if (e instanceof EmptyUserNameException emptyUserNameException) {
+        builder.withEmptyUserNameException(emptyUserNameException);
       } else {
         builder.withUnexpectedException(e);
       }

identity/src/main/java/life/qbic/identity/application/user/registration/UserRegistrationException.java

@@ -3,6 +3,7 @@
 import java.io.Serial;
 import java.util.Optional;
 import life.qbic.application.commons.ApplicationException;
+import life.qbic.identity.application.user.IdentityService.EmptyUserNameException;
 import life.qbic.identity.application.user.IdentityService.UserExistsException;
 import life.qbic.identity.application.user.IdentityService.UserNameNotAvailableException;
 import life.qbic.identity.domain.model.EmailAddress.EmailValidationException;
@@ -32,6 +33,7 @@ public class UserRegistrationException extends ApplicationException {
   private final transient FullNameValidationException fullNameException;
 
   private final transient UserNameNotAvailableException userNameNotAvailableException;
+  private final transient EmptyUserNameException emptyUserNameException;
 
   private final transient UserExistsException userExistsException;
   private final transient RuntimeException unexpectedException;
@@ -51,6 +53,7 @@ public static class Builder {
     private UserExistsException userExistsException;
     private RuntimeException unexpectedException;
     private UserNameNotAvailableException userNameNotAvailableException;
+    private EmptyUserNameException emptyUserNameException;
 
     protected Builder() {
 
@@ -89,6 +92,11 @@ public Builder withUserNameNotAvailableException(UserNameNotAvailableException e
       this.userNameNotAvailableException = e;
       return this;
     }
+
+    public Builder withEmptyUserNameException(EmptyUserNameException emptyUserNameException) {
+      this.emptyUserNameException = emptyUserNameException;
+      return this;
+    }
   }
 
   private UserRegistrationException(Builder builder) {
@@ -98,6 +106,7 @@ private UserRegistrationException(Builder builder) {
     userExistsException = builder.userExistsException;
     unexpectedException = builder.unexpectedException;
     userNameNotAvailableException = builder.userNameNotAvailableException;
+    emptyUserNameException = builder.emptyUserNameException;
   }
 
   public Optional<EmailValidationException> emailFormatException() {
@@ -120,6 +129,10 @@ public Optional<UserNameNotAvailableException> userNameNotAvailableException() {
     return Optional.ofNullable(userNameNotAvailableException);
   }
 
+  public Optional<EmptyUserNameException> emptyUserNameException() {
+    return Optional.ofNullable(emptyUserNameException);
+  }
+
   public Optional<RuntimeException> unexpectedException() {
     return Optional.ofNullable(unexpectedException);
   }