Refactoring et Ajouts de nouveaux endpoints

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

@@ -0,0 +1,25 @@
+package com.lions.dev.core.errors;
+
+import com.lions.dev.core.errors.exceptions.EventNotFoundException;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.ext.ExceptionMapper;
+import jakarta.ws.rs.ext.Provider;
+
+/**
+ * Gestionnaire global des exceptions pour mapper les exceptions à des réponses HTTP appropriées.
+ */
+@Provider
+public class GlobalExceptionHandler implements ExceptionMapper<Throwable> {
+
+  @Override
+  public Response toResponse(Throwable exception) {
+    if (exception instanceof EventNotFoundException) {
+      return Response.status(Response.Status.NOT_FOUND)
+                     .entity(exception.getMessage())
+                     .build();
+    }
+    return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+                   .entity("Une erreur interne est survenue.")
+                   .build();
+  }
+}

src/main/java/com/lions/dev/core/errors/exceptions/EventNotFoundException.java

@@ -0,0 +1,15 @@
+package com.lions.dev.core.errors.exceptions;
+
+/**
+ * Exception lancée lorsque l'événement n'est pas trouvé.
+ */
+public class EventNotFoundException extends RuntimeException {
+
+  public EventNotFoundException(String message) {
+    super(message);
+  }
+
+  public EventNotFoundException(java.util.UUID eventId) {
+    super("L'événement avec l'ID " + eventId + " n'a pas été trouvé.");
+  }
+}

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

@@ -8,53 +8,33 @@ import java.time.LocalDateTime;
 /**
  * DTO pour la création d'un événement.
  * Ce DTO est utilisé dans les requêtes de création d'événements, envoyant les informations
- * nécessaires comme le titre, les dates et le créateur.
+ * nécessaires comme le titre, les dates, la description, le créateur, et d'autres attributs.
  */
-public class EventRequestDTO {
+@lombok.Getter
+@lombok.Setter
+public class EventCreateRequestDTO {
 
   @NotNull(message = "Le titre de l'événement est obligatoire.")
   @Size(min = 3, max = 100, message = "Le titre doit comporter entre 3 et 100 caractères.")
   private String title; // Titre de l'événement
 
+  private String description; // Description de l'événement
+
   @NotNull(message = "La date de début est obligatoire.")
   private LocalDateTime startDate; // Date de début de l'événement
 
   @NotNull(message = "La date de fin est obligatoire.")
   private LocalDateTime endDate; // Date de fin de l'événement
 
+  private String location; // Lieu de l'événement
+  private String category; // Catégorie de l'événement
+  private String link; // Lien d'information supplémentaire
+  private String imageUrl; // URL de l'image associée à l'événement
+
   @NotNull(message = "Le créateur de l'événement est obligatoire.")
   private Users creator; // Utilisateur créateur de l'événement
 
-  // Getters et setters
-  public String getTitle() {
-    return title;
-  }
-
-  public void setTitle(String title) {
-    this.title = title;
-  }
-
-  public LocalDateTime getStartDate() {
-    return startDate;
-  }
-
-  public void setStartDate(LocalDateTime startDate) {
-    this.startDate = startDate;
-  }
-
-  public LocalDateTime getEndDate() {
-    return endDate;
-  }
-
-  public void setEndDate(LocalDateTime endDate) {
-    this.endDate = endDate;
-  }
-
-  public Users getCreator() {
-    return creator;
-  }
-
-  public void setCreator(Users creator) {
-    this.creator = creator;
+  public EventCreateRequestDTO() {
+    System.out.println("[LOG] DTO de requête de création d'événement initialisé.");
   }
 }

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

@@ -0,0 +1,20 @@
+package com.lions.dev.dto.request.events;
+
+import jakarta.validation.constraints.NotNull;
+import java.util.UUID;
+
+/**
+ * DTO pour la suppression d'un événement.
+ * Ce DTO est utilisé pour capturer l'ID d'un événement à supprimer.
+ */
+@lombok.Getter
+@lombok.Setter
+public class EventDeleteRequestDTO {
+
+  @NotNull(message = "L'ID de l'événement est obligatoire.")
+  private UUID eventId; // ID de l'événement à supprimer
+
+  public EventDeleteRequestDTO() {
+    System.out.println("[LOG] DTO de requête de suppression d'événement initialisé.");
+  }
+}

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

@@ -0,0 +1,20 @@
+package com.lions.dev.dto.request.events;
+
+import jakarta.validation.constraints.NotNull;
+import java.util.UUID;
+
+/**
+ * DTO pour lire un événement par son ID.
+ * Ce DTO est utilisé dans les requêtes pour récupérer les informations d'un événement spécifique.
+ */
+@lombok.Getter
+@lombok.Setter
+public class EventReadRequestDTO {
+
+  @NotNull(message = "L'ID de l'événement est obligatoire.")
+  private UUID eventId; // ID de l'événement à lire
+
+  public EventReadRequestDTO() {
+    System.out.println("[LOG] DTO de requête de lecture d'événement initialisé.");
+  }
+}

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

@@ -0,0 +1,22 @@
+package com.lions.dev.dto.request.events;
+
+import java.time.LocalDateTime;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * DTO pour la mise à jour d'un événement.
+ * Ce DTO est utilisé dans les requêtes de mise à jour des événements.
+ */
+@Getter
+@Setter
+public class EventUpdateRequestDTO {
+  private String title;
+  private String description;
+  private LocalDateTime startDate;
+  private LocalDateTime endDate;
+  private String location;
+  private String category;
+  private String link;
+  private String imageUrl;
+}

src/main/java/com/lions/dev/dto/request/users/UserCreateRequestDTO.java

@@ -13,7 +13,7 @@ import lombok.Setter;
  */
 @Getter
 @Setter
-public class UserRequestDTO {
+public class UserCreateRequestDTO {
 
   @NotNull(message = "Le nom est obligatoire.")
   @Size(min = 1, max = 100, message = "Le nom doit comporter entre 1 et 100 caractères.")

src/main/java/com/lions/dev/dto/request/users/UserDeleteRequestDto.java

@@ -0,0 +1,32 @@
+package com.lions.dev.dto.request.users;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import java.util.UUID;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * DTO pour la requête de suppression d'un utilisateur.
+ * Utilisé pour encapsuler l'ID de l'utilisateur à supprimer.
+ */
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class UserDeleteRequestDto {
+
+  private static final Logger logger = LoggerFactory.getLogger(UserDeleteRequestDto.class);
+
+  /**
+   * Identifiant unique de l'utilisateur à supprimer.
+   */
+  private UUID userId;
+
+  // Méthode pour loguer les détails de la requête de suppression
+  public void logRequestDetails() {
+    logger.info("Demande de suppression pour l'utilisateur avec l'ID : {}", userId);
+  }
+}

src/main/java/com/lions/dev/dto/response/events/EventCreateResponseDTO.java

@@ -8,11 +8,17 @@ import java.time.LocalDateTime;
  * Ce DTO est utilisé pour structurer les données retournées dans les réponses
  * après les opérations sur les événements (création, récupération).
  */
-public class EventResponseDTO {
+@lombok.Getter
+public class EventCreateResponseDTO {
 
   private String title; // Titre de l'événement
+  private String description; // Description de l'événement
   private LocalDateTime startDate; // Date de début de l'événement
   private LocalDateTime endDate; // Date de fin de l'événement
+  private String location; // Lieu de l'événement
+  private String category; // Catégorie de l'événement
+  private String link; // Lien vers plus d'informations
+  private String imageUrl; // URL d'une image pour l'événement
   private String creatorEmail; // Email du créateur de l'événement
 
   /**
@@ -20,27 +26,15 @@ public class EventResponseDTO {
    *
    * @param event L'événement à convertir en DTO.
    */
-  public EventResponseDTO(Events event) {
+  public EventCreateResponseDTO(Events event) {
     this.title = event.getTitle();
+    this.description = event.getDescription();
     this.startDate = event.getStartDate();
     this.endDate = event.getEndDate();
+    this.location = event.getLocation();
+    this.category = event.getCategory();
+    this.link = event.getLink();
+    this.imageUrl = event.getImageUrl();
     this.creatorEmail = event.getCreator().getEmail();
   }
-
-  // Getters
-  public String getTitle() {
-    return title;
-  }
-
-  public LocalDateTime getStartDate() {
-    return startDate;
-  }
-
-  public LocalDateTime getEndDate() {
-    return endDate;
-  }
-
-  public String getCreatorEmail() {
-    return creatorEmail;
-  }
 }

src/main/java/com/lions/dev/dto/response/events/EventDeleteResponseDTO.java

@@ -0,0 +1,36 @@
+package com.lions.dev.dto.response.events;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * DTO pour la réponse après la tentative de suppression d'un événement.
+ * Indique si la suppression a réussi ou échoué.
+ */
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class EventDeleteResponseDTO {
+
+  private static final Logger logger = LoggerFactory.getLogger(EventDeleteResponseDTO.class);
+
+  /**
+   * Statut indiquant si la suppression a réussi ou échoué.
+   */
+  private boolean success;
+
+  /**
+   * Message décrivant le résultat de l'opération.
+   */
+  private String message;
+
+  // Méthode pour loguer les détails de la réponse
+  public void logResponseDetails() {
+    logger.info("[LOG] Suppression d'événement - Succès : {}, Message : {}", success, message);
+  }
+}

src/main/java/com/lions/dev/dto/response/events/EventUpdateResponseDTO.java

@@ -0,0 +1,33 @@
+package com.lions.dev.dto.response.events;
+
+import com.lions.dev.entity.events.Events;
+import java.time.LocalDateTime;
+import lombok.Getter;
+
+/**
+ * DTO pour renvoyer les informations après la mise à jour d'un événement.
+ */
+@Getter
+public class EventUpdateResponseDTO {
+  private String title;
+  private String description;
+  private LocalDateTime startDate;
+  private LocalDateTime endDate;
+  private String location;
+  private String category;
+  private String link;
+  private String imageUrl;
+  private String creatorEmail;
+
+  public EventUpdateResponseDTO(Events event) {
+    this.title = event.getTitle();
+    this.description = event.getDescription();
+    this.startDate = event.getStartDate();
+    this.endDate = event.getEndDate();
+    this.location = event.getLocation();
+    this.category = event.getCategory();
+    this.link = event.getLink();
+    this.imageUrl = event.getImageUrl();
+    this.creatorEmail = event.getCreator().getEmail();
+  }
+}

src/main/java/com/lions/dev/dto/response/users/UserAuthenticateResponseDTO.java

@@ -20,12 +20,6 @@ public class UserAuthenticateResponseDTO {
 
   private static final Logger logger = LoggerFactory.getLogger(UserAuthenticateResponseDTO.class);
 
-  /**
-   * Jeton JWT généré après une authentification réussie.
-   * Il doit être utilisé pour toutes les communications sécurisées avec l'API.
-   */
-  // private String token;
-
   /**
    * Identifiant unique de l'utilisateur authentifié.
    */
@@ -55,11 +49,13 @@ public class UserAuthenticateResponseDTO {
    * Log de création de l'objet DTO.
    */
   static {
-    logger.info("UserAuthenticateResponseDTO - DTO pour la réponse d'authentification initialisé");
+    logger.info("[LOG] UserAuthenticateResponseDTO - DTO pour la réponse d'authentification initialisé");
   }
 
-  // Méthode personnalisée pour loguer les détails de la réponse
+  /**
+   * Méthode personnalisée pour loguer les détails de la réponse.
+   */
   public void logResponseDetails() {
-    logger.info("Réponse d'authentification - Utilisateur: {}, {}, Email: {}, Rôle: {}, ID: {}, Token généré", prenoms, nom, email, role, userId);
+    logger.info("[LOG] Réponse d'authentification - Utilisateur: {}, {}, Email: {}, Rôle: {}, ID: {}", prenoms, nom, email, role, userId);
   }
 }

src/main/java/com/lions/dev/dto/response/users/UserCreateResponseDTO.java

@@ -10,9 +10,9 @@ import lombok.Getter;
  * après les opérations sur les utilisateurs (création, récupération).
  */
 @Getter
-public class UserResponseDTO {
+public class UserCreateResponseDTO {
 
-  private UUID uuid;
+  private UUID uuid;  // Identifiant unique de l'utilisateur
   private String nom; // Nom de l'utilisateur
   private String prenoms; // Prénoms de l'utilisateur
   private String email; // Email de l'utilisateur
@@ -22,10 +22,11 @@ public class UserResponseDTO {
    *
    * @param user L'utilisateur à convertir en DTO.
    */
-  public UserResponseDTO(Users user) {
+  public UserCreateResponseDTO(Users user) {
     this.uuid = user.getId();
     this.nom = user.getNom();
     this.prenoms = user.getPrenoms();
     this.email = user.getEmail();
+    System.out.println("[LOG] DTO créé pour l'utilisateur : " + this.email);
   }
 }

src/main/java/com/lions/dev/dto/response/users/UserDeleteResponseDto.java

@@ -0,0 +1,38 @@
+package com.lions.dev.dto.response.users;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * DTO pour la réponse après la tentative de suppression d'un utilisateur.
+ * Indique si la suppression a réussi ou échoué.
+ */
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class UserDeleteResponseDto {
+
+  private static final Logger logger = LoggerFactory.getLogger(UserDeleteResponseDto.class);
+
+  /**
+   * Statut indiquant si la suppression a réussi ou échoué.
+   */
+  private boolean success;
+
+  /**
+   * Message décrivant le résultat de l'opération.
+   */
+  private String message;
+
+  /**
+   * Méthode pour loguer les détails de la réponse.
+   */
+  public void logResponseDetails() {
+    logger.info("[LOG] Suppression d'utilisateur - Succès : {}, Message : {}", success, message);
+  }
+}

src/main/java/com/lions/dev/entity/events/Events.java

@@ -14,9 +14,8 @@ import java.util.Set;
 
 /**
  * Entité représentant un événement dans le système AfterWork.
- * Chaque événement possède un titre, une date de début, une date de fin, un créateur,
- * et des participants.
- *
+ * Chaque événement possède un titre, une description, une date de début, une date de fin,
+ * un créateur, une catégorie, un lieu, une URL d'image, et des participants.
  * Tous les logs et commentaires nécessaires pour la traçabilité et la documentation sont inclus.
  */
 @Entity
@@ -27,17 +26,33 @@ import java.util.Set;
 @ToString
 public class Events extends BaseEntity {
 
-  // Attributs de l'entité événement
-
   @Column(name = "title", nullable = false)
   private String title; // Le titre de l'événement
 
+  @Column(name = "description")
+  private String description; // La description de l'événement
+
   @Column(name = "start_date", nullable = false)
   private LocalDateTime startDate; // La date de début de l'événement
 
   @Column(name = "end_date", nullable = false)
   private LocalDateTime endDate; // La date de fin de l'événement
 
+  @Column(name = "location")
+  private String location; // Le lieu de l'événement
+
+  @Column(name = "category")
+  private String category; // La catégorie de l'événement
+
+  @Column(name = "link")
+  private String link; // Un lien vers plus d'informations sur l'événement
+
+  @Column(name = "image_url")
+  private String imageUrl; // URL d'une image associée à l'événement
+
+  @Column(name = "status", nullable = false)
+  private String status = "en cours"; // Le statut de l'événement (en cours, terminé, annulé, etc.)
+
   @ManyToOne(fetch = FetchType.LAZY)
   @JoinColumn(name = "creator_id", nullable = false)
   private Users creator; // L'utilisateur créateur de l'événement
@@ -50,6 +65,8 @@ public class Events extends BaseEntity {
   )
   private Set<Users> participants = new HashSet<>(); // Les participants à l'événement
 
+  // Méthodes
+
   /**
    * Ajoute un utilisateur en tant que participant à l'événement.
    *
@@ -80,4 +97,12 @@ public class Events extends BaseEntity {
     System.out.println("[LOG] Nombre de participants à l'événement : " + this.title + " - " + count);
     return count;
   }
+
+  /**
+   * Ferme l'événement en changeant son statut.
+   */
+  public void setClosed(boolean closed) {
+    this.status = closed ? "fermé" : "en cours";
+    System.out.println("[LOG] Statut de l'événement mis à jour : " + this.title + " - " + this.status);
+  }
 }

src/main/java/com/lions/dev/entity/users/Users.java

@@ -23,8 +23,6 @@ import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 @ToString
 public class Users extends BaseEntity {
 
-  // Attributs de l'entité utilisateur
-
   @Column(name = "nom", nullable = false, length = 100)
   private String nom; // Le nom de l'utilisateur
 

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

@@ -2,6 +2,7 @@ package com.lions.dev.exception;
 
 import jakarta.ws.rs.WebApplicationException;
 import jakarta.ws.rs.core.Response;
+import java.util.UUID;
 
 /**
  * Exception levée lorsque l'événement demandé n'est pas trouvé dans la base de données.
@@ -10,12 +11,12 @@ import jakarta.ws.rs.core.Response;
 public class EventNotFoundException extends WebApplicationException {
 
   /**
-   * Constructeur qui prend un message d'erreur à afficher lorsque l'exception est levée.
+   * Constructeur qui prend un UUID et convertit l'UUID en message détaillant l'erreur.
    *
-   * @param message Le message détaillant l'erreur.
+   * @param eventId L'UUID de l'événement qui n'a pas été trouvé.
    */
-  public EventNotFoundException(String message) {
-    super(message, Response.Status.NOT_FOUND);
-    System.out.println("[ERROR] Événement non trouvé : " + message);
+  public EventNotFoundException(UUID eventId) {
+    super("Événement non trouvé avec l'ID : " + eventId.toString(), Response.Status.NOT_FOUND);
+    System.out.println("[ERROR] Événement non trouvé avec l'ID : " + eventId.toString());
   }
 }

src/main/java/com/lions/dev/repository/EventsRepository.java

@@ -3,79 +3,28 @@ package com.lions.dev.repository;
 import com.lions.dev.entity.events.Events;
 import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
 import jakarta.enterprise.context.ApplicationScoped;
-
 import java.time.LocalDateTime;
 import java.util.List;
-import java.util.Optional;
 import java.util.UUID;
 
 /**
  * Repository pour l'entité Events.
- * Ce repository gère les opérations de base (CRUD) sur les événements ainsi que des méthodes de filtrage personnalisées.
- *
- * Utilisation de Panache pour simplifier les opérations sur la base de données.
+ * Ce repository gère les opérations de base (CRUD) sur les événements et inclut
+ * des méthodes personnalisées comme la récupération des événements après une certaine date.
  */
 @ApplicationScoped
 public class EventsRepository implements PanacheRepositoryBase<Events, UUID> {
 
   /**
-   * Recherche un événement par son titre.
+   * Récupère tous les événements après une date donnée.
    *
-   * @param title Le titre de l'événement à rechercher.
-   * @return Un Optional contenant l'événement s'il est trouvé, sinon un Optional vide.
-   */
-  public Optional<Events> findByTitle(String title) {
-    System.out.println("[LOG] Recherche de l'événement avec le titre : " + title);
-    Events event = find("title", title).firstResult();
-    if (event != null) {
-      System.out.println("[LOG] Événement trouvé : " + event.getTitle());
-    } else {
-      System.out.println("[LOG] Aucun événement trouvé avec le titre : " + title);
-    }
-    return Optional.ofNullable(event);
-  }
-
-  /**
-   * Récupère tous les événements créés par un utilisateur spécifique.
-   *
-   * @param userId L'ID de l'utilisateur créateur des événements.
-   * @return Une liste d'événements créés par l'utilisateur.
-   */
-  public List<Events> findByCreator(UUID userId) {
-    System.out.println("[LOG] Récupération des événements créés par l'utilisateur avec l'ID : " + userId);
-    List<Events> events = list("creator.id", userId);
-    System.out.println("[LOG] Nombre d'événements trouvés pour l'utilisateur : " + events.size());
-    return events;
-  }
-
-  /**
-   * Supprime un événement par son identifiant UUID.
-   *
-   * @param id L'UUID de l'événement à supprimer.
-   * @return true si l'événement a été supprimé, sinon false.
-   */
-  public boolean deleteById(UUID id) {
-    System.out.println("[LOG] Suppression de l'événement avec l'ID : " + id);
-    long deletedCount = delete("id", id);  // Utiliser long pour récupérer le nombre d'enregistrements supprimés
-    boolean deleted = deletedCount > 0;  // Convertir en boolean
-    if (deleted) {
-      System.out.println("[LOG] Événement avec l'ID " + id + " supprimé avec succès.");
-    } else {
-      System.out.println("[LOG] Aucune suppression, événement avec l'ID " + id + " introuvable.");
-    }
-    return deleted;
-  }
-
-  /**
-   * Récupère une liste d'événements avec filtrage par date de début.
-   *
-   * @param startDate La date de début à partir de laquelle rechercher les événements.
-   * @return Une liste d'événements filtrés.
+   * @param startDate La date de début de filtre.
+   * @return Une liste d'événements après cette date.
    */
   public List<Events> findEventsAfterDate(LocalDateTime startDate) {
     System.out.println("[LOG] Récupération des événements après la date : " + startDate);
-    List<Events> events = list("startDate >= ?1", startDate);
-    System.out.println("[LOG] Nombre d'événements trouvés après la date : " + startDate + " : " + events.size());
+    List<Events> events = list("startDate > ?1", startDate);
+    System.out.println("[LOG] Nombre d'événements trouvés après la date " + startDate + " : " + events.size());
     return events;
   }
 }

src/main/java/com/lions/dev/repository/UsersRepository.java

@@ -63,5 +63,4 @@ public class UsersRepository implements PanacheRepositoryBase<Users, UUID> {
     }
     return deleted;
   }
-
 }

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

@@ -1,10 +1,13 @@
 package com.lions.dev.resource;
 
+import com.lions.dev.dto.response.events.EventUpdateResponseDTO;
+import com.lions.dev.dto.request.events.EventUpdateRequestDTO;
+import com.lions.dev.entity.users.Users;
+import com.lions.dev.dto.request.events.EventCreateRequestDTO;
+import com.lions.dev.dto.response.events.EventCreateResponseDTO;
 import com.lions.dev.entity.events.Events;
 import com.lions.dev.repository.EventsRepository;
-import com.lions.dev.dto.request.events.EventRequestDTO;
-import com.lions.dev.dto.response.events.EventResponseDTO;
-import com.lions.dev.exception.EventNotFoundException;
+import com.lions.dev.repository.UsersRepository; // Ajout du UsersRepository pour gérer les participants
 import jakarta.inject.Inject;
 import jakarta.transaction.Transactional;
 import jakarta.ws.rs.*;
@@ -31,30 +34,38 @@ public class EventsResource {
   @Inject
   EventsRepository eventsRepository;
 
+  @Inject
+  UsersRepository usersRepository;  // Ajout pour la gestion des participants
+
   private static final Logger LOG = Logger.getLogger(EventsResource.class);
 
   /**
    * Endpoint pour créer un nouvel événement.
    *
-   * @param eventRequestDTO Le DTO contenant les informations de l'événement à créer.
+   * @param eventCreateRequestDTO 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 et retourne ses détails")
-  public Response createEvent(EventRequestDTO eventRequestDTO) {
-    LOG.info("Tentative de création d'un nouvel événement : " + eventRequestDTO.getTitle());
+  public Response createEvent(EventCreateRequestDTO eventCreateRequestDTO) {
+    LOG.info("[LOG] Tentative de création d'un nouvel événement : " + eventCreateRequestDTO.getTitle());
 
     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
+    event.setTitle(eventCreateRequestDTO.getTitle());
+    event.setStartDate(eventCreateRequestDTO.getStartDate());
+    event.setEndDate(eventCreateRequestDTO.getEndDate());
+    event.setDescription(eventCreateRequestDTO.getDescription());
+    event.setLocation(eventCreateRequestDTO.getLocation());
+    event.setCategory(eventCreateRequestDTO.getCategory());
+    event.setLink(eventCreateRequestDTO.getLink());
+    event.setImageUrl(eventCreateRequestDTO.getImageUrl());
+    event.setCreator(eventCreateRequestDTO.getCreator());
 
     eventsRepository.persist(event);
-    LOG.info("Événement créé avec succès : " + event.getTitle());
+    LOG.info("[LOG] Événement créé avec succès : " + event.getTitle());
 
-    EventResponseDTO responseDTO = new EventResponseDTO(event);
+    EventCreateResponseDTO responseDTO = new EventCreateResponseDTO(event);
     return Response.status(Response.Status.CREATED).entity(responseDTO).build();
   }
 
@@ -68,17 +79,16 @@ public class EventsResource {
   @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.info("Récupération de l'événement avec l'ID : " + id);
+    LOG.info("[LOG] Récupération de l'événement avec l'ID : " + id);
 
     Events event = eventsRepository.findById(id);
     if (event == null) {
-      LOG.warn("Événement non trouvé avec l'ID : " + id);
-      return Response.status(Response.Status.NOT_FOUND)
-          .entity("Événement non trouvé.").build();
+      LOG.warn("[LOG] Événement non trouvé avec l'ID : " + id);
+      return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build();
     }
 
-    EventResponseDTO responseDTO = new EventResponseDTO(event);
-    LOG.info("Événement trouvé : " + event.getTitle());
+    EventCreateResponseDTO responseDTO = new EventCreateResponseDTO(event);
+    LOG.info("[LOG] Événement trouvé : " + event.getTitle());
     return Response.ok(responseDTO).build();
   }
 
@@ -92,17 +102,16 @@ public class EventsResource {
   @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);
+    LOG.info("[LOG] 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();
+      LOG.warn("[LOG] 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();
     }
 
-    List<EventResponseDTO> responseDTOs = events.stream().map(EventResponseDTO::new).toList();
-    LOG.info("Nombre d'événements trouvés après la date : " + events.size());
+    List<EventCreateResponseDTO> responseDTOs = events.stream().map(EventCreateResponseDTO::new).toList();
+    LOG.info("[LOG] Nombre d'événements trouvés après la date : " + events.size());
     return Response.ok(responseDTOs).build();
   }
 
@@ -126,7 +135,156 @@ public class EventsResource {
     } else {
       LOG.warn("Échec de la suppression : événement introuvable avec l'ID : " + id);
       return Response.status(Response.Status.NOT_FOUND)
-          .entity("Événement non trouvé.").build();
+                     .entity("Événement non trouvé.").build();
     }
   }
+
+  /**
+   * Endpoint pour ajouter un participant à un événement.
+   *
+   * @param eventId L'ID de l'événement.
+   * @param user L'utilisateur à ajouter comme participant.
+   * @return Une réponse HTTP indiquant le succès de l'ajout.
+   */
+  @POST
+  @Path("/{id}/participants")
+  @Transactional
+  @Operation(summary = "Ajouter un participant à un événement", description = "Ajoute un utilisateur à un événement")
+  public Response addParticipant(@PathParam("id") UUID eventId, Users user) {
+    LOG.info("Ajout d'un participant à l'événement : " + eventId);
+    Events event = eventsRepository.findById(eventId);
+
+    if (event == null) {
+      LOG.warn("Événement non trouvé avec l'ID : " + eventId);
+      return Response.status(Response.Status.NOT_FOUND)
+                     .entity("Événement non trouvé.").build();
+    }
+
+    event.addParticipant(user);
+    eventsRepository.persist(event);
+    LOG.info("Participant ajouté avec succès à l'événement : " + event.getTitle());
+    return Response.ok(new EventCreateResponseDTO(event)).build();
+  }
+
+  /**
+   * Endpoint pour retirer un participant d'un événement.
+   *
+   * @param eventId L'ID de l'événement.
+   * @param userId L'ID de l'utilisateur à retirer.
+   * @return Une réponse HTTP indiquant le succès du retrait.
+   */
+  @DELETE
+  @Path("/{id}/participants/{userId}")
+  @Transactional
+  @Operation(summary = "Retirer un participant d'un événement", description = "Supprime un utilisateur de la liste des participants d'un événement")
+  public Response removeParticipant(@PathParam("id") UUID eventId, @PathParam("userId") UUID userId) {
+    LOG.info("Retrait d'un participant de l'événement : " + eventId);
+    Events event = eventsRepository.findById(eventId);
+
+    if (event == null) {
+      LOG.warn("Événement non trouvé avec l'ID : " + eventId);
+      return Response.status(Response.Status.NOT_FOUND)
+                     .entity("Événement non trouvé.").build();
+    }
+
+    Users user = usersRepository.findById(userId);
+    if (user == null) {
+      LOG.warn("Utilisateur non trouvé avec l'ID : " + userId);
+      return Response.status(Response.Status.NOT_FOUND)
+                     .entity("Utilisateur non trouvé.").build();
+    }
+
+    event.removeParticipant(user);
+    eventsRepository.persist(event);
+    LOG.info("Participant retiré avec succès de l'événement : " + event.getTitle());
+    return Response.noContent().build();
+  }
+
+  /**
+   * Endpoint pour obtenir le nombre de participants à un événement.
+   *
+   * @param eventId L'ID de l'événement.
+   * @return Le nombre de participants.
+   */
+  @GET
+  @Path("/{id}/participants/count")
+  @Operation(summary = "Obtenir le nombre de participants à un événement", description = "Retourne le nombre total de participants à un événement")
+  public Response getNumberOfParticipants(@PathParam("id") UUID eventId) {
+    LOG.info("Récupération du nombre de participants pour l'événement : " + eventId);
+    Events event = eventsRepository.findById(eventId);
+
+    if (event == null) {
+      LOG.warn("Événement non trouvé avec l'ID : " + eventId);
+      return Response.status(Response.Status.NOT_FOUND)
+                     .entity("Événement non trouvé.").build();
+    }
+
+    int participantCount = event.getNumberOfParticipants();
+    LOG.info("Nombre de participants pour l'événement : " + participantCount);
+    return Response.ok(participantCount).build();
+  }
+
+  /**
+   * Endpoint pour fermer un événement.
+   *
+   * @param eventId L'ID de l'événement.
+   * @return Une réponse HTTP indiquant le succès de la fermeture.
+   */
+  @POST
+  @Path("/{id}/close")
+  @Transactional
+  @Operation(summary = "Fermer un événement", description = "Ferme un événement et empêche les nouvelles participations")
+  public Response closeEvent(@PathParam("id") UUID eventId) {
+    LOG.info("Tentative de fermeture de l'événement avec l'ID : " + eventId);
+    Events event = eventsRepository.findById(eventId);
+
+    if (event == null) {
+      LOG.warn("Événement non trouvé avec l'ID : " + eventId);
+      return Response.status(Response.Status.NOT_FOUND)
+                     .entity("Événement non trouvé.").build();
+    }
+
+    event.setClosed(true); // Marquer l'événement comme fermé
+    eventsRepository.persist(event);
+    LOG.info("Événement fermé avec succès : " + event.getTitle());
+    return Response.ok(new EventCreateResponseDTO(event)).build();
+  }
+
+  /**
+   * Endpoint pour mettre à jour un événement.
+   *
+   * @param id L'ID de l'événement.
+   * @param eventUpdateRequestDTO Le DTO de la requête de mise à jour.
+   * @return Une réponse HTTP indiquant la mise à jour.
+   */
+  @PUT
+  @Path("/{id}")
+  @Transactional
+  @Operation(summary = "Mettre à jour un événement", description = "Modifie un événement existant")
+  public Response updateEvent(@PathParam("id") UUID id, EventUpdateRequestDTO eventUpdateRequestDTO) {
+    LOG.info("[LOG] Tentative de mise à jour de l'événement avec l'ID : " + id);
+
+    Events event = eventsRepository.findById(id);
+    if (event == null) {
+      LOG.warn("[LOG] Événement non trouvé avec l'ID : " + id);
+      return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build();
+    }
+
+    // Mise à jour des attributs de l'événement
+    event.setTitle(eventUpdateRequestDTO.getTitle());
+    event.setStartDate(eventUpdateRequestDTO.getStartDate());
+    event.setEndDate(eventUpdateRequestDTO.getEndDate());
+    event.setDescription(eventUpdateRequestDTO.getDescription());
+    event.setLocation(eventUpdateRequestDTO.getLocation());
+    event.setCategory(eventUpdateRequestDTO.getCategory());
+    event.setLink(eventUpdateRequestDTO.getLink());
+    event.setImageUrl(eventUpdateRequestDTO.getImageUrl());
+
+    eventsRepository.persist(event);
+    LOG.info("[LOG] Événement mis à jour avec succès : " + event.getTitle());
+
+    EventUpdateResponseDTO responseDTO = new EventUpdateResponseDTO(event);
+    return Response.ok(responseDTO).build();
+  }
+
 }

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

@@ -1,9 +1,8 @@
 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.dto.response.users.UserDeleteResponseDto;
 import com.lions.dev.entity.users.Users;
 import com.lions.dev.service.UserService;
 import jakarta.inject.Inject;
@@ -34,7 +33,7 @@ public class UsersResource {
   /**
    * Endpoint pour créer un nouvel utilisateur.
    *
-   * @param userRequestDTO Le DTO contenant les informations de l'utilisateur à créer.
+   * @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
@@ -42,15 +41,17 @@ public class UsersResource {
   @Operation(
       summary = "Créer un nouvel utilisateur",
       description = "Crée un nouvel utilisateur et retourne les détails")
-  public Response createUser(UserRequestDTO userRequestDTO) {
+  public Response createUser(
+      com.lions.dev.dto.request.users.UserCreateRequestDTO userCreateRequestDTO) {
     LOG.info(
         "Tentative de création d'un nouvel utilisateur avec l'email : "
-            + userRequestDTO.getEmail());
+        + userCreateRequestDTO.getEmail());
 
     // Utilisation de UserService pour créer l'utilisateur
-    Users user = userService.createUser(userRequestDTO);
+    Users user = userService.createUser(userCreateRequestDTO);
 
-    UserResponseDTO responseDTO = new UserResponseDTO(user);
+    com.lions.dev.dto.response.users.UserCreateResponseDTO
+        responseDTO = new com.lions.dev.dto.response.users.UserCreateResponseDTO(user);
     return Response.status(Response.Status.CREATED).entity(responseDTO).build();
   }
 
@@ -104,7 +105,8 @@ public class UsersResource {
     // Utilisation de UserService pour récupérer l'utilisateur
     Users user = userService.getUserById(id);
 
-    UserResponseDTO responseDTO = new UserResponseDTO(user);
+    com.lions.dev.dto.response.users.UserCreateResponseDTO
+        responseDTO = new com.lions.dev.dto.response.users.UserCreateResponseDTO(user);
     LOG.info("Utilisateur trouvé : " + user.getEmail());
     return Response.ok(responseDTO).build();
   }
@@ -113,7 +115,7 @@ public class UsersResource {
    * 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.
+   * @return Une réponse HTTP avec le statut de suppression.
    */
   @DELETE
   @Path("/{id}")
@@ -127,12 +129,20 @@ public class UsersResource {
     // Utilisation de UserService pour supprimer l'utilisateur
     boolean deleted = userService.deleteUser(id);
 
+    UserDeleteResponseDto responseDTO = new UserDeleteResponseDto();
     if (deleted) {
       LOG.info("Utilisateur supprimé avec succès.");
-      return Response.noContent().build();
+      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);
-      return Response.status(Response.Status.NOT_FOUND).entity("Utilisateur non trouvé.").build();
+      responseDTO.setSuccess(false);
+      responseDTO.setMessage("Utilisateur non trouvé.");
+      responseDTO.logResponseDetails();
+      return Response.status(Response.Status.NOT_FOUND).entity(responseDTO).build();
     }
   }
+
 }

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

@@ -1,9 +1,12 @@
 package com.lions.dev.service;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import jakarta.transaction.Transactional;
+import com.lions.dev.dto.request.events.EventCreateRequestDTO;
 import com.lions.dev.entity.events.Events;
 import com.lions.dev.entity.users.Users;
 import com.lions.dev.repository.EventsRepository;
-import com.lions.dev.dto.request.events.EventRequestDTO;
 import com.lions.dev.exception.EventNotFoundException;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
@@ -21,19 +24,27 @@ public class EventService {
   @Inject
   EventsRepository eventsRepository;
 
+  private static final Logger logger = LoggerFactory.getLogger(EventService.class);
+
   /**
    * Crée un nouvel événement dans le système.
    *
-   * @param eventRequestDTO Le DTO contenant les informations de l'événement à créer.
+   * @param eventCreateRequestDTO Le DTO contenant les informations de l'événement à créer.
    * @param creator L'utilisateur créateur de l'événement.
    * @return L'événement créé.
    */
-  public Events createEvent(EventRequestDTO eventRequestDTO, Users creator) {
+  public Events createEvent(EventCreateRequestDTO eventCreateRequestDTO, Users creator) {
     Events event = new Events();
-    event.setTitle(eventRequestDTO.getTitle());
-    event.setStartDate(eventRequestDTO.getStartDate());
-    event.setEndDate(eventRequestDTO.getEndDate());
+    event.setTitle(eventCreateRequestDTO.getTitle());
+    event.setDescription(eventCreateRequestDTO.getDescription());
+    event.setStartDate(eventCreateRequestDTO.getStartDate());
+    event.setEndDate(eventCreateRequestDTO.getEndDate());
+    event.setLocation(eventCreateRequestDTO.getLocation());
+    event.setCategory(eventCreateRequestDTO.getCategory());
+    event.setLink(eventCreateRequestDTO.getLink());
+    event.setImageUrl(eventCreateRequestDTO.getImageUrl());
     event.setCreator(creator);
+    event.setStatus("en cours");
     eventsRepository.persist(event);
     System.out.println("[LOG] Événement créé : " + event.getTitle());
     return event;
@@ -50,7 +61,7 @@ public class EventService {
     Events event = eventsRepository.findById(id);
     if (event == null) {
       System.out.println("[ERROR] Événement non trouvé avec l'ID : " + id);
-      throw new EventNotFoundException("Événement non trouvé avec l'ID : " + id);
+      throw new EventNotFoundException(id);
     }
     System.out.println("[LOG] Événement trouvé avec l'ID : " + id);
     return event;
@@ -74,12 +85,16 @@ public class EventService {
    * @param id L'ID de l'événement à supprimer.
    * @return true si l'événement a été supprimé, false sinon.
    */
+  @Transactional
   public boolean deleteEvent(UUID id) {
+    logger.info("[LOG] Tentative de suppression de l'événement avec l'ID : {}", id);
+
     boolean deleted = eventsRepository.deleteById(id);
     if (deleted) {
-      System.out.println("[LOG] Événement supprimé avec succès : " + id);
+      logger.info("[LOG] Événement avec l'ID {} supprimé avec succès.", id);
     } else {
-      System.out.println("[ERROR] Échec de la suppression de l'événement avec l'ID : " + id);
+      logger.warn("[LOG] Échec de la suppression : événement avec l'ID {} introuvable.", id);
+      throw new EventNotFoundException(id);
     }
     return deleted;
   }

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

@@ -2,7 +2,6 @@ package com.lions.dev.service;
 
 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.exception.UserNotFoundException;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
@@ -22,21 +21,21 @@ public class UserService {
   /**
    * Crée un nouvel utilisateur dans le système.
    *
-   * @param userRequestDTO Le DTO contenant les informations de l'utilisateur à créer.
+   * @param userCreateRequestDTO Le DTO contenant les informations de l'utilisateur à créer.
    * @return L'utilisateur créé.
    */
-  public Users createUser(UserRequestDTO userRequestDTO) {
+  public Users createUser(com.lions.dev.dto.request.users.UserCreateRequestDTO userCreateRequestDTO) {
     Users user = new Users();
-    user.setNom(userRequestDTO.getNom());
-    user.setPrenoms(userRequestDTO.getPrenoms());
-    user.setEmail(userRequestDTO.getEmail());
-    user.setMotDePasse(userRequestDTO.getMotDePasse()); // Hachage automatique
+    user.setNom(userCreateRequestDTO.getNom());
+    user.setPrenoms(userCreateRequestDTO.getPrenoms());
+    user.setEmail(userCreateRequestDTO.getEmail());
+    user.setMotDePasse(userCreateRequestDTO.getMotDePasse()); // Hachage automatique
 
     // Vérifier si le rôle est défini, sinon attribuer un rôle par défaut
-    if (userRequestDTO.getRole() == null || userRequestDTO.getRole().isEmpty()) {
+    if (userCreateRequestDTO.getRole() == null || userCreateRequestDTO.getRole().isEmpty()) {
       user.setRole("USER"); // Assigner un rôle par défaut, par exemple "USER"
     } else {
-      user.setRole(userRequestDTO.getRole());
+      user.setRole(userCreateRequestDTO.getRole());
     }
 
     usersRepository.persist(user);