Refactoring

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

@@ -5,17 +5,19 @@ 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;
+import org.jboss.logging.Logger;
 
 /**
  * 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<Exception> {
+public class GlobalExceptionHandler implements ExceptionMapper<Throwable> {
+
+  private static final Logger logger = Logger.getLogger(GlobalExceptionHandler.class);
 
   /**
    * Gère les exceptions non traitées et retourne une réponse appropriée.
@@ -24,18 +26,26 @@ public class GlobalExceptionHandler implements ExceptionMapper<Exception> {
    * @return Une réponse HTTP avec un message d'erreur et le code de statut approprié.
    */
   @Override
-  public Response toResponse(Exception exception) {
+  public Response toResponse(Throwable exception) {
     if (exception instanceof BadRequestException) {
+      logger.warn("BadRequestException intercepted: " + exception.getMessage());
       return buildResponse(Response.Status.BAD_REQUEST, exception.getMessage());
     } else if (exception instanceof EventNotFoundException || exception instanceof NotFoundException) {
+      logger.warn("NotFoundException intercepted: " + exception.getMessage());
       return buildResponse(Response.Status.NOT_FOUND, exception.getMessage());
     } else if (exception instanceof UnauthorizedException) {
+      logger.warn("UnauthorizedException intercepted: " + exception.getMessage());
       return buildResponse(Response.Status.UNAUTHORIZED, exception.getMessage());
     } else if (exception instanceof ServerException) {
+      logger.error("ServerException intercepted: " + exception.getMessage());
       return buildResponse(Response.Status.INTERNAL_SERVER_ERROR, "Erreur interne du serveur.");
+    } else if (exception instanceof RuntimeException) {
+      logger.error("RuntimeException intercepted: " + exception.getMessage());
+      return buildResponse(Response.Status.INTERNAL_SERVER_ERROR, "Erreur inattendue.");
+    } else {
+      logger.error("Unexpected error: " + exception.getMessage(), exception);
+      return buildResponse(Response.Status.INTERNAL_SERVER_ERROR, "Erreur inattendue : " + exception.getMessage());
     }
-
-    return buildResponse(Response.Status.INTERNAL_SERVER_ERROR, "Erreur inattendue : " + exception.getMessage());
   }
 
   /**

src/main/java/com/lions/dev/dto/request/events/EventReadOneByIdRequestDTO.java

@@ -9,12 +9,12 @@ import java.util.UUID;
  */
 @lombok.Getter
 @lombok.Setter
-public class EventGetOneByIdRequestDTO {
+public class EventReadOneByIdRequestDTO {
 
   @NotNull(message = "L'ID de l'événement est obligatoire.")
   private UUID eventId; // ID de l'événement à lire
 
-  public EventGetOneByIdRequestDTO() {
+  public EventReadOneByIdRequestDTO() {
     System.out.println("[LOG] DTO de requête de lecture d'événement initialisé.");
   }
 }

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

@@ -13,12 +13,18 @@ import java.util.UUID;
 @Getter
 @Setter
 @NoArgsConstructor
-public class FriendshipRequestDTO {
+public class FriendshipCreateOneRequestDTO {
 
   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) {
+  /**
+   * Constructeur avec paramètres pour initialiser les IDs.
+   *
+   * @param userId L'ID de l'utilisateur qui envoie la demande d'amitié.
+   * @param friendId L'ID de l'utilisateur qui reçoit la demande d'amitié.
+   */
+  public FriendshipCreateOneRequestDTO(UUID userId, UUID friendId) {
     this.userId = userId;
     this.friendId = friendId;
   }

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

@@ -0,0 +1,31 @@
+package com.lions.dev.dto.request.friends;
+
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.UUID;
+
+/**
+ * DTO pour récupérer les détails d'un ami.
+ * Contient les informations nécessaires pour récupérer les détails d'un ami spécifique.
+ */
+@Getter
+@Setter
+@NoArgsConstructor
+public class FriendshipReadFriendDetailsRequestDTO {
+
+  private UUID userId;   // ID de l'utilisateur demandant les détails
+  private UUID friendId; // ID de l'ami dont les détails sont requis
+
+  /**
+   * Constructeur avec paramètres pour initialiser les IDs.
+   *
+   * @param userId L'ID de l'utilisateur demandant les détails de l'ami.
+   * @param friendId L'ID de l'ami dont les détails sont requis.
+   */
+  public FriendshipReadFriendDetailsRequestDTO(UUID userId, UUID friendId) {
+    this.userId = userId;
+    this.friendId = friendId;
+  }
+}

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

@@ -0,0 +1,38 @@
+package com.lions.dev.dto.request.friends;
+
+import com.lions.dev.entity.friends.FriendshipStatus;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.UUID;
+
+/**
+ * DTO de requête pour récupérer les demandes d'amitié par statut.
+ * Contient les informations nécessaires pour filtrer les demandes d'amitié d'un utilisateur.
+ */
+@Getter
+@Setter
+@NoArgsConstructor
+public class FriendshipReadStatusRequestDTO {
+
+  private UUID userId; // ID de l'utilisateur
+  private FriendshipStatus status; // Statut des demandes (PENDING, ACCEPTED, REJECTED)
+  private int page = 1; // Numéro de la page pour la pagination
+  private int size = 10; // Taille de la page pour la pagination
+
+  /**
+   * Constructeur avec paramètres pour initialiser les informations de la demande.
+   *
+   * @param userId ID de l'utilisateur
+   * @param status Statut des demandes à récupérer
+   * @param page Numéro de la page pour la pagination
+   * @param size Nombre d'éléments par page
+   */
+  public FriendshipReadStatusRequestDTO(UUID userId, FriendshipStatus status, int page, int size) {
+    this.userId = userId;
+    this.status = status;
+    this.page = page;
+    this.size = size;
+  }
+}

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

@@ -16,16 +16,21 @@ import java.util.UUID;
 @Getter
 @Setter
 @NoArgsConstructor
-public class FriendshipResponseDTO {
+public class FriendshipCreateOneResponseDTO {
 
-  private UUID id;
+  private UUID id; // ID de la relation d'amitié
-  private UUID userId;
+  private UUID userId; // ID de l'utilisateur qui a envoyé la demande
-  private UUID friendId;
+  private UUID friendId; // ID de l'utilisateur qui a reçu la demande
-  private FriendshipStatus status;
+  private FriendshipStatus status; // Statut de la relation d'amitié (PENDING, ACCEPTED, REJECTED)
-  private LocalDateTime createdAt;
+  private LocalDateTime createdAt; // Date de création de la relation d'amitié
-  private LocalDateTime updatedAt;
+  private LocalDateTime updatedAt; // Date de la dernière mise à jour
 
-  public FriendshipResponseDTO(Friendship friendship) {
+  /**
+   * Constructeur pour mapper l'entité `Friendship` à ce DTO.
+   *
+   * @param friendship L'entité `Friendship` à convertir en DTO.
+   */
+  public FriendshipCreateOneResponseDTO(Friendship friendship) {
     this.id = friendship.getId();
     this.userId = friendship.getUser().getId();
     this.friendId = friendship.getFriend().getId();

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

@@ -0,0 +1,54 @@
+package com.lions.dev.dto.response.friends;
+
+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 détails d'un ami.
+ * Contient toutes les informations disponibles sur un ami spécifique.
+ */
+@Getter
+@Setter
+@NoArgsConstructor
+public class FriendshipReadFriendDetailsResponseDTO {
+
+  private UUID userId;       // ID de l'utilisateur qui a initié la relation
+  private UUID friendId;     // ID de l'ami
+  private String friendLastName; // Nom de l'ami
+  private String friendFirstName; // Prénom de l'ami
+  private String friendEmail; // Email de l'ami
+  private FriendshipStatus status; // Statut de la relation d'amitié
+  private LocalDateTime createdAt; // Date de création de la relation d'amitié
+  private LocalDateTime updatedAt; // Date de la dernière mise à jour de la relation
+
+  /**
+   * Constructeur pour initialiser le DTO avec des informations sur l'ami.
+   *
+   * @param userId L'ID de l'utilisateur initiant la demande d'amitié.
+   * @param friendId L'ID de l'ami.
+   * @param friendLastName Le nom de l'ami.
+   * @param friendFirstName Le prénom de l'ami.
+   * @param friendEmail L'email de l'ami.
+   * @param status Le statut de la relation d'amitié.
+   * @param createdAt La date de création de la relation.
+   * @param updatedAt La date de la dernière mise à jour de la relation.
+   */
+  public FriendshipReadFriendDetailsResponseDTO(UUID userId, UUID friendId, String friendLastName,
+                                                String friendFirstName,
+                                                String friendEmail, FriendshipStatus status,
+                                                LocalDateTime createdAt, LocalDateTime updatedAt) {
+    this.userId = userId;
+    this.friendId = friendId;
+    this.friendLastName = friendLastName;
+    this.friendFirstName = friendFirstName;
+    this.friendEmail = friendEmail;
+    this.status = status;
+    this.createdAt = createdAt;
+    this.updatedAt = updatedAt;
+  }
+}

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

@@ -0,0 +1,47 @@
+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é filtrées par statut.
+ * Contient les informations essentielles sans données sensibles.
+ */
+@Getter
+@Setter
+@NoArgsConstructor
+public class FriendshipReadStatusResponseDTO {
+
+  private UUID friendshipId; // ID de la relation d'amitié
+  private UUID userId; // ID de l'utilisateur ayant initié la demande
+  private String userNom; // Nom de l'utilisateur ayant initié la demande
+  private String userPrenoms; // Prénoms de l'utilisateur ayant initié la demande
+  private UUID friendId; // ID de l'utilisateur ayant reçu la demande
+  private String friendNom; // Nom de l'utilisateur ayant reçu la demande
+  private String friendPrenoms; // Prénoms de l'utilisateur ayant reçu la demande
+  private FriendshipStatus status; // Statut de la demande d'amitié
+  private LocalDateTime createdAt; // Date de création de la demande
+
+  /**
+   * Constructeur qui mappe directement l'entité `Friendship` à ce DTO.
+   *
+   * @param friendship L'entité `Friendship` à convertir en DTO.
+   */
+  public FriendshipReadStatusResponseDTO(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/FriendshipRequestStatusResponseDTO.java

@@ -1,57 +0,0 @@
-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/entity/friends/Friendship.java

@@ -1,29 +1,22 @@
 package com.lions.dev.entity.friends;
 
-import com.lions.dev.entity.BaseEntity; // Import de BaseEntity
+import com.lions.dev.entity.BaseEntity;
 import com.lions.dev.entity.users.Users;
 import jakarta.persistence.*;
-import lombok.AllArgsConstructor;
+import lombok.*;
-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. */
- * Représentation de l'entité Friendship qui gère les relations d'amitié entre utilisateurs.
- */
 @Entity
 @Getter
 @Setter
 @NoArgsConstructor
 @AllArgsConstructor
-@ToString
 @Builder
+@ToString
 @Table(name = "friendships")
-public class Friendship extends BaseEntity { // Hérite de BaseEntity
+public class Friendship extends BaseEntity {
 
-  // L'utilisateur qui a initié la demande d'ami
+  // Utilisateur qui initie la demande
   @ManyToOne(fetch = FetchType.LAZY)
   @JoinColumn(name = "user_id", nullable = false)
   private Users user;
@@ -39,16 +32,18 @@ public class Friendship extends BaseEntity { // Hérite de BaseEntity
   private FriendshipStatus status;
 
   /**
-   * Log des changements de statut de l'amitié.
+   * Mise à jour du statut de la relation d'amitié avec log des changements.
+   *
+   * @param newStatus Nouveau statut de l'amitié
    */
   public void setStatus(FriendshipStatus newStatus) {
     this.status = newStatus;
     System.out.println(
-        "[LOG] Changement de statut pour l'amitié entre "
+        "[LOG] Statut changé pour l'amitié entre "
-        + this.user.getEmail()
+            + this.user.getEmail()
-        + " et "
+            + " et "
-        + this.friend.getEmail()
+            + this.friend.getEmail()
-        + " - Nouveau statut : "
+            + " - Nouveau statut : "
-        + this.status);
+            + this.status);
   }
 }

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

@@ -8,8 +8,4 @@ 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

@@ -3,7 +3,7 @@ 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 io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
 import jakarta.enterprise.context.ApplicationScoped;
 
 import java.util.List;
@@ -12,26 +12,29 @@ import java.util.UUID;
 
 /**
  * Repository pour gérer les relations d'amitié (Friendship) dans la base de données.
+ * Il contient des méthodes pour récupérer, ajouter, et supprimer des relations d'amitié.
  */
 @ApplicationScoped
-public class FriendshipRepository implements PanacheRepository<Friendship> {
+public class FriendshipRepository implements PanacheRepositoryBase<Friendship, UUID> {
 
   /**
-   * Trouve une relation d'amitié entre deux utilisateurs.
+   * Trouver une relation d'amitié entre deux utilisateurs.
    *
-   * @param user L'utilisateur qui envoie la demande.
+   * @param user   L'utilisateur qui envoie la demande d'amitié.
    * @param friend L'ami qui reçoit la demande.
-   * @return Une Optional contenant la relation d'amitié, si elle existe.
+   * @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.
+   * Récupérer la liste des amis d'un utilisateur, c'est-à-dire toutes les relations acceptées.
    *
    * @param user L'utilisateur dont on souhaite récupérer les amis.
-   * @return Une liste de relations d'amitié.
+   * @param page Le numéro de la page à récupérer.
+   * @param size La taille de la page (nombre d'éléments).
+   * @return Une liste paginée de relations d'amitié acceptées.
    */
   public List<Friendship> findFriendsByUser(Users user, int page, int size) {
     return find("(user = ?1 or friend = ?1) and status = ?2", user, FriendshipStatus.ACCEPTED)
@@ -40,37 +43,13 @@ public class FriendshipRepository implements PanacheRepository<Friendship> {
   }
 
   /**
-   * Trouve une relation d'amitié par son ID.
+   * Récupérer toutes les relations d'amitié d'un utilisateur avec un statut spécifique.
    *
-   * @param id L'ID de la relation d'amitié.
+   * @param user   L'utilisateur dont on souhaite récupérer les amitiés.
-   * @return Une Optional contenant la relation d'amitié, si elle existe.
+   * @param status Le statut des relations d'amitié à filtrer.
-   */
+   * @param page   Le numéro de la page.
-  public Optional<Friendship> findById(UUID id) {
+   * @param size   La taille de la page.
-    return find("id", id).firstResultOptional();
+   * @return Une liste paginée de relations d'amitié avec le statut spécifié.
-  }
-
-  /**
-   * 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)

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

@@ -1,12 +1,11 @@
 package com.lions.dev.resource;
 
-import com.lions.dev.dto.request.friends.FriendshipRequestDTO;
+import com.lions.dev.dto.request.friends.FriendshipCreateOneRequestDTO;
-import com.lions.dev.dto.response.friends.FriendshipRequestStatusResponseDTO;
+import com.lions.dev.dto.request.friends.FriendshipReadFriendDetailsRequestDTO;
-import com.lions.dev.dto.response.friends.FriendshipResponseDTO;
+import com.lions.dev.dto.request.friends.FriendshipReadStatusRequestDTO;
-import com.lions.dev.entity.friends.Friendship;
+import com.lions.dev.dto.response.friends.FriendshipCreateOneResponseDTO;
-import com.lions.dev.entity.friends.FriendshipStatus;
+import com.lions.dev.dto.response.friends.FriendshipReadFriendDetailsResponseDTO;
-import com.lions.dev.entity.users.Users;
+import com.lions.dev.dto.response.friends.FriendshipReadStatusResponseDTO;
-import com.lions.dev.repository.UsersRepository;
 import com.lions.dev.service.FriendshipService;
 import jakarta.inject.Inject;
 import jakarta.validation.Valid;
@@ -17,7 +16,6 @@ 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;
@@ -27,46 +25,45 @@ 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
+ * rejeter et supprimer des demandes d'amitié. Toutes les opérations sont loguées pour faciliter le
- * déroulement en temps réel.
+ * suivi en temps réel.
  */
 @Path("/friends")
-@Produces(MediaType.APPLICATION_JSON)
+@Produces(MediaType.APPLICATION_JSON) // Assure que la réponse sera en JSON
-@Consumes(MediaType.APPLICATION_JSON)
+@Consumes(MediaType.APPLICATION_JSON) // Assure que la requête attend du JSON
 @Tag(name = "Friendship", description = "Opérations liées à la gestion des amis")
 public class FriendshipResource {
 
-  @Inject
+  @Inject FriendshipService friendshipService; // Injection du service d'amitié
-  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.
+   * @param request DTO contenant l'ID de l'utilisateur qui envoie la demande et l'utilisateur qui
+   *     la reçoit.
    * @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")
+      description = "Permet à un utilisateur d'envoyer une demande d'amitié")
   @APIResponses({
     @APIResponse(
         responseCode = "200",
-        description = "Demande d'amitié envoyée",
+        description = "Demande d'amitié envoyée avec succès",
         content =
             @Content(
                 mediaType = MediaType.APPLICATION_JSON,
-                schema = @Schema(implementation = FriendshipResponseDTO.class))),
+                schema = @Schema(implementation = FriendshipCreateOneResponseDTO.class))),
     @APIResponse(responseCode = "400", description = "Requête invalide"),
-    @APIResponse(responseCode = "500", description = "Erreur interne du serveur")
+    @APIResponse(
+        responseCode = "500",
+        description = "Erreur serveur lors de l'envoi de la demande d'amitié")
   })
-  public Response sendFriendRequest(@Valid @NotNull FriendshipRequestDTO request) {
+  public Response sendFriendRequest(@Valid @NotNull FriendshipCreateOneRequestDTO request) {
     logger.info(
         "[LOG] Reçu une demande pour envoyer une demande d'amitié de l'utilisateur "
             + request.getUserId()
@@ -74,16 +71,17 @@ public class FriendshipResource {
             + request.getFriendId());
 
     try {
-      Friendship friendship =
+      // Appel du service pour envoyer la demande d'amitié
-          friendshipService.sendFriendRequest(request.getUserId(), request.getFriendId());
+      FriendshipCreateOneResponseDTO friendshipResponse =
+          friendshipService.sendFriendRequest(request);
       logger.info(
-          "[LOG] Demande d'amitié envoyée avec succès : "
+          "[LOG] Demande d'amitié envoyée avec succès entre les utilisateurs "
-              + friendship.getUser().getEmail()
+              + friendshipResponse.getUserId()
-              + " à "
+              + " et "
-              + friendship.getFriend().getEmail());
+              + friendshipResponse.getFriendId());
-      return Response.ok(new FriendshipResponseDTO(friendship)).build();
+      return Response.ok(friendshipResponse).build();
     } catch (Exception e) {
-      logger.error("[ERROR] Erreur lors de l'envoi de la demande d'amitié : " + e.getMessage());
+      logger.error("[ERROR] Erreur lors de l'envoi de la demande d'amitié : " + e.getMessage(), e);
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
           .entity("{\"message\": \"Erreur lors de l'envoi de la demande d'amitié.\"}")
           .build();
@@ -108,30 +106,28 @@ public class FriendshipResource {
         content =
             @Content(
                 mediaType = MediaType.APPLICATION_JSON,
-                schema = @Schema(implementation = FriendshipResponseDTO.class))),
+                schema = @Schema(implementation = FriendshipCreateOneResponseDTO.class))),
     @APIResponse(responseCode = "404", description = "Demande d'amitié non trouvée"),
-    @APIResponse(responseCode = "500", description = "Erreur interne du serveur")
+    @APIResponse(
+        responseCode = "500",
+        description = "Erreur lors de l'acceptation de la demande d'amitié")
   })
   public Response acceptFriendRequest(@PathParam("friendshipId") UUID friendshipId) {
     logger.info(
-        "[LOG] Reçu une demande pour accepter une demande d'amitié avec l'ID : " + friendshipId);
+        "[LOG] Reçu une demande pour accepter la demande d'amitié avec l'ID : " + friendshipId);
 
     try {
-      Friendship friendship = friendshipService.acceptFriendRequest(friendshipId);
+      FriendshipCreateOneResponseDTO friendshipResponse =
+          friendshipService.acceptFriendRequest(friendshipId);
       logger.info(
-          "[LOG] Demande d'amitié acceptée entre "
+          "[LOG] Demande d'amitié acceptée avec succès entre les utilisateurs "
-              + friendship.getUser().getEmail()
+              + friendshipResponse.getUserId()
               + " et "
-              + friendship.getFriend().getEmail());
+              + friendshipResponse.getFriendId());
-      return Response.ok(new FriendshipResponseDTO(friendship)).build();
+      return Response.ok(friendshipResponse).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());
+          "[ERROR] Erreur lors de l'acceptation de la demande d'amitié : " + e.getMessage(), e);
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
           .entity("{\"message\": \"Erreur lors de l'acceptation de la demande d'amitié.\"}")
           .build();
@@ -152,23 +148,18 @@ public class FriendshipResource {
   @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")
+    @APIResponse(responseCode = "500", description = "Erreur lors du rejet de la demande d'amitié")
   })
   public Response rejectFriendRequest(@PathParam("friendshipId") UUID friendshipId) {
     logger.info(
-        "[LOG] Reçu une demande pour rejeter une demande d'amitié avec l'ID : " + friendshipId);
+        "[LOG] Reçu une demande pour rejeter la demande d'amitié avec l'ID : " + friendshipId);
 
     try {
       friendshipService.rejectFriendRequest(friendshipId);
-      logger.info("[LOG] Demande d'amitié rejetée pour l'ID : " + friendshipId);
+      logger.info("[LOG] Demande d'amitié rejetée avec succès.");
       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());
+      logger.error("[ERROR] Erreur lors du rejet de la demande d'amitié : " + e.getMessage(), e);
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
           .entity("{\"message\": \"Erreur lors du rejet de la demande d'amitié.\"}")
           .build();
@@ -189,7 +180,9 @@ public class FriendshipResource {
   @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")
+    @APIResponse(
+        responseCode = "500",
+        description = "Erreur lors de la suppression de la relation d'amitié")
   })
   public Response removeFriend(@PathParam("friendshipId") UUID friendshipId) {
     logger.info(
@@ -197,16 +190,11 @@ public class FriendshipResource {
 
     try {
       friendshipService.removeFriend(friendshipId);
-      logger.info("[LOG] Relation d'amitié supprimée avec succès pour l'ID : " + friendshipId);
+      logger.info("[LOG] Relation d'amitié supprimée avec succès.");
       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());
+          "[ERROR] Erreur lors de la suppression de la relation d'amitié : " + e.getMessage(), e);
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
           .entity("{\"message\": \"Erreur lors de la suppression de la relation d'amitié.\"}")
           .build();
@@ -216,102 +204,140 @@ public class FriendshipResource {
   /**
    * 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 userId L'ID de l'utilisateur
-   * @param page Numéro de la page pour la pagination.
+   * @param page Numéro de la page pour la pagination
-   * @param size Nombre d'éléments par page.
+   * @param size Nombre d'éléments par page
-   * @return La liste des amis de l'utilisateur.
+   * @return Liste des amis de l'utilisateur avec pagination
    */
   @GET
   @Path("/list/{userId}")
   @Operation(
-      summary = "Lister les amis d'un utilisateur",
+      summary = "Récupérer la liste des amis",
-      description = "Récupère la liste de tous les amis d'un utilisateur donné")
+      description = "Retourne la liste des amis d'un utilisateur avec pagination")
   @APIResponses({
     @APIResponse(
         responseCode = "200",
-        description = "Liste des amis récupérée",
+        description = "Liste des amis récupérée avec succès",
         content =
             @Content(
                 mediaType = MediaType.APPLICATION_JSON,
-                schema =
+                schema = @Schema(implementation = FriendshipReadFriendDetailsResponseDTO.class))),
-                    @Schema(
-                        type = SchemaType.ARRAY,
-                        implementation = FriendshipResponseDTO.class))),
     @APIResponse(responseCode = "404", description = "Utilisateur non trouvé"),
-    @APIResponse(responseCode = "500", description = "Erreur interne du serveur")
+    @APIResponse(responseCode = "500", description = "Erreur lors de la récupération des amis")
   })
   public Response listFriends(
       @PathParam("userId") UUID userId,
-      @QueryParam("page") @DefaultValue("1") int page,
+      @QueryParam("page") @DefaultValue("0") 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);
+      List<FriendshipReadFriendDetailsResponseDTO> friendships =
-      logger.info(
+          friendshipService.listFriends(userId, page, size);
-          "[LOG] Liste des amis récupérée avec succès pour l'utilisateur "
+      logger.info("[LOG] Liste des amis récupérée avec succès.");
-              + userId
+      return Response.ok(friendships).build();
-              + ", 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());
+          "[ERROR] Erreur lors de la récupération de la liste des amis : " + e.getMessage(), e);
       return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la récupération de la liste des amis.\"}")
+          .entity("{\"message\": \"Erreur lors de la récupération des amis.\"}")
           .build();
     }
   }
 
   /**
-   * Endpoint pour récupérer les demandes d'amitié avec un statut spécifique.
+   * Récupérer les demandes d'amitié avec un statut spécifique.
    *
-   * @param userId L'ID de l'utilisateur.
+   * @param request DTO contenant les informations de filtrage (statut).
-   * @param status Le statut des demandes à filtrer (PENDING, ACCEPTED, REJECTED).
+   * @return Liste des demandes d'amitié avec le statut spécifié.
-   * @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
+  @POST
   @Path("/status")
   @Operation(
-      summary = "Récupérer les demandes d'amitié faites par un utilisateur par statut",
+      summary = "Récupérer les demandes d'amitié par statut",
-      description = "Retourne la liste des demandes d'amitié faites par un utilisateur avec un "
+      description = "Retourne la liste des demandes d'amitié avec un statut particulier")
-                    + "statut particulier.")
+  @APIResponses({
+    @APIResponse(
+        responseCode = "200",
+        description = "Demandes d'amitié récupérées",
+        content =
+            @Content(
+                mediaType = MediaType.APPLICATION_JSON,
+                schema = @Schema(implementation = FriendshipReadStatusResponseDTO.class))),
+    @APIResponse(responseCode = "404", description = "Utilisateur non trouvé"),
+    @APIResponse(
+        responseCode = "500",
+        description = "Erreur lors de la récupération des demandes d'amitié")
+  })
   public Response listFriendRequestsByStatus(
-      @QueryParam("userId") UUID userId,
+      @Valid @NotNull FriendshipReadStatusRequestDTO request) {
-      @QueryParam("status") FriendshipStatus status,
+    logger.info("[LOG] Récupération des demandes d'amitié avec le statut : " + request.getStatus());
-      @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);
+    try {
+      List<FriendshipReadStatusResponseDTO> friendships =
+          friendshipService.listFriendRequestsByStatus(request);
+      logger.info("[LOG] " + friendships.size() + " demandes d'amitié récupérées avec succès.");
+      return Response.ok(friendships).build();
+    } catch (Exception e) {
+      logger.error(
+          "[ERROR] Erreur lors de la récupération des demandes d'amitié : " + e.getMessage(), e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity("{\"message\": \"Erreur lors de la récupération des demandes d'amitié.\"}")
+          .build();
+    }
+  }
 
-    // Récupère l'utilisateur à partir de l'ID fourni
+  /**
-    Users user = usersRepository.findById(userId);
+   * Récupère les détails complets d'un ami.
-    if (user == null) {
+   *
+   * @param request DTO contenant l'ID de l'utilisateur et de l'ami dont les détails sont requis.
+   * @return Les détails complets de l'ami.
+   */
+  @POST
+  @Path("/details")
+  @Operation(
+      summary = "Récupérer les détails d'un ami",
+      description = "Permet de récupérer toutes les informations disponibles sur un ami spécifique")
+  @APIResponses({
+      @APIResponse(
+          responseCode = "200",
+          description = "Détails de l'ami récupérés avec succès",
+          content =
+          @Content(
+              mediaType = MediaType.APPLICATION_JSON,
+              schema = @Schema(implementation = FriendshipReadFriendDetailsResponseDTO.class))),
+      @APIResponse(responseCode = "404", description = "Ami non trouvé"),
+      @APIResponse(responseCode = "500", description = "Erreur serveur lors de la récupération des détails de l'ami")
+  })
+  public Response getFriendDetails(@Valid @NotNull FriendshipReadFriendDetailsRequestDTO request) {
+    logger.info(
+        "[LOG] Reçu une demande pour récupérer les détails de l'ami avec l'ID : "
+        + request.getFriendId() + " pour l'utilisateur : " + request.getUserId());
+
+    try {
+      // Appel du service pour récupérer les détails de l'ami
+      FriendshipReadFriendDetailsResponseDTO friendDetails =
+          friendshipService.getFriendDetails(request);
+      logger.info(
+          "[LOG] Détails de l'ami récupérés avec succès pour l'utilisateur : "
+          + request.getUserId() + ", ami ID : " + request.getFriendId());
+      return Response.ok(friendDetails).build();
+    } catch (NotFoundException e) {
+      logger.warn(
+          "[WARN] Aucun ami trouvé pour l'utilisateur : " + request.getUserId()
+          + " avec l'ID de l'ami : " + request.getFriendId());
       return Response.status(Response.Status.NOT_FOUND)
-                     .entity("{\"message\": \"Utilisateur non trouvé.\"}")
+                     .entity("{\"message\": \"Ami non trouvé.\"}")
+                     .build();
+    } catch (Exception e) {
+      logger.error(
+          "[ERROR] Erreur lors de la récupération des détails de l'ami : "
+          + e.getMessage(), e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+                     .entity("{\"message\": \"Erreur lors de la récupération des détails de l'ami.\"}")
                      .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/service/FriendshipService.java

@@ -1,5 +1,11 @@
 package com.lions.dev.service;
 
+import com.lions.dev.dto.request.friends.FriendshipCreateOneRequestDTO;
+import com.lions.dev.dto.request.friends.FriendshipReadFriendDetailsRequestDTO;
+import com.lions.dev.dto.request.friends.FriendshipReadStatusRequestDTO;
+import com.lions.dev.dto.response.friends.FriendshipCreateOneResponseDTO;
+import com.lions.dev.dto.response.friends.FriendshipReadFriendDetailsResponseDTO;
+import com.lions.dev.dto.response.friends.FriendshipReadStatusResponseDTO;
 import com.lions.dev.entity.friends.Friendship;
 import com.lions.dev.entity.friends.FriendshipStatus;
 import com.lions.dev.entity.users.Users;
@@ -10,175 +16,224 @@ import com.lions.dev.repository.UsersRepository;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
 import jakarta.transaction.Transactional;
+import org.jboss.logging.Logger;
+
 import java.util.List;
-import java.util.Optional;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 /**
- * Service de gestion des amitiés. Ce service gère l'envoi, l'acceptation, le rejet et la
+ * Service pour gérer les relations d'amitié.
- * suppression d'amitiés.
+ * Contient la logique métier pour envoyer, accepter, rejeter, et supprimer des relations d'amitié.
  */
 @ApplicationScoped
 public class FriendshipService {
 
-  @Inject FriendshipRepository friendshipRepository;
+  @Inject
+  FriendshipRepository friendshipRepository; // Injecte le repository des amitiés
+  @Inject
+  UsersRepository usersRepository; // Injecte le repository des utilisateurs
 
-  @Inject UsersRepository usersRepository;
+  private static final Logger logger = Logger.getLogger(FriendshipService.class);
 
   /**
    * Envoie une demande d'amitié entre deux utilisateurs.
    *
-   * @param userId L'ID de l'utilisateur qui envoie la demande.
+   * @param request DTO contenant les informations sur l'utilisateur et l'ami.
-   * @param friendId L'ID de l'utilisateur qui reçoit la demande.
+   * @return Le DTO de la relation d'amitié créée.
-   * @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) {
+  public FriendshipCreateOneResponseDTO sendFriendRequest(FriendshipCreateOneRequestDTO request) {
-    System.out.println(
+    logger.info("[LOG] Envoi d'une demande d'amitié de l'utilisateur " + request.getUserId() + " à l'utilisateur " + request.getFriendId());
-        "[LOG] Envoi de demande d'amitié de l'utilisateur "
-            + userId
-            + " à l'utilisateur "
-            + friendId);
 
-    Users user = usersRepository.findById(userId);
+    // Récupérer les utilisateurs concernés
-    Users friend = usersRepository.findById(friendId);
+    Users user = usersRepository.findById(request.getUserId());
+    Users friend = usersRepository.findById(request.getFriendId());
 
     if (user == null || friend == null) {
-      System.out.println(
+      String notFoundId = user == null ? request.getUserId().toString() : request.getFriendId().toString();
-          "[ERROR] Utilisateur non trouvé pour l'ID : " + (user == null ? userId : friendId));
+      logger.error("[ERROR] Utilisateur non trouvé pour l'ID : " + notFoundId);
-      throw new UserNotFoundException("L'utilisateur avec l'ID spécifié n'existe pas.");
+      throw new UserNotFoundException("Utilisateur avec l'ID " + notFoundId + " introuvable.");
     }
 
-    Optional<Friendship> existingFriendship = friendshipRepository.findByUsers(user, friend);
+    // Vérifier s'il existe déjà une relation d'amitié
-    if (existingFriendship.isPresent()) {
+    Friendship existingFriendship = friendshipRepository.findByUsers(user, friend).orElse(null);
-      System.out.println("[ERROR] Une relation d'amitié existe déjà entre ces deux utilisateurs.");
+    if (existingFriendship != null) {
+      logger.error("[ERROR] Relation d'amitié déjà existante entre les utilisateurs.");
       throw new IllegalArgumentException("Relation d'amitié déjà existante.");
     }
 
-    Friendship friendship =
+    // Créer et persister une nouvelle relation d'amitié
-        Friendship.builder().user(user).friend(friend).status(FriendshipStatus.PENDING).build();
+    Friendship friendship = new Friendship(user, friend, FriendshipStatus.PENDING);
-
     friendshipRepository.persist(friendship);
-    System.out.println(
-        "[LOG] Demande d'amitié envoyée de " + user.getEmail() + " à " + friend.getEmail());
 
-    return friendship;
+    logger.info("[LOG] Demande d'amitié envoyée avec succès.");
+    return new FriendshipCreateOneResponseDTO(friendship);
   }
 
   /**
-   * Accepte une demande d'amitié.
+   * Accepter une demande d'amitié.
    *
-   * @param friendshipId L'ID de la demande d'amitié.
+   * @param friendshipId ID de la demande à accepter.
-   * @return La relation d'amitié acceptée.
+   * @return Le DTO de la relation d'amitié acceptée.
-   * @throws FriendshipNotFoundException Si la relation d'amitié n'est pas trouvée.
    */
   @Transactional
-  public Friendship acceptFriendRequest(UUID friendshipId) {
+  public FriendshipCreateOneResponseDTO acceptFriendRequest(UUID friendshipId) {
-    System.out.println("[LOG] Acceptation de la demande d'amitié avec l'ID : " + friendshipId);
+    Friendship friendship = friendshipRepository.findById(friendshipId);
-
+    if (friendship == null) {
-    Friendship friendship =
+      throw new FriendshipNotFoundException("Demande d'amitié introuvable.");
-        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.");
     }
 
+    // Vérifier que la demande n'est pas déjà acceptée
+    if (friendship.getStatus() == FriendshipStatus.ACCEPTED) {
+      logger.error("[ERROR] Demande d'amitié déjà acceptée.");
+      throw new IllegalArgumentException("Demande d'amitié déjà acceptée.");
+    }
+
+    // Accepter la demande
     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;
+    logger.info("[LOG] Demande d'amitié acceptée avec succès.");
+    return new FriendshipCreateOneResponseDTO(friendship);
   }
 
   /**
-   * Rejette une demande d'amitié.
+   * Rejeter une demande d'amitié.
    *
-   * @param friendshipId L'ID de la demande d'amitié.
+   * @param friendshipId ID de la demande à rejeter.
-   * @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);
-
+    if (friendship == null) {
-    Friendship friendship =
+      throw new FriendshipNotFoundException("Demande d'amitié introuvable.");
-        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 "
+    logger.info("[LOG] Demande d'amitié rejetée.");
-            + friendship.getUser().getEmail()
-            + " et "
-            + friendship.getFriend().getEmail());
   }
 
   /**
-   * Supprime une relation d'amitié.
+   * Supprimer une relation d'amitié.
    *
-   * @param friendshipId L'ID de la relation d'amitié à supprimer.
+   * @param friendshipId ID de la relation à 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);
-
+    if (friendship == null) {
-    Friendship friendship =
+      throw new FriendshipNotFoundException("Relation d'amitié introuvable.");
-        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);
+    friendshipRepository.delete(friendship);
+    logger.info("[LOG] Relation d'amitié supprimée.");
   }
 
   /**
-   * Récupère toutes les demandes d'amitié avec un statut spécifique.
+   * Récupère les détails d'un ami spécifique pour un utilisateur donné.
    *
-   * @param user L'utilisateur.
+   * @param request DTO contenant l'ID de l'utilisateur et de l'ami.
-   * @param status Le statut des demandes d'amitié à récupérer (PENDING, ACCEPTED, REJECTED).
+   * @return Le DTO des détails de l'ami.
-   * @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) {
+  @Transactional
-    System.out.println("[LOG] Récupération des demandes d'amitié avec le statut : " + status);
+  public FriendshipReadFriendDetailsResponseDTO getFriendDetails(
-    return friendshipRepository.findByUserAndStatus(user, status, page, size);
+      FriendshipReadFriendDetailsRequestDTO request) {
+    logger.info("[LOG] Tentative de récupération des détails de l'ami avec l'ID : "
+                + request.getFriendId() + " pour l'utilisateur : " + request.getUserId());
+
+    // Récupération de l'utilisateur et de l'ami
+    Users user = usersRepository.findById(request.getUserId());
+    Users friend = usersRepository.findById(request.getFriendId());
+
+    if (user == null) {
+      logger.error("[ERROR] Utilisateur introuvable avec l'ID : " + request.getUserId());
+      throw new UserNotFoundException("Utilisateur introuvable avec l'ID " + request.getUserId());
+    }
+
+    if (friend == null) {
+      logger.error("[ERROR] Ami introuvable avec l'ID : " + request.getFriendId());
+      throw new UserNotFoundException("Ami introuvable avec l'ID " + request.getFriendId());
+    }
+
+    // Récupérer la relation d'amitié entre les deux utilisateurs
+    Friendship friendship = friendshipRepository.findByUsers(user, friend).orElse(null);
+    if (friendship == null) {
+      logger.error("[ERROR] Aucune relation d'amitié trouvée entre l'utilisateur et l'ami.");
+      throw new FriendshipNotFoundException("Relation d'amitié introuvable.");
+    }
+
+    logger.info("[LOG] Détails de l'ami récupérés avec succès pour l'utilisateur : "
+                + user.getId() + ", ami ID : " + friend.getId());
+
+    // Création du DTO de réponse à partir des informations de l'ami et de la relation
+    return new FriendshipReadFriendDetailsResponseDTO(
+        user.getId(), // ID de l'utilisateur
+        friend.getId(), // ID de l'ami
+        friend.getNom(), // Nom de l'ami
+        friend.getPrenoms(),
+        friend.getEmail(), // Email de l'ami
+        friendship.getStatus(), // Statut de la relation
+        friendship.getCreatedAt(), // Date de création de la relation
+        friendship.getUpdatedAt() // Date de mise à jour de la relation
+    );
   }
 
+  /**
+   * Récupérer la liste des amis d'un utilisateur.
+   *
+   * @param userId ID de l'utilisateur.
+   * @param page Numéro de la page.
+   * @param size Taille de la page.
+   * @return Liste paginée des relations d'amitié.
+   */
+  public List<FriendshipReadFriendDetailsResponseDTO> listFriends(UUID userId, int page, int size) {
+    Users user = usersRepository.findById(userId);
+    if (user == null) {
+      logger.error("[ERROR] Utilisateur non trouvé.");
+      throw new UserNotFoundException("Utilisateur introuvable.");
+    }
+
+    // Récupérer les amitiés acceptées
+    List<Friendship> friendships = friendshipRepository.findFriendsByUser(user, page, size);
+    logger.info("[LOG] " + friendships.size() + " amis récupérés.");
+
+    // Ajouter un log pour chaque amitié récupérée
+    friendships.forEach(friendship -> logger.info("[LOG] Ami : " + friendship.getFriend().getEmail()));
+
+    return friendships.stream()
+                      .map(friendship -> new FriendshipReadFriendDetailsResponseDTO(
+                          friendship.getUser().getId(),
+                          friendship.getFriend().getId(),
+                          friendship.getFriend().getNom(),
+                          friendship.getFriend().getPrenoms(),
+                          friendship.getFriend().getEmail(),
+                          friendship.getStatus(),
+                          friendship.getCreatedAt(),
+                          friendship.getUpdatedAt()
+                      ))
+                      .collect(Collectors.toList());
+  }
+
+  /**
+   * Récupérer les demandes d'amitié avec un statut spécifique.
+   *
+   * @param request DTO contenant les informations de filtrage (statut).
+   * @return Liste des demandes d'amitié avec le statut spécifié.
+   */
+  public List<FriendshipReadStatusResponseDTO> listFriendRequestsByStatus(FriendshipReadStatusRequestDTO request) {
+    Users user = usersRepository.findById(request.getUserId());
+    if (user == null) {
+      logger.error("[ERROR] Utilisateur non trouvé.");
+      throw new UserNotFoundException("Utilisateur introuvable.");
+    }
+
+    // Récupérer les demandes d'amitié selon le statut
+    List<Friendship> friendships = friendshipRepository.findByUserAndStatus(user, request.getStatus(), request.getPage() - 1, request.getSize());
+    logger.info("[LOG] " + friendships.size() + " demandes d'amitié récupérées.");
+
+    return friendships.stream().map(FriendshipReadStatusResponseDTO::new).collect(Collectors.toList());
+  }
 }

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

@@ -29,26 +29,29 @@ public class UsersService {
    * @return L'utilisateur créé.
    */
   public Users createUser(UserCreateRequestDTO userCreateRequestDTO) {
+    // Vérification si l'email existe déjà
+    Optional<Users> existingUser = usersRepository.findByEmail(userCreateRequestDTO.getEmail());
+    if (existingUser.isPresent()) {
+      throw new IllegalArgumentException("Un utilisateur avec cet email existe déjà.");
+    }
+
     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
+    // Logique pour l'image et le rôle par défaut.
-    if (userCreateRequestDTO.getProfileImageUrl() == null
+    user.setProfileImageUrl(
-        || userCreateRequestDTO.getProfileImageUrl().isEmpty()) {
+        userCreateRequestDTO.getProfileImageUrl() != null
-      user.setProfileImageUrl("https://via.placeholder.com/150"); // Assigner une image par défaut
+        ? userCreateRequestDTO.getProfileImageUrl()
-    } else {
+        : "https://via.placeholder.com/150"
-      user.setProfileImageUrl(userCreateRequestDTO.getProfileImageUrl());
+    );
-    }
+    user.setRole(
-
+        userCreateRequestDTO.getRole() != null
-    // Vérifier si le rôle est défini, sinon attribuer un rôle par défaut
+        ? userCreateRequestDTO.getRole()
-    if (userCreateRequestDTO.getRole() == null || userCreateRequestDTO.getRole().isEmpty()) {
+        : "USER"
-      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());

src/main/resources/application.properties

@@ -12,7 +12,7 @@ quarkus.datasource.jdbc.url=jdbc:oracle:thin:@localhost:1522:ORCLCDB
 quarkus.datasource.username=C##AFTERWORK
 quarkus.datasource.password=afterwork
 quarkus.datasource.jdbc.driver=oracle.jdbc.OracleDriver
-quarkus.hibernate-orm.database.generation=drop-and-create
+quarkus.hibernate-orm.database.generation=update
 quarkus.hibernate-orm.log.sql=true
 quarkus.datasource.devservices.enabled=false