Convert login by id into login by email.

codiki-application/src/main/java/org/codiki/application/security/JwtService.java

@@ -1,14 +1,24 @@
 package org.codiki.application.security;
 
 import java.time.ZonedDateTime;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
 
+import static org.codiki.domain.user.model.builder.UserBuilder.anUser;
 import org.codiki.domain.user.model.User;
+import org.codiki.domain.user.model.UserRole;
+import org.codiki.domain.user.model.builder.UserBuilder;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import com.auth0.jwt.JWT;
 import com.auth0.jwt.JWTVerifier;
 import com.auth0.jwt.algorithms.Algorithm;
 import com.auth0.jwt.exceptions.JWTVerificationException;
+import com.auth0.jwt.interfaces.Claim;
 
 @Service
 public class JwtService {
@@ -31,6 +41,7 @@ public class JwtService {
         return JWT.create()
             .withSubject(user.id().toString())
             .withExpiresAt(expirationDate.toInstant())
+            .withPayload(user.toJwtPayload())
             .sign(algorithm);
     }
 
@@ -45,7 +56,54 @@ public class JwtService {
         return result;
     }
 
-    public String extractUsername(String token) {
-        return JWT.decode(token).getSubject();
+    public Optional<User> extractUser(String token) {
+        Map<String, Claim> claims = JWT.decode(token).getClaims();
+
+        UserBuilder userBuilder = anUser()
+            .withPassword("****");
+
+        Optional.ofNullable(claims.get("sub"))
+            .map(Claim::asString)
+            .map(this::mapUuid)
+            .ifPresent(userBuilder::withId);
+
+        Optional.ofNullable(claims.get("pseudo"))
+            .map(Claim::asString)
+            .ifPresent(userBuilder::withPseudo);
+
+        Optional.ofNullable(claims.get("email"))
+            .map(Claim::asString)
+            .ifPresent(userBuilder::withEmail);
+
+        Optional.ofNullable(claims.get("photoId"))
+            .map(Claim::asString)
+            .map(this::mapUuid)
+            .ifPresent(userBuilder::withPhotoId);
+
+        extractRoles(claims)
+            .stream()
+            .flatMap(Collection::stream)
+            .map(UserRole::from)
+            .flatMap(Optional::stream)
+            .forEach(userBuilder::withRole);
+
+        return Optional.of(userBuilder.build());
+    }
+
+    private static Optional<List<String>> extractRoles(Map<String, Claim> claims) {
+        return Optional.ofNullable(claims.get("roles"))
+            .map(Claim::asString)
+            .map(roles -> roles.split(","))
+            .map(Arrays::asList);
+    }
+
+    private UUID mapUuid(String uuidAsString) {
+        UUID result;
+        try {
+            result = UUID.fromString(uuidAsString);
+        } catch (IllegalArgumentException exception) {
+            result = null;
+        }
+        return result;
     }
 }

codiki-application/src/main/java/org/codiki/application/user/UserUseCases.java

@@ -60,8 +60,8 @@ public class UserUseCases {
         return userPort.findAll();
     }
 
-    public UserAuthenticationData authenticate(UUID userId, String password) {
-        User user = userPort.findById(userId)
+    public UserAuthenticationData authenticate(String userEmail, String password) {
+        User user = userPort.findByEmail(userEmail)
             .orElseThrow(LoginFailureException::new);
 
         if (!passwordEncoder.matches(password, user.password())) {