lionsdev/afterwork-server-impl-quarkus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bon checkpoint + Refactoring

Browse Source
This commit is contained in:
DahoudG
2024-11-08 20:30:39 +00:00
parent 841789f8c2
commit 588984aa9c
13 changed files with 1048 additions and 478 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
src/main/java/com/lions/dev/service/EventService.java
View File

@@ -16,7 +16,8 @@ import java.util.UUID;
/**
* Service de gestion des événements.
* Ce service contient la logique métier pour la création, récupération et suppression des événements.
* Ce service contient la logique métier pour la création, récupération, mise à jour et suppression des événements.
* Chaque méthode est loguée pour assurer une traçabilité exhaustive des actions effectuées.
*/
@ApplicationScoped
public class EventService {
@@ -34,6 +35,7 @@ public class EventService {
* @return L'événement créé.
*/
public Events createEvent(EventCreateRequestDTO eventCreateRequestDTO, Users creator) {
// Initialisation de l'entité Event avec les détails fournis
Events event = new Events();
event.setTitle(eventCreateRequestDTO.getTitle());
event.setDescription(eventCreateRequestDTO.getDescription());
@@ -46,8 +48,9 @@ public class EventService {
event.setCreator(creator);
event.setStatus("ouvert");
// Persiste l'événement dans la base de données
eventsRepository.persist(event);
logger.info("[LOG] Événement créé avec succès : {}", event.getTitle());
logger.info("[logger] Événement créé avec succès : {}", event.getTitle());
return event;
}
@@ -59,24 +62,28 @@ public class EventService {
* @throws EventNotFoundException Si l'événement n'est pas trouvé.
*/
public Events getEventById(UUID id) {
logger.info("[logger] Tentative de récupération de l'événement avec l'ID : {}", id);
Events event = eventsRepository.findById(id);
if (event == null) {
logger.error("[ERROR] Événement non trouvé avec l'ID : {}", id);
throw new EventNotFoundException(id);
}
logger.info("[LOG] Événement trouvé avec l'ID : {}", id);
logger.info("[logger] Événement trouvé avec l'ID : {}", id);
return event;
}
/**
* Récupère tous les événements après une date donnée.
*
* @param startDate La date de début de filtre.
* @return Une liste d'événements.
* @param startDate La date de début pour filtrer les événements.
* @return Une liste d'événements après cette date.
*/
public List<Events> getEventsAfterDate(LocalDateTime startDate) {
logger.info("[logger] Récupération des événements après la date : {}", startDate);
List<Events> events = eventsRepository.findEventsAfterDate(startDate);
logger.info("[LOG] Nombre d'événements trouvés après la date {} : {}", startDate, events.size());
logger.info("[logger] Nombre d'événements trouvés après la date {} : {}", startDate, events.size());
return events;
}
@@ -85,16 +92,17 @@ public class EventService {
*
* @param id L'ID de l'événement à supprimer.
* @return true si l'événement a été supprimé, false sinon.
* @throws EventNotFoundException Si l'événement n'est pas trouvé.
*/
@Transactional
public boolean deleteEvent(UUID id) {
logger.info("[LOG] Tentative de suppression de l'événement avec l'ID : {}", id);
logger.info("[logger] Tentative de suppression de l'événement avec l'ID : {}", id);
boolean deleted = eventsRepository.deleteById(id);
if (deleted) {
logger.info("[LOG] Événement avec l'ID {} supprimé avec succès.", id);
logger.info("[logger] Événement avec l'ID {} supprimé avec succès.", id);
} else {
logger.warn("[LOG] Échec de la suppression : événement avec l'ID {} introuvable.", id);
logger.warn("[logger] Échec de la suppression : événement avec l'ID {} introuvable.", id);
throw new EventNotFoundException(id);
}
return deleted;
@@ -103,11 +111,14 @@ public class EventService {
/**
* Met à jour un événement dans le système.
*
* @param event L'événement à mettre à jour.
* @param event L'événement contenant les détails mis à jour.
* @return L'événement mis à jour.
* @throws EventNotFoundException Si l'événement n'est pas trouvé.
*/
@Transactional
public Events updateEvent(Events event) {
logger.info("[logger] Tentative de mise à jour de l'événement avec l'ID : {}", event.getId());
Events existingEvent = eventsRepository.findById(event.getId());
if (existingEvent == null) {
logger.error("[ERROR] Événement non trouvé avec l'ID : {}", event.getId());
@@ -125,8 +136,9 @@ public class EventService {
existingEvent.setImageUrl(event.getImageUrl());
existingEvent.setStatus(event.getStatus());
// Persiste les modifications dans la base de données
eventsRepository.persist(existingEvent);
logger.info("[LOG] Événement mis à jour avec succès : {}", existingEvent.getTitle());
logger.info("[logger] Événement mis à jour avec succès : {}", existingEvent.getTitle());
return existingEvent;
}
@@ -137,27 +149,36 @@ public class EventService {
* @return La liste des événements dans cette catégorie.
*/
public List<Events> findEventsByCategory(String category) {
return eventsRepository.find("category", category).list();
logger.info("[logger] Récupération des événements dans la catégorie : {}", category);
List<Events> events = eventsRepository.find("category", category).list();
logger.info("[logger] Nombre d'événements trouvés dans la catégorie '{}' : {}", category, events.size());
return events;
}
/**
* Recherche des événements par mot-clé.
* Recherche des événements par mot-clé dans le titre ou la description.
*
* @param keyword Le mot-clé à rechercher.
* @return La liste des événements correspondant au mot-clé.
*/
public List<Events> searchEvents(String keyword) {
return eventsRepository.find("title like ?1 or description like ?1", "%" + keyword + "%").list();
logger.info("[logger] Recherche d'événements avec le mot-clé : {}", keyword);
List<Events> events = eventsRepository.find("title like ?1 or description like ?1", "%" + keyword + "%").list();
logger.info("[logger] Nombre d'événements trouvés pour le mot-clé '{}' : {}", keyword, events.size());
return events;
}
/**
* Récupère les événements d'un utilisateur.
* Récupère les événements auxquels un utilisateur participe.
*
* @param user L'utilisateur pour lequel récupérer les événements.
* @return La liste des événements auxquels l'utilisateur participe.
*/
public List<Events> findEventsByUser(Users user) {
return eventsRepository.find("participants", user).list();
logger.info("[logger] Récupération des événements pour l'utilisateur avec l'ID : {}", user.getId());
List<Events> events = eventsRepository.find("participants", user).list();
logger.info("[logger] Nombre d'événements pour l'utilisateur avec l'ID {} : {}", user.getId(), events.size());
return events;
}
/**
@@ -167,17 +188,98 @@ public class EventService {
* @return La liste des événements ayant ce statut.
*/
public List<Events> findEventsByStatus(String status) {
return eventsRepository.find("status", status).list();
logger.info("[logger] Récupération des événements avec le statut : {}", status);
List<Events> events = eventsRepository.find("status", status).list();
logger.info("[logger] Nombre d'événements avec le statut '{}' : {}", status, events.size());
return events;
}
/**
* Récupère les événements entre deux dates.
* Récupère les événements qui se déroulent entre deux dates spécifiques.
*
* @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<Events> findEventsBetweenDates(LocalDateTime startDate, LocalDateTime endDate) {
return eventsRepository.findEventsBetweenDates(startDate, endDate);
logger.info("[logger] Récupération des événements entre les dates : {} et {}", startDate, endDate);
// Vérifie la validité des dates fournies
if (startDate == null || endDate == null || endDate.isBefore(startDate)) {
logger.error("[ERROR] Dates invalides fournies : startDate={}, endDate={}", startDate, endDate);
throw new IllegalArgumentException("Les dates sont invalides ou mal formatées.");
}
List<Events> events = eventsRepository.findEventsBetweenDates(startDate, endDate);
logger.info("[logger] Nombre d'événements trouvés entre les dates : {}", events.size());
return events;
}
/**
* Récupère les événements futurs.
*
* @return Une liste d'événements à venir.
*/
public List<Events> findUpcomingEvents() {
logger.info("[logger] Récupération des événements futurs.");
LocalDateTime now = LocalDateTime.now();
List<Events> events = eventsRepository.find("startDate > ?1", now).list();
logger.info("[logger] Nombre d'événements futurs trouvés : " + events.size());
return events;
}
/**
* Récupère les événements passés.
*
* @return Une liste d'événements passés.
*/
public List<Events> findPastEvents() {
logger.info("[logger] Récupération des événements passés.");
LocalDateTime now = LocalDateTime.now();
List<Events> events = eventsRepository.find("endDate < ?1", now).list();
logger.info("[logger] Nombre d'événements passés trouvés : " + events.size());
return events;
}
/**
* Récupère les événements par localisation.
*
* @param location La localisation des événements.
* @return La liste des événements situés à cette localisation.
*/
public List<Events> findEventsByLocation(String location) {
logger.info("[logger] Récupération des événements pour la localisation : " + location);
List<Events> events = eventsRepository.find("location", location).list();
logger.info("[logger] Nombre d'événements trouvés pour la localisation '" + location + "' : " + events.size());
return events;
}
/**
* Récupère les événements populaires en fonction du nombre de participants.
*
* @return Une liste d'événements populaires.
*/
public List<Events> findPopularEvents() {
logger.info("[logger] Récupération des événements populaires.");
List<Events> events = eventsRepository.listAll().stream()
.sorted((e1, e2) -> Integer.compare(e2.getNumberOfParticipants(), e1.getNumberOfParticipants()))
.limit(10)
.toList();
logger.info("[logger] Nombre d'événements populaires trouvés : " + events.size());
return events;
}
/**
* Recommande des événements pour un utilisateur spécifique.
*
* @param user L'utilisateur pour lequel recommander des événements.
* @return La liste des événements recommandés.
*/
public List<Events> recommendEventsForUser(Users user) {
logger.info("[logger] Recommandation d'événements pour l'utilisateur : " + user.getEmail());
List<Events> events = eventsRepository.find("category", user.getPreferredCategory()).list();
logger.info("[logger] Nombre d'événements recommandés pour l'utilisateur : " + events.size());
return events;
}
}

49
src/main/java/com/lions/dev/service/FileService.java
View File

@@ -1,23 +1,32 @@
package com.lions.dev.service;
import org.jboss.logging.Logger;
import com.lions.dev.repository.EventsRepository;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import java.io.IOException;
import java.nio.file.FileAlreadyExistsException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import org.jboss.logging.Logger;
/**
* Service pour la gestion des fichiers uploadés.
* Ce service permet de sauvegarder et gérer les fichiers uploadés sur le serveur.
*
* <p>Toutes les actions sont loguées pour assurer une traçabilité complète.
*/
@ApplicationScoped
public class FileService {
private static final Logger LOG = Logger.getLogger(FileService.class);
@Inject
EventsRepository eventsRepository;
/**
* Sauvegarde le fichier uploadé sur le serveur.
* Sauvegarde le fichier uploadé sur le serveur, avec création du répertoire de destination
* si nécessaire et gestion des erreurs de manière contrôlée.
*
* @param uploadedFilePath Le chemin temporaire du fichier uploadé.
* @param destinationDir Le répertoire de destination où sauvegarder le fichier.
@@ -26,10 +35,34 @@ public class FileService {
* @throws IOException Si une erreur survient lors de la sauvegarde.
*/
public Path saveFile(Path uploadedFilePath, String destinationDir, String fileName) throws IOException {
Path destination = Paths.get(destinationDir, fileName);
Files.createDirectories(Paths.get(destinationDir)); // Crée le répertoire s'il n'existe pas
Files.copy(uploadedFilePath, destination); // Copie le fichier vers sa destination
LOG.info("Fichier sauvegardé avec succès : " + destination);
return destination;
Path destinationPath = Paths.get(destinationDir, fileName);
LOG.info("[LOG] Tentative de sauvegarde du fichier vers : " + destinationPath);
if (Files.notExists(uploadedFilePath)) {
LOG.error("[ERROR] Le fichier uploadé n'existe pas : " + uploadedFilePath);
throw new IOException("Le fichier uploadé n'existe pas : " + uploadedFilePath);
}
try {
Files.createDirectories(Paths.get(destinationDir));
LOG.info("[LOG] Répertoire de destination créé ou déjà existant : " + destinationDir);
} catch (IOException e) {
LOG.error("[ERROR] Impossible de créer le répertoire de destination : " + destinationDir, e);
throw new IOException("Impossible de créer le répertoire de destination : " + destinationDir, e);
}
try {
Files.copy(uploadedFilePath, destinationPath, StandardCopyOption.REPLACE_EXISTING);
LOG.info("[LOG] Fichier sauvegardé avec succès à l'emplacement : " + destinationPath);
} catch (FileAlreadyExistsException e) {
LOG.warn("[WARNING] Le fichier existe déjà, il sera remplacé : " + destinationPath);
Files.copy(uploadedFilePath, destinationPath, StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) {
LOG.error("[ERROR] Erreur lors de la copie du fichier vers : " + destinationPath, e);
throw new IOException("Erreur lors de la sauvegarde du fichier : " + destinationPath, e);
}
return destinationPath;
}
}

42
src/main/java/com/lions/dev/service/FriendshipService.java
View File

@@ -16,11 +16,11 @@ import com.lions.dev.repository.UsersRepository;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import org.jboss.logging.Logger;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
import org.jboss.logging.Logger;
/**
* Service pour gérer les relations d'amitié.
@@ -196,25 +196,29 @@ public class FriendshipService {
throw new UserNotFoundException("Utilisateur introuvable.");
}
// Récupérer les amitiés acceptées
List<Friendship> friendships = friendshipRepository.findFriendsByUser(user, page, size);
logger.info("[LOG] " + friendships.size() + " amis récupérés.");
logger.info("[LOG] " + friendships.size() + " amis récupérés (avant filtrage des doublons).");
// Ajouter un log pour chaque amitié récupérée
friendships.forEach(friendship -> logger.info("[LOG] Ami : " + friendship.getFriend().getEmail()));
// Utilisation d'un ensemble pour stocker des clés uniques basées sur les IDs des amis
Set<String> uniqueFriendKeys = new HashSet<>();
return friendships.stream()
.map(friendship -> new FriendshipReadFriendDetailsResponseDTO(
friendship.getUser().getId(),
friendship.getFriend().getId(),
friendship.getFriend().getNom(),
friendship.getFriend().getPrenoms(),
friendship.getFriend().getEmail(),
friendship.getStatus(),
friendship.getCreatedAt(),
friendship.getUpdatedAt()
))
.collect(Collectors.toList());
.map(friendship -> {
Users friend = friendship.getUser().equals(user) ? friendship.getFriend() : friendship.getUser();
return new FriendshipReadFriendDetailsResponseDTO(
user.getId(),
friend.getId(),
friend.getNom(),
friend.getPrenoms(),
friend.getEmail(),
friendship.getStatus(),
friendship.getCreatedAt(),
friendship.getUpdatedAt()
);
})
.filter(dto -> uniqueFriendKeys.add(dto.getUserId().toString() + "-" + dto.getFriendId().toString()))
.limit(size) // Limite la taille au paramètre 'size' requis
.toList();
}
/**
@@ -234,6 +238,6 @@ public class FriendshipService {
List<Friendship> friendships = friendshipRepository.findByUserAndStatus(user, request.getStatus(), request.getPage() - 1, request.getSize());
logger.info("[LOG] " + friendships.size() + " demandes d'amitié récupérées.");
return friendships.stream().map(FriendshipReadStatusResponseDTO::new).collect(Collectors.toList());
return friendships.stream().map(FriendshipReadStatusResponseDTO::new).toList();
}
}