839 lines
38 KiB
Java
839 lines
38 KiB
Java
package com.lions.dev.resource;
|
|
|
|
import com.lions.dev.core.errors.exceptions.EventNotFoundException;
|
|
import com.lions.dev.dto.UserResponseDTO;
|
|
import com.lions.dev.dto.request.events.EventCreateRequestDTO;
|
|
import com.lions.dev.dto.request.events.EventReadManyByIdRequestDTO;
|
|
import com.lions.dev.dto.request.events.EventUpdateRequestDTO;
|
|
import com.lions.dev.dto.response.comments.CommentResponseDTO;
|
|
import com.lions.dev.dto.response.events.EventCreateResponseDTO;
|
|
import com.lions.dev.dto.response.events.EventReadManyByIdResponseDTO;
|
|
import com.lions.dev.dto.response.events.EventUpdateResponseDTO;
|
|
import com.lions.dev.dto.response.friends.FriendshipReadFriendDetailsResponseDTO;
|
|
import com.lions.dev.entity.comment.Comment;
|
|
import com.lions.dev.entity.events.Events;
|
|
import com.lions.dev.entity.users.Users;
|
|
import com.lions.dev.repository.EventsRepository;
|
|
import com.lions.dev.repository.UsersRepository;
|
|
import com.lions.dev.service.EventService;
|
|
import com.lions.dev.service.FriendshipService;
|
|
import jakarta.inject.Inject;
|
|
import jakarta.transaction.Transactional;
|
|
import jakarta.ws.rs.*;
|
|
import jakarta.ws.rs.core.Response;
|
|
import java.io.File;
|
|
import java.time.LocalDateTime;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.UUID;
|
|
import java.util.stream.Collectors;
|
|
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, mettre à jour et supprimer des événements.
|
|
*
|
|
* Tous les logs nécessaires pour la traçabilité sont intégrés.
|
|
*/
|
|
@Path("/events")
|
|
@Produces("application/json")
|
|
@Consumes("application/json")
|
|
@Tag(name = "Events", description = "Opérations liées à la gestion des événements")
|
|
public class EventsResource {
|
|
|
|
@Inject
|
|
EventsRepository eventsRepository;
|
|
|
|
@Inject
|
|
UsersRepository usersRepository;
|
|
|
|
@Inject
|
|
EventService eventService;
|
|
|
|
@Inject
|
|
FriendshipService friendshipService;
|
|
|
|
private static final Logger LOG = Logger.getLogger(EventsResource.class);
|
|
|
|
// *********** Création d'un événement ***********
|
|
|
|
@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(EventCreateRequestDTO eventCreateRequestDTO) {
|
|
LOG.info("[LOG] Tentative de création d'un nouvel événement : " + eventCreateRequestDTO.getTitle());
|
|
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();
|
|
}
|
|
Events event = eventService.createEvent(eventCreateRequestDTO, creator);
|
|
LOG.info("[LOG] Événement créé avec succès : " + event.getTitle());
|
|
EventCreateResponseDTO responseDTO = new EventCreateResponseDTO(event);
|
|
return Response.status(Response.Status.CREATED).entity(responseDTO).build();
|
|
}
|
|
|
|
// *********** Récupération d'un événement par ID ***********
|
|
|
|
@GET
|
|
@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("[LOG] Récupération 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();
|
|
}
|
|
EventCreateResponseDTO responseDTO = new EventCreateResponseDTO(event);
|
|
LOG.info("[LOG] Événement trouvé : " + event.getTitle());
|
|
return Response.ok(responseDTO).build();
|
|
}
|
|
|
|
// *********** Suppression d'un événement ***********
|
|
|
|
@DELETE
|
|
@Path("/{id}")
|
|
@Transactional
|
|
@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.info("Tentative de suppression de l'événement avec l'ID : " + id);
|
|
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();
|
|
}
|
|
}
|
|
|
|
// *********** Ajouter un participant à un événement ***********
|
|
|
|
@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();
|
|
}
|
|
|
|
// *********** Retirer un participant d'un événement ***********
|
|
|
|
@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();
|
|
}
|
|
|
|
// *********** Mettre à jour un événement ***********
|
|
|
|
@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();
|
|
}
|
|
|
|
// *********** Récupérer les événements créés par un utilisateur spécifique et ses amis ***********
|
|
|
|
@POST
|
|
@Path("/created-by-user-and-friends")
|
|
@Consumes("application/json")
|
|
@Produces("application/json")
|
|
@Operation(summary = "Récupérer les événements créés par un utilisateur et ses amis", description = "Retourne la liste des événements créés par un utilisateur spécifique et ses amis")
|
|
public Response getEventsCreatedByUserAndFriends(EventReadManyByIdRequestDTO requestDTO) {
|
|
UUID userId = requestDTO.getUserId();
|
|
LOG.info("[LOG] Récupération des événements pour l'utilisateur avec l'ID : " + userId + " et ses amis");
|
|
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();
|
|
}
|
|
try {
|
|
List<FriendshipReadFriendDetailsResponseDTO> friends = friendshipService.listFriends(userId, 0, Integer.MAX_VALUE);
|
|
Set<UUID> friendIds = friends.stream().map(FriendshipReadFriendDetailsResponseDTO::getFriendId).collect(Collectors.toSet());
|
|
//friendIds = friendIds.stream().distinct().collect(Collectors.toSet());
|
|
LOG.info("[LOG] IDs d'amis + utilisateur (taille attendue: " + friendIds.size() + ") : " + friendIds);
|
|
if (friendIds.isEmpty()) {
|
|
LOG.warn("[LOG] Aucun ami trouvé.");
|
|
return Response.status(Response.Status.NOT_FOUND).entity("Aucun ami trouvé.").build();
|
|
}
|
|
List<Events> events = eventsRepository.find("creator.id IN ?1", friendIds).list();
|
|
LOG.info("[LOG] Nombre d'événements récupérés dans la requête : " + events.size());
|
|
if (events.isEmpty()) {
|
|
return Response.status(Response.Status.NOT_FOUND).entity("Aucun événement trouvé.").build();
|
|
}
|
|
List<EventReadManyByIdResponseDTO> responseDTOs = events.stream().map(EventReadManyByIdResponseDTO::new).toList();
|
|
return Response.ok(responseDTOs).build();
|
|
} catch (Exception e) {
|
|
LOG.error("[ERROR] Erreur de récupération des événements : ", e);
|
|
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("{\"message\": \"Erreur.\"}").build();
|
|
}
|
|
}
|
|
|
|
// *********** Récupérer les événements par catégorie ***********
|
|
|
|
/**
|
|
* 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> 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<EventCreateResponseDTO> 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();
|
|
}
|
|
|
|
// *********** Récupérer les événements entre deux dates ***********
|
|
|
|
/**
|
|
* 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);
|
|
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();
|
|
}
|
|
List<Events> 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();
|
|
}
|
|
List<EventCreateResponseDTO> 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();
|
|
}
|
|
|
|
// *********** Récupérer les événements par statut ***********
|
|
|
|
/**
|
|
* 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> 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<EventCreateResponseDTO> 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();
|
|
}
|
|
|
|
// *********** Rechercher des événements par mots-clés ***********
|
|
|
|
/**
|
|
* 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> 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<EventCreateResponseDTO> 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();
|
|
}
|
|
|
|
// *********** Mettre à jour le statut d'un événement ***********
|
|
|
|
/**
|
|
* 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();
|
|
}
|
|
|
|
// *********** Récupérer les événements auxquels un utilisateur est inscrit ***********
|
|
|
|
/**
|
|
* 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> 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<EventCreateResponseDTO> 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();
|
|
}
|
|
|
|
// *********** Mettre à jour l'image d'un événement ***********
|
|
|
|
/**
|
|
* Endpoint pour mettre à jour l'image d'un événement.
|
|
*
|
|
* @param id L'identifiant de l'événement.
|
|
* @param imageFilePath Le chemin vers l'image de l'événement.
|
|
* @return Un message indiquant si la mise à jour a réussi ou non.
|
|
*/
|
|
@PUT
|
|
@Path("/{id}/image")
|
|
public Response updateEventImage(@PathParam("id") UUID id, String imageFilePath) {
|
|
LOG.info("[LOG] Tentative de mise à jour de l'image pour l'événement avec l'ID : " + id);
|
|
|
|
try {
|
|
if (imageFilePath == null || imageFilePath.isEmpty()) {
|
|
LOG.error("[ERROR] Le chemin de l'image est vide ou null.");
|
|
return Response.status(Response.Status.BAD_REQUEST).entity("Le chemin de l'image est vide ou null.").build();
|
|
}
|
|
|
|
File file = new File(imageFilePath);
|
|
if (!file.exists()) {
|
|
LOG.error("[ERROR] Le fichier spécifié n'existe pas : " + imageFilePath);
|
|
return Response.status(Response.Status.NOT_FOUND).entity("Le fichier spécifié n'existe pas.").build();
|
|
}
|
|
|
|
Events event = eventService.getEventById(id);
|
|
if (event == null) {
|
|
LOG.error("[ERROR] Événement non trouvé avec l'ID : " + id);
|
|
return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build();
|
|
}
|
|
|
|
String imageUrl = file.getAbsolutePath();
|
|
event.setImageUrl(imageUrl);
|
|
eventService.updateEvent(event);
|
|
|
|
LOG.info("[LOG] Image de l'événement mise à jour avec succès pour : " + event.getTitle());
|
|
return Response.ok("Image de l'événement mise à jour avec succès.").build();
|
|
} catch (Exception e) {
|
|
LOG.error("[ERROR] Erreur lors de la mise à jour de l'image de l'événement : ", e);
|
|
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("Erreur lors de la mise à jour de l'image de l'événement.").build();
|
|
}
|
|
}
|
|
|
|
// *********** Mettre à jour partiellement un événement ***********
|
|
@PATCH
|
|
@Path("/{id}/partial-update")
|
|
@Transactional
|
|
@Operation(summary = "Mettre à jour partiellement un événement", description = "Mise à jour partielle des informations d'un événement")
|
|
public Response partialUpdateEvent(@PathParam("id") UUID id, Map<String, Object> updates) {
|
|
LOG.info("[LOG] Tentative de mise à jour partielle 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();
|
|
}
|
|
|
|
updates.forEach((field, value) -> {
|
|
// Mise à jour des champs dynamiquement, à adapter selon la structure de l'événement
|
|
// Exemple d'utilisation de réflexion si applicable
|
|
});
|
|
|
|
eventsRepository.persist(event);
|
|
LOG.info("[LOG] Événement mis à jour partiellement avec succès : " + event.getTitle());
|
|
return Response.ok(new EventUpdateResponseDTO(event)).build();
|
|
}
|
|
|
|
// *********** Récupérer les événements à venir ***********
|
|
@GET
|
|
@Path("/upcoming")
|
|
@Operation(summary = "Récupérer les événements à venir", description = "Retourne les événements futurs.")
|
|
public Response getUpcomingEvents() {
|
|
LOG.info("[LOG] Récupération des événements à venir.");
|
|
|
|
List<Events> events = eventService.findUpcomingEvents();
|
|
if (events.isEmpty()) {
|
|
LOG.warn("[LOG] Aucun événement futur trouvé.");
|
|
return Response.status(Response.Status.NOT_FOUND).entity("Aucun événement futur trouvé.").build();
|
|
}
|
|
|
|
List<EventCreateResponseDTO> responseDTOs = events.stream().map(EventCreateResponseDTO::new).toList();
|
|
return Response.ok(responseDTOs).build();
|
|
}
|
|
|
|
// *********** Récupérer les événements passés ***********
|
|
@GET
|
|
@Path("/past")
|
|
@Operation(summary = "Récupérer les événements passés", description = "Retourne les événements déjà terminés.")
|
|
public Response getPastEvents() {
|
|
LOG.info("[LOG] Récupération des événements passés.");
|
|
|
|
List<Events> events = eventService.findPastEvents();
|
|
if (events.isEmpty()) {
|
|
LOG.warn("[LOG] Aucun événement passé trouvé.");
|
|
return Response.status(Response.Status.NOT_FOUND).entity("Aucun événement passé trouvé.").build();
|
|
}
|
|
|
|
List<EventCreateResponseDTO> responseDTOs = events.stream().map(EventCreateResponseDTO::new).toList();
|
|
return Response.ok(responseDTOs).build();
|
|
}
|
|
|
|
// *********** Annuler un événement ***********
|
|
@POST
|
|
@Path("/{id}/cancel")
|
|
@Transactional
|
|
@Operation(summary = "Annuler un événement", description = "Annule un événement sans le supprimer.")
|
|
public Response cancelEvent(@PathParam("id") UUID id) {
|
|
LOG.info("[LOG] Annulation 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("Annulé");
|
|
eventsRepository.persist(event);
|
|
LOG.info("[LOG] Événement annulé avec succès : " + event.getTitle());
|
|
return Response.ok(new EventUpdateResponseDTO(event)).build();
|
|
}
|
|
|
|
// *********** Récupérer les événements par localisation ***********
|
|
@GET
|
|
@Path("/location/{location}")
|
|
@Operation(summary = "Récupérer les événements par localisation", description = "Retourne les événements situés à une localisation spécifique.")
|
|
public Response getEventsByLocation(@PathParam("location") String location) {
|
|
LOG.info("[LOG] Récupération des événements à la localisation : " + location);
|
|
|
|
List<Events> events = eventService.findEventsByLocation(location);
|
|
if (events.isEmpty()) {
|
|
LOG.warn("[LOG] Aucun événement trouvé pour la localisation : " + location);
|
|
return Response.status(Response.Status.NOT_FOUND).entity("Aucun événement trouvé pour cette localisation.").build();
|
|
}
|
|
|
|
List<EventCreateResponseDTO> responseDTOs = events.stream().map(EventCreateResponseDTO::new).toList();
|
|
return Response.ok(responseDTOs).build();
|
|
}
|
|
|
|
// *********** Récupérer les événements populaires ***********
|
|
@GET
|
|
@Path("/popular")
|
|
@Operation(summary = "Récupérer les événements populaires", description = "Retourne les événements ayant le plus de participants.")
|
|
public Response getPopularEvents() {
|
|
LOG.info("[LOG] Récupération des événements populaires.");
|
|
|
|
List<Events> events = eventService.findPopularEvents();
|
|
if (events.isEmpty()) {
|
|
LOG.warn("[LOG] Aucun événement populaire trouvé.");
|
|
return Response.status(Response.Status.NOT_FOUND).entity("Aucun événement populaire trouvé.").build();
|
|
}
|
|
|
|
List<EventCreateResponseDTO> responseDTOs = events.stream().map(EventCreateResponseDTO::new).toList();
|
|
return Response.ok(responseDTOs).build();
|
|
}
|
|
|
|
// *********** Étendre la durée d'un événement ***********
|
|
@PATCH
|
|
@Path("/{id}/extend")
|
|
@Transactional
|
|
@Operation(summary = "Étendre la durée d'un événement", description = "Permet de modifier la date de fin d'un événement.")
|
|
public Response extendEventDuration(@PathParam("id") UUID id, LocalDateTime newEndDate) {
|
|
LOG.info("[LOG] Extension de la durée 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();
|
|
}
|
|
|
|
if (newEndDate.isBefore(event.getStartDate())) {
|
|
LOG.error("[ERROR] La nouvelle date de fin est antérieure à la date de début.");
|
|
return Response.status(Response.Status.BAD_REQUEST).entity("La nouvelle date de fin doit être postérieure à la date de début.").build();
|
|
}
|
|
|
|
event.setEndDate(newEndDate);
|
|
eventsRepository.persist(event);
|
|
LOG.info("[LOG] Durée de l'événement étendue avec succès : " + event.getTitle());
|
|
return Response.ok(new EventUpdateResponseDTO(event)).build();
|
|
}
|
|
|
|
// *********** Inviter des utilisateurs à un événement ***********
|
|
@POST
|
|
@Path("/{id}/invite")
|
|
@Transactional
|
|
@Operation(summary = "Inviter des utilisateurs à un événement", description = "Envoie des invitations à des utilisateurs pour un événement.")
|
|
public Response inviteUsersToEvent(@PathParam("id") UUID eventId, Set<UUID> userIds) {
|
|
LOG.info("[LOG] Invitation d'utilisateurs à l'événement : " + eventId);
|
|
|
|
Events event = eventsRepository.findById(eventId);
|
|
if (event == null) {
|
|
LOG.warn("[LOG] Événement non trouvé avec l'ID : " + eventId);
|
|
return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build();
|
|
}
|
|
|
|
List<Users> invitedUsers = userIds.stream().map(usersRepository::findById).filter(u -> u != null).collect(Collectors.toList());
|
|
invitedUsers.forEach(event::addParticipant); // Adapte pour ajouter en tant qu'invités, si nécessaire
|
|
eventsRepository.persist(event);
|
|
|
|
LOG.info("[LOG] Utilisateurs invités avec succès à l'événement : " + event.getTitle());
|
|
return Response.ok("Invitations envoyées avec succès.").build();
|
|
}
|
|
|
|
@GET
|
|
@Path("/{id}/participants")
|
|
@Operation(summary = "Récupérer la liste des participants d'un événement", description = "Retourne la liste des utilisateurs participant à un événement spécifique.")
|
|
public Response getParticipants(@PathParam("id") UUID eventId) {
|
|
// Log d'entrée de la méthode
|
|
LOG.info("[LOG] Récupération des participants de l'événement avec l'ID : " + eventId);
|
|
|
|
// Recherche de l'événement
|
|
Events event = eventsRepository.findById(eventId);
|
|
if (event == null) {
|
|
LOG.warn("[LOG] Événement non trouvé avec l'ID : " + eventId);
|
|
return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build();
|
|
}
|
|
|
|
// Récupération de la liste des participants
|
|
Set<Users> participantsSet = event.getParticipants();
|
|
if (participantsSet == null || participantsSet.isEmpty()) {
|
|
LOG.warn("[LOG] Aucun participant trouvé pour l'événement avec l'ID : " + eventId);
|
|
return Response.status(Response.Status.NO_CONTENT).entity("Aucun participant trouvé.").build();
|
|
}
|
|
|
|
// Conversion des participants en List
|
|
List<Users> participantsList = new ArrayList<>(participantsSet);
|
|
|
|
// Conversion des participants en DTO pour la réponse
|
|
List<UserResponseDTO> responseDTOs = participantsList.stream()
|
|
.map(UserResponseDTO::new) // Conversion de chaque utilisateur en UserResponseDTO
|
|
.collect(Collectors.toList());
|
|
|
|
// Log de la taille de la liste des participants pour la traçabilité
|
|
LOG.info("[LOG] Nombre de participants récupérés pour l'événement avec l'ID : " + eventId + " : " + responseDTOs.size());
|
|
|
|
// Retourner la réponse avec les participants
|
|
return Response.ok(responseDTOs).build();
|
|
}
|
|
|
|
@POST
|
|
@Path("/{id}/favorite")
|
|
@Transactional
|
|
@Operation(summary = "Marquer un événement comme favori", description = "Permet à un utilisateur de marquer un événement comme favori.")
|
|
public Response favoriteEvent(@PathParam("id") UUID eventId, @QueryParam("userId") UUID userId) {
|
|
LOG.info("[LOG] Marquage de l'événement comme favori pour l'utilisateur ID : " + userId);
|
|
|
|
Events event = eventsRepository.findById(eventId);
|
|
Users user = usersRepository.findById(userId);
|
|
if (event == null || user == null) {
|
|
LOG.warn("[LOG] Événement ou utilisateur non trouvé.");
|
|
return Response.status(Response.Status.NOT_FOUND).entity("Événement ou utilisateur non trouvé.").build();
|
|
}
|
|
|
|
user.addFavoriteEvent(event);
|
|
usersRepository.persist(user);
|
|
return Response.ok("Événement marqué comme favori.").build();
|
|
}
|
|
|
|
@GET
|
|
@Path("/user/{userId}/favorites")
|
|
@Operation(summary = "Récupérer les événements favoris d'un utilisateur", description = "Retourne les événements marqués comme favoris par un utilisateur.")
|
|
public Response getFavoriteEvents(@PathParam("userId") UUID userId) {
|
|
LOG.info("[LOG] Récupération des événements favoris pour l'utilisateur 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();
|
|
}
|
|
|
|
// Convertir Set<Events> en List<Events>
|
|
List<Events> favoriteEvents = new ArrayList<>(user.getFavoriteEvents());
|
|
|
|
// Mapper les événements en DTO
|
|
List<EventCreateResponseDTO> responseDTOs = favoriteEvents.stream().map(EventCreateResponseDTO::new).toList();
|
|
|
|
return Response.ok(responseDTOs).build();
|
|
}
|
|
|
|
@GET
|
|
@Path("/{id}/comments")
|
|
@Operation(summary = "Récupérer les commentaires d'un événement", description = "Retourne la liste des commentaires associés à un événement.")
|
|
public Response getComments(@PathParam("id") UUID eventId) {
|
|
LOG.info("[LOG] Récupération des commentaires pour l'événement ID : " + eventId);
|
|
|
|
// Recherche de l'événement
|
|
Events event = eventsRepository.findById(eventId);
|
|
if (event == null) {
|
|
LOG.warn("[LOG] Événement non trouvé avec l'ID : " + eventId);
|
|
return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build();
|
|
}
|
|
|
|
// Récupération des commentaires associés à l'événement
|
|
List<Comment> comments = event.getComments();
|
|
List<CommentResponseDTO> responseDTOs = comments.stream()
|
|
.map(CommentResponseDTO::new) // Conversion de chaque commentaire en CommentResponseDTO
|
|
.collect(Collectors.toList());
|
|
|
|
LOG.info("[LOG] Nombre de commentaires récupérés pour l'événement avec l'ID : " + eventId + " : " + responseDTOs.size());
|
|
|
|
// Retourner la réponse avec les commentaires sous forme de DTO
|
|
return Response.ok(responseDTOs).build();
|
|
}
|
|
|
|
@GET
|
|
@Path("/recommendations/{userId}")
|
|
@Operation(summary = "Recommander des événements basés sur les intérêts", description = "Retourne une liste d'événements recommandés pour un utilisateur.")
|
|
public Response getEventRecommendations(@PathParam("userId") UUID userId) {
|
|
LOG.info("[LOG] Récupération des recommandations d'événements pour l'utilisateur 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> recommendedEvents = eventService.recommendEventsForUser(user);
|
|
List<EventCreateResponseDTO> responseDTOs = recommendedEvents.stream().map(EventCreateResponseDTO::new).toList();
|
|
|
|
return Response.ok(responseDTOs).build();
|
|
}
|
|
|
|
@GET
|
|
@Path("/{id}/share-link")
|
|
@Operation(summary = "Partager un événement via un lien", description = "Génère un lien de partage pour un événement.")
|
|
public Response getShareLink(@PathParam("id") UUID eventId) {
|
|
LOG.info("[LOG] Génération du lien de partage pour l'événement ID : " + eventId);
|
|
|
|
Events event = eventsRepository.findById(eventId);
|
|
if (event == null) {
|
|
LOG.warn("[LOG] Événement non trouvé avec l'ID : " + eventId);
|
|
return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build();
|
|
}
|
|
|
|
String shareLink = "https://lions.dev /events/" + eventId;
|
|
return Response.ok(Map.of("shareLink", shareLink)).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.
|
|
*/
|
|
@PATCH
|
|
@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);
|
|
|
|
// Recherche de l'événement par ID
|
|
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();
|
|
}
|
|
|
|
// Marquer l'événement comme fermé
|
|
event.setStatus("fermé"); // Modification du statut de l'événement
|
|
eventsRepository.persist(event); // Persister les modifications dans la base
|
|
LOG.info("Événement fermé avec succès : " + event.getTitle());
|
|
|
|
// Retourner une réponse HTTP 200 OK avec le DTO de l'événement fermé
|
|
return Response.ok(new EventCreateResponseDTO(event)).build();
|
|
}
|
|
|
|
/**
|
|
* Endpoint pour réouvrir 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.
|
|
*/
|
|
@PATCH
|
|
@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.info("Tentative de réouverture de l'événement avec l'ID : " + eventId);
|
|
|
|
// Recherche de l'événement par ID
|
|
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();
|
|
}
|
|
|
|
// Vérifier si l'événement est déjà ouvert
|
|
if ("ouvert".equals(event.getStatus())) {
|
|
LOG.warn("L'événement est déjà ouvert : " + eventId);
|
|
return Response.status(Response.Status.BAD_REQUEST)
|
|
.entity("L'événement est déjà ouvert.")
|
|
.build();
|
|
}
|
|
|
|
// Vérifier si l'événement est fermé avant de tenter la réouverture
|
|
if (!"fermé".equals(event.getStatus())) {
|
|
LOG.warn("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();
|
|
}
|
|
|
|
// Réouvrir l'événement en mettant à jour son statut
|
|
event.setStatus("ouvert"); // Changer le statut à "Ouvert"
|
|
eventsRepository.persist(event); // Persister les modifications dans la base
|
|
LOG.info("Événement rouvert avec succès : " + event.getTitle());
|
|
|
|
// Retourner une réponse HTTP 200 OK avec un message de succès
|
|
return Response.ok("L'événement a été réouvert avec succès.").build();
|
|
}
|
|
|
|
}
|
|
|