Refactoring

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
- * suppression d'amitiés.
+ * Service pour gérer les relations d'amitié.
+ * 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 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é.
+   * @param request DTO contenant les informations sur l'utilisateur et l'ami.
+   * @return Le DTO de la relation d'amitié créée.
    */
   @Transactional
-  public Friendship sendFriendRequest(UUID userId, UUID friendId) {
-    System.out.println(
-        "[LOG] Envoi de demande d'amitié de l'utilisateur "
-            + userId
-            + " à l'utilisateur "
-            + friendId);
+  public FriendshipCreateOneResponseDTO sendFriendRequest(FriendshipCreateOneRequestDTO request) {
+    logger.info("[LOG] Envoi d'une demande d'amitié de l'utilisateur " + request.getUserId() + " à l'utilisateur " + request.getFriendId());
 
-    Users user = usersRepository.findById(userId);
-    Users friend = usersRepository.findById(friendId);
+    // Récupérer les utilisateurs concernés
+    Users user = usersRepository.findById(request.getUserId());
+    Users friend = usersRepository.findById(request.getFriendId());
 
     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.");
+      String notFoundId = user == null ? request.getUserId().toString() : request.getFriendId().toString();
+      logger.error("[ERROR] Utilisateur non trouvé pour l'ID : " + notFoundId);
+      throw new UserNotFoundException("Utilisateur avec l'ID " + notFoundId + " introuvable.");
     }
 
-    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.");
+    // Vérifier s'il existe déjà une relation d'amitié
+    Friendship existingFriendship = friendshipRepository.findByUsers(user, friend).orElse(null);
+    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 =
-        Friendship.builder().user(user).friend(friend).status(FriendshipStatus.PENDING).build();
-
+    // Créer et persister une nouvelle relation d'amitié
+    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é.
-   * @return La relation d'amitié acceptée.
-   * @throws FriendshipNotFoundException Si la relation d'amitié n'est pas trouvée.
+   * @param friendshipId ID de la demande à accepter.
+   * @return Le DTO de la relation d'amitié accepté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.");
+  public FriendshipCreateOneResponseDTO acceptFriendRequest(UUID friendshipId) {
+    Friendship friendship = friendshipRepository.findById(friendshipId);
+    if (friendship == null) {
+      throw new FriendshipNotFoundException("Demande d'amitié introuvable.");
     }
 
+    // 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é.
-   * @throws FriendshipNotFoundException Si la relation d'amitié n'est pas trouvée.
+   * @param friendshipId ID de la demande à rejeter.
    */
   @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 friendship = friendshipRepository.findById(friendshipId);
+    if (friendship == null) {
+      throw 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());
+
+    logger.info("[LOG] Demande d'amitié rejetée.");
   }
 
   /**
-   * Supprime une relation d'amitié.
+   * Supprimer 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.
+   * @param friendshipId ID de la relation à supprimer.
    */
   @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é.");
+    Friendship friendship = friendshipRepository.findById(friendshipId);
+    if (friendship == null) {
+      throw new FriendshipNotFoundException("Relation d'amitié introuvable.");
     }
 
-    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 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é.
+   * @param request DTO contenant l'ID de l'utilisateur et de l'ami.
+   * @return Le DTO des détails de l'ami.
    */
-  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);
+  @Transactional
+  public FriendshipReadFriendDetailsResponseDTO getFriendDetails(
+      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());
+  }
 }