Refactoring et amélioration des endpoints friendship

src/main/java/com/lions/dev/core/errors/GlobalExceptionHandler.java

@@ -1,25 +1,53 @@
 package com.lions.dev.core.errors;
 
+import com.lions.dev.core.errors.exceptions.BadRequestException;
 import com.lions.dev.core.errors.exceptions.EventNotFoundException;
+import com.lions.dev.core.errors.exceptions.NotFoundException;
+import com.lions.dev.core.errors.exceptions.ServerException;
+import com.lions.dev.core.errors.exceptions.UnauthorizedException;
+
 import jakarta.ws.rs.core.Response;
 import jakarta.ws.rs.ext.ExceptionMapper;
 import jakarta.ws.rs.ext.Provider;
 
 /**
- * Gestionnaire global des exceptions pour mapper les exceptions à des réponses HTTP appropriées.
+ * Gestionnaire global des exceptions pour l'API.
+ * Ce gestionnaire intercepte les exceptions spécifiques et renvoie des réponses appropriées.
  */
 @Provider
-public class GlobalExceptionHandler implements ExceptionMapper<Throwable> {
+public class GlobalExceptionHandler implements ExceptionMapper<Exception> {
 
+  /**
+   * Gère les exceptions non traitées et retourne une réponse appropriée.
+   *
+   * @param exception L'exception interceptée.
+   * @return Une réponse HTTP avec un message d'erreur et le code de statut approprié.
+   */
   @Override
-  public Response toResponse(Throwable exception) {
+  public Response toResponse(Exception exception) {
-    if (exception instanceof EventNotFoundException) {
+    if (exception instanceof BadRequestException) {
-      return Response.status(Response.Status.NOT_FOUND)
+      return buildResponse(Response.Status.BAD_REQUEST, exception.getMessage());
-                     .entity(exception.getMessage())
+    } else if (exception instanceof EventNotFoundException || exception instanceof NotFoundException) {
-                     .build();
+      return buildResponse(Response.Status.NOT_FOUND, exception.getMessage());
+    } else if (exception instanceof UnauthorizedException) {
+      return buildResponse(Response.Status.UNAUTHORIZED, exception.getMessage());
+    } else if (exception instanceof ServerException) {
+      return buildResponse(Response.Status.INTERNAL_SERVER_ERROR, "Erreur interne du serveur.");
     }
-    return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+
-                   .entity("Une erreur interne est survenue.")
+    return buildResponse(Response.Status.INTERNAL_SERVER_ERROR, "Erreur inattendue : " + exception.getMessage());
+  }
+
+  /**
+   * Crée une réponse HTTP avec un code de statut et un message d'erreur.
+   *
+   * @param status  Le code de statut HTTP.
+   * @param message Le message d'erreur.
+   * @return La réponse HTTP formée.
+   */
+  private Response buildResponse(Response.Status status, String message) {
+    return Response.status(status)
+                   .entity("{\"error\":\"" + message + "\"}")
                    .build();
   }
 }

src/main/java/com/lions/dev/core/errors/exceptions/BadRequestException.java

@@ -18,4 +18,5 @@ public class BadRequestException extends WebApplicationException {
     super(message, Response.Status.BAD_REQUEST);
     System.out.println("[ERROR] Requête invalide : " + message);
   }
+
 }

src/main/java/com/lions/dev/dto/request/friends/FriendshipRequestDTO.java

@@ -0,0 +1,25 @@
+package com.lions.dev.dto.request.friends;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.NoArgsConstructor;
+
+import java.util.UUID;
+
+/**
+ * DTO pour envoyer une demande d'amitié.
+ * Contient les informations nécessaires pour initier une demande d'amitié.
+ */
+@Getter
+@Setter
+@NoArgsConstructor
+public class FriendshipRequestDTO {
+
+  private UUID userId;   // ID de l'utilisateur qui envoie la demande
+  private UUID friendId; // ID de l'utilisateur qui reçoit la demande
+
+  public FriendshipRequestDTO(UUID userId, UUID friendId) {
+    this.userId = userId;
+    this.friendId = friendId;
+  }
+}

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

@@ -31,6 +31,8 @@ public class UserCreateRequestDTO {
   @Size(min = 6, message = "Le mot de passe doit comporter au moins 6 caractères.")
   private String motDePasse;
 
+  private String profileImageUrl;
+
   // Ajout du rôle avec validation
   @NotNull(message = "Le rôle est obligatoire.")
   private String role;  // Rôle de l'utilisateur (par exemple : ADMIN, USER, etc.)

src/main/java/com/lions/dev/dto/response/friends/FriendshipRequestStatusResponseDTO.java

@@ -0,0 +1,57 @@
+package com.lions.dev.dto.response.friends;
+
+import com.lions.dev.entity.friends.Friendship;
+import com.lions.dev.entity.friends.FriendshipStatus;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+/**
+ * DTO de réponse pour les demandes d'amitié par statut.
+ * Contient les informations essentielles sans données sensibles.
+ */
+@Getter
+@Setter
+@NoArgsConstructor
+public class FriendshipRequestStatusResponseDTO {
+
+  private UUID friendshipId;
+  private UUID userId;
+  private String userNom;
+  private String userPrenoms;
+  private UUID friendId;
+  private String friendNom;
+  private String friendPrenoms;
+  private FriendshipStatus status;
+  private LocalDateTime createdAt;
+
+  public FriendshipRequestStatusResponseDTO(UUID friendshipId, UUID userId, String userNom, String userPrenoms,
+                                            UUID friendId, String friendNom, String friendPrenoms,
+                                            FriendshipStatus status, LocalDateTime createdAt) {
+    this.friendshipId = friendshipId;
+    this.userId = userId;
+    this.userNom = userNom;
+    this.userPrenoms = userPrenoms;
+    this.friendId = friendId;
+    this.friendNom = friendNom;
+    this.friendPrenoms = friendPrenoms;
+    this.status = status;
+    this.createdAt = createdAt;
+  }
+
+  // Constructor to map directly from Friendship entity
+  public FriendshipRequestStatusResponseDTO(Friendship friendship) {
+    this.friendshipId = friendship.getId();
+    this.userId = friendship.getUser().getId();
+    this.userNom = friendship.getUser().getNom();
+    this.userPrenoms = friendship.getUser().getPrenoms();
+    this.friendId = friendship.getFriend().getId();
+    this.friendNom = friendship.getFriend().getNom();
+    this.friendPrenoms = friendship.getFriend().getPrenoms();
+    this.status = friendship.getStatus();
+    this.createdAt = friendship.getCreatedAt();
+  }
+}

src/main/java/com/lions/dev/dto/response/friends/FriendshipResponseDTO.java

@@ -0,0 +1,36 @@
+package com.lions.dev.dto.response.friends;
+
+import com.lions.dev.entity.friends.Friendship;
+import com.lions.dev.entity.friends.FriendshipStatus;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+/**
+ * DTO de réponse pour une relation d'amitié.
+ * Contient les informations sur une relation d'amitié existante.
+ */
+@Getter
+@Setter
+@NoArgsConstructor
+public class FriendshipResponseDTO {
+
+  private UUID id;
+  private UUID userId;
+  private UUID friendId;
+  private FriendshipStatus status;
+  private LocalDateTime createdAt;
+  private LocalDateTime updatedAt;
+
+  public FriendshipResponseDTO(Friendship friendship) {
+    this.id = friendship.getId();
+    this.userId = friendship.getUser().getId();
+    this.friendId = friendship.getFriend().getId();
+    this.status = friendship.getStatus();
+    this.createdAt = friendship.getCreatedAt();
+    this.updatedAt = friendship.getUpdatedAt();
+  }
+}

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

@@ -16,7 +16,8 @@ public class UserCreateResponseDTO {
   private String nom; // Nom de l'utilisateur
   private String prenoms; // Prénoms de l'utilisateur
   private String email; // Email de l'utilisateur
-
+  private String role; // Roğe de l'utilisateur
+  private String profileImageUrl; // Url de l'image de profil de l'utilisateur
   /**
    * Constructeur qui transforme une entité Users en DTO.
    *
@@ -27,6 +28,8 @@ public class UserCreateResponseDTO {
     this.nom = user.getNom();
     this.prenoms = user.getPrenoms();
     this.email = user.getEmail();
+    this.role = user.getRole();
+    this.profileImageUrl = user.getProfileImageUrl();
     System.out.println("[LOG] DTO créé pour l'utilisateur : " + this.email);
   }
 }

src/main/java/com/lions/dev/entity/friends/Friendship.java

@@ -0,0 +1,54 @@
+package com.lions.dev.entity.friends;
+
+import com.lions.dev.entity.BaseEntity; // Import de BaseEntity
+import com.lions.dev.entity.users.Users;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+
+/**
+ * Représentation de l'entité Friendship qui gère les relations d'amitié entre utilisateurs.
+ */
+@Entity
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@ToString
+@Builder
+@Table(name = "friendships")
+public class Friendship extends BaseEntity { // Hérite de BaseEntity
+
+  // L'utilisateur qui a initié la demande d'ami
+  @ManyToOne(fetch = FetchType.LAZY)
+  @JoinColumn(name = "user_id", nullable = false)
+  private Users user;
+
+  // L'ami avec qui la relation est établie
+  @ManyToOne(fetch = FetchType.LAZY)
+  @JoinColumn(name = "friend_id", nullable = false)
+  private Users friend;
+
+  // Statut de la relation (en attente, acceptée, rejetée)
+  @Enumerated(EnumType.STRING)
+  @Column(nullable = false)
+  private FriendshipStatus status;
+
+  /**
+   * Log des changements de statut de l'amitié.
+   */
+  public void setStatus(FriendshipStatus newStatus) {
+    this.status = newStatus;
+    System.out.println(
+        "[LOG] Changement de statut pour l'amitié entre "
+        + this.user.getEmail()
+        + " et "
+        + this.friend.getEmail()
+        + " - Nouveau statut : "
+        + this.status);
+  }
+}

src/main/java/com/lions/dev/entity/friends/FriendshipStatus.java

@@ -0,0 +1,7 @@
+package com.lions.dev.entity.friends;
+
+public enum FriendshipStatus {
+  PENDING, // Demande envoyée, en attente d'acceptation
+  ACCEPTED, // Demande acceptée
+  REJECTED // Demande rejetée
+}

src/main/java/com/lions/dev/exception/FriendshipNotFoundException.java

@@ -0,0 +1,15 @@
+package com.lions.dev.exception;
+
+/**
+ * Exception levée lorsque la relation d'amitié n'est pas trouvée.
+ */
+public class FriendshipNotFoundException extends RuntimeException {
+
+  public FriendshipNotFoundException(String message) {
+    super(message);
+  }
+
+  public FriendshipNotFoundException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/com/lions/dev/repository/FriendshipRepository.java

@@ -0,0 +1,80 @@
+package com.lions.dev.repository;
+
+import com.lions.dev.entity.friends.Friendship;
+import com.lions.dev.entity.friends.FriendshipStatus;
+import com.lions.dev.entity.users.Users;
+import io.quarkus.hibernate.orm.panache.PanacheRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+/**
+ * Repository pour gérer les relations d'amitié (Friendship) dans la base de données.
+ */
+@ApplicationScoped
+public class FriendshipRepository implements PanacheRepository<Friendship> {
+
+  /**
+   * Trouve une relation d'amitié entre deux utilisateurs.
+   *
+   * @param user L'utilisateur qui envoie la demande.
+   * @param friend L'ami qui reçoit la demande.
+   * @return Une Optional contenant la relation d'amitié, si elle existe.
+   */
+  public Optional<Friendship> findByUsers(Users user, Users friend) {
+    return find("user = ?1 and friend = ?2", user, friend).firstResultOptional();
+  }
+
+  /**
+   * Récupère la liste des amis d'un utilisateur.
+   *
+   * @param user L'utilisateur dont on souhaite récupérer les amis.
+   * @return Une liste de relations d'amitié.
+   */
+  public List<Friendship> findFriendsByUser(Users user, int page, int size) {
+    return find("(user = ?1 or friend = ?1) and status = ?2", user, FriendshipStatus.ACCEPTED)
+        .page(page, size)
+        .list();
+  }
+
+  /**
+   * Trouve une relation d'amitié par son ID.
+   *
+   * @param id L'ID de la relation d'amitié.
+   * @return Une Optional contenant la relation d'amitié, si elle existe.
+   */
+  public Optional<Friendship> findById(UUID id) {
+    return find("id", id).firstResultOptional();
+  }
+
+  /**
+   * Supprime une relation d'amitié de la base de données.
+   *
+   * @param friendship La relation d'amitié à supprimer.
+   */
+  public void deleteFriendship(Friendship friendship) {
+    if (friendship != null) {
+      this.delete(friendship);  // Suppression de l'entité Friendship
+      System.out.println("[LOG] Entité Friendship supprimée : " + friendship.getId());
+    } else {
+      System.out.println("[ERROR] Tentative de suppression d'une entité Friendship inexistante.");
+    }
+  }
+
+  /**
+   * Récupère toutes les relations d'amitié d'un utilisateur ayant un statut particulier.
+   *
+   * @param user L'utilisateur dont on souhaite récupérer les amitiés.
+   * @param status Le statut des relations d'amitié à rechercher.
+   * @param page Le numéro de la page à récupérer.
+   * @param size Le nombre d'éléments par page.
+   * @return Une liste paginée de relations d'amitié ayant le statut spécifié pour cet utilisateur.
+   */
+  public List<Friendship> findByUserAndStatus(Users user, FriendshipStatus status, int page, int size) {
+    return find("(user = ?1 or friend = ?1) and status = ?2", user, status)
+        .page(page, size)
+        .list();
+  }
+}

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

@@ -0,0 +1,317 @@
+package com.lions.dev.resource;
+
+import com.lions.dev.dto.request.friends.FriendshipRequestDTO;
+import com.lions.dev.dto.response.friends.FriendshipRequestStatusResponseDTO;
+import com.lions.dev.dto.response.friends.FriendshipResponseDTO;
+import com.lions.dev.entity.friends.Friendship;
+import com.lions.dev.entity.friends.FriendshipStatus;
+import com.lions.dev.entity.users.Users;
+import com.lions.dev.repository.UsersRepository;
+import com.lions.dev.service.FriendshipService;
+import jakarta.inject.Inject;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
+import jakarta.ws.rs.*;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import java.util.List;
+import java.util.UUID;
+import org.eclipse.microprofile.openapi.annotations.Operation;
+import org.eclipse.microprofile.openapi.annotations.enums.SchemaType;
+import org.eclipse.microprofile.openapi.annotations.media.Content;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
+import org.eclipse.microprofile.openapi.annotations.responses.APIResponses;
+import org.eclipse.microprofile.openapi.annotations.tags.Tag;
+import org.jboss.logging.Logger;
+
+/**
+ * Ressource REST pour gérer les amitiés. Ce contrôleur expose des endpoints pour envoyer, accepter,
+ * rejeter et supprimer des demandes d'amitié. Les opérations sont loguées pour suivre leur
+ * déroulement en temps réel.
+ */
+@Path("/friends")
+@Produces(MediaType.APPLICATION_JSON)
+@Consumes(MediaType.APPLICATION_JSON)
+@Tag(name = "Friendship", description = "Opérations liées à la gestion des amis")
+public class FriendshipResource {
+
+  @Inject
+  FriendshipService friendshipService;
+
+  @Inject
+  UsersRepository usersRepository;
+
+  private static final Logger logger = Logger.getLogger(FriendshipResource.class);
+
+  /**
+   * Envoie une demande d'amitié.
+   *
+   * @param request DTO contenant l'ID de l'utilisateur qui reçoit la demande.
+   * @return La relation d'amitié créée.
+   */
+  @POST
+  @Path("/send")
+  @Operation(
+      summary = "Envoyer une demande d'amitié",
+      description = "Envoie une demande d'amitié d'un utilisateur à un autre")
+  @APIResponses({
+    @APIResponse(
+        responseCode = "200",
+        description = "Demande d'amitié envoyée",
+        content =
+            @Content(
+                mediaType = MediaType.APPLICATION_JSON,
+                schema = @Schema(implementation = FriendshipResponseDTO.class))),
+    @APIResponse(responseCode = "400", description = "Requête invalide"),
+    @APIResponse(responseCode = "500", description = "Erreur interne du serveur")
+  })
+  public Response sendFriendRequest(@Valid @NotNull FriendshipRequestDTO request) {
+    logger.info(
+        "[LOG] Reçu une demande pour envoyer une demande d'amitié de l'utilisateur "
+            + request.getUserId()
+            + " à l'utilisateur "
+            + request.getFriendId());
+
+    try {
+      Friendship friendship =
+          friendshipService.sendFriendRequest(request.getUserId(), request.getFriendId());
+      logger.info(
+          "[LOG] Demande d'amitié envoyée avec succès : "
+              + friendship.getUser().getEmail()
+              + " à "
+              + friendship.getFriend().getEmail());
+      return Response.ok(new FriendshipResponseDTO(friendship)).build();
+    } catch (Exception e) {
+      logger.error("[ERROR] Erreur lors de l'envoi de la demande d'amitié : " + e.getMessage());
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity("{\"message\": \"Erreur lors de l'envoi de la demande d'amitié.\"}")
+          .build();
+    }
+  }
+
+  /**
+   * Accepte une demande d'amitié.
+   *
+   * @param friendshipId L'ID de la relation d'amitié à accepter.
+   * @return La relation d'amitié acceptée.
+   */
+  @PATCH
+  @Path("/{friendshipId}/accept")
+  @Operation(
+      summary = "Accepter une demande d'amitié",
+      description = "Accepte une demande d'amitié en attente")
+  @APIResponses({
+    @APIResponse(
+        responseCode = "200",
+        description = "Demande d'amitié acceptée",
+        content =
+            @Content(
+                mediaType = MediaType.APPLICATION_JSON,
+                schema = @Schema(implementation = FriendshipResponseDTO.class))),
+    @APIResponse(responseCode = "404", description = "Demande d'amitié non trouvée"),
+    @APIResponse(responseCode = "500", description = "Erreur interne du serveur")
+  })
+  public Response acceptFriendRequest(@PathParam("friendshipId") UUID friendshipId) {
+    logger.info(
+        "[LOG] Reçu une demande pour accepter une demande d'amitié avec l'ID : " + friendshipId);
+
+    try {
+      Friendship friendship = friendshipService.acceptFriendRequest(friendshipId);
+      logger.info(
+          "[LOG] Demande d'amitié acceptée entre "
+              + friendship.getUser().getEmail()
+              + " et "
+              + friendship.getFriend().getEmail());
+      return Response.ok(new FriendshipResponseDTO(friendship)).build();
+    } catch (NotFoundException e) {
+      logger.error("[ERROR] Demande d'amitié non trouvée : " + e.getMessage());
+      return Response.status(Response.Status.NOT_FOUND)
+          .entity("{\"message\": \"Demande d'amitié non trouvée.\"}")
+          .build();
+    } catch (Exception e) {
+      logger.error(
+          "[ERROR] Erreur lors de l'acceptation de la demande d'amitié : " + e.getMessage());
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity("{\"message\": \"Erreur lors de l'acceptation de la demande d'amitié.\"}")
+          .build();
+    }
+  }
+
+  /**
+   * Rejette une demande d'amitié.
+   *
+   * @param friendshipId L'ID de la relation d'amitié à rejeter.
+   * @return Confirmation de la demande rejetée.
+   */
+  @PATCH
+  @Path("/{friendshipId}/reject")
+  @Operation(
+      summary = "Rejeter une demande d'amitié",
+      description = "Rejette une demande d'amitié en attente")
+  @APIResponses({
+    @APIResponse(responseCode = "204", description = "Demande d'amitié rejetée"),
+    @APIResponse(responseCode = "404", description = "Demande d'amitié non trouvée"),
+    @APIResponse(responseCode = "500", description = "Erreur interne du serveur")
+  })
+  public Response rejectFriendRequest(@PathParam("friendshipId") UUID friendshipId) {
+    logger.info(
+        "[LOG] Reçu une demande pour rejeter une demande d'amitié avec l'ID : " + friendshipId);
+
+    try {
+      friendshipService.rejectFriendRequest(friendshipId);
+      logger.info("[LOG] Demande d'amitié rejetée pour l'ID : " + friendshipId);
+      return Response.noContent().build();
+    } catch (NotFoundException e) {
+      logger.error("[ERROR] Demande d'amitié non trouvée : " + e.getMessage());
+      return Response.status(Response.Status.NOT_FOUND)
+          .entity("{\"message\": \"Demande d'amitié non trouvée.\"}")
+          .build();
+    } catch (Exception e) {
+      logger.error("[ERROR] Erreur lors du rejet de la demande d'amitié : " + e.getMessage());
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity("{\"message\": \"Erreur lors du rejet de la demande d'amitié.\"}")
+          .build();
+    }
+  }
+
+  /**
+   * Supprime une relation d'amitié.
+   *
+   * @param friendshipId L'ID de la relation d'amitié à supprimer.
+   * @return Confirmation de la suppression.
+   */
+  @DELETE
+  @Path("/{friendshipId}")
+  @Operation(
+      summary = "Supprimer une relation d'amitié",
+      description = "Supprime une relation d'amitié existante")
+  @APIResponses({
+    @APIResponse(responseCode = "204", description = "Relation d'amitié supprimée"),
+    @APIResponse(responseCode = "404", description = "Relation d'amitié non trouvée"),
+    @APIResponse(responseCode = "500", description = "Erreur interne du serveur")
+  })
+  public Response removeFriend(@PathParam("friendshipId") UUID friendshipId) {
+    logger.info(
+        "[LOG] Reçu une demande pour supprimer la relation d'amitié avec l'ID : " + friendshipId);
+
+    try {
+      friendshipService.removeFriend(friendshipId);
+      logger.info("[LOG] Relation d'amitié supprimée avec succès pour l'ID : " + friendshipId);
+      return Response.noContent().build();
+    } catch (NotFoundException e) {
+      logger.error("[ERROR] Relation d'amitié non trouvée : " + e.getMessage());
+      return Response.status(Response.Status.NOT_FOUND)
+          .entity("{\"message\": \"Relation d'amitié non trouvée.\"}")
+          .build();
+    } catch (Exception e) {
+      logger.error(
+          "[ERROR] Erreur lors de la suppression de la relation d'amitié : " + e.getMessage());
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity("{\"message\": \"Erreur lors de la suppression de la relation d'amitié.\"}")
+          .build();
+    }
+  }
+
+  /**
+   * Récupère la liste des amis d'un utilisateur.
+   *
+   * @param userId L'ID de l'utilisateur dont on veut récupérer les amis.
+   * @param page Numéro de la page pour la pagination.
+   * @param size Nombre d'éléments par page.
+   * @return La liste des amis de l'utilisateur.
+   */
+  @GET
+  @Path("/list/{userId}")
+  @Operation(
+      summary = "Lister les amis d'un utilisateur",
+      description = "Récupère la liste de tous les amis d'un utilisateur donné")
+  @APIResponses({
+    @APIResponse(
+        responseCode = "200",
+        description = "Liste des amis récupérée",
+        content =
+            @Content(
+                mediaType = MediaType.APPLICATION_JSON,
+                schema =
+                    @Schema(
+                        type = SchemaType.ARRAY,
+                        implementation = FriendshipResponseDTO.class))),
+    @APIResponse(responseCode = "404", description = "Utilisateur non trouvé"),
+    @APIResponse(responseCode = "500", description = "Erreur interne du serveur")
+  })
+  public Response listFriends(
+      @PathParam("userId") UUID userId,
+      @QueryParam("page") @DefaultValue("1") int page,
+      @QueryParam("size") @DefaultValue("10") int size) {
+    logger.info(
+        "[LOG] Reçu une demande pour récupérer la liste des amis de l'utilisateur avec l'ID : "
+            + userId);
+
+    try {
+      List<Friendship> friends = friendshipService.listFriends(userId, page, size);
+      logger.info(
+          "[LOG] Liste des amis récupérée avec succès pour l'utilisateur "
+              + userId
+              + ", nombre d'amis : "
+              + friends.size());
+      return Response.ok(friends.stream().map(FriendshipResponseDTO::new)).build();
+    } catch (NotFoundException e) {
+      logger.error("[ERROR] Utilisateur non trouvé : " + e.getMessage());
+      return Response.status(Response.Status.NOT_FOUND)
+          .entity("{\"message\": \"Utilisateur non trouvé.\"}")
+          .build();
+    } catch (Exception e) {
+      logger.error(
+          "[ERROR] Erreur lors de la récupération de la liste des amis : " + e.getMessage());
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity("{\"message\": \"Erreur lors de la récupération de la liste des amis.\"}")
+          .build();
+    }
+  }
+
+  /**
+   * Endpoint pour récupérer les demandes d'amitié avec un statut spécifique.
+   *
+   * @param userId L'ID de l'utilisateur.
+   * @param status Le statut des demandes à filtrer (PENDING, ACCEPTED, REJECTED).
+   * @param page Le numéro de la page à récupérer.
+   * @param size Le nombre d'éléments par page.
+   * @return La liste paginée des demandes d'amitié avec le statut spécifié.
+   */
+  @GET
+  @Path("/status")
+  @Operation(
+      summary = "Récupérer les demandes d'amitié faites par un utilisateur par statut",
+      description = "Retourne la liste des demandes d'amitié faites par un utilisateur avec un "
+                    + "statut particulier.")
+  public Response listFriendRequestsByStatus(
+      @QueryParam("userId") UUID userId,
+      @QueryParam("status") FriendshipStatus status,
+      @QueryParam("page") @DefaultValue("1") int page,
+      @QueryParam("size") @DefaultValue("10") int size) {
+
+    logger.info("[LOG] Récupération des demandes d'amitié avec le statut : " + status);
+
+    // Récupère l'utilisateur à partir de l'ID fourni
+    Users user = usersRepository.findById(userId);
+    if (user == null) {
+      return Response.status(Response.Status.NOT_FOUND)
+                     .entity("{\"message\": \"Utilisateur non trouvé.\"}")
+                     .build();
+    }
+
+    // Ajuste la pagination (Panache commence à 0)
+    int adjustedPage = page - 1;
+    if (adjustedPage < 0) adjustedPage = 0;
+
+    List<Friendship> friendships = friendshipService.listFriendRequestsByStatus(user, status, adjustedPage, size);
+
+    // Transformation des entités Friendship en DTOs adaptés
+    List<FriendshipRequestStatusResponseDTO> responseDTOs = friendships.stream()
+                                                                       .map(FriendshipRequestStatusResponseDTO::new)
+                                                                       .toList();
+
+    return Response.ok(responseDTOs).build();
+  }
+}

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

@@ -1,37 +1,39 @@
 package com.lions.dev.resource;
 
-import java.io.File;
-
-import jakarta.ws.rs.Path;
 import com.lions.dev.dto.request.users.UserAuthenticateRequestDTO;
+import com.lions.dev.dto.request.users.UserCreateRequestDTO;
 import com.lions.dev.dto.response.users.UserAuthenticateResponseDTO;
+import com.lions.dev.dto.response.users.UserCreateResponseDTO;
 import com.lions.dev.dto.response.users.UserDeleteResponseDto;
 import com.lions.dev.entity.users.Users;
-import com.lions.dev.service.UserService;
+import com.lions.dev.service.UsersService;
 import jakarta.inject.Inject;
 import jakarta.transaction.Transactional;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
 import jakarta.ws.rs.*;
+import jakarta.ws.rs.core.MediaType;
 import jakarta.ws.rs.core.Response;
+import java.io.File;
+import java.util.List;
 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. Cette classe expose
+ * Ressource REST pour la gestion des utilisateurs dans le système AfterWork.
- * des endpoints pour créer, authentifier, récupérer et supprimer des utilisateurs.
+ * Cette classe expose 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")
+@Produces(MediaType.APPLICATION_JSON)
-@Consumes("application/json")
+@Consumes(MediaType.APPLICATION_JSON)
 @Tag(name = "Users", description = "Opérations liées à la gestion des utilisateurs")
 public class UsersResource {
 
   @Inject
-  UserService userService;
+  UsersService userService;
 
   private static final Logger LOG = Logger.getLogger(UsersResource.class);
 
@@ -46,17 +48,13 @@ public class UsersResource {
   @Operation(
       summary = "Créer un nouvel utilisateur",
       description = "Crée un nouvel utilisateur et retourne les détails")
-  public Response createUser(
+  public Response createUser(@Valid @NotNull UserCreateRequestDTO userCreateRequestDTO) {
-      com.lions.dev.dto.request.users.UserCreateRequestDTO userCreateRequestDTO) {
     LOG.info(
         "Tentative de création d'un nouvel utilisateur avec l'email : "
         + userCreateRequestDTO.getEmail());
 
-    // Utilisation de UserService pour créer l'utilisateur
     Users user = userService.createUser(userCreateRequestDTO);
-
+    UserCreateResponseDTO responseDTO = new UserCreateResponseDTO(user);
-    com.lions.dev.dto.response.users.UserCreateResponseDTO
-        responseDTO = new com.lions.dev.dto.response.users.UserCreateResponseDTO(user);
     return Response.status(Response.Status.CREATED).entity(responseDTO).build();
   }
 
@@ -71,25 +69,14 @@ public class UsersResource {
   @Operation(
       summary = "Authentifier un utilisateur",
       description = "Vérifie les informations de connexion de l'utilisateur")
-  public Response authenticateUser(UserAuthenticateRequestDTO userAuthenticateRequestDTO) {
+  public Response authenticateUser(@Valid @NotNull UserAuthenticateRequestDTO userAuthenticateRequestDTO) {
-    LOG.info(
+    LOG.info("Tentative d'authentification pour l'utilisateur avec l'email : " + userAuthenticateRequestDTO.getEmail());
-        "Tentative d'authentification pour l'utilisateur avec l'email : "
-            + userAuthenticateRequestDTO.getEmail());
-
-    // Utilisation de UserService pour authentifier l'utilisateur
-    Users user =
-        userService.authenticateUser(
-            userAuthenticateRequestDTO.getEmail(), userAuthenticateRequestDTO.getMotDePasse());
 
+    Users user = userService.authenticateUser(userAuthenticateRequestDTO.getEmail(), userAuthenticateRequestDTO.getMotDePasse());
     LOG.info("Authentification réussie pour l'utilisateur : " + user.getEmail());
 
-    // 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());
-    UserAuthenticateResponseDTO responseDTO =
-        new UserAuthenticateResponseDTO(
-            user.getId(), user.getPrenoms(), user.getNom(), user.getEmail(), user.getRole());
-
     responseDTO.logResponseDetails();
-
     return Response.ok(responseDTO).build();
   }
 
@@ -107,15 +94,31 @@ public class UsersResource {
   public Response getUserById(@PathParam("id") UUID id) {
     LOG.info("Récupération de l'utilisateur avec l'ID : " + id);
 
-    // Utilisation de UserService pour récupérer l'utilisateur
     Users user = userService.getUserById(id);
-
+    UserCreateResponseDTO responseDTO = new UserCreateResponseDTO(user);
-    com.lions.dev.dto.response.users.UserCreateResponseDTO
-        responseDTO = new com.lions.dev.dto.response.users.UserCreateResponseDTO(user);
     LOG.info("Utilisateur trouvé : " + user.getEmail());
     return Response.ok(responseDTO).build();
   }
 
+  /**
+   * Endpoint pour récupérer tous les utilisateurs avec pagination.
+   *
+   * @param page Le numéro de la page à récupérer.
+   * @param size Le nombre d'utilisateurs par page.
+   * @return Une réponse HTTP contenant la liste des utilisateurs paginée.
+   */
+  @GET
+  @Operation(
+      summary = "Récupérer tous les utilisateurs avec pagination",
+      description = "Retourne la liste paginée des utilisateurs")
+  public Response listUsers(@QueryParam("page") @DefaultValue("1") int page, @QueryParam("size") @DefaultValue("10") int size) {
+    LOG.info("Récupération de la liste des utilisateurs - page : " + page + ", taille : " + size);
+
+    List<Users> users = userService.listUsers(page, size);
+    LOG.info("Liste des utilisateurs récupérée avec succès, taille : " + users.size());
+    return Response.ok(users).build();
+  }
+
   /**
    * Endpoint pour supprimer un utilisateur par ID.
    *
@@ -131,7 +134,6 @@ public class UsersResource {
   public Response deleteUser(@PathParam("id") UUID id) {
     LOG.info("Tentative de suppression de l'utilisateur avec l'ID : " + id);
 
-    // Utilisation de UserService pour supprimer l'utilisateur
     boolean deleted = userService.deleteUser(id);
 
     UserDeleteResponseDto responseDTO = new UserDeleteResponseDto();
@@ -150,6 +152,50 @@ public class UsersResource {
     }
   }
 
+  /**
+   * Endpoint pour mettre à jour un utilisateur.
+   *
+   * @param id L'ID de l'utilisateur à mettre à jour.
+   * @param userCreateRequestDTO Les informations mises à jour de l'utilisateur.
+   * @return Les informations de l'utilisateur mis à jour.
+   */
+  @PUT
+  @Path("/{id}")
+  @Transactional
+  @Operation(
+      summary = "Mettre à jour un utilisateur",
+      description = "Met à jour les informations d'un utilisateur existant")
+  public Response updateUser(@PathParam("id") UUID id, @Valid UserCreateRequestDTO userCreateRequestDTO) {
+    LOG.info("Tentative de mise à jour de l'utilisateur avec l'ID : " + id);
+
+    // Appel au service avec l'ID et les nouvelles informations
+    Users updatedUser = userService.updateUser(id, userCreateRequestDTO);
+
+    LOG.info("Utilisateur mis à jour avec succès : " + updatedUser.getEmail());
+    UserCreateResponseDTO responseDTO = new UserCreateResponseDTO(updatedUser);
+    return Response.ok(responseDTO).build();
+  }
+
+  /**
+   * Endpoint pour réinitialiser le mot de passe d'un utilisateur.
+   *
+   * @param id L'ID de l'utilisateur.
+   * @param nouveauMotDePasse Le nouveau mot de passe.
+   * @return Un message indiquant si la réinitialisation a réussi.
+   */
+  @PATCH
+  @Path("/{id}/reset-password")
+  @Transactional
+  @Operation(
+      summary = "Réinitialiser le mot de passe d'un utilisateur",
+      description = "Réinitialise le mot de passe de l'utilisateur et le met à jour dans la base de données")
+  public Response resetPassword(@PathParam("id") UUID id, @QueryParam("newPassword") String nouveauMotDePasse) {
+    LOG.info("Réinitialisation du mot de passe pour l'utilisateur avec l'ID : " + id);
+
+    userService.resetPassword(id, nouveauMotDePasse);
+    return Response.ok("{\"message\": \"Mot de passe réinitialisé avec succès.\"}").build();
+  }
+
   /**
    * Endpoint pour mettre à jour l'image de profil de l'utilisateur.
    *
@@ -158,37 +204,25 @@ public class UsersResource {
    * @return Un message indiquant si la mise à jour a réussi.
    */
   @PUT
-  @jakarta.ws.rs.Path("/{id}/profile-image")  // Annotation REST avec jakarta.ws.rs.Path
+  @Path("/{id}/profile-image")
+  @Operation(summary = "Mettre à jour l'image de profil d'un utilisateur", description = "Met à jour l'image de profil d'un utilisateur.")
   public String updateUserProfileImage(@PathParam("id") UUID id, String imageFilePath) {
     try {
-      // Utiliser File au lieu de Path pour vérifier si le fichier existe
       File file = new File(imageFilePath);
       if (!file.exists()) {
-        System.out.println("[ERROR] Le fichier spécifié n'existe pas : " + imageFilePath);
+        LOG.error("[ERROR] Le fichier spécifié n'existe pas : " + imageFilePath);
         return "Le fichier spécifié n'existe pas.";
       }
 
-      // Récupérer l'utilisateur par son ID
+      String profileImageUrl = file.getAbsolutePath();
-      Users user = userService.getUserById(id);
+      userService.updateUserProfileImage(id, profileImageUrl); // Appel à la méthode correcte
-      if (user == null) {
-        System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id);
-        return "Utilisateur non trouvé.";
-      }
-
-      // Mettre à jour l'URL de l'image de profil
-      String profileImageUrl = file.getAbsolutePath();  // Obtenir le chemin complet du fichier
-      user.setProfileImageUrl(profileImageUrl);
-
-      // Mise à jour de l'utilisateur
-      userService.updateUser(user);
-      System.out.println("[LOG] Image de profil mise à jour pour l'utilisateur : " + user.getEmail());
 
+      LOG.info("[LOG] Image de profil mise à jour pour l'utilisateur avec l'ID : " + id);
       return "Image de profil mise à jour avec succès.";
     } catch (Exception e) {
-      System.out.println("[ERROR] Erreur lors de la mise à jour de l'image de profil : " + e.getMessage());
+      LOG.error("[ERROR] Erreur lors de la mise à jour de l'image de profil : " + e.getMessage());
       return "Erreur lors de la mise à jour de l'image de profil.";
     }
   }
 
-
 }

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

@@ -0,0 +1,184 @@
+package com.lions.dev.service;
+
+import com.lions.dev.entity.friends.Friendship;
+import com.lions.dev.entity.friends.FriendshipStatus;
+import com.lions.dev.entity.users.Users;
+import com.lions.dev.exception.FriendshipNotFoundException;
+import com.lions.dev.exception.UserNotFoundException;
+import com.lions.dev.repository.FriendshipRepository;
+import com.lions.dev.repository.UsersRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jakarta.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+/**
+ * Service de gestion des amitiés. Ce service gère l'envoi, l'acceptation, le rejet et la
+ * suppression d'amitiés.
+ */
+@ApplicationScoped
+public class FriendshipService {
+
+  @Inject FriendshipRepository friendshipRepository;
+
+  @Inject UsersRepository usersRepository;
+
+  /**
+   * Envoie une demande d'amitié entre deux utilisateurs.
+   *
+   * @param userId L'ID de l'utilisateur qui envoie la demande.
+   * @param friendId L'ID de l'utilisateur qui reçoit la demande.
+   * @return La relation d'amitié créée.
+   * @throws UserNotFoundException Si l'un des utilisateurs n'est pas trouvé.
+   */
+  @Transactional
+  public Friendship sendFriendRequest(UUID userId, UUID friendId) {
+    System.out.println(
+        "[LOG] Envoi de demande d'amitié de l'utilisateur "
+            + userId
+            + " à l'utilisateur "
+            + friendId);
+
+    Users user = usersRepository.findById(userId);
+    Users friend = usersRepository.findById(friendId);
+
+    if (user == null || friend == null) {
+      System.out.println(
+          "[ERROR] Utilisateur non trouvé pour l'ID : " + (user == null ? userId : friendId));
+      throw new UserNotFoundException("L'utilisateur avec l'ID spécifié n'existe pas.");
+    }
+
+    Optional<Friendship> existingFriendship = friendshipRepository.findByUsers(user, friend);
+    if (existingFriendship.isPresent()) {
+      System.out.println("[ERROR] Une relation d'amitié existe déjà entre ces deux utilisateurs.");
+      throw new IllegalArgumentException("Relation d'amitié déjà existante.");
+    }
+
+    Friendship friendship =
+        Friendship.builder().user(user).friend(friend).status(FriendshipStatus.PENDING).build();
+
+    friendshipRepository.persist(friendship);
+    System.out.println(
+        "[LOG] Demande d'amitié envoyée de " + user.getEmail() + " à " + friend.getEmail());
+
+    return friendship;
+  }
+
+  /**
+   * Accepte une demande d'amitié.
+   *
+   * @param friendshipId L'ID de la demande d'amitié.
+   * @return La relation d'amitié acceptée.
+   * @throws FriendshipNotFoundException Si la relation d'amitié n'est pas trouvée.
+   */
+  @Transactional
+  public Friendship acceptFriendRequest(UUID friendshipId) {
+    System.out.println("[LOG] Acceptation de la demande d'amitié avec l'ID : " + friendshipId);
+
+    Friendship friendship =
+        friendshipRepository
+            .findById(friendshipId)
+            .orElseThrow(() -> new FriendshipNotFoundException("Demande d'amitié introuvable."));
+
+    if (friendship.getStatus() == FriendshipStatus.ACCEPTED) {
+      System.out.println("[ERROR] La demande d'amitié a déjà été acceptée.");
+      throw new IllegalArgumentException("Cette demande d'amitié a déjà été acceptée.");
+    }
+
+    friendship.setStatus(FriendshipStatus.ACCEPTED);
+    friendshipRepository.persist(friendship);
+    System.out.println(
+        "[LOG] Demande d'amitié acceptée entre "
+            + friendship.getUser().getEmail()
+            + " et "
+            + friendship.getFriend().getEmail());
+
+    return friendship;
+  }
+
+  /**
+   * Rejette une demande d'amitié.
+   *
+   * @param friendshipId L'ID de la demande d'amitié.
+   * @throws FriendshipNotFoundException Si la relation d'amitié n'est pas trouvée.
+   */
+  @Transactional
+  public void rejectFriendRequest(UUID friendshipId) {
+    System.out.println("[LOG] Rejet de la demande d'amitié avec l'ID : " + friendshipId);
+
+    Friendship friendship =
+        friendshipRepository
+            .findById(friendshipId)
+            .orElseThrow(() -> new FriendshipNotFoundException("Demande d'amitié introuvable."));
+
+    friendship.setStatus(FriendshipStatus.REJECTED);
+    friendshipRepository.persist(friendship);
+    System.out.println(
+        "[LOG] Demande d'amitié rejetée entre "
+            + friendship.getUser().getEmail()
+            + " et "
+            + friendship.getFriend().getEmail());
+  }
+
+  /**
+   * Supprime une relation d'amitié.
+   *
+   * @param friendshipId L'ID de la relation d'amitié à supprimer.
+   * @throws FriendshipNotFoundException Si la relation d'amitié n'est pas trouvée.
+   */
+  @Transactional
+  public void removeFriend(UUID friendshipId) {
+    System.out.println("[LOG] Suppression de la relation d'amitié avec l'ID : " + friendshipId);
+
+    Friendship friendship =
+        friendshipRepository
+            .findById(friendshipId)
+            .orElseThrow(() -> new FriendshipNotFoundException("Amitié introuvable."));
+
+    friendshipRepository.deleteFriendship(friendship); // Appel à deleteFriendship
+    System.out.println(
+        "[LOG] Amitié supprimée entre "
+        + friendship.getUser().getEmail()
+        + " et "
+        + friendship.getFriend().getEmail());
+  }
+
+  /**
+   * Récupère la liste des amis d'un utilisateur avec pagination.
+   *
+   * @param userId L'ID de l'utilisateur.
+   * @param page Le numéro de la page à récupérer.
+   * @param size Le nombre d'éléments par page.
+   * @return La liste paginée des relations d'amitié.
+   * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé.
+   */
+  public List<Friendship> listFriends(UUID userId, int page, int size) {
+    System.out.println(
+        "[LOG] Récupération de la liste paginée des amis pour l'utilisateur avec l'ID : " + userId);
+
+    Users user = usersRepository.findById(userId);
+    if (user == null) {
+      System.out.println("[ERROR] Utilisateur non trouvé pour l'ID : " + userId);
+      throw new UserNotFoundException("Utilisateur non trouvé.");
+    }
+
+    return friendshipRepository.findFriendsByUser(user, page, size);
+  }
+
+  /**
+   * Récupère toutes les demandes d'amitié avec un statut spécifique.
+   *
+   * @param user L'utilisateur.
+   * @param status Le statut des demandes d'amitié à récupérer (PENDING, ACCEPTED, REJECTED).
+   * @param page Le numéro de la page à récupérer.
+   * @param size Le nombre d'éléments par page.
+   * @return La liste paginée des relations d'amitié avec le statut spécifié.
+   */
+  public List<Friendship> listFriendRequestsByStatus(Users user, FriendshipStatus status, int page, int size) {
+    System.out.println("[LOG] Récupération des demandes d'amitié avec le statut : " + status);
+    return friendshipRepository.findByUserAndStatus(user, status, page, size);
+  }
+
+}

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

@@ -1,129 +0,0 @@
-package com.lions.dev.service;
-
-import com.lions.dev.entity.users.Users;
-import com.lions.dev.repository.UsersRepository;
-import com.lions.dev.exception.UserNotFoundException;
-import jakarta.enterprise.context.ApplicationScoped;
-import jakarta.inject.Inject;
-import java.util.Optional;
-import java.util.UUID;
-
-/**
- * Service de gestion des utilisateurs.
- * Ce service contient la logique métier pour la création, récupération et suppression des utilisateurs.
- */
-@ApplicationScoped
-public class UserService {
-
-  @Inject
-  UsersRepository usersRepository;
-
-  /**
-   * Crée un nouvel utilisateur dans le système.
-   *
-   * @param userCreateRequestDTO Le DTO contenant les informations de l'utilisateur à créer.
-   * @return L'utilisateur créé.
-   */
-  public Users createUser(com.lions.dev.dto.request.users.UserCreateRequestDTO userCreateRequestDTO) {
-    Users user = new Users();
-    user.setNom(userCreateRequestDTO.getNom());
-    user.setPrenoms(userCreateRequestDTO.getPrenoms());
-    user.setEmail(userCreateRequestDTO.getEmail());
-    user.setMotDePasse(userCreateRequestDTO.getMotDePasse()); // Hachage automatique
-
-    // Vérifier si le rôle est défini, sinon attribuer un rôle par défaut
-    if (userCreateRequestDTO.getRole() == null || userCreateRequestDTO.getRole().isEmpty()) {
-      user.setRole("USER"); // Assigner un rôle par défaut, par exemple "USER"
-    } else {
-      user.setRole(userCreateRequestDTO.getRole());
-    }
-
-    usersRepository.persist(user);
-    System.out.println("[LOG] Utilisateur créé : " + user.getEmail());
-    return user;
-  }
-
-  /**
-   * Met à jour un utilisateur existant dans le système.
-   *
-   * @param user L'utilisateur à mettre à jour.
-   * @return L'utilisateur mis à jour.
-   */
-  public Users updateUser(Users user) {
-    try {
-      Users existingUser = usersRepository.findById(user.getId());
-      if (existingUser == null) {
-        System.out.println("[ERROR] Utilisateur non trouvé pour la mise à jour avec l'ID : " + user.getId());
-        throw new UserNotFoundException("Utilisateur non trouvé avec l'ID : " + user.getId());
-      }
-
-      // Mettre à jour les champs de l'utilisateur existant
-      existingUser.setNom(user.getNom());
-      existingUser.setPrenoms(user.getPrenoms());
-      existingUser.setEmail(user.getEmail());
-      existingUser.setMotDePasse(user.getMotDePasse()); // Hachage automatique si nécessaire
-      existingUser.setRole(user.getRole());
-
-      usersRepository.persist(existingUser);
-      System.out.println("[LOG] Utilisateur mis à jour avec succès : " + existingUser.getEmail());
-      return existingUser;
-    } catch (Exception e) {
-      System.out.println("[ERROR] Erreur lors de la mise à jour de l'utilisateur : " + e.getMessage());
-      throw e;
-    }
-  }
-
-
-  /**
-   * Authentifie un utilisateur avec son email et son mot de passe.
-   *
-   * @param email L'email de l'utilisateur.
-   * @param motDePasse Le mot de passe de l'utilisateur.
-   * @return L'utilisateur authentifié.
-   * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé ou si le mot de passe est incorrect.
-   */
-  public Users authenticateUser(String email, String motDePasse) {
-    Optional<Users> userOptional = usersRepository.findByEmail(email);
-    if (userOptional.isEmpty() || !userOptional.get().verifierMotDePasse(motDePasse)) {
-      System.out.println("[ERROR] Échec de l'authentification pour l'email : " + email);
-      throw new UserNotFoundException("Utilisateur ou mot de passe incorrect.");
-    }
-    System.out.println("[LOG] Utilisateur authentifié : " + email);
-    return userOptional.get();
-  }
-
-  /**
-   * Récupère un utilisateur par son ID.
-   *
-   * @param id L'ID de l'utilisateur.
-   * @return L'utilisateur trouvé.
-   * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé.
-   */
-  public Users getUserById(UUID id) {
-    Users user = usersRepository.findById(id);
-    if (user == null) {
-      System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id);
-      throw new UserNotFoundException("Utilisateur non trouvé avec l'ID : " + id);
-    }
-    System.out.println("[LOG] Utilisateur trouvé avec l'ID : " + id);
-    return user;
-  }
-
-  /**
-   * Supprime un utilisateur par son ID.
-   *
-   * @param id L'ID de l'utilisateur à supprimer.
-   * @return true si l'utilisateur a été supprimé, false sinon.
-   */
-  public boolean deleteUser(UUID id) {
-    boolean deleted = usersRepository.deleteById(id);
-    if (deleted) {
-      System.out.println("[LOG] Utilisateur supprimé avec succès : " + id);
-    } else {
-      System.out.println("[ERROR] Échec de la suppression de l'utilisateur avec l'ID : " + id);
-    }
-    return deleted;
-  }
-
-
-}

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

@@ -0,0 +1,191 @@
+package com.lions.dev.service;
+
+import com.lions.dev.dto.request.users.UserCreateRequestDTO;
+import com.lions.dev.entity.users.Users;
+import com.lions.dev.exception.UserNotFoundException;
+import com.lions.dev.repository.UsersRepository;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jakarta.transaction.Transactional;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+/**
+ * Service de gestion des utilisateurs.
+ * Ce service contient la logique métier pour la création, récupération et suppression des utilisateurs.
+ */
+@ApplicationScoped
+public class UsersService {
+
+  @Inject
+  UsersRepository usersRepository;
+
+  /**
+   * Crée un nouvel utilisateur dans le système.
+   *
+   * @param userCreateRequestDTO Le DTO contenant les informations de l'utilisateur à créer.
+   * @return L'utilisateur créé.
+   */
+  public Users createUser(UserCreateRequestDTO userCreateRequestDTO) {
+    Users user = new Users();
+    user.setNom(userCreateRequestDTO.getNom());
+    user.setPrenoms(userCreateRequestDTO.getPrenoms());
+    user.setEmail(userCreateRequestDTO.getEmail());
+    user.setMotDePasse(userCreateRequestDTO.getMotDePasse()); // Hachage automatique
+
+    // Vérifier si le profile image est défini, sinon attribuer une image par défaut
+    if (userCreateRequestDTO.getProfileImageUrl() == null
+        || userCreateRequestDTO.getProfileImageUrl().isEmpty()) {
+      user.setProfileImageUrl("https://via.placeholder.com/150"); // Assigner une image par défaut
+    } else {
+      user.setProfileImageUrl(userCreateRequestDTO.getProfileImageUrl());
+    }
+
+    // Vérifier si le rôle est défini, sinon attribuer un rôle par défaut
+    if (userCreateRequestDTO.getRole() == null || userCreateRequestDTO.getRole().isEmpty()) {
+      user.setRole("USER"); // Assigner un rôle par défaut
+    } else {
+      user.setRole(userCreateRequestDTO.getRole());
+    }
+
+    usersRepository.persist(user);
+    System.out.println("[LOG] Utilisateur créé : " + user.getEmail());
+    return user;
+  }
+
+  /**
+   * Met à jour un utilisateur existant dans le système.
+   *
+   * @param id L'ID de l'utilisateur à mettre à jour.
+   * @param userCreateRequestDTO Les nouvelles informations de l'utilisateur.
+   * @return L'utilisateur mis à jour.
+   * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé.
+   */
+  @Transactional
+  public Users updateUser(UUID id, UserCreateRequestDTO userCreateRequestDTO) {
+    Users existingUser = usersRepository.findById(id);
+    if (existingUser == null) {
+      System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id);
+      throw new UserNotFoundException("Utilisateur non trouvé avec l'ID : " + id);
+    }
+
+    // Mettre à jour les champs de l'utilisateur existant
+    existingUser.setNom(userCreateRequestDTO.getNom());
+    existingUser.setPrenoms(userCreateRequestDTO.getPrenoms());
+    existingUser.setEmail(userCreateRequestDTO.getEmail());
+    existingUser.setMotDePasse(userCreateRequestDTO.getMotDePasse()); // Hachage automatique si nécessaire
+    existingUser.setRole(userCreateRequestDTO.getRole());
+    existingUser.setProfileImageUrl(userCreateRequestDTO.getProfileImageUrl());
+
+    usersRepository.persist(existingUser);
+    System.out.println("[LOG] Utilisateur mis à jour avec succès : " + existingUser.getEmail());
+    return existingUser;
+  }
+  /**
+   * Met à jour l'image de profil d'un utilisateur existant dans le système.
+   *
+   * @param id L'ID de l'utilisateur à mettre à jour.
+   * @param profileImageUrl Les nouvelles informations de l'utilisateur.
+   * @return L'utilisateur mis à jour.
+   * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé.
+   */
+  @Transactional
+  public Users updateUserProfileImage(UUID id, String profileImageUrl) {
+    Users existingUser = usersRepository.findById(id);
+    if (existingUser == null) {
+      System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id);
+      throw new UserNotFoundException("Utilisateur non trouvé avec l'ID : " + id);
+    }
+
+    // Mettre à jour les champs de l'utilisateur existant
+    existingUser.setProfileImageUrl(profileImageUrl);
+
+    usersRepository.persist(existingUser);
+    System.out.println("[LOG] L'image de profile de l\'Utilisateur mis à jour avec succès : " + existingUser.getEmail());
+    return existingUser;
+  }
+
+  /**
+   * Liste tous les utilisateurs avec pagination.
+   *
+   * @param page Le numéro de la page à récupérer.
+   * @param size Le nombre d'utilisateurs par page.
+   * @return La liste des utilisateurs paginée.
+   */
+  public List<Users> listUsers(int page, int size) {
+    return usersRepository.findAll().page(page - 1, size).list();
+  }
+
+  /**
+   * Authentifie un utilisateur avec son email et son mot de passe.
+   *
+   * @param email L'email de l'utilisateur.
+   * @param motDePasse Le mot de passe de l'utilisateur.
+   * @return L'utilisateur authentifié.
+   * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé ou si le mot de passe est incorrect.
+   */
+  public Users authenticateUser(String email, String motDePasse) {
+    Optional<Users> userOptional = usersRepository.findByEmail(email);
+    if (userOptional.isEmpty() || !userOptional.get().verifierMotDePasse(motDePasse)) {
+      System.out.println("[ERROR] Échec de l'authentification pour l'email : " + email);
+      throw new UserNotFoundException("Utilisateur ou mot de passe incorrect.");
+    }
+    System.out.println("[LOG] Utilisateur authentifié : " + email);
+    return userOptional.get();
+  }
+
+  /**
+   * Récupère un utilisateur par son ID.
+   *
+   * @param id L'ID de l'utilisateur.
+   * @return L'utilisateur trouvé.
+   * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé.
+   */
+  public Users getUserById(UUID id) {
+    Users user = usersRepository.findById(id);
+    if (user == null) {
+      System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id);
+      throw new UserNotFoundException("Utilisateur non trouvé avec l'ID : " + id);
+    }
+    System.out.println("[LOG] Utilisateur trouvé avec l'ID : " + id);
+    return user;
+  }
+
+  /**
+   * Réinitialise le mot de passe d'un utilisateur.
+   *
+   * @param id L'ID de l'utilisateur.
+   * @param newPassword Le nouveau mot de passe à définir.
+   * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé.
+   */
+  @Transactional
+  public void resetPassword(UUID id, String newPassword) {
+    Users user = usersRepository.findById(id);
+    if (user == null) {
+      System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id);
+      throw new UserNotFoundException("Utilisateur non trouvé.");
+    }
+
+    user.setMotDePasse(newPassword); // Hachage automatique
+    usersRepository.persist(user);
+    System.out.println("[LOG] Mot de passe réinitialisé pour l'utilisateur : " + user.getEmail());
+  }
+
+  /**
+   * Supprime un utilisateur par son ID.
+   *
+   * @param id L'ID de l'utilisateur à supprimer.
+   * @return true si l'utilisateur a été supprimé, false sinon.
+   */
+  public boolean deleteUser(UUID id) {
+    boolean deleted = usersRepository.deleteById(id);
+    if (deleted) {
+      System.out.println("[LOG] Utilisateur supprimé avec succès : " + id);
+    } else {
+      System.out.println("[ERROR] Échec de la suppression de l'utilisateur avec l'ID : " + id);
+    }
+    return deleted;
+  }
+}