diff --git a/src/main/java/com/lions/dev/dto/request/events/EventCreateRequestDTO.java b/src/main/java/com/lions/dev/dto/request/events/EventCreateRequestDTO.java index c411a59..422e445 100644 --- a/src/main/java/com/lions/dev/dto/request/events/EventCreateRequestDTO.java +++ b/src/main/java/com/lions/dev/dto/request/events/EventCreateRequestDTO.java @@ -1,6 +1,8 @@ package com.lions.dev.dto.request.events; -import com.lions.dev.entity.users.Users; +import java.util.UUID; +import lombok.Getter; +import lombok.Setter; import jakarta.validation.constraints.NotNull; import jakarta.validation.constraints.Size; import java.time.LocalDateTime; @@ -10,8 +12,8 @@ import java.time.LocalDateTime; * Ce DTO est utilisé dans les requêtes de création d'événements, envoyant les informations * nécessaires comme le titre, les dates, la description, le créateur, et d'autres attributs. */ -@lombok.Getter -@lombok.Setter +@Getter +@Setter public class EventCreateRequestDTO { @NotNull(message = "Le titre de l'événement est obligatoire.") @@ -31,8 +33,8 @@ public class EventCreateRequestDTO { 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 + @NotNull(message = "L'identifiant du créateur est obligatoire.") + private UUID creatorId; // Identifiant du créateur de l'événement public EventCreateRequestDTO() { System.out.println("[LOG] DTO de requête de création d'événement initialisé."); diff --git a/src/main/java/com/lions/dev/dto/request/events/EventReadRequestDTO.java b/src/main/java/com/lions/dev/dto/request/events/EventGetOneByIdRequestDTO.java similarity index 86% rename from src/main/java/com/lions/dev/dto/request/events/EventReadRequestDTO.java rename to src/main/java/com/lions/dev/dto/request/events/EventGetOneByIdRequestDTO.java index 46c5983..3a07606 100644 --- a/src/main/java/com/lions/dev/dto/request/events/EventReadRequestDTO.java +++ b/src/main/java/com/lions/dev/dto/request/events/EventGetOneByIdRequestDTO.java @@ -9,12 +9,12 @@ import java.util.UUID; */ @lombok.Getter @lombok.Setter -public class EventReadRequestDTO { +public class EventGetOneByIdRequestDTO { @NotNull(message = "L'ID de l'événement est obligatoire.") private UUID eventId; // ID de l'événement à lire - public EventReadRequestDTO() { + public EventGetOneByIdRequestDTO() { System.out.println("[LOG] DTO de requête de lecture d'événement initialisé."); } } diff --git a/src/main/java/com/lions/dev/dto/response/events/EventCreateResponseDTO.java b/src/main/java/com/lions/dev/dto/response/events/EventCreateResponseDTO.java index 3a7ed79..7c79188 100644 --- a/src/main/java/com/lions/dev/dto/response/events/EventCreateResponseDTO.java +++ b/src/main/java/com/lions/dev/dto/response/events/EventCreateResponseDTO.java @@ -11,6 +11,7 @@ import java.time.LocalDateTime; @lombok.Getter public class EventCreateResponseDTO { + private String id; // Identifiant de l'événement 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 @@ -27,6 +28,7 @@ public class EventCreateResponseDTO { * @param event L'événement à convertir en DTO. */ public EventCreateResponseDTO(Events event) { + this.id = event.getId().toString(); this.title = event.getTitle(); this.description = event.getDescription(); this.startDate = event.getStartDate(); diff --git a/src/main/java/com/lions/dev/repository/EventsRepository.java b/src/main/java/com/lions/dev/repository/EventsRepository.java index 146f988..a9fce37 100644 --- a/src/main/java/com/lions/dev/repository/EventsRepository.java +++ b/src/main/java/com/lions/dev/repository/EventsRepository.java @@ -6,6 +6,7 @@ import jakarta.enterprise.context.ApplicationScoped; import java.time.LocalDateTime; import java.util.List; import java.util.UUID; +import org.jboss.logging.Logger; /** * Repository pour l'entité Events. @@ -15,6 +16,8 @@ import java.util.UUID; @ApplicationScoped public class EventsRepository implements PanacheRepositoryBase { + private static final Logger LOG = Logger.getLogger(EventsRepository.class); + /** * Récupère tous les événements après une date donnée. * @@ -22,9 +25,28 @@ public class EventsRepository implements PanacheRepositoryBase { * @return Une liste d'événements après cette date. */ public List findEventsAfterDate(LocalDateTime startDate) { - System.out.println("[LOG] 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 = list("startDate > ?1", startDate); - System.out.println("[LOG] Nombre d'événements trouvés après la date " + startDate + " : " + events.size()); + LOG.info("[LOG] Nombre d'événements trouvés après la date " + startDate + " : " + events.size()); + return events; + } + + /** + * Récupère tous les événements entre deux dates. + * + * @param startDate La date de début de filtre. + * @param endDate La date de fin de filtre. + * @return Une liste d'événements entre ces deux dates. + */ + public List findEventsBetweenDates(LocalDateTime startDate, LocalDateTime endDate) { + if (endDate.isBefore(startDate)) { + LOG.warn("[LOG] La date de fin " + endDate + " est antérieure à la date de début " + startDate); + return List.of(); // Retourner une liste vide en cas de dates invalides + } + + LOG.info("[LOG] Récupération des événements entre les dates : " + startDate + " et " + endDate); + List events = list("startDate >= ?1 and endDate <= ?2", startDate, endDate); + LOG.info("[LOG] Nombre d'événements trouvés entre les dates " + startDate + " et " + endDate + " : " + events.size()); return events; } } diff --git a/src/main/java/com/lions/dev/resource/EventsResource.java b/src/main/java/com/lions/dev/resource/EventsResource.java index 9a045e6..5036f12 100644 --- a/src/main/java/com/lions/dev/resource/EventsResource.java +++ b/src/main/java/com/lions/dev/resource/EventsResource.java @@ -17,6 +17,7 @@ import java.io.File; // participants import java.time.LocalDateTime; import java.util.List; import java.util.UUID; +import com.lions.dev.core.errors.exceptions.EventNotFoundException; import org.eclipse.microprofile.openapi.annotations.Operation; import org.eclipse.microprofile.openapi.annotations.tags.Tag; import org.jboss.logging.Logger; @@ -59,18 +60,15 @@ public class EventsResource { LOG.info( "[LOG] Tentative de création d'un nouvel événement : " + eventCreateRequestDTO.getTitle()); - Events event = new Events(); - 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()); + // Récupérer l'utilisateur créateur à partir de l'identifiant + Users creator = usersRepository.findById(eventCreateRequestDTO.getCreatorId()); + if (creator == null) { + LOG.error("[ERROR] Créateur non trouvé avec l'ID : " + eventCreateRequestDTO.getCreatorId()); + return Response.status(Response.Status.BAD_REQUEST).entity("Créateur non trouvé").build(); + } - eventsRepository.persist(event); + // Appel au service pour créer l'événement + Events event = eventService.createEvent(eventCreateRequestDTO, creator); LOG.info("[LOG] Événement créé avec succès : " + event.getTitle()); EventCreateResponseDTO responseDTO = new EventCreateResponseDTO(event); @@ -116,17 +114,21 @@ public class EventsResource { public Response getEventsAfterDate(@QueryParam("startDate") LocalDateTime startDate) { LOG.info("[LOG] Récupération des événements après la date : " + startDate); - List events = eventsRepository.findEventsAfterDate(startDate); + // Appel au service pour récupérer les événements après une date donnée + List events = eventService.getEventsAfterDate(startDate); if (events.isEmpty()) { 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(); + .entity("Aucun événement trouvé après cette date.") + .build(); } - List responseDTOs = - events.stream().map(EventCreateResponseDTO::new).toList(); + // Transformer la liste des événements en DTO pour la réponse + List 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(); } @@ -145,16 +147,23 @@ public class EventsResource { public Response deleteEvent(@PathParam("id") UUID id) { LOG.info("Tentative de suppression de l'événement avec l'ID : " + id); - 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); + // Appel du service pour la suppression de l'événement + try { + boolean deleted = eventService.deleteEvent(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 non trouvé.").build(); + } + } catch (EventNotFoundException e) { + LOG.error("[ERROR] Échec de la suppression : " + e.getMessage()); return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build(); } } + /** * Endpoint pour ajouter un participant à un événement. * @@ -355,4 +364,225 @@ public class EventsResource { return "Erreur lors de la mise à jour de l'image de l'événement."; } } + + /** + * Endpoint pour récupérer la liste de tous les événements. + * + * @return Une réponse HTTP contenant la liste des événements. + */ + @GET + @Operation( + summary = "Récupérer tous les événements", + description = "Retourne la liste de tous les événements disponibles") + public Response getAllEvents() { + LOG.info("[LOG] Récupération de tous les événements disponibles"); + + List events = eventsRepository.findAll().list(); + if (events.isEmpty()) { + LOG.warn("[LOG] Aucun événement trouvé."); + return Response.status(Response.Status.NOT_FOUND) + .entity("Aucun événement trouvé.") + .build(); + } + + List responseDTOs = events.stream() + .map(EventCreateResponseDTO::new) + .toList(); + LOG.info("[LOG] Nombre total d'événements trouvés : " + events.size()); + return Response.ok(responseDTOs).build(); + } + + /** + * Endpoint pour récupérer les événements par catégorie. + * + * @param category La catégorie d'événement à filtrer. + * @return Une réponse HTTP contenant la liste des événements dans cette catégorie. + */ + @GET + @Path("/category/{category}") + @Operation( + summary = "Récupérer les événements par catégorie", + description = "Retourne la liste des événements correspondant à une catégorie donnée") + public Response getEventsByCategory(@PathParam("category") String category) { + LOG.info("[LOG] Récupération des événements dans la catégorie : " + category); + + List events = eventService.findEventsByCategory(category); + if (events.isEmpty()) { + LOG.warn("[LOG] Aucun événement trouvé pour la catégorie : " + category); + return Response.status(Response.Status.NOT_FOUND) + .entity("Aucun événement trouvé pour cette catégorie.") + .build(); + } + + List responseDTOs = events.stream() + .map(EventCreateResponseDTO::new) + .toList(); + LOG.info("[LOG] Nombre d'événements trouvés dans la catégorie '" + category + "' : " + events.size()); + return Response.ok(responseDTOs).build(); + } + + /** + * Endpoint pour mettre à jour le statut d'un événement. + * + * @param id L'ID de l'événement. + * @param status Le nouveau statut de l'événement. + * @return Une réponse HTTP indiquant la mise à jour du statut. + */ + @PUT + @Path("/{id}/status") + @Transactional + @Operation( + summary = "Mettre à jour le statut d'un événement", + description = "Modifie le statut d'un événement (ouvert, fermé, annulé, etc.)") + public Response updateEventStatus(@PathParam("id") UUID id, @QueryParam("status") String status) { + LOG.info("[LOG] Mise à jour du statut 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(); + } + + event.setStatus(status); + eventsRepository.persist(event); + LOG.info("[LOG] Statut de l'événement mis à jour avec succès : " + status); + + EventUpdateResponseDTO responseDTO = new EventUpdateResponseDTO(event); + return Response.ok(responseDTO).build(); + } + + /** + * Endpoint pour rechercher des événements par mots-clés. + * + * @param keyword Le mot-clé à rechercher. + * @return Une réponse HTTP contenant la liste des événements correspondant au mot-clé. + */ + @GET + @Path("/search") + @Operation( + summary = "Rechercher des événements par mots-clés", + description = "Retourne la liste des événements dont le titre ou la description contient les mots-clés spécifiés") + public Response searchEvents(@QueryParam("keyword") String keyword) { + LOG.info("[LOG] Recherche d'événements avec le mot-clé : " + keyword); + + List events = eventService.searchEvents(keyword); + if (events.isEmpty()) { + LOG.warn("[LOG] Aucun événement trouvé avec le mot-clé : " + keyword); + return Response.status(Response.Status.NOT_FOUND) + .entity("Aucun événement trouvé pour ce mot-clé.") + .build(); + } + + List responseDTOs = events.stream() + .map(EventCreateResponseDTO::new) + .toList(); + LOG.info("[LOG] Nombre d'événements trouvés avec le mot-clé '" + keyword + "' : " + events.size()); + return Response.ok(responseDTOs).build(); + } + + /** + * Endpoint pour récupérer les événements auxquels un utilisateur est inscrit. + * + * @param userId L'ID de l'utilisateur. + * @return Une réponse HTTP contenant la liste des événements. + */ + @GET + @Path("/user/{userId}") + @Operation( + summary = "Récupérer les événements auxquels un utilisateur est inscrit", + description = "Retourne la liste des événements auxquels un utilisateur spécifique est inscrit") + public Response getEventsByUser(@PathParam("userId") UUID userId) { + LOG.info("[LOG] Récupération des événements pour l'utilisateur avec l'ID : " + userId); + + Users user = usersRepository.findById(userId); + if (user == null) { + LOG.warn("[LOG] Utilisateur non trouvé avec l'ID : " + userId); + return Response.status(Response.Status.NOT_FOUND).entity("Utilisateur non trouvé.").build(); + } + + List events = eventService.findEventsByUser(user); + if (events.isEmpty()) { + LOG.warn("[LOG] Aucun événement trouvé pour l'utilisateur avec l'ID : " + userId); + return Response.status(Response.Status.NOT_FOUND).entity("Aucun événement trouvé.").build(); + } + + List responseDTOs = events.stream() + .map(EventCreateResponseDTO::new) + .toList(); + LOG.info("[LOG] Nombre d'événements trouvés pour l'utilisateur : " + events.size()); + return Response.ok(responseDTOs).build(); + } + + /** + * Endpoint pour récupérer les événements par statut. + * + * @param status Le statut des événements à filtrer (en cours, terminé, etc.). + * @return Une réponse HTTP contenant la liste des événements avec ce statut. + */ + @GET + @Path("/status/{status}") + @Operation( + summary = "Récupérer les événements par statut", + description = "Retourne la liste des événements correspondant à un statut spécifique") + public Response getEventsByStatus(@PathParam("status") String status) { + LOG.info("[LOG] Récupération des événements avec le statut : " + status); + + List events = eventService.findEventsByStatus(status); + if (events.isEmpty()) { + LOG.warn("[LOG] Aucun événement trouvé avec le statut : " + status); + return Response.status(Response.Status.NOT_FOUND) + .entity("Aucun événement trouvé pour ce statut.") + .build(); + } + + List responseDTOs = events.stream() + .map(EventCreateResponseDTO::new) + .toList(); + LOG.info("[LOG] Nombre d'événements trouvés avec le statut '" + status + "' : " + events.size()); + return Response.ok(responseDTOs).build(); + } + + /** + * Endpoint pour récupérer les événements entre deux dates spécifiques. + * + * @param startDate La date de début pour filtrer les événements. + * @param endDate La date de fin pour filtrer les événements. + * @return Une réponse HTTP contenant la liste des événements entre les deux dates. + */ + @GET + @Path("/between-dates") + @Operation( + summary = "Récupérer les événements entre deux dates", + description = "Retourne la liste des événements qui se déroulent entre deux dates spécifiques") + public Response findEventsBetweenDates( + @QueryParam("startDate") LocalDateTime startDate, + @QueryParam("endDate") LocalDateTime endDate) { + + LOG.info("[LOG] Récupération des événements entre les dates : " + startDate + " et " + endDate); + + // Vérification de la validité des dates + if (startDate == null || endDate == null || endDate.isBefore(startDate)) { + LOG.error("[ERROR] Les dates fournies sont invalides."); + return Response.status(Response.Status.BAD_REQUEST) + .entity("Les dates sont invalides ou mal formatées.") + .build(); + } + + // Appel au service pour récupérer les événements entre les dates données + List events = eventService.findEventsBetweenDates(startDate, endDate); + if (events.isEmpty()) { + LOG.warn("[LOG] Aucun événement trouvé entre les dates : " + startDate + " et " + endDate); + return Response.status(Response.Status.NOT_FOUND) + .entity("Aucun événement trouvé entre ces dates.") + .build(); + } + + // Transformation des événements en DTO pour la réponse + List responseDTOs = events.stream() + .map(EventCreateResponseDTO::new) + .toList(); + LOG.info("[LOG] Nombre d'événements trouvés entre les dates : " + events.size()); + return Response.ok(responseDTOs).build(); + } + } diff --git a/src/main/java/com/lions/dev/service/EventService.java b/src/main/java/com/lions/dev/service/EventService.java index 6e155b3..31fa4e0 100644 --- a/src/main/java/com/lions/dev/service/EventService.java +++ b/src/main/java/com/lions/dev/service/EventService.java @@ -45,8 +45,9 @@ public class EventService { event.setImageUrl(eventCreateRequestDTO.getImageUrl()); event.setCreator(creator); event.setStatus("en cours"); + eventsRepository.persist(event); - System.out.println("[LOG] Événement créé : " + event.getTitle()); + logger.info("[LOG] Événement créé avec succès : {}", event.getTitle()); return event; } @@ -60,10 +61,10 @@ public class EventService { public Events getEventById(UUID id) { Events event = eventsRepository.findById(id); if (event == null) { - System.out.println("[ERROR] Événement non trouvé avec l'ID : " + id); + logger.error("[ERROR] Événement non trouvé avec l'ID : {}", id); throw new EventNotFoundException(id); } - System.out.println("[LOG] Événement trouvé avec l'ID : " + id); + logger.info("[LOG] Événement trouvé avec l'ID : {}", id); return event; } @@ -75,7 +76,7 @@ public class EventService { */ public List getEventsAfterDate(LocalDateTime startDate) { List events = eventsRepository.findEventsAfterDate(startDate); - System.out.println("[LOG] Nombre d'événements trouvés après la date " + startDate + " : " + events.size()); + logger.info("[LOG] Nombre d'événements trouvés après la date {} : {}", startDate, events.size()); return events; } @@ -128,4 +129,55 @@ public class EventService { logger.info("[LOG] Événement mis à jour avec succès : {}", existingEvent.getTitle()); return existingEvent; } + + /** + * Récupère les événements par catégorie. + * + * @param category La catégorie des événements. + * @return La liste des événements dans cette catégorie. + */ + public List findEventsByCategory(String category) { + return eventsRepository.find("category", category).list(); + } + + /** + * Recherche des événements par mot-clé. + * + * @param keyword Le mot-clé à rechercher. + * @return La liste des événements correspondant au mot-clé. + */ + public List searchEvents(String keyword) { + return eventsRepository.find("title like ?1 or description like ?1", "%" + keyword + "%").list(); + } + + /** + * Récupère les événements d'un utilisateur. + * + * @param user L'utilisateur pour lequel récupérer les événements. + * @return La liste des événements auxquels l'utilisateur participe. + */ + public List findEventsByUser(Users user) { + return eventsRepository.find("participants", user).list(); + } + + /** + * Récupère les événements par statut. + * + * @param status Le statut des événements (en cours, fermé, etc.). + * @return La liste des événements ayant ce statut. + */ + public List findEventsByStatus(String status) { + return eventsRepository.find("status", status).list(); + } + + /** + * Récupère les événements entre deux dates. + * + * @param startDate La date de début. + * @param endDate La date de fin. + * @return La liste des événements entre ces deux dates. + */ + public List findEventsBetweenDates(LocalDateTime startDate, LocalDateTime endDate) { + return eventsRepository.findEventsBetweenDates(startDate, endDate); + } }