lionsdev/mic-after-work-server-impl-quarkus-main
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Amélioration structurelle Best Practices Endpoint

Browse Source
This commit is contained in:
DahoudG
2024-09-10 23:44:56 +00:00
parent 57ad010feb
commit e54a74d248
35 changed files with 1296 additions and 1017 deletions
Download Patch File Download Diff File Expand all files Collapse all files

402
src/main/java/com/lions/dev/resource/EventsResource.java
View File

@@ -1,384 +1,132 @@
package com.lions.dev.resource;
import com.lions.dev.entity.Events;
import com.lions.dev.entity.Users;
import com.lions.dev.entity.events.Events;
import com.lions.dev.repository.EventsRepository;
import com.lions.dev.repository.UsersRepository;
import com.lions.dev.dto.request.events.EventRequestDTO;
import com.lions.dev.dto.response.events.EventResponseDTO;
import com.lions.dev.exception.EventNotFoundException;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import jakarta.validation.Valid;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import org.eclipse.microprofile.openapi.annotations.Operation;
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
import java.time.LocalDateTime;
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 événements dans le système AfterWork.
* Cette classe expose des endpoints pour créer, récupérer, et supprimer des événements.
*
* Tous les logs nécessaires pour la traçabilité sont intégrés.
*/
@Path("/events")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Tag(name = "Events", description = "Opérations liées à l'entité Events")
@Produces("application/json")
@Consumes("application/json")
@Tag(name = "Events", description = "Opérations liées à la gestion des événements")
public class EventsResource {
@Inject
UsersRepository usersRepository;
@Inject
EventsRepository eventsRepository;
/**
* Récupérer tous les événements.
*
* @return Liste de tous les événements.
*/
@GET
@Operation(summary = "Récupérer tous les événements", description = "Retourne une liste de tous les événements")
public List<Events> getAllEvents() {
// Log pour le début de la récupération des événements
System.out.println("Tentative de récupération de tous les événements.");
List<Events> events = eventsRepository.findAllEvents();
// Log du nombre d'événements récupérés
System.out.println("Nombre d'événements récupérés: " + events.size());
return events;
}
private static final Logger LOG = Logger.getLogger(EventsResource.class);
/**
* Créer un nouvel événement.
* Endpoint pour créer un nouvel événement.
*
* @param event L'événement à créer.
* @return Réponse HTTP indiquant le succès ou l'échec de la création.
* @param eventRequestDTO Le DTO contenant les informations de l'événement à créer.
* @return Une réponse HTTP contenant l'événement créé ou un message d'erreur.
*/
@POST
@Transactional
@Operation(summary = "Créer un nouvel événement", description = "Crée un nouvel événement")
public Response createEvent(@Valid Events event) {
try {
// Validation de la date de l'événement
if (event.getEventDate() == null) {
return Response.status(Response.Status.BAD_REQUEST)
.entity("La date de l'événement (eventDate) est requise.")
.build();
}
@Operation(summary = "Créer un nouvel événement", description = "Crée un nouvel événement et retourne ses détails")
public Response createEvent(EventRequestDTO eventRequestDTO) {
LOG.info("Tentative de création d'un nouvel événement : " + eventRequestDTO.getTitle());
// Validation de l'existence du créateur
if (event.getCreator() == null || event.getCreator().getId() == null) {
return Response.status(Response.Status.BAD_REQUEST)
.entity("Les informations du créateur sont manquantes ou invalides.")
.build();
}
Events event = new Events();
event.setTitle(eventRequestDTO.getTitle());
event.setStartDate(eventRequestDTO.getStartDate());
event.setEndDate(eventRequestDTO.getEndDate());
event.setCreator(eventRequestDTO.getCreator()); // Créateur de l'événement
UUID creatorId = event.getCreator().getId();
Users creator = usersRepository.findById(creatorId);
if (creator == null) {
return Response.status(Response.Status.BAD_REQUEST)
.entity("Créateur non trouvé.")
.build();
}
eventsRepository.persist(event);
LOG.info("Événement créé avec succès : " + event.getTitle());
// Associer le créateur et l'ajouter en tant que participant par défaut
event.setCreator(creator);
event.addParticipant(creator);
// Log avant la persistance de l'événement
System.out.println("Tentative de persistance de l'événement: " + event.getTitle());
eventsRepository.persist(event);
// Log après la persistance
System.out.println("Événement persisté avec succès: " + event.getId());
return Response.status(Response.Status.CREATED).entity(event).build();
} catch (Exception e) {
e.printStackTrace();
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
.entity("Une erreur est survenue lors de la création de l'événement : " + e.getMessage())
.build();
}
EventResponseDTO responseDTO = new EventResponseDTO(event);
return Response.status(Response.Status.CREATED).entity(responseDTO).build();
}
/**
* Récupérer un événement par ID.
* Endpoint pour récupérer les détails d'un événement par ID.
*
* @param id L'ID de l'événement.
* @return L'événement correspondant à l'ID ou une réponse HTTP 404 si non trouvé.
* @return Une réponse HTTP contenant les informations de l'événement.
*/
@GET
@Path("{id}")
@Operation(summary = "Récupérer un événement par ID", description = "Retourne un événement par son ID")
@Path("/{id}")
@Operation(summary = "Récupérer un événement par ID", description = "Retourne les détails de l'événement demandé")
public Response getEventById(@PathParam("id") UUID id) {
// Log pour la récupération par ID
System.out.println("Tentative de récupération de l'événement avec ID: " + id);
LOG.info("Récupération de l'événement avec l'ID : " + id);
Events event = eventsRepository.findById(id);
if (event == null) {
// Log si l'événement n'est pas trouvé
System.out.println("Événement non trouvé: " + id);
return Response.status(Response.Status.NOT_FOUND).build();
LOG.warn("Événement non trouvé avec l'ID : " + id);
return Response.status(Response.Status.NOT_FOUND)
.entity("Événement non trouvé.").build();
}
// Log de la réussite de la récupération
System.out.println("Événement trouvé: " + event.getTitle());
return Response.ok(event).build();
EventResponseDTO responseDTO = new EventResponseDTO(event);
LOG.info("Événement trouvé : " + event.getTitle());
return Response.ok(responseDTO).build();
}
/**
* Mettre à jour un événement existant.
* Endpoint pour récupérer une liste de tous les événements après une date donnée.
*
* @param id L'ID de l'événement à mettre à jour.
* @param event Les nouvelles informations de l'événement.
* @return L'événement mis à jour ou une réponse HTTP 404 si non trouvé.
* @param startDate La date de début à partir de laquelle filtrer les événements.
* @return Une réponse HTTP contenant la liste des événements après cette date.
*/
@PUT
@Path("{id}")
@Transactional
@Operation(summary = "Mettre à jour un événement", description = "Met à jour un événement existant par ID")
public Response updateEvent(@PathParam("id") UUID id, @Valid Events event) {
// Log pour la tentative de mise à jour
System.out.println("Tentative de mise à jour de l'événement avec ID: " + id);
Events entity = eventsRepository.findById(id);
if (entity == null) {
// Log si l'événement n'est pas trouvé
System.out.println("Événement non trouvé: " + id);
return Response.status(Response.Status.NOT_FOUND).build();
@GET
@Path("/after-date")
@Operation(summary = "Récupérer les événements après une date", description = "Retourne les événements après une date donnée")
public Response getEventsAfterDate(@QueryParam("startDate") LocalDateTime startDate) {
LOG.info("Récupération des événements après la date : " + startDate);
List<Events> events = eventsRepository.findEventsAfterDate(startDate);
if (events.isEmpty()) {
LOG.warn("Aucun événement trouvé après la date : " + startDate);
return Response.status(Response.Status.NOT_FOUND)
.entity("Aucun événement trouvé après cette date.").build();
}
// Mise à jour des informations de l'événement
entity.setTitle(event.getTitle());
entity.setDescription(event.getDescription());
entity.setEventDate(event.getEventDate());
entity.setLocation(event.getLocation());
entity.setCategory(event.getCategory());
entity.setLink(event.getLink());
entity.setImageUrl(event.getImageUrl());
// Log après mise à jour
System.out.println("Événement mis à jour avec succès: " + entity.getId());
return Response.ok(entity).build();
List<EventResponseDTO> responseDTOs = events.stream().map(EventResponseDTO::new).toList();
LOG.info("Nombre d'événements trouvés après la date : " + events.size());
return Response.ok(responseDTOs).build();
}
/**
* Supprimer un événement.
* Endpoint pour supprimer un événement par ID.
*
* @param id L'ID de l'événement à supprimer.
* @return Une réponse HTTP 204 (No Content) ou 404 si non trouvé.
* @return Une réponse HTTP indiquant le succès ou l'échec de la suppression.
*/
@DELETE
@Path("{id}")
@Path("/{id}")
@Transactional
@Operation(summary = "Supprimer un événement", description = "Supprime un événement existant par ID")
@Operation(summary = "Supprimer un événement", description = "Supprime un événement de la base de données")
public Response deleteEvent(@PathParam("id") UUID id) {
// Log pour la tentative de suppression
System.out.println("Tentative de suppression de l'événement avec ID: " + id);
Events event = eventsRepository.findById(id);
if (event == null) {
// Log si l'événement n'est pas trouvé
System.out.println("Événement non trouvé: " + id);
return Response.status(Response.Status.NOT_FOUND).build();
}
LOG.info("Tentative de suppression de l'événement avec l'ID : " + id);
eventsRepository.delete(event);
// Log après suppression
System.out.println("Événement supprimé avec succès: " + id);
return Response.noContent().build();
}
/**
* Ajouter un participant à un événement.
*
* @param eventId L'ID de l'événement.
* @param userId L'ID de l'utilisateur à ajouter comme participant.
* @return L'événement mis à jour ou une réponse HTTP 404 si l'événement ou l'utilisateur est non trouvé.
*/
@POST
@Path("{eventId}/participants/{userId}")
@Transactional
@Operation(summary = "Ajouter un participant à un événement", description = "Ajoute un utilisateur en tant que participant à un événement")
public Response addParticipant(@PathParam("eventId") UUID eventId, @PathParam("userId") UUID userId) {
// Log pour l'ajout de participant
System.out.println("Tentative d'ajout du participant avec ID: " + userId + " à l'événement avec ID: " + eventId);
Events event = eventsRepository.findById(eventId);
Users user = usersRepository.findById(userId);
if (event == null || user == null) {
// Log si l'événement ou l'utilisateur n'est pas trouvé
System.out.println("Événement ou utilisateur non trouvé. Event ID: " + eventId + ", User ID: " + userId);
boolean deleted = eventsRepository.deleteById(id);
if (deleted) {
LOG.info("Événement supprimé avec succès.");
return Response.noContent().build();
} else {
LOG.warn("Échec de la suppression : événement introuvable avec l'ID : " + id);
return Response.status(Response.Status.NOT_FOUND)
.entity("Événement ou utilisateur non trouvé.")
.build();
.entity("Événement non trouvé.").build();
}
event.addParticipant(user);
// Log après l'ajout de participant
System.out.println("Participant ajouté avec succès. Event ID: " + eventId + ", User ID: " + userId);
return Response.ok(event).build();
}
/**
* Retirer un participant d'un événement.
*
* @param eventId L'ID de l'événement.
* @param userId L'ID de l'utilisateur à retirer comme participant.
* @return L'événement mis à jour ou une réponse HTTP 404 si l'événement ou l'utilisateur est non trouvé.
*/
@DELETE
@Path("{eventId}/participants/{userId}")
@Transactional
@Operation(summary = "Retirer un participant d'un événement", description = "Retire un utilisateur en tant que participant d'un événement")
public Response removeParticipant(@PathParam("eventId") UUID eventId, @PathParam("userId") UUID userId) {
// Log pour la tentative de retrait du participant
System.out.println("Tentative de retrait du participant avec ID: " + userId + " de l'événement avec ID: " + eventId);
Events event = eventsRepository.findById(eventId);
Users user = usersRepository.findById(userId);
if (event == null || user == null) {
// Log si l'événement ou l'utilisateur n'est pas trouvé
System.out.println("Événement ou utilisateur non trouvé. Event ID: " + eventId + ", User ID: " + userId);
return Response.status(Response.Status.NOT_FOUND)
.entity("Événement ou utilisateur non trouvé.")
.build();
}
event.removeParticipant(user);
// Log après le retrait du participant
System.out.println("Participant retiré avec succès. Event ID: " + eventId + ", User ID: " + userId);
return Response.ok(event).build();
}
/**
* Ajouter un "j'aime" à un événement.
*
* @param eventId L'ID de l'événement.
* @param userId L'ID de l'utilisateur qui aime l'événement.
* @return L'événement mis à jour ou une réponse HTTP 404 si l'événement ou l'utilisateur est non trouvé.
*/
@POST
@Path("{eventId}/like/{userId}")
@Transactional
@Operation(summary = "Ajouter un 'j'aime' à un événement", description = "Ajoute un utilisateur aux 'j'aime' d'un événement")
public Response likeEvent(@PathParam("eventId") UUID eventId, @PathParam("userId") UUID userId) {
// Log pour l'ajout d'un "j'aime"
System.out.println("Tentative d'ajout d'un 'j'aime' par l'utilisateur avec ID: " + userId + " pour l'événement avec ID: " + eventId);
Events event = eventsRepository.findById(eventId);
Users user = usersRepository.findById(userId);
if (event == null || user == null) {
// Log si l'événement ou l'utilisateur n'est pas trouvé
System.out.println("Événement ou utilisateur non trouvé. Event ID: " + eventId + ", User ID: " + userId);
return Response.status(Response.Status.NOT_FOUND)
.entity("Événement ou utilisateur non trouvé.")
.build();
}
event.addLike(user);
// Log après l'ajout du "j'aime"
System.out.println("'J'aime' ajouté avec succès. Event ID: " + eventId + ", User ID: " + userId);
return Response.ok(event).build();
}
/**
* Retirer un "j'aime" d'un événement.
*
* @param eventId L'ID de l'événement.
* @param userId L'ID de l'utilisateur qui retire son "j'aime".
* @return L'événement mis à jour ou une réponse HTTP 404 si l'événement ou l'utilisateur est non trouvé.
*/
@DELETE
@Path("{eventId}/like/{userId}")
@Transactional
@Operation(summary = "Retirer un 'j'aime' d'un événement", description = "Retire un utilisateur des 'j'aime' d'un événement")
public Response unlikeEvent(@PathParam("eventId") UUID eventId, @PathParam("userId") UUID userId) {
// Log pour la tentative de retrait d'un "j'aime"
System.out.println("Tentative de retrait d'un 'j'aime' par l'utilisateur avec ID: " + userId + " pour l'événement avec ID: " + eventId);
Events event = eventsRepository.findById(eventId);
Users user = usersRepository.findById(userId);
if (event == null || user == null) {
// Log si l'événement ou l'utilisateur n'est pas trouvé
System.out.println("Événement ou utilisateur non trouvé. Event ID: " + eventId + ", User ID: " + userId);
return Response.status(Response.Status.NOT_FOUND)
.entity("Événement ou utilisateur non trouvé.")
.build();
}
event.removeLike(user);
// Log après le retrait du "j'aime"
System.out.println("'J'aime' retiré avec succès. Event ID: " + eventId + ", User ID: " + userId);
return Response.ok(event).build();
}
/**
* Fermer un événement.
*
* @param eventId L'ID de l'événement à fermer.
* @return Une réponse HTTP indiquant le succès ou l'échec de la fermeture.
*/
@POST
@Path("{eventId}/close")
@Transactional
@Operation(summary = "Fermer un événement", description = "Ferme un événement existant")
public Response closeEvent(@PathParam("eventId") UUID eventId) {
// Log pour la tentative de fermeture de l'événement
System.out.println("Tentative de fermeture de l'événement avec ID: " + eventId);
Events event = eventsRepository.findById(eventId);
if (event == null) {
// Log si l'événement n'est pas trouvé
System.out.println("Événement non trouvé: " + eventId);
return Response.status(Response.Status.NOT_FOUND)
.entity("Événement non trouvé.")
.build();
}
if ("CLOSED".equals(event.getStatus())) {
// Log si l'événement est déjà fermé
System.out.println("L'événement est déjà fermé: " + eventId);
return Response.status(Response.Status.BAD_REQUEST)
.entity("L'événement est déjà fermé.")
.build();
}
event.setStatus("CLOSED");
eventsRepository.persist(event);
// Log après la fermeture de l'événement
System.out.println("Événement fermé avec succès: " + eventId);
return Response.ok("Événement fermé avec succès.").build();
}
/**
* Rouvrir un événement.
*
* @param eventId L'ID de l'événement à rouvrir.
* @return Une réponse HTTP indiquant le succès ou l'échec de la réouverture.
*/
@POST
@Path("{eventId}/reopen")
@Transactional
@Operation(summary = "Rouvrir un événement", description = "Rouvre un événement existant qui est actuellement fermé")
public Response reopenEvent(@PathParam("eventId") UUID eventId) {
// Log pour la tentative de réouverture de l'événement
System.out.println("Tentative de réouverture de l'événement avec ID: " + eventId);
Events event = eventsRepository.findById(eventId);
if (event == null) {
// Log si l'événement n'est pas trouvé
System.out.println("Événement non trouvé: " + eventId);
return Response.status(Response.Status.NOT_FOUND)
.entity("Événement non trouvé.")
.build();
}
if (!"CLOSED".equals(event.getStatus())) {
// Log si l'événement n'est pas fermé
System.out.println("L'événement n'est pas fermé, donc il ne peut pas être rouvert: " + eventId);
return Response.status(Response.Status.BAD_REQUEST)
.entity("L'événement n'est pas fermé et ne peut pas être rouvert.")
.build();
}
// Rouvrir l'événement
event.setStatus("OPEN");
eventsRepository.persist(event);
// Log après la réouverture de l'événement
System.out.println("Événement rouvert avec succès: " + eventId);
return Response.ok("Événement rouvert avec succès.").build();
}
}

171
src/main/java/com/lions/dev/resource/UsersResource.java
View File

@@ -1,143 +1,142 @@
package com.lions.dev.resource;
import com.lions.dev.entity.Users;
import com.lions.dev.entity.users.Users;
import com.lions.dev.repository.UsersRepository;
import com.lions.dev.dto.request.users.UserRequestDTO;
import com.lions.dev.dto.response.users.UserResponseDTO;
import com.lions.dev.exception.UserNotFoundException;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import jakarta.validation.Valid;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotNull;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import lombok.Getter;
import lombok.Setter;
import java.time.LocalDateTime;
import java.util.UUID;
import org.eclipse.microprofile.openapi.annotations.Operation;
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
import java.util.List;
import java.util.UUID;
import org.jboss.logging.Logger;
/**
* Ressource REST pour gérer les entités Users.
* 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 à l'entité Users")
@Produces("application/json")
@Consumes("application/json")
@Tag(name = "Users", description = "Opérations liées à la gestion des utilisateurs")
public class UsersResource {
@Inject
UsersRepository usersRepository;
/**
* Récupère tous les utilisateurs.
*
* @return Liste des utilisateurs.
*/
@GET
@Operation(summary = "Récupérer tous les utilisateurs", description = "Retourne une liste de tous les utilisateurs")
public List<Users> getAllUsers() {
return usersRepository.listAll();
}
private static final Logger LOG = Logger.getLogger(UsersResource.class);
/**
* Crée un nouvel utilisateur.
* Endpoint pour créer un nouvel utilisateur.
*
* @param user L'utilisateur à créer.
* @return L'utilisateur créé.
* @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")
public Response createUser(@Valid Users user) {
if (user.getId() != null && usersRepository.findById(user.getId()) != null) {
@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());
if (usersRepository.existsByEmail(userRequestDTO.getEmail())) {
LOG.warn("Un utilisateur avec cet email existe déjà : " + userRequestDTO.getEmail());
return Response.status(Response.Status.CONFLICT)
.entity("L'utilisateur avec l'ID " + user.getId() + " existe déjà.")
.build();
.entity("Un utilisateur avec cet email existe déjà.").build();
}
if (user.getMotDePasse() == null || user.getMotDePasse().isEmpty()) {
return Response.status(Response.Status.BAD_REQUEST)
.entity("Le mot de passe est obligatoire.")
.build();
Users user = new Users();
user.setNom(userRequestDTO.getNom());
user.setPrenoms(userRequestDTO.getPrenoms());
user.setEmail(userRequestDTO.getEmail());
user.setMotDePasse(userRequestDTO.getMotDePasse()); // Hachage automatique dans l'entité
// Assigner un rôle par défaut si non fourni (par exemple : USER)
if (user.getRole() == null) {
user.setRole("USER"); // Définir le rôle par défaut
}
usersRepository.persist(user);
return Response.status(Response.Status.CREATED).entity(user).build();
LOG.info("Utilisateur créé avec succès : " + user.getEmail() + " à " + LocalDateTime.now());
UserResponseDTO responseDTO = new UserResponseDTO(user);
return Response.status(Response.Status.CREATED).entity(responseDTO).build();
}
/**
* Authentifie un utilisateur avec son email et mot de passe.
* Endpoint pour authentifier un utilisateur.
*
* @param credentials Les identifiants de l'utilisateur.
* @return L'utilisateur authentifié.
* @param userRequestDTO Le DTO contenant les informations d'authentification.
* @return Une réponse HTTP indiquant si l'authentification a réussi ou échoué.
*/
@POST
@Path("/authenticate")
@Transactional
@Operation(summary = "Authentifier un utilisateur", description = "Authentifie un utilisateur avec email et mot de passe")
public Response authenticateUser(@Valid UserCredentials credentials) {
Users user = usersRepository.find("email", credentials.getEmail()).firstResult();
if (user == null || !user.getMotDePasse().equals(credentials.getMotDePasse())) {
return Response.status(Response.Status.UNAUTHORIZED)
.entity("Email ou mot de passe incorrect")
.build();
@Operation(summary = "Authentifier un utilisateur", description = "Vérifie les informations de connexion de l'utilisateur")
public Response authenticateUser(UserRequestDTO userRequestDTO) {
LOG.info("Tentative d'authentification pour l'utilisateur avec l'email : " + userRequestDTO.getEmail());
Users user = usersRepository.findByEmail(userRequestDTO.getEmail())
.orElseThrow(() -> new UserNotFoundException("Utilisateur non trouvé avec l'email : " + userRequestDTO.getEmail()));
if (!user.verifierMotDePasse(userRequestDTO.getMotDePasse())) {
LOG.warn("Échec de l'authentification : mot de passe incorrect pour l'email : " + userRequestDTO.getEmail());
return Response.status(Response.Status.UNAUTHORIZED).entity("Mot de passe incorrect.").build();
}
return Response.ok(user).build();
LOG.info("Authentification réussie pour l'utilisateur : " + user.getEmail());
UserResponseDTO responseDTO = new UserResponseDTO(user);
return Response.ok(responseDTO).build();
}
/**
* Met à jour un utilisateur existant.
* Endpoint pour récupérer les détails d'un utilisateur par ID.
*
* @param id L'ID de l'utilisateur à mettre à jour.
* @param user Les nouvelles informations de l'utilisateur.
* @return L'utilisateur mis à jour.
* @param id L'ID de l'utilisateur.
* @return Une réponse HTTP contenant les informations de l'utilisateur.
*/
@PUT
@Path("{id}")
@Transactional
@Operation(summary = "Mettre à jour un utilisateur", description = "Met à jour un utilisateur existant par ID")
public Response updateUser(@PathParam("id") UUID id, @Valid Users user) {
Users entity = usersRepository.findById(id);
if (entity == null) {
return Response.status(Response.Status.NOT_FOUND).build();
@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 = usersRepository.findById(id);
if (user == null) {
LOG.warn("Utilisateur non trouvé avec l'ID : " + id);
return Response.status(Response.Status.NOT_FOUND)
.entity("Utilisateur non trouvé.").build();
}
entity.setNom(user.getNom());
entity.setPrenoms(user.getPrenoms());
entity.setEmail(user.getEmail());
entity.setMotDePasse(user.getMotDePasse());
return Response.ok(entity).build();
UserResponseDTO responseDTO = new UserResponseDTO(user);
LOG.info("Utilisateur trouvé : " + user.getEmail());
return Response.ok(responseDTO).build();
}
/**
* Supprime un utilisateur existant.
* Endpoint pour supprimer un utilisateur par ID.
*
* @param id L'ID de l'utilisateur à supprimer.
* @return Une réponse vide avec le statut HTTP approprié.
* @return Une réponse HTTP indiquant le succès ou l'échec de la suppression.
*/
@DELETE
@Path("{id}")
@Path("/{id}")
@Transactional
@Operation(summary = "Supprimer un utilisateur", description = "Supprime un utilisateur existant par ID")
@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 = usersRepository.deleteById(id);
if (!deleted) {
return Response.status(Response.Status.NOT_FOUND).build();
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();
}
return Response.noContent().build();
}
/**
* Classe pour les identifiants de l'utilisateur lors de l'authentification.
*/
@Setter
@Getter
public static class UserCredentials {
@NotNull
@Email
private String email;
@NotNull
private String motDePasse;
}
}