mic-after-work-server-impl-quarkus-main/src/main/java/com/lions/dev/resource/UsersResource.java

package com.lions.dev.resource;

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.exception.UserNotFoundException;
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 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.
 */
@Path("/users")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Tag(name = "Users", description = "Opérations liées à la gestion des utilisateurs")
public class UsersResource {

  @Inject
  UsersService userService;

  private static final Logger LOG = Logger.getLogger(UsersResource.class);

  /**
   * Endpoint pour créer un nouvel utilisateur.
   *
   * @param userCreateRequestDTO Le DTO contenant les informations de l'utilisateur à créer.
   * @return Une réponse HTTP contenant l'utilisateur créé ou un message d'erreur.
   */
  @POST
  @Transactional
  @Operation(
      summary = "Créer un nouvel utilisateur",
      description = "Crée un nouvel utilisateur et retourne les détails")
  public Response createUser(@Valid @NotNull UserCreateRequestDTO userCreateRequestDTO) {
    LOG.info(
        "Tentative de création d'un nouvel utilisateur avec l'email : "
        + userCreateRequestDTO.getEmail());

    Users user = userService.createUser(userCreateRequestDTO);
    UserCreateResponseDTO responseDTO = new UserCreateResponseDTO(user);
    return Response.status(Response.Status.CREATED).entity(responseDTO).build();
  }

  /**
   * Endpoint pour authentifier un utilisateur (v2.0).
   *
   * @param userAuthenticateRequestDTO Le DTO contenant les informations d'authentification.
   * @return Une réponse HTTP indiquant si l'authentification a réussi ou échoué.
   */
  @POST
  @Path("/authenticate")
  @Operation(
      summary = "Authentifier un utilisateur",
      description = "Vérifie les informations de connexion de l'utilisateur")
  public Response authenticateUser(@Valid @NotNull UserAuthenticateRequestDTO userAuthenticateRequestDTO) {
    LOG.info("Tentative d'authentification pour l'utilisateur avec l'email : " + userAuthenticateRequestDTO.getEmail());

    // v2.0 - Utiliser getPassword() qui gère la compatibilité v1.0 et v2.0
    Users user = userService.authenticateUser(userAuthenticateRequestDTO.getEmail(), userAuthenticateRequestDTO.getPassword());
    LOG.info("Authentification réussie pour l'utilisateur : " + user.getEmail());

    // v2.0 - Utiliser les nouveaux noms de champs
    UserAuthenticateResponseDTO responseDTO = new UserAuthenticateResponseDTO(
        user.getId(), 
        user.getFirstName(), // v2.0
        user.getLastName(), // v2.0
        user.getEmail(), 
        user.getRole()
    );
    responseDTO.logResponseDetails();
    return Response.ok(responseDTO).build();
  }

  /**
   * Endpoint pour récupérer les détails d'un utilisateur par ID.
   *
   * @param id L'ID de l'utilisateur.
   * @return Une réponse HTTP contenant les informations de l'utilisateur.
   */
  @GET
  @Path("/{id}")
  @Operation(
      summary = "Récupérer un utilisateur par ID",
      description = "Retourne les détails de l'utilisateur demandé")
  public Response getUserById(@PathParam("id") UUID id) {
    LOG.info("Récupération de l'utilisateur avec l'ID : " + id);

    Users user = userService.getUserById(id);
    UserCreateResponseDTO responseDTO = new 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.
   *
   * @param id L'ID de l'utilisateur à supprimer.
   * @return Une réponse HTTP avec le statut de suppression.
   */
  @DELETE
  @Path("/{id}")
  @Transactional
  @Operation(
      summary = "Supprimer un utilisateur",
      description = "Supprime un utilisateur de la base de données")
  public Response deleteUser(@PathParam("id") UUID id) {
    LOG.info("Tentative de suppression de l'utilisateur avec l'ID : " + id);

    boolean deleted = userService.deleteUser(id);

    UserDeleteResponseDto responseDTO = new UserDeleteResponseDto();
    if (deleted) {
      LOG.info("Utilisateur supprimé avec succès.");
      responseDTO.setSuccess(true);
      responseDTO.setMessage("Utilisateur supprimé avec succès.");
      responseDTO.logResponseDetails();
      return Response.ok(responseDTO).build();
    } else {
      LOG.warn("Échec de la suppression : utilisateur introuvable avec l'ID : " + id);
      responseDTO.setSuccess(false);
      responseDTO.setMessage("Utilisateur non trouvé.");
      responseDTO.logResponseDetails();
      return Response.status(Response.Status.NOT_FOUND).entity(responseDTO).build();
    }
  }

  /**
   * 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.
   *
   * @param id L'identifiant de l'utilisateur.
   * @param imageFilePath Le chemin vers l'image de profil.
   * @return Un message indiquant si la mise à jour a réussi.
   */
  @PUT
  @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 {
      File file = new File(imageFilePath);
      if (!file.exists()) {
        LOG.error("[ERROR] Le fichier spécifié n'existe pas : " + imageFilePath);
        return "Le fichier spécifié n'existe pas.";
      }

      String profileImageUrl = file.getAbsolutePath();
      userService.updateUserProfileImage(id, profileImageUrl); // Appel à la méthode correcte

      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) {
      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.";
    }
  }

  /**
   * Endpoint pour rechercher un utilisateur par email.
   *
   * @param email L'email de l'utilisateur à rechercher.
   * @return Une réponse HTTP contenant les informations de l'utilisateur.
   */
  @GET
  @Path("/search")
  @Operation(
      summary = "Rechercher un utilisateur par email",
      description = "Retourne les détails de l'utilisateur correspondant à l'email fourni")
  public Response searchUserByEmail(@QueryParam("email") String email) {
    if (email == null || email.isBlank()) {
      LOG.warn("Tentative de recherche avec un email vide ou null");
      return Response.status(Response.Status.BAD_REQUEST)
          .entity("{\"message\": \"L'email est requis pour la recherche.\"}")
          .build();
    }

    LOG.info("Recherche de l'utilisateur avec l'email : " + email);

    try {
      Users user = userService.getUserByEmail(email);
      UserCreateResponseDTO responseDTO = new UserCreateResponseDTO(user);
      LOG.info("Utilisateur trouvé : " + user.getEmail());
      return Response.ok(responseDTO).build();
    } catch (UserNotFoundException e) {
      LOG.warn("Utilisateur non trouvé avec l'email : " + email);
      return Response.status(Response.Status.NOT_FOUND)
          .entity("{\"message\": \"Utilisateur non trouvé avec cet email.\"}")
          .build();
    } catch (Exception e) {
      LOG.error("[ERROR] Erreur lors de la recherche de l'utilisateur : " + e.getMessage(), e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity("{\"message\": \"Erreur lors de la recherche de l'utilisateur.\"}")
          .build();
    }
  }

}