Refactoring : Version Très Clean

pom.xml

@@ -30,6 +30,11 @@
     </dependencyManagement>
 
     <dependencies>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-smallrye-jwt</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>org.springframework.security</groupId>
             <artifactId>spring-security-core</artifactId>

src/main/java/com/lions/dev/dto/request/users/UserAuthenticateRequestDTO.java

@@ -0,0 +1,44 @@
+package com.lions.dev.dto.request.users;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * DTO pour la requête d'authentification de l'utilisateur.
+ * Utilisé pour encapsuler les informations nécessaires lors de l'authentification d'un utilisateur.
+ */
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class UserAuthenticateRequestDTO {
+
+  private static final Logger logger = LoggerFactory.getLogger(UserAuthenticateRequestDTO.class);
+
+  /**
+   * Adresse email de l'utilisateur. Doit être validée côté front-end et back-end.
+   */
+  private String email;
+
+  /**
+   * Mot de passe de l'utilisateur en texte clair.
+   * Ce champ sera haché avant d'être utilisé pour l'authentification.
+   */
+  private String motDePasse;
+
+  /**
+   * Log de création de l'objet DTO.
+   */
+  static {
+    logger.info("UserAuthenticateRequestDTO - DTO pour l'authentification initialisé");
+  }
+
+  // Méthode personnalisée pour loguer les détails de la requête
+  public void logRequestDetails() {
+    logger.info("Authentification demandée pour l'email: {}", email);
+  }
+}

src/main/java/com/lions/dev/dto/response/users/UserAuthenticateResponseDTO.java

@@ -0,0 +1,65 @@
+package com.lions.dev.dto.response.users;
+
+import java.util.UUID;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * DTO pour la réponse d'authentification de l'utilisateur.
+ * Utilisé pour renvoyer les informations nécessaires après l'authentification réussie d'un utilisateur.
+ */
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class UserAuthenticateResponseDTO {
+
+  private static final Logger logger = LoggerFactory.getLogger(UserAuthenticateResponseDTO.class);
+
+  /**
+   * Jeton JWT généré après une authentification réussie.
+   * Il doit être utilisé pour toutes les communications sécurisées avec l'API.
+   */
+  // private String token;
+
+  /**
+   * Identifiant unique de l'utilisateur authentifié.
+   */
+  private UUID userId;
+
+  /**
+   * Nom de l'utilisateur.
+   */
+  private String nom;
+
+  /**
+   * Prénom de l'utilisateur.
+   */
+  private String prenoms;
+
+  /**
+   * Adresse email de l'utilisateur.
+   */
+  private String email;
+
+  /**
+   * Rôle de l'utilisateur.
+   */
+  private String role;
+
+  /**
+   * Log de création de l'objet DTO.
+   */
+  static {
+    logger.info("UserAuthenticateResponseDTO - DTO pour la réponse d'authentification initialisé");
+  }
+
+  // Méthode personnalisée pour loguer les détails de la réponse
+  public void logResponseDetails() {
+    logger.info("Réponse d'authentification - Utilisateur: {}, {}, Email: {}, Rôle: {}, ID: {}, Token généré", prenoms, nom, email, role, userId);
+  }
+}

src/main/java/com/lions/dev/dto/response/users/UserResponseDTO.java

@@ -1,6 +1,7 @@
 package com.lions.dev.dto.response.users;
 
 import com.lions.dev.entity.users.Users;
+import java.util.UUID;
 import lombok.Getter;
 
 /**
@@ -11,6 +12,7 @@ import lombok.Getter;
 @Getter
 public class UserResponseDTO {
 
+  private UUID uuid;
   private String nom; // Nom de l'utilisateur
   private String prenoms; // Prénoms de l'utilisateur
   private String email; // Email de l'utilisateur
@@ -21,6 +23,7 @@ public class UserResponseDTO {
    * @param user L'utilisateur à convertir en DTO.
    */
   public UserResponseDTO(Users user) {
+    this.uuid = user.getId();
     this.nom = user.getNom();
     this.prenoms = user.getPrenoms();
     this.email = user.getEmail();

src/main/java/com/lions/dev/resource/UsersResource.java

@@ -1,25 +1,25 @@
 package com.lions.dev.resource;
 
-import com.lions.dev.entity.users.Users;
+import com.lions.dev.dto.request.users.UserAuthenticateRequestDTO;
-import com.lions.dev.repository.UsersRepository;
 import com.lions.dev.dto.request.users.UserRequestDTO;
+import com.lions.dev.dto.response.users.UserAuthenticateResponseDTO;
 import com.lions.dev.dto.response.users.UserResponseDTO;
-import com.lions.dev.exception.UserNotFoundException;
+import com.lions.dev.entity.users.Users;
+import com.lions.dev.service.UserService;
 import jakarta.inject.Inject;
 import jakarta.transaction.Transactional;
 import jakarta.ws.rs.*;
 import jakarta.ws.rs.core.Response;
-import java.time.LocalDateTime;
 import java.util.UUID;
 import org.eclipse.microprofile.openapi.annotations.Operation;
 import org.eclipse.microprofile.openapi.annotations.tags.Tag;
 import org.jboss.logging.Logger;
 
 /**
- * Ressource REST pour la gestion des utilisateurs dans le système AfterWork.
+ * Ressource REST pour la gestion des utilisateurs dans le système AfterWork. Cette classe expose
- * Cette classe expose des endpoints pour créer, authentifier, récupérer et supprimer des utilisateurs.
+ * des endpoints pour créer, authentifier, récupérer et supprimer des utilisateurs.
  *
- * Tous les logs nécessaires pour la traçabilité sont intégrés.
+ * <p>Tous les logs nécessaires pour la traçabilité sont intégrés.
  */
 @Path("/users")
 @Produces("application/json")
@@ -27,8 +27,7 @@ import org.jboss.logging.Logger;
 @Tag(name = "Users", description = "Opérations liées à la gestion des utilisateurs")
 public class UsersResource {
 
-    @Inject
+  @Inject UserService userService;
-    UsersRepository usersRepository;
 
   private static final Logger LOG = Logger.getLogger(UsersResource.class);
 
@@ -40,28 +39,16 @@ public class UsersResource {
    */
   @POST
   @Transactional
-    @Operation(summary = "Créer un nouvel utilisateur", description = "Crée un nouvel utilisateur et retourne les détails")
+  @Operation(
+      summary = "Créer un nouvel utilisateur",
+      description = "Crée un nouvel utilisateur et retourne les détails")
   public Response createUser(UserRequestDTO userRequestDTO) {
-        LOG.info("Tentative de création d'un nouvel utilisateur avec l'email : " + userRequestDTO.getEmail());
+    LOG.info(
+        "Tentative de création d'un nouvel utilisateur avec l'email : "
+            + userRequestDTO.getEmail());
 
-        if (usersRepository.existsByEmail(userRequestDTO.getEmail())) {
+    // Utilisation de UserService pour créer l'utilisateur
-            LOG.warn("Un utilisateur avec cet email existe déjà : " + userRequestDTO.getEmail());
+    Users user = userService.createUser(userRequestDTO);
-            return Response.status(Response.Status.CONFLICT)
-                .entity("Un utilisateur avec cet email existe déjà.").build();
-        }
-
-        Users user = new Users();
-        user.setNom(userRequestDTO.getNom());
-        user.setPrenoms(userRequestDTO.getPrenoms());
-        user.setEmail(userRequestDTO.getEmail());
-        user.setMotDePasse(userRequestDTO.getMotDePasse()); // Hachage automatique dans l'entité
-        // Assigner un rôle par défaut si non fourni (par exemple : USER)
-        if (user.getRole() == null) {
-            user.setRole("USER");  // Définir le rôle par défaut
-        }
-
-        usersRepository.persist(user);
-        LOG.info("Utilisateur créé avec succès : " + user.getEmail() + " à " + LocalDateTime.now());
 
     UserResponseDTO responseDTO = new UserResponseDTO(user);
     return Response.status(Response.Status.CREATED).entity(responseDTO).build();
@@ -70,25 +57,33 @@ public class UsersResource {
   /**
    * Endpoint pour authentifier un utilisateur.
    *
-     * @param userRequestDTO Le DTO contenant les informations d'authentification.
+   * @param userAuthenticateRequestDTO Le DTO contenant les informations d'authentification.
    * @return Une réponse HTTP indiquant si l'authentification a réussi ou échoué.
    */
   @POST
   @Path("/authenticate")
-    @Operation(summary = "Authentifier un utilisateur", description = "Vérifie les informations de connexion de l'utilisateur")
+  @Operation(
-    public Response authenticateUser(UserRequestDTO userRequestDTO) {
+      summary = "Authentifier un utilisateur",
-        LOG.info("Tentative d'authentification pour l'utilisateur avec l'email : " + userRequestDTO.getEmail());
+      description = "Vérifie les informations de connexion de l'utilisateur")
+  public Response authenticateUser(UserAuthenticateRequestDTO userAuthenticateRequestDTO) {
+    LOG.info(
+        "Tentative d'authentification pour l'utilisateur avec l'email : "
+            + userAuthenticateRequestDTO.getEmail());
 
-        Users user = usersRepository.findByEmail(userRequestDTO.getEmail())
+    // Utilisation de UserService pour authentifier l'utilisateur
-            .orElseThrow(() -> new UserNotFoundException("Utilisateur non trouvé avec l'email : " + userRequestDTO.getEmail()));
+    Users user =
-
+        userService.authenticateUser(
-        if (!user.verifierMotDePasse(userRequestDTO.getMotDePasse())) {
+            userAuthenticateRequestDTO.getEmail(), userAuthenticateRequestDTO.getMotDePasse());
-            LOG.warn("Échec de l'authentification : mot de passe incorrect pour l'email : " + userRequestDTO.getEmail());
-            return Response.status(Response.Status.UNAUTHORIZED).entity("Mot de passe incorrect.").build();
-        }
 
     LOG.info("Authentification réussie pour l'utilisateur : " + user.getEmail());
-        UserResponseDTO responseDTO = new UserResponseDTO(user);
+
+    // Création du DTO de réponse avec les informations supplémentaires de l'utilisateur
+    UserAuthenticateResponseDTO responseDTO =
+        new UserAuthenticateResponseDTO(
+            user.getId(), user.getPrenoms(), user.getNom(), user.getEmail(), user.getRole());
+
+    responseDTO.logResponseDetails();
+
     return Response.ok(responseDTO).build();
   }
 
@@ -100,16 +95,14 @@ public class UsersResource {
    */
   @GET
   @Path("/{id}")
-    @Operation(summary = "Récupérer un utilisateur par ID", description = "Retourne les détails de l'utilisateur demandé")
+  @Operation(
+      summary = "Récupérer un utilisateur par ID",
+      description = "Retourne les détails de l'utilisateur demandé")
   public Response getUserById(@PathParam("id") UUID id) {
     LOG.info("Récupération de l'utilisateur avec l'ID : " + id);
 
-        Users user = usersRepository.findById(id);
+    // Utilisation de UserService pour récupérer l'utilisateur
-        if (user == null) {
+    Users user = userService.getUserById(id);
-            LOG.warn("Utilisateur non trouvé avec l'ID : " + id);
-            return Response.status(Response.Status.NOT_FOUND)
-                .entity("Utilisateur non trouvé.").build();
-        }
 
     UserResponseDTO responseDTO = new UserResponseDTO(user);
     LOG.info("Utilisateur trouvé : " + user.getEmail());
@@ -125,18 +118,21 @@ public class UsersResource {
   @DELETE
   @Path("/{id}")
   @Transactional
-    @Operation(summary = "Supprimer un utilisateur", description = "Supprime un utilisateur de la base de données")
+  @Operation(
+      summary = "Supprimer un utilisateur",
+      description = "Supprime un utilisateur de la base de données")
   public Response deleteUser(@PathParam("id") UUID id) {
     LOG.info("Tentative de suppression de l'utilisateur avec l'ID : " + id);
 
-        boolean deleted = usersRepository.deleteById(id);
+    // Utilisation de UserService pour supprimer l'utilisateur
+    boolean deleted = userService.deleteUser(id);
+
     if (deleted) {
       LOG.info("Utilisateur supprimé avec succès.");
       return Response.noContent().build();
     } else {
       LOG.warn("Échec de la suppression : utilisateur introuvable avec l'ID : " + id);
-            return Response.status(Response.Status.NOT_FOUND)
+      return Response.status(Response.Status.NOT_FOUND).entity("Utilisateur non trouvé.").build();
-                .entity("Utilisateur non trouvé.").build();
     }
   }
 }

src/main/java/com/lions/dev/service/UserService.java

@@ -31,6 +31,14 @@ public class UserService {
     user.setPrenoms(userRequestDTO.getPrenoms());
     user.setEmail(userRequestDTO.getEmail());
     user.setMotDePasse(userRequestDTO.getMotDePasse()); // Hachage automatique
+
+    // Vérifier si le rôle est défini, sinon attribuer un rôle par défaut
+    if (userRequestDTO.getRole() == null || userRequestDTO.getRole().isEmpty()) {
+      user.setRole("USER"); // Assigner un rôle par défaut, par exemple "USER"
+    } else {
+      user.setRole(userRequestDTO.getRole());
+    }
+
     usersRepository.persist(user);
     System.out.println("[LOG] Utilisateur créé : " + user.getEmail());
     return user;

src/main/resources/application.properties

@@ -18,3 +18,12 @@ quarkus.datasource.devservices.enabled=false
 
 # Niveau de logging
 quarkus.log.level=INFO
+
+# Configuration la cl<63> de signature JWT
+# mp.jwt.verify.publickey.location=META-INF/resources/publicKey.pem
+# mp.jwt.verify.issuer=https://issuer.example.com
+# mp.jwt.token.header=Authorization
+# mp.jwt.token.schemes=Bearer
+# smallrye.jwt.sign.key.location=META-INF/resources/privateKey.pem
+# smallrye.jwt.sign.key.algorithm=RS256
+# smallrye.jwt.token.lifetime=3600