139 lines
5.0 KiB
Java
139 lines
5.0 KiB
Java
package com.lions.dev.resource;
|
|
|
|
import com.lions.dev.dto.request.users.UserAuthenticateRequestDTO;
|
|
import com.lions.dev.dto.request.users.UserRequestDTO;
|
|
import com.lions.dev.dto.response.users.UserAuthenticateResponseDTO;
|
|
import com.lions.dev.dto.response.users.UserResponseDTO;
|
|
import com.lions.dev.entity.users.Users;
|
|
import com.lions.dev.service.UserService;
|
|
import jakarta.inject.Inject;
|
|
import jakarta.transaction.Transactional;
|
|
import jakarta.ws.rs.*;
|
|
import jakarta.ws.rs.core.Response;
|
|
import java.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.
|
|
*
|
|
* <p>Tous les logs nécessaires pour la traçabilité sont intégrés.
|
|
*/
|
|
@Path("/users")
|
|
@Produces("application/json")
|
|
@Consumes("application/json")
|
|
@Tag(name = "Users", description = "Opérations liées à la gestion des utilisateurs")
|
|
public class UsersResource {
|
|
|
|
@Inject UserService userService;
|
|
|
|
private static final Logger LOG = Logger.getLogger(UsersResource.class);
|
|
|
|
/**
|
|
* Endpoint pour créer un nouvel utilisateur.
|
|
*
|
|
* @param userRequestDTO 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(UserRequestDTO userRequestDTO) {
|
|
LOG.info(
|
|
"Tentative de création d'un nouvel utilisateur avec l'email : "
|
|
+ userRequestDTO.getEmail());
|
|
|
|
// Utilisation de UserService pour créer l'utilisateur
|
|
Users user = userService.createUser(userRequestDTO);
|
|
|
|
UserResponseDTO responseDTO = new UserResponseDTO(user);
|
|
return Response.status(Response.Status.CREATED).entity(responseDTO).build();
|
|
}
|
|
|
|
/**
|
|
* Endpoint pour authentifier un utilisateur.
|
|
*
|
|
* @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(UserAuthenticateRequestDTO userAuthenticateRequestDTO) {
|
|
LOG.info(
|
|
"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());
|
|
|
|
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());
|
|
|
|
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);
|
|
|
|
// Utilisation de UserService pour récupérer l'utilisateur
|
|
Users user = userService.getUserById(id);
|
|
|
|
UserResponseDTO responseDTO = new UserResponseDTO(user);
|
|
LOG.info("Utilisateur trouvé : " + user.getEmail());
|
|
return Response.ok(responseDTO).build();
|
|
}
|
|
|
|
/**
|
|
* Endpoint pour supprimer un utilisateur par ID.
|
|
*
|
|
* @param id L'ID de l'utilisateur à supprimer.
|
|
* @return Une réponse HTTP indiquant le succès ou l'échec de la 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);
|
|
|
|
// Utilisation de UserService pour supprimer l'utilisateur
|
|
boolean deleted = userService.deleteUser(id);
|
|
|
|
if (deleted) {
|
|
LOG.info("Utilisateur supprimé avec succès.");
|
|
return Response.noContent().build();
|
|
} else {
|
|
LOG.warn("Échec de la suppression : utilisateur introuvable avec l'ID : " + id);
|
|
return Response.status(Response.Status.NOT_FOUND).entity("Utilisateur non trouvé.").build();
|
|
}
|
|
}
|
|
}
|