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

Refactoring

Browse Source
This commit is contained in:
DahoudG
2024-11-02 15:27:03 +00:00
parent 2c7d671588
commit 841789f8c2
16 changed files with 568 additions and 380 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/main/java/com/lions/dev/core/errors/GlobalExceptionHandler.java
View File

@@ -5,17 +5,19 @@ import com.lions.dev.core.errors.exceptions.EventNotFoundException;
import com.lions.dev.core.errors.exceptions.NotFoundException;
import com.lions.dev.core.errors.exceptions.ServerException;
import com.lions.dev.core.errors.exceptions.UnauthorizedException;
import jakarta.ws.rs.core.Response;
import jakarta.ws.rs.ext.ExceptionMapper;
import jakarta.ws.rs.ext.Provider;
import org.jboss.logging.Logger;
/**
* Gestionnaire global des exceptions pour l'API.
* Ce gestionnaire intercepte les exceptions spécifiques et renvoie des réponses appropriées.
*/
@Provider
public class GlobalExceptionHandler implements ExceptionMapper<Exception> {
public class GlobalExceptionHandler implements ExceptionMapper<Throwable> {
private static final Logger logger = Logger.getLogger(GlobalExceptionHandler.class);
/**
* Gère les exceptions non traitées et retourne une réponse appropriée.
@@ -24,19 +26,27 @@ public class GlobalExceptionHandler implements ExceptionMapper<Exception> {
* @return Une réponse HTTP avec un message d'erreur et le code de statut approprié.
*/
@Override
public Response toResponse(Exception exception) {
public Response toResponse(Throwable exception) {
if (exception instanceof BadRequestException) {
logger.warn("BadRequestException intercepted: " + exception.getMessage());
return buildResponse(Response.Status.BAD_REQUEST, exception.getMessage());
} else if (exception instanceof EventNotFoundException || exception instanceof NotFoundException) {
logger.warn("NotFoundException intercepted: " + exception.getMessage());
return buildResponse(Response.Status.NOT_FOUND, exception.getMessage());
} else if (exception instanceof UnauthorizedException) {
logger.warn("UnauthorizedException intercepted: " + exception.getMessage());
return buildResponse(Response.Status.UNAUTHORIZED, exception.getMessage());
} else if (exception instanceof ServerException) {
logger.error("ServerException intercepted: " + exception.getMessage());
return buildResponse(Response.Status.INTERNAL_SERVER_ERROR, "Erreur interne du serveur.");
}
} else if (exception instanceof RuntimeException) {
logger.error("RuntimeException intercepted: " + exception.getMessage());
return buildResponse(Response.Status.INTERNAL_SERVER_ERROR, "Erreur inattendue.");
} else {
logger.error("Unexpected error: " + exception.getMessage(), exception);
return buildResponse(Response.Status.INTERNAL_SERVER_ERROR, "Erreur inattendue : " + exception.getMessage());
}
}
/**
* Crée une réponse HTTP avec un code de statut et un message d'erreur.

4
src/main/java/com/lions/dev/dto/request/events/EventGetOneByIdRequestDTO.java → src/main/java/com/lions/dev/dto/request/events/EventReadOneByIdRequestDTO.java
View File

@@ -9,12 +9,12 @@ import java.util.UUID;
*/
@lombok.Getter
@lombok.Setter
public class EventGetOneByIdRequestDTO {
public class EventReadOneByIdRequestDTO {
@NotNull(message = "L'ID de l'événement est obligatoire.")
private UUID eventId; // ID de l'événement à lire
public EventGetOneByIdRequestDTO() {
public EventReadOneByIdRequestDTO() {
System.out.println("[LOG] DTO de requête de lecture d'événement initialisé.");
}
}

10
src/main/java/com/lions/dev/dto/request/friends/FriendshipRequestDTO.java → src/main/java/com/lions/dev/dto/request/friends/FriendshipCreateOneRequestDTO.java
View File

@@ -13,12 +13,18 @@ import java.util.UUID;
@Getter
@Setter
@NoArgsConstructor
public class FriendshipRequestDTO {
public class FriendshipCreateOneRequestDTO {
private UUID userId; // ID de l'utilisateur qui envoie la demande
private UUID friendId; // ID de l'utilisateur qui reçoit la demande
public FriendshipRequestDTO(UUID userId, UUID friendId) {
/**
* Constructeur avec paramètres pour initialiser les IDs.
*
* @param userId L'ID de l'utilisateur qui envoie la demande d'amitié.
* @param friendId L'ID de l'utilisateur qui reçoit la demande d'amitié.
*/
public FriendshipCreateOneRequestDTO(UUID userId, UUID friendId) {
this.userId = userId;
this.friendId = friendId;
}

31
src/main/java/com/lions/dev/dto/request/friends/FriendshipReadFriendDetailsRequestDTO.java Normal file
View File

@@ -0,0 +1,31 @@
package com.lions.dev.dto.request.friends;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import java.util.UUID;
/**
* DTO pour récupérer les détails d'un ami.
* Contient les informations nécessaires pour récupérer les détails d'un ami spécifique.
*/
@Getter
@Setter
@NoArgsConstructor
public class FriendshipReadFriendDetailsRequestDTO {
private UUID userId; // ID de l'utilisateur demandant les détails
private UUID friendId; // ID de l'ami dont les détails sont requis
/**
* Constructeur avec paramètres pour initialiser les IDs.
*
* @param userId L'ID de l'utilisateur demandant les détails de l'ami.
* @param friendId L'ID de l'ami dont les détails sont requis.
*/
public FriendshipReadFriendDetailsRequestDTO(UUID userId, UUID friendId) {
this.userId = userId;
this.friendId = friendId;
}
}

38
src/main/java/com/lions/dev/dto/request/friends/FriendshipReadStatusRequestDTO.java Normal file
View File

@@ -0,0 +1,38 @@
package com.lions.dev.dto.request.friends;
import com.lions.dev.entity.friends.FriendshipStatus;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import java.util.UUID;
/**
* DTO de requête pour récupérer les demandes d'amitié par statut.
* Contient les informations nécessaires pour filtrer les demandes d'amitié d'un utilisateur.
*/
@Getter
@Setter
@NoArgsConstructor
public class FriendshipReadStatusRequestDTO {
private UUID userId; // ID de l'utilisateur
private FriendshipStatus status; // Statut des demandes (PENDING, ACCEPTED, REJECTED)
private int page = 1; // Numéro de la page pour la pagination
private int size = 10; // Taille de la page pour la pagination
/**
* Constructeur avec paramètres pour initialiser les informations de la demande.
*
* @param userId ID de l'utilisateur
* @param status Statut des demandes à récupérer
* @param page Numéro de la page pour la pagination
* @param size Nombre d'éléments par page
*/
public FriendshipReadStatusRequestDTO(UUID userId, FriendshipStatus status, int page, int size) {
this.userId = userId;
this.status = status;
this.page = page;
this.size = size;
}
}

21
src/main/java/com/lions/dev/dto/response/friends/FriendshipResponseDTO.java → src/main/java/com/lions/dev/dto/response/friends/FriendshipCreateOneResponseDTO.java
View File

@@ -16,16 +16,21 @@ import java.util.UUID;
@Getter
@Setter
@NoArgsConstructor
public class FriendshipResponseDTO {
public class FriendshipCreateOneResponseDTO {
private UUID id;
private UUID userId;
private UUID friendId;
private FriendshipStatus status;
private LocalDateTime createdAt;
private LocalDateTime updatedAt;
private UUID id; // ID de la relation d'amitié
private UUID userId; // ID de l'utilisateur qui a envoyé la demande
private UUID friendId; // ID de l'utilisateur qui a reçu la demande
private FriendshipStatus status; // Statut de la relation d'amitié (PENDING, ACCEPTED, REJECTED)
private LocalDateTime createdAt; // Date de création de la relation d'amitié
private LocalDateTime updatedAt; // Date de la dernière mise à jour
public FriendshipResponseDTO(Friendship friendship) {
/**
* Constructeur pour mapper l'entité `Friendship` à ce DTO.
*
* @param friendship L'entité `Friendship` à convertir en DTO.
*/
public FriendshipCreateOneResponseDTO(Friendship friendship) {
this.id = friendship.getId();
this.userId = friendship.getUser().getId();
this.friendId = friendship.getFriend().getId();

54
src/main/java/com/lions/dev/dto/response/friends/FriendshipReadFriendDetailsResponseDTO.java Normal file
View File

@@ -0,0 +1,54 @@
package com.lions.dev.dto.response.friends;
import com.lions.dev.entity.friends.FriendshipStatus;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import java.time.LocalDateTime;
import java.util.UUID;
/**
* DTO de réponse pour les détails d'un ami.
* Contient toutes les informations disponibles sur un ami spécifique.
*/
@Getter
@Setter
@NoArgsConstructor
public class FriendshipReadFriendDetailsResponseDTO {
private UUID userId; // ID de l'utilisateur qui a initié la relation
private UUID friendId; // ID de l'ami
private String friendLastName; // Nom de l'ami
private String friendFirstName; // Prénom de l'ami
private String friendEmail; // Email de l'ami
private FriendshipStatus status; // Statut de la relation d'amitié
private LocalDateTime createdAt; // Date de création de la relation d'amitié
private LocalDateTime updatedAt; // Date de la dernière mise à jour de la relation
/**
* Constructeur pour initialiser le DTO avec des informations sur l'ami.
*
* @param userId L'ID de l'utilisateur initiant la demande d'amitié.
* @param friendId L'ID de l'ami.
* @param friendLastName Le nom de l'ami.
* @param friendFirstName Le prénom de l'ami.
* @param friendEmail L'email de l'ami.
* @param status Le statut de la relation d'amitié.
* @param createdAt La date de création de la relation.
* @param updatedAt La date de la dernière mise à jour de la relation.
*/
public FriendshipReadFriendDetailsResponseDTO(UUID userId, UUID friendId, String friendLastName,
String friendFirstName,
String friendEmail, FriendshipStatus status,
LocalDateTime createdAt, LocalDateTime updatedAt) {
this.userId = userId;
this.friendId = friendId;
this.friendLastName = friendLastName;
this.friendFirstName = friendFirstName;
this.friendEmail = friendEmail;
this.status = status;
this.createdAt = createdAt;
this.updatedAt = updatedAt;
}
}

47
src/main/java/com/lions/dev/dto/response/friends/FriendshipReadStatusResponseDTO.java Normal file
View File

@@ -0,0 +1,47 @@
package com.lions.dev.dto.response.friends;
import com.lions.dev.entity.friends.Friendship;
import com.lions.dev.entity.friends.FriendshipStatus;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import java.time.LocalDateTime;
import java.util.UUID;
/**
* DTO de réponse pour les demandes d'amitié filtrées par statut.
* Contient les informations essentielles sans données sensibles.
*/
@Getter
@Setter
@NoArgsConstructor
public class FriendshipReadStatusResponseDTO {
private UUID friendshipId; // ID de la relation d'amitié
private UUID userId; // ID de l'utilisateur ayant initié la demande
private String userNom; // Nom de l'utilisateur ayant initié la demande
private String userPrenoms; // Prénoms de l'utilisateur ayant initié la demande
private UUID friendId; // ID de l'utilisateur ayant reçu la demande
private String friendNom; // Nom de l'utilisateur ayant reçu la demande
private String friendPrenoms; // Prénoms de l'utilisateur ayant reçu la demande
private FriendshipStatus status; // Statut de la demande d'amitié
private LocalDateTime createdAt; // Date de création de la demande
/**
* Constructeur qui mappe directement l'entité `Friendship` à ce DTO.
*
* @param friendship L'entité `Friendship` à convertir en DTO.
*/
public FriendshipReadStatusResponseDTO(Friendship friendship) {
this.friendshipId = friendship.getId();
this.userId = friendship.getUser().getId();
this.userNom = friendship.getUser().getNom();
this.userPrenoms = friendship.getUser().getPrenoms();
this.friendId = friendship.getFriend().getId();
this.friendNom = friendship.getFriend().getNom();
this.friendPrenoms = friendship.getFriend().getPrenoms();
this.status = friendship.getStatus();
this.createdAt = friendship.getCreatedAt();
}
}

57
src/main/java/com/lions/dev/dto/response/friends/FriendshipRequestStatusResponseDTO.java
View File

@@ -1,57 +0,0 @@
package com.lions.dev.dto.response.friends;
import com.lions.dev.entity.friends.Friendship;
import com.lions.dev.entity.friends.FriendshipStatus;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import java.time.LocalDateTime;
import java.util.UUID;
/**
* DTO de réponse pour les demandes d'amitié par statut.
* Contient les informations essentielles sans données sensibles.
*/
@Getter
@Setter
@NoArgsConstructor
public class FriendshipRequestStatusResponseDTO {
private UUID friendshipId;
private UUID userId;
private String userNom;
private String userPrenoms;
private UUID friendId;
private String friendNom;
private String friendPrenoms;
private FriendshipStatus status;
private LocalDateTime createdAt;
public FriendshipRequestStatusResponseDTO(UUID friendshipId, UUID userId, String userNom, String userPrenoms,
UUID friendId, String friendNom, String friendPrenoms,
FriendshipStatus status, LocalDateTime createdAt) {
this.friendshipId = friendshipId;
this.userId = userId;
this.userNom = userNom;
this.userPrenoms = userPrenoms;
this.friendId = friendId;
this.friendNom = friendNom;
this.friendPrenoms = friendPrenoms;
this.status = status;
this.createdAt = createdAt;
}
// Constructor to map directly from Friendship entity
public FriendshipRequestStatusResponseDTO(Friendship friendship) {
this.friendshipId = friendship.getId();
this.userId = friendship.getUser().getId();
this.userNom = friendship.getUser().getNom();
this.userPrenoms = friendship.getUser().getPrenoms();
this.friendId = friendship.getFriend().getId();
this.friendNom = friendship.getFriend().getNom();
this.friendPrenoms = friendship.getFriend().getPrenoms();
this.status = friendship.getStatus();
this.createdAt = friendship.getCreatedAt();
}
}

25
src/main/java/com/lions/dev/entity/friends/Friendship.java
View File

@@ -1,29 +1,22 @@
package com.lions.dev.entity.friends;
import com.lions.dev.entity.BaseEntity; // Import de BaseEntity
import com.lions.dev.entity.BaseEntity;
import com.lions.dev.entity.users.Users;
import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import lombok.*;
/**
* Représentation de l'entité Friendship qui gère les relations d'amitié entre utilisateurs.
*/
/** Représentation de l'entité Friendship qui gère les relations d'amitié entre utilisateurs. */
@Entity
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@ToString
@Builder
@ToString
@Table(name = "friendships")
public class Friendship extends BaseEntity { // Hérite de BaseEntity
public class Friendship extends BaseEntity {
// L'utilisateur qui a initié la demande d'ami
// Utilisateur qui initie la demande
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "user_id", nullable = false)
private Users user;
@@ -39,12 +32,14 @@ public class Friendship extends BaseEntity { // Hérite de BaseEntity
private FriendshipStatus status;
/**
* Log des changements de statut de l'amitié.
* Mise à jour du statut de la relation d'amitié avec log des changements.
*
* @param newStatus Nouveau statut de l'amitié
*/
public void setStatus(FriendshipStatus newStatus) {
this.status = newStatus;
System.out.println(
"[LOG] Changement de statut pour l'amitié entre "
"[LOG] Statut changé pour l'amitié entre "
+ this.user.getEmail()
+ " et "
+ this.friend.getEmail()

4
src/main/java/com/lions/dev/exception/FriendshipNotFoundException.java
View File

@@ -8,8 +8,4 @@ public class FriendshipNotFoundException extends RuntimeException {
public FriendshipNotFoundException(String message) {
super(message);
}
public FriendshipNotFoundException(String message, Throwable cause) {
super(message, cause);
}
}

51
src/main/java/com/lions/dev/repository/FriendshipRepository.java
View File

@@ -3,7 +3,7 @@ package com.lions.dev.repository;
import com.lions.dev.entity.friends.Friendship;
import com.lions.dev.entity.friends.FriendshipStatus;
import com.lions.dev.entity.users.Users;
import io.quarkus.hibernate.orm.panache.PanacheRepository;
import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
import jakarta.enterprise.context.ApplicationScoped;
import java.util.List;
@@ -12,26 +12,29 @@ import java.util.UUID;
/**
* Repository pour gérer les relations d'amitié (Friendship) dans la base de données.
* Il contient des méthodes pour récupérer, ajouter, et supprimer des relations d'amitié.
*/
@ApplicationScoped
public class FriendshipRepository implements PanacheRepository<Friendship> {
public class FriendshipRepository implements PanacheRepositoryBase<Friendship, UUID> {
/**
* Trouve une relation d'amitié entre deux utilisateurs.
* Trouver une relation d'amitié entre deux utilisateurs.
*
* @param user L'utilisateur qui envoie la demande.
* @param user L'utilisateur qui envoie la demande d'amitié.
* @param friend L'ami qui reçoit la demande.
* @return Une Optional contenant la relation d'amitié, si elle existe.
* @return Une Optional contenant la relation d'amitié si elle existe.
*/
public Optional<Friendship> findByUsers(Users user, Users friend) {
return find("user = ?1 and friend = ?2", user, friend).firstResultOptional();
}
/**
* Récupère la liste des amis d'un utilisateur.
* Récupérer la liste des amis d'un utilisateur, c'est-à-dire toutes les relations acceptées.
*
* @param user L'utilisateur dont on souhaite récupérer les amis.
* @return Une liste de relations d'amitié.
* @param page Le numéro de la page à récupérer.
* @param size La taille de la page (nombre d'éléments).
* @return Une liste paginée de relations d'amitié acceptées.
*/
public List<Friendship> findFriendsByUser(Users user, int page, int size) {
return find("(user = ?1 or friend = ?1) and status = ?2", user, FriendshipStatus.ACCEPTED)
@@ -40,37 +43,13 @@ public class FriendshipRepository implements PanacheRepository<Friendship> {
}
/**
* Trouve une relation d'amitié par son ID.
*
* @param id L'ID de la relation d'amitié.
* @return Une Optional contenant la relation d'amitié, si elle existe.
*/
public Optional<Friendship> findById(UUID id) {
return find("id", id).firstResultOptional();
}
/**
* Supprime une relation d'amitié de la base de données.
*
* @param friendship La relation d'amitié à supprimer.
*/
public void deleteFriendship(Friendship friendship) {
if (friendship != null) {
this.delete(friendship); // Suppression de l'entité Friendship
System.out.println("[LOG] Entité Friendship supprimée : " + friendship.getId());
} else {
System.out.println("[ERROR] Tentative de suppression d'une entité Friendship inexistante.");
}
}
/**
* Récupère toutes les relations d'amitié d'un utilisateur ayant un statut particulier.
* Récupérer toutes les relations d'amitié d'un utilisateur avec un statut spécifique.
*
* @param user L'utilisateur dont on souhaite récupérer les amitiés.
* @param status Le statut des relations d'amitié à rechercher.
* @param page Le numéro de la page à récupérer.
* @param size Le nombre d'éléments par page.
* @return Une liste paginée de relations d'amitié ayant le statut spécifié pour cet utilisateur.
* @param status Le statut des relations d'amitié à filtrer.
* @param page Le numéro de la page.
* @param size La taille de la page.
* @return Une liste paginée de relations d'amitié avec le statut spécifié.
*/
public List<Friendship> findByUserAndStatus(Users user, FriendshipStatus status, int page, int size) {
return find("(user = ?1 or friend = ?1) and status = ?2", user, status)

268
src/main/java/com/lions/dev/resource/FriendshipResource.java
View File

@@ -1,12 +1,11 @@
package com.lions.dev.resource;
import com.lions.dev.dto.request.friends.FriendshipRequestDTO;
import com.lions.dev.dto.response.friends.FriendshipRequestStatusResponseDTO;
import com.lions.dev.dto.response.friends.FriendshipResponseDTO;
import com.lions.dev.entity.friends.Friendship;
import com.lions.dev.entity.friends.FriendshipStatus;
import com.lions.dev.entity.users.Users;
import com.lions.dev.repository.UsersRepository;
import com.lions.dev.dto.request.friends.FriendshipCreateOneRequestDTO;
import com.lions.dev.dto.request.friends.FriendshipReadFriendDetailsRequestDTO;
import com.lions.dev.dto.request.friends.FriendshipReadStatusRequestDTO;
import com.lions.dev.dto.response.friends.FriendshipCreateOneResponseDTO;
import com.lions.dev.dto.response.friends.FriendshipReadFriendDetailsResponseDTO;
import com.lions.dev.dto.response.friends.FriendshipReadStatusResponseDTO;
import com.lions.dev.service.FriendshipService;
import jakarta.inject.Inject;
import jakarta.validation.Valid;
@@ -17,7 +16,6 @@ import jakarta.ws.rs.core.Response;
import java.util.List;
import java.util.UUID;
import org.eclipse.microprofile.openapi.annotations.Operation;
import org.eclipse.microprofile.openapi.annotations.enums.SchemaType;
import org.eclipse.microprofile.openapi.annotations.media.Content;
import org.eclipse.microprofile.openapi.annotations.media.Schema;
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
@@ -27,46 +25,45 @@ import org.jboss.logging.Logger;
/**
* Ressource REST pour gérer les amitiés. Ce contrôleur expose des endpoints pour envoyer, accepter,
* rejeter et supprimer des demandes d'amitié. Les opérations sont loguées pour suivre leur
* déroulement en temps réel.
* rejeter et supprimer des demandes d'amitié. Toutes les opérations sont loguées pour faciliter le
* suivi en temps réel.
*/
@Path("/friends")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON) // Assure que la réponse sera en JSON
@Consumes(MediaType.APPLICATION_JSON) // Assure que la requête attend du JSON
@Tag(name = "Friendship", description = "Opérations liées à la gestion des amis")
public class FriendshipResource {
@Inject
FriendshipService friendshipService;
@Inject
UsersRepository usersRepository;
@Inject FriendshipService friendshipService; // Injection du service d'amitié
private static final Logger logger = Logger.getLogger(FriendshipResource.class);
/**
* Envoie une demande d'amitié.
*
* @param request DTO contenant l'ID de l'utilisateur qui reçoit la demande.
* @param request DTO contenant l'ID de l'utilisateur qui envoie la demande et l'utilisateur qui
* la reçoit.
* @return La relation d'amitié créée.
*/
@POST
@Path("/send")
@Operation(
summary = "Envoyer une demande d'amitié",
description = "Envoie une demande d'amitié d'un utilisateur à un autre")
description = "Permet à un utilisateur d'envoyer une demande d'amitié")
@APIResponses({
@APIResponse(
responseCode = "200",
description = "Demande d'amitié envoyée",
description = "Demande d'amitié envoyée avec succès",
content =
@Content(
mediaType = MediaType.APPLICATION_JSON,
schema = @Schema(implementation = FriendshipResponseDTO.class))),
schema = @Schema(implementation = FriendshipCreateOneResponseDTO.class))),
@APIResponse(responseCode = "400", description = "Requête invalide"),
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
@APIResponse(
responseCode = "500",
description = "Erreur serveur lors de l'envoi de la demande d'amitié")
})
public Response sendFriendRequest(@Valid @NotNull FriendshipRequestDTO request) {
public Response sendFriendRequest(@Valid @NotNull FriendshipCreateOneRequestDTO request) {
logger.info(
"[LOG] Reçu une demande pour envoyer une demande d'amitié de l'utilisateur "
+ request.getUserId()
@@ -74,16 +71,17 @@ public class FriendshipResource {
+ request.getFriendId());
try {
Friendship friendship =
friendshipService.sendFriendRequest(request.getUserId(), request.getFriendId());
// Appel du service pour envoyer la demande d'amitié
FriendshipCreateOneResponseDTO friendshipResponse =
friendshipService.sendFriendRequest(request);
logger.info(
"[LOG] Demande d'amitié envoyée avec succès : "
+ friendship.getUser().getEmail()
+ " à "
+ friendship.getFriend().getEmail());
return Response.ok(new FriendshipResponseDTO(friendship)).build();
"[LOG] Demande d'amitié envoyée avec succès entre les utilisateurs "
+ friendshipResponse.getUserId()
+ " et "
+ friendshipResponse.getFriendId());
return Response.ok(friendshipResponse).build();
} catch (Exception e) {
logger.error("[ERROR] Erreur lors de l'envoi de la demande d'amitié : " + e.getMessage());
logger.error("[ERROR] Erreur lors de l'envoi de la demande d'amitié : " + e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
.entity("{\"message\": \"Erreur lors de l'envoi de la demande d'amitié.\"}")
.build();
@@ -108,30 +106,28 @@ public class FriendshipResource {
content =
@Content(
mediaType = MediaType.APPLICATION_JSON,
schema = @Schema(implementation = FriendshipResponseDTO.class))),
schema = @Schema(implementation = FriendshipCreateOneResponseDTO.class))),
@APIResponse(responseCode = "404", description = "Demande d'amitié non trouvée"),
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
@APIResponse(
responseCode = "500",
description = "Erreur lors de l'acceptation de la demande d'amitié")
})
public Response acceptFriendRequest(@PathParam("friendshipId") UUID friendshipId) {
logger.info(
"[LOG] Reçu une demande pour accepter une demande d'amitié avec l'ID : " + friendshipId);
"[LOG] Reçu une demande pour accepter la demande d'amitié avec l'ID : " + friendshipId);
try {
Friendship friendship = friendshipService.acceptFriendRequest(friendshipId);
FriendshipCreateOneResponseDTO friendshipResponse =
friendshipService.acceptFriendRequest(friendshipId);
logger.info(
"[LOG] Demande d'amitié acceptée entre "
+ friendship.getUser().getEmail()
"[LOG] Demande d'amitié acceptée avec succès entre les utilisateurs "
+ friendshipResponse.getUserId()
+ " et "
+ friendship.getFriend().getEmail());
return Response.ok(new FriendshipResponseDTO(friendship)).build();
} catch (NotFoundException e) {
logger.error("[ERROR] Demande d'amitié non trouvée : " + e.getMessage());
return Response.status(Response.Status.NOT_FOUND)
.entity("{\"message\": \"Demande d'amitié non trouvée.\"}")
.build();
+ friendshipResponse.getFriendId());
return Response.ok(friendshipResponse).build();
} catch (Exception e) {
logger.error(
"[ERROR] Erreur lors de l'acceptation de la demande d'amitié : " + e.getMessage());
"[ERROR] Erreur lors de l'acceptation de la demande d'amitié : " + e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
.entity("{\"message\": \"Erreur lors de l'acceptation de la demande d'amitié.\"}")
.build();
@@ -152,23 +148,18 @@ public class FriendshipResource {
@APIResponses({
@APIResponse(responseCode = "204", description = "Demande d'amitié rejetée"),
@APIResponse(responseCode = "404", description = "Demande d'amitié non trouvée"),
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
@APIResponse(responseCode = "500", description = "Erreur lors du rejet de la demande d'amitié")
})
public Response rejectFriendRequest(@PathParam("friendshipId") UUID friendshipId) {
logger.info(
"[LOG] Reçu une demande pour rejeter une demande d'amitié avec l'ID : " + friendshipId);
"[LOG] Reçu une demande pour rejeter la demande d'amitié avec l'ID : " + friendshipId);
try {
friendshipService.rejectFriendRequest(friendshipId);
logger.info("[LOG] Demande d'amitié rejetée pour l'ID : " + friendshipId);
logger.info("[LOG] Demande d'amitié rejetée avec succès.");
return Response.noContent().build();
} catch (NotFoundException e) {
logger.error("[ERROR] Demande d'amitié non trouvée : " + e.getMessage());
return Response.status(Response.Status.NOT_FOUND)
.entity("{\"message\": \"Demande d'amitié non trouvée.\"}")
.build();
} catch (Exception e) {
logger.error("[ERROR] Erreur lors du rejet de la demande d'amitié : " + e.getMessage());
logger.error("[ERROR] Erreur lors du rejet de la demande d'amitié : " + e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
.entity("{\"message\": \"Erreur lors du rejet de la demande d'amitié.\"}")
.build();
@@ -189,7 +180,9 @@ public class FriendshipResource {
@APIResponses({
@APIResponse(responseCode = "204", description = "Relation d'amitié supprimée"),
@APIResponse(responseCode = "404", description = "Relation d'amitié non trouvée"),
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
@APIResponse(
responseCode = "500",
description = "Erreur lors de la suppression de la relation d'amitié")
})
public Response removeFriend(@PathParam("friendshipId") UUID friendshipId) {
logger.info(
@@ -197,16 +190,11 @@ public class FriendshipResource {
try {
friendshipService.removeFriend(friendshipId);
logger.info("[LOG] Relation d'amitié supprimée avec succès pour l'ID : " + friendshipId);
logger.info("[LOG] Relation d'amitié supprimée avec succès.");
return Response.noContent().build();
} catch (NotFoundException e) {
logger.error("[ERROR] Relation d'amitié non trouvée : " + e.getMessage());
return Response.status(Response.Status.NOT_FOUND)
.entity("{\"message\": \"Relation d'amitié non trouvée.\"}")
.build();
} catch (Exception e) {
logger.error(
"[ERROR] Erreur lors de la suppression de la relation d'amitié : " + e.getMessage());
"[ERROR] Erreur lors de la suppression de la relation d'amitié : " + e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
.entity("{\"message\": \"Erreur lors de la suppression de la relation d'amitié.\"}")
.build();
@@ -216,102 +204,140 @@ public class FriendshipResource {
/**
* Récupère la liste des amis d'un utilisateur.
*
* @param userId L'ID de l'utilisateur dont on veut récupérer les amis.
* @param page Numéro de la page pour la pagination.
* @param size Nombre d'éléments par page.
* @return La liste des amis de l'utilisateur.
* @param userId L'ID de l'utilisateur
* @param page Numéro de la page pour la pagination
* @param size Nombre d'éléments par page
* @return Liste des amis de l'utilisateur avec pagination
*/
@GET
@Path("/list/{userId}")
@Operation(
summary = "Lister les amis d'un utilisateur",
description = "Récupère la liste de tous les amis d'un utilisateur donné")
summary = "Récupérer la liste des amis",
description = "Retourne la liste des amis d'un utilisateur avec pagination")
@APIResponses({
@APIResponse(
responseCode = "200",
description = "Liste des amis récupérée",
description = "Liste des amis récupérée avec succès",
content =
@Content(
mediaType = MediaType.APPLICATION_JSON,
schema =
@Schema(
type = SchemaType.ARRAY,
implementation = FriendshipResponseDTO.class))),
schema = @Schema(implementation = FriendshipReadFriendDetailsResponseDTO.class))),
@APIResponse(responseCode = "404", description = "Utilisateur non trouvé"),
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
@APIResponse(responseCode = "500", description = "Erreur lors de la récupération des amis")
})
public Response listFriends(
@PathParam("userId") UUID userId,
@QueryParam("page") @DefaultValue("1") int page,
@QueryParam("page") @DefaultValue("0") int page,
@QueryParam("size") @DefaultValue("10") int size) {
logger.info(
"[LOG] Reçu une demande pour récupérer la liste des amis de l'utilisateur avec l'ID : "
+ userId);
try {
List<Friendship> friends = friendshipService.listFriends(userId, page, size);
logger.info(
"[LOG] Liste des amis récupérée avec succès pour l'utilisateur "
+ userId
+ ", nombre d'amis : "
+ friends.size());
return Response.ok(friends.stream().map(FriendshipResponseDTO::new)).build();
} catch (NotFoundException e) {
logger.error("[ERROR] Utilisateur non trouvé : " + e.getMessage());
return Response.status(Response.Status.NOT_FOUND)
.entity("{\"message\": \"Utilisateur non trouvé.\"}")
.build();
List<FriendshipReadFriendDetailsResponseDTO> friendships =
friendshipService.listFriends(userId, page, size);
logger.info("[LOG] Liste des amis récupérée avec succès.");
return Response.ok(friendships).build();
} catch (Exception e) {
logger.error(
"[ERROR] Erreur lors de la récupération de la liste des amis : " + e.getMessage());
"[ERROR] Erreur lors de la récupération de la liste des amis : " + e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
.entity("{\"message\": \"Erreur lors de la récupération de la liste des amis.\"}")
.entity("{\"message\": \"Erreur lors de la récupération des amis.\"}")
.build();
}
}
/**
* Endpoint pour récupérer les demandes d'amitié avec un statut spécifique.
* Récupérer les demandes d'amitié avec un statut spécifique.
*
* @param userId L'ID de l'utilisateur.
* @param status Le statut des demandes à filtrer (PENDING, ACCEPTED, REJECTED).
* @param page Le numéro de la page à récupérer.
* @param size Le nombre d'éléments par page.
* @return La liste paginée des demandes d'amitié avec le statut spécifié.
* @param request DTO contenant les informations de filtrage (statut).
* @return Liste des demandes d'amitié avec le statut spécifié.
*/
@GET
@POST
@Path("/status")
@Operation(
summary = "Récupérer les demandes d'amitié faites par un utilisateur par statut",
description = "Retourne la liste des demandes d'amitié faites par un utilisateur avec un "
+ "statut particulier.")
summary = "Récupérer les demandes d'amitié par statut",
description = "Retourne la liste des demandes d'amitié avec un statut particulier")
@APIResponses({
@APIResponse(
responseCode = "200",
description = "Demandes d'amitié récupérées",
content =
@Content(
mediaType = MediaType.APPLICATION_JSON,
schema = @Schema(implementation = FriendshipReadStatusResponseDTO.class))),
@APIResponse(responseCode = "404", description = "Utilisateur non trouvé"),
@APIResponse(
responseCode = "500",
description = "Erreur lors de la récupération des demandes d'amitié")
})
public Response listFriendRequestsByStatus(
@QueryParam("userId") UUID userId,
@QueryParam("status") FriendshipStatus status,
@QueryParam("page") @DefaultValue("1") int page,
@QueryParam("size") @DefaultValue("10") int size) {
@Valid @NotNull FriendshipReadStatusRequestDTO request) {
logger.info("[LOG] Récupération des demandes d'amitié avec le statut : " + request.getStatus());
logger.info("[LOG] Récupération des demandes d'amitié avec le statut : " + status);
// Récupère l'utilisateur à partir de l'ID fourni
Users user = usersRepository.findById(userId);
if (user == null) {
return Response.status(Response.Status.NOT_FOUND)
.entity("{\"message\": \"Utilisateur non trouvé.\"}")
try {
List<FriendshipReadStatusResponseDTO> friendships =
friendshipService.listFriendRequestsByStatus(request);
logger.info("[LOG] " + friendships.size() + " demandes d'amitié récupérées avec succès.");
return Response.ok(friendships).build();
} catch (Exception e) {
logger.error(
"[ERROR] Erreur lors de la récupération des demandes d'amitié : " + e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
.entity("{\"message\": \"Erreur lors de la récupération des demandes d'amitié.\"}")
.build();
}
}
// Ajuste la pagination (Panache commence à 0)
int adjustedPage = page - 1;
if (adjustedPage < 0) adjustedPage = 0;
/**
* Récupère les détails complets d'un ami.
*
* @param request DTO contenant l'ID de l'utilisateur et de l'ami dont les détails sont requis.
* @return Les détails complets de l'ami.
*/
@POST
@Path("/details")
@Operation(
summary = "Récupérer les détails d'un ami",
description = "Permet de récupérer toutes les informations disponibles sur un ami spécifique")
@APIResponses({
@APIResponse(
responseCode = "200",
description = "Détails de l'ami récupérés avec succès",
content =
@Content(
mediaType = MediaType.APPLICATION_JSON,
schema = @Schema(implementation = FriendshipReadFriendDetailsResponseDTO.class))),
@APIResponse(responseCode = "404", description = "Ami non trouvé"),
@APIResponse(responseCode = "500", description = "Erreur serveur lors de la récupération des détails de l'ami")
})
public Response getFriendDetails(@Valid @NotNull FriendshipReadFriendDetailsRequestDTO request) {
logger.info(
"[LOG] Reçu une demande pour récupérer les détails de l'ami avec l'ID : "
+ request.getFriendId() + " pour l'utilisateur : " + request.getUserId());
List<Friendship> friendships = friendshipService.listFriendRequestsByStatus(user, status, adjustedPage, size);
// Transformation des entités Friendship en DTOs adaptés
List<FriendshipRequestStatusResponseDTO> responseDTOs = friendships.stream()
.map(FriendshipRequestStatusResponseDTO::new)
.toList();
return Response.ok(responseDTOs).build();
try {
// Appel du service pour récupérer les détails de l'ami
FriendshipReadFriendDetailsResponseDTO friendDetails =
friendshipService.getFriendDetails(request);
logger.info(
"[LOG] Détails de l'ami récupérés avec succès pour l'utilisateur : "
+ request.getUserId() + ", ami ID : " + request.getFriendId());
return Response.ok(friendDetails).build();
} catch (NotFoundException e) {
logger.warn(
"[WARN] Aucun ami trouvé pour l'utilisateur : " + request.getUserId()
+ " avec l'ID de l'ami : " + request.getFriendId());
return Response.status(Response.Status.NOT_FOUND)
.entity("{\"message\": \"Ami non trouvé.\"}")
.build();
} catch (Exception e) {
logger.error(
"[ERROR] Erreur lors de la récupération des détails de l'ami : "
+ e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
.entity("{\"message\": \"Erreur lors de la récupération des détails de l'ami.\"}")
.build();
}
}
}

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

@@ -1,5 +1,11 @@
package com.lions.dev.service;
import com.lions.dev.dto.request.friends.FriendshipCreateOneRequestDTO;
import com.lions.dev.dto.request.friends.FriendshipReadFriendDetailsRequestDTO;
import com.lions.dev.dto.request.friends.FriendshipReadStatusRequestDTO;
import com.lions.dev.dto.response.friends.FriendshipCreateOneResponseDTO;
import com.lions.dev.dto.response.friends.FriendshipReadFriendDetailsResponseDTO;
import com.lions.dev.dto.response.friends.FriendshipReadStatusResponseDTO;
import com.lions.dev.entity.friends.Friendship;
import com.lions.dev.entity.friends.FriendshipStatus;
import com.lions.dev.entity.users.Users;
@@ -10,175 +16,224 @@ 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.List;
import java.util.Optional;
import java.util.UUID;
import java.util.stream.Collectors;
/**
* Service de gestion des amitiés. Ce service gère l'envoi, l'acceptation, le rejet et la
* suppression d'amitiés.
* Service pour gérer les relations d'amitié.
* Contient la logique métier pour envoyer, accepter, rejeter, et supprimer des relations d'amitié.
*/
@ApplicationScoped
public class FriendshipService {
@Inject FriendshipRepository friendshipRepository;
@Inject
FriendshipRepository friendshipRepository; // Injecte le repository des amitiés
@Inject
UsersRepository usersRepository; // Injecte le repository des utilisateurs
@Inject UsersRepository usersRepository;
private static final Logger logger = Logger.getLogger(FriendshipService.class);
/**
* Envoie une demande d'amitié entre deux utilisateurs.
*
* @param userId L'ID de l'utilisateur qui envoie la demande.
* @param friendId L'ID de l'utilisateur qui reçoit la demande.
* @return La relation d'amitié créée.
* @throws UserNotFoundException Si l'un des utilisateurs n'est pas trouvé.
* @param request DTO contenant les informations sur l'utilisateur et l'ami.
* @return Le DTO de la relation d'amitié créée.
*/
@Transactional
public Friendship sendFriendRequest(UUID userId, UUID friendId) {
System.out.println(
"[LOG] Envoi de demande d'amitié de l'utilisateur "
+ userId
+ " à l'utilisateur "
+ friendId);
public FriendshipCreateOneResponseDTO sendFriendRequest(FriendshipCreateOneRequestDTO request) {
logger.info("[LOG] Envoi d'une demande d'amitié de l'utilisateur " + request.getUserId() + " à l'utilisateur " + request.getFriendId());
Users user = usersRepository.findById(userId);
Users friend = usersRepository.findById(friendId);
// Récupérer les utilisateurs concernés
Users user = usersRepository.findById(request.getUserId());
Users friend = usersRepository.findById(request.getFriendId());
if (user == null || friend == null) {
System.out.println(
"[ERROR] Utilisateur non trouvé pour l'ID : " + (user == null ? userId : friendId));
throw new UserNotFoundException("L'utilisateur avec l'ID spécifié n'existe pas.");
String notFoundId = user == null ? request.getUserId().toString() : request.getFriendId().toString();
logger.error("[ERROR] Utilisateur non trouvé pour l'ID : " + notFoundId);
throw new UserNotFoundException("Utilisateur avec l'ID " + notFoundId + " introuvable.");
}
Optional<Friendship> existingFriendship = friendshipRepository.findByUsers(user, friend);
if (existingFriendship.isPresent()) {
System.out.println("[ERROR] Une relation d'amitié existe déjà entre ces deux utilisateurs.");
// Vérifier s'il existe déjà une relation d'amitié
Friendship existingFriendship = friendshipRepository.findByUsers(user, friend).orElse(null);
if (existingFriendship != null) {
logger.error("[ERROR] Relation d'amitié déjà existante entre les utilisateurs.");
throw new IllegalArgumentException("Relation d'amitié déjà existante.");
}
Friendship friendship =
Friendship.builder().user(user).friend(friend).status(FriendshipStatus.PENDING).build();
// Créer et persister une nouvelle relation d'amitié
Friendship friendship = new Friendship(user, friend, FriendshipStatus.PENDING);
friendshipRepository.persist(friendship);
System.out.println(
"[LOG] Demande d'amitié envoyée de " + user.getEmail() + " à " + friend.getEmail());
return friendship;
logger.info("[LOG] Demande d'amitié envoyée avec succès.");
return new FriendshipCreateOneResponseDTO(friendship);
}
/**
* Accepte une demande d'amitié.
* Accepter une demande d'amitié.
*
* @param friendshipId L'ID de la demande d'amitié.
* @return La relation d'amitié acceptée.
* @throws FriendshipNotFoundException Si la relation d'amitié n'est pas trouvée.
* @param friendshipId ID de la demande à accepter.
* @return Le DTO de la relation d'amitié acceptée.
*/
@Transactional
public Friendship acceptFriendRequest(UUID friendshipId) {
System.out.println("[LOG] Acceptation de la demande d'amitié avec l'ID : " + friendshipId);
Friendship friendship =
friendshipRepository
.findById(friendshipId)
.orElseThrow(() -> new FriendshipNotFoundException("Demande d'amitié introuvable."));
if (friendship.getStatus() == FriendshipStatus.ACCEPTED) {
System.out.println("[ERROR] La demande d'amitié a déjà été acceptée.");
throw new IllegalArgumentException("Cette demande d'amitié a déjà été acceptée.");
public FriendshipCreateOneResponseDTO acceptFriendRequest(UUID friendshipId) {
Friendship friendship = friendshipRepository.findById(friendshipId);
if (friendship == null) {
throw new FriendshipNotFoundException("Demande d'amitié introuvable.");
}
// Vérifier que la demande n'est pas déjà acceptée
if (friendship.getStatus() == FriendshipStatus.ACCEPTED) {
logger.error("[ERROR] Demande d'amitié déjà acceptée.");
throw new IllegalArgumentException("Demande d'amitié déjà acceptée.");
}
// Accepter la demande
friendship.setStatus(FriendshipStatus.ACCEPTED);
friendshipRepository.persist(friendship);
System.out.println(
"[LOG] Demande d'amitié acceptée entre "
+ friendship.getUser().getEmail()
+ " et "
+ friendship.getFriend().getEmail());
return friendship;
logger.info("[LOG] Demande d'amitié acceptée avec succès.");
return new FriendshipCreateOneResponseDTO(friendship);
}
/**
* Rejette une demande d'amitié.
* Rejeter une demande d'amitié.
*
* @param friendshipId L'ID de la demande d'amitié.
* @throws FriendshipNotFoundException Si la relation d'amitié n'est pas trouvée.
* @param friendshipId ID de la demande à rejeter.
*/
@Transactional
public void rejectFriendRequest(UUID friendshipId) {
System.out.println("[LOG] Rejet de la demande d'amitié avec l'ID : " + friendshipId);
Friendship friendship =
friendshipRepository
.findById(friendshipId)
.orElseThrow(() -> new FriendshipNotFoundException("Demande d'amitié introuvable."));
Friendship friendship = friendshipRepository.findById(friendshipId);
if (friendship == null) {
throw new FriendshipNotFoundException("Demande d'amitié introuvable.");
}
friendship.setStatus(FriendshipStatus.REJECTED);
friendshipRepository.persist(friendship);
System.out.println(
"[LOG] Demande d'amitié rejetée entre "
+ friendship.getUser().getEmail()
+ " et "
+ friendship.getFriend().getEmail());
logger.info("[LOG] Demande d'amitié rejetée.");
}
/**
* Supprime une relation d'amitié.
* Supprimer une relation d'amitié.
*
* @param friendshipId L'ID de la relation d'amitié à supprimer.
* @throws FriendshipNotFoundException Si la relation d'amitié n'est pas trouvée.
* @param friendshipId ID de la relation à supprimer.
*/
@Transactional
public void removeFriend(UUID friendshipId) {
System.out.println("[LOG] Suppression de la relation d'amitié avec l'ID : " + friendshipId);
Friendship friendship = friendshipRepository.findById(friendshipId);
if (friendship == null) {
throw new FriendshipNotFoundException("Relation d'amitié introuvable.");
}
Friendship friendship =
friendshipRepository
.findById(friendshipId)
.orElseThrow(() -> new FriendshipNotFoundException("Amitié introuvable."));
friendshipRepository.deleteFriendship(friendship); // Appel à deleteFriendship
System.out.println(
"[LOG] Amitié supprimée entre "
+ friendship.getUser().getEmail()
+ " et "
+ friendship.getFriend().getEmail());
friendshipRepository.delete(friendship);
logger.info("[LOG] Relation d'amitié supprimée.");
}
/**
* Récupère la liste des amis d'un utilisateur avec pagination.
* Récupère les détails d'un ami spécifique pour un utilisateur donné.
*
* @param userId L'ID de l'utilisateur.
* @param page Le numéro de la page à récupérer.
* @param size Le nombre d'éléments par page.
* @return La liste paginée des relations d'amitié.
* @throws UserNotFoundException Si l'utilisateur n'est pas trouvé.
* @param request DTO contenant l'ID de l'utilisateur et de l'ami.
* @return Le DTO des détails de l'ami.
*/
public List<Friendship> listFriends(UUID userId, int page, int size) {
System.out.println(
"[LOG] Récupération de la liste paginée des amis pour l'utilisateur avec l'ID : " + userId);
@Transactional
public FriendshipReadFriendDetailsResponseDTO getFriendDetails(
FriendshipReadFriendDetailsRequestDTO request) {
logger.info("[LOG] Tentative de récupération des détails de l'ami avec l'ID : "
+ request.getFriendId() + " pour l'utilisateur : " + request.getUserId());
// Récupération de l'utilisateur et de l'ami
Users user = usersRepository.findById(request.getUserId());
Users friend = usersRepository.findById(request.getFriendId());
if (user == null) {
logger.error("[ERROR] Utilisateur introuvable avec l'ID : " + request.getUserId());
throw new UserNotFoundException("Utilisateur introuvable avec l'ID " + request.getUserId());
}
if (friend == null) {
logger.error("[ERROR] Ami introuvable avec l'ID : " + request.getFriendId());
throw new UserNotFoundException("Ami introuvable avec l'ID " + request.getFriendId());
}
// Récupérer la relation d'amitié entre les deux utilisateurs
Friendship friendship = friendshipRepository.findByUsers(user, friend).orElse(null);
if (friendship == null) {
logger.error("[ERROR] Aucune relation d'amitié trouvée entre l'utilisateur et l'ami.");
throw new FriendshipNotFoundException("Relation d'amitié introuvable.");
}
logger.info("[LOG] Détails de l'ami récupérés avec succès pour l'utilisateur : "
+ user.getId() + ", ami ID : " + friend.getId());
// Création du DTO de réponse à partir des informations de l'ami et de la relation
return new FriendshipReadFriendDetailsResponseDTO(
user.getId(), // ID de l'utilisateur
friend.getId(), // ID de l'ami
friend.getNom(), // Nom de l'ami
friend.getPrenoms(),
friend.getEmail(), // Email de l'ami
friendship.getStatus(), // Statut de la relation
friendship.getCreatedAt(), // Date de création de la relation
friendship.getUpdatedAt() // Date de mise à jour de la relation
);
}
/**
* Récupérer la liste des amis d'un utilisateur.
*
* @param userId ID de l'utilisateur.
* @param page Numéro de la page.
* @param size Taille de la page.
* @return Liste paginée des relations d'amitié.
*/
public List<FriendshipReadFriendDetailsResponseDTO> listFriends(UUID userId, int page, int size) {
Users user = usersRepository.findById(userId);
if (user == null) {
System.out.println("[ERROR] Utilisateur non trouvé pour l'ID : " + userId);
throw new UserNotFoundException("Utilisateur non trouvé.");
logger.error("[ERROR] Utilisateur non trouvé.");
throw new UserNotFoundException("Utilisateur introuvable.");
}
return friendshipRepository.findFriendsByUser(user, page, size);
// 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.");
// Ajouter un log pour chaque amitié récupérée
friendships.forEach(friendship -> logger.info("[LOG] Ami : " + friendship.getFriend().getEmail()));
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());
}
/**
* Récupère toutes les demandes d'amitié avec un statut spécifique.
* Récupérer les demandes d'amitié avec un statut spécifique.
*
* @param user L'utilisateur.
* @param status Le statut des demandes d'amitié à récupérer (PENDING, ACCEPTED, REJECTED).
* @param page Le numéro de la page à récupérer.
* @param size Le nombre d'éléments par page.
* @return La liste paginée des relations d'amitié avec le statut spécifié.
* @param request DTO contenant les informations de filtrage (statut).
* @return Liste des demandes d'amitié avec le statut spécifié.
*/
public List<Friendship> listFriendRequestsByStatus(Users user, FriendshipStatus status, int page, int size) {
System.out.println("[LOG] Récupération des demandes d'amitié avec le statut : " + status);
return friendshipRepository.findByUserAndStatus(user, status, page, size);
public List<FriendshipReadStatusResponseDTO> listFriendRequestsByStatus(FriendshipReadStatusRequestDTO request) {
Users user = usersRepository.findById(request.getUserId());
if (user == null) {
logger.error("[ERROR] Utilisateur non trouvé.");
throw new UserNotFoundException("Utilisateur introuvable.");
}
// Récupérer les demandes d'amitié selon le statut
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());
}
}

31
src/main/java/com/lions/dev/service/UsersService.java
View File

@@ -29,26 +29,29 @@ public class UsersService {
* @return L'utilisateur créé.
*/
public Users createUser(UserCreateRequestDTO userCreateRequestDTO) {
// Vérification si l'email existe déjà
Optional<Users> existingUser = usersRepository.findByEmail(userCreateRequestDTO.getEmail());
if (existingUser.isPresent()) {
throw new IllegalArgumentException("Un utilisateur avec cet email existe déjà.");
}
Users user = new Users();
user.setNom(userCreateRequestDTO.getNom());
user.setPrenoms(userCreateRequestDTO.getPrenoms());
user.setEmail(userCreateRequestDTO.getEmail());
user.setMotDePasse(userCreateRequestDTO.getMotDePasse()); // Hachage automatique
// Vérifier si le profile image est défini, sinon attribuer une image par défaut
if (userCreateRequestDTO.getProfileImageUrl() == null
|| userCreateRequestDTO.getProfileImageUrl().isEmpty()) {
user.setProfileImageUrl("https://via.placeholder.com/150"); // Assigner une image par défaut
} else {
user.setProfileImageUrl(userCreateRequestDTO.getProfileImageUrl());
}
// Vérifier si le rôle est défini, sinon attribuer un rôle par défaut
if (userCreateRequestDTO.getRole() == null || userCreateRequestDTO.getRole().isEmpty()) {
user.setRole("USER"); // Assigner un rôle par défaut
} else {
user.setRole(userCreateRequestDTO.getRole());
}
// Logique pour l'image et le rôle par défaut.
user.setProfileImageUrl(
userCreateRequestDTO.getProfileImageUrl() != null
? userCreateRequestDTO.getProfileImageUrl()
: "https://via.placeholder.com/150"
);
user.setRole(
userCreateRequestDTO.getRole() != null
? userCreateRequestDTO.getRole()
: "USER"
);
usersRepository.persist(user);
System.out.println("[LOG] Utilisateur créé : " + user.getEmail());

2
src/main/resources/application.properties
View File

@@ -12,7 +12,7 @@ quarkus.datasource.jdbc.url=jdbc:oracle:thin:@localhost:1522:ORCLCDB
quarkus.datasource.username=C##AFTERWORK
quarkus.datasource.password=afterwork
quarkus.datasource.jdbc.driver=oracle.jdbc.OracleDriver
quarkus.hibernate-orm.database.generation=drop-and-create
quarkus.hibernate-orm.database.generation=update
quarkus.hibernate-orm.log.sql=true
quarkus.datasource.devservices.enabled=false