diff --git a/src/main/java/com/lions/dev/core/errors/GlobalExceptionHandler.java b/src/main/java/com/lions/dev/core/errors/GlobalExceptionHandler.java index 4bdcf11..75bac61 100644 --- a/src/main/java/com/lions/dev/core/errors/GlobalExceptionHandler.java +++ b/src/main/java/com/lions/dev/core/errors/GlobalExceptionHandler.java @@ -1,25 +1,53 @@ package com.lions.dev.core.errors; +import com.lions.dev.core.errors.exceptions.BadRequestException; 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; /** - * Gestionnaire global des exceptions pour mapper les exceptions à des réponses HTTP appropriées. + * 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 { +public class GlobalExceptionHandler implements ExceptionMapper { + /** + * Gère les exceptions non traitées et retourne une réponse appropriée. + * + * @param exception L'exception interceptée. + * @return Une réponse HTTP avec un message d'erreur et le code de statut approprié. + */ @Override - public Response toResponse(Throwable exception) { - if (exception instanceof EventNotFoundException) { - return Response.status(Response.Status.NOT_FOUND) - .entity(exception.getMessage()) - .build(); + public Response toResponse(Exception exception) { + if (exception instanceof BadRequestException) { + return buildResponse(Response.Status.BAD_REQUEST, exception.getMessage()); + } else if (exception instanceof EventNotFoundException || exception instanceof NotFoundException) { + return buildResponse(Response.Status.NOT_FOUND, exception.getMessage()); + } else if (exception instanceof UnauthorizedException) { + return buildResponse(Response.Status.UNAUTHORIZED, exception.getMessage()); + } else if (exception instanceof ServerException) { + return buildResponse(Response.Status.INTERNAL_SERVER_ERROR, "Erreur interne du serveur."); } - return Response.status(Response.Status.INTERNAL_SERVER_ERROR) - .entity("Une erreur interne est survenue.") + + 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. + * + * @param status Le code de statut HTTP. + * @param message Le message d'erreur. + * @return La réponse HTTP formée. + */ + private Response buildResponse(Response.Status status, String message) { + return Response.status(status) + .entity("{\"error\":\"" + message + "\"}") .build(); } } diff --git a/src/main/java/com/lions/dev/core/errors/exceptions/BadRequestException.java b/src/main/java/com/lions/dev/core/errors/exceptions/BadRequestException.java index 14ddcb2..cf57486 100644 --- a/src/main/java/com/lions/dev/core/errors/exceptions/BadRequestException.java +++ b/src/main/java/com/lions/dev/core/errors/exceptions/BadRequestException.java @@ -18,4 +18,5 @@ public class BadRequestException extends WebApplicationException { super(message, Response.Status.BAD_REQUEST); System.out.println("[ERROR] Requête invalide : " + message); } + } diff --git a/src/main/java/com/lions/dev/dto/request/friends/FriendshipRequestDTO.java b/src/main/java/com/lions/dev/dto/request/friends/FriendshipRequestDTO.java new file mode 100644 index 0000000..9804d95 --- /dev/null +++ b/src/main/java/com/lions/dev/dto/request/friends/FriendshipRequestDTO.java @@ -0,0 +1,25 @@ +package com.lions.dev.dto.request.friends; + +import lombok.Getter; +import lombok.Setter; +import lombok.NoArgsConstructor; + +import java.util.UUID; + +/** + * DTO pour envoyer une demande d'amitié. + * Contient les informations nécessaires pour initier une demande d'amitié. + */ +@Getter +@Setter +@NoArgsConstructor +public class FriendshipRequestDTO { + + 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) { + this.userId = userId; + this.friendId = friendId; + } +} diff --git a/src/main/java/com/lions/dev/dto/request/users/UserCreateRequestDTO.java b/src/main/java/com/lions/dev/dto/request/users/UserCreateRequestDTO.java index d70ca3e..4e47ec9 100644 --- a/src/main/java/com/lions/dev/dto/request/users/UserCreateRequestDTO.java +++ b/src/main/java/com/lions/dev/dto/request/users/UserCreateRequestDTO.java @@ -31,6 +31,8 @@ public class UserCreateRequestDTO { @Size(min = 6, message = "Le mot de passe doit comporter au moins 6 caractères.") private String motDePasse; + private String profileImageUrl; + // Ajout du rôle avec validation @NotNull(message = "Le rôle est obligatoire.") private String role; // Rôle de l'utilisateur (par exemple : ADMIN, USER, etc.) diff --git a/src/main/java/com/lions/dev/dto/response/friends/FriendshipRequestStatusResponseDTO.java b/src/main/java/com/lions/dev/dto/response/friends/FriendshipRequestStatusResponseDTO.java new file mode 100644 index 0000000..fe94d57 --- /dev/null +++ b/src/main/java/com/lions/dev/dto/response/friends/FriendshipRequestStatusResponseDTO.java @@ -0,0 +1,57 @@ +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(); + } +} diff --git a/src/main/java/com/lions/dev/dto/response/friends/FriendshipResponseDTO.java b/src/main/java/com/lions/dev/dto/response/friends/FriendshipResponseDTO.java new file mode 100644 index 0000000..cfdbeca --- /dev/null +++ b/src/main/java/com/lions/dev/dto/response/friends/FriendshipResponseDTO.java @@ -0,0 +1,36 @@ +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 une relation d'amitié. + * Contient les informations sur une relation d'amitié existante. + */ +@Getter +@Setter +@NoArgsConstructor +public class FriendshipResponseDTO { + + private UUID id; + private UUID userId; + private UUID friendId; + private FriendshipStatus status; + private LocalDateTime createdAt; + private LocalDateTime updatedAt; + + public FriendshipResponseDTO(Friendship friendship) { + this.id = friendship.getId(); + this.userId = friendship.getUser().getId(); + this.friendId = friendship.getFriend().getId(); + this.status = friendship.getStatus(); + this.createdAt = friendship.getCreatedAt(); + this.updatedAt = friendship.getUpdatedAt(); + } +} diff --git a/src/main/java/com/lions/dev/dto/response/users/UserCreateResponseDTO.java b/src/main/java/com/lions/dev/dto/response/users/UserCreateResponseDTO.java index fa47a31..7d3cf5f 100644 --- a/src/main/java/com/lions/dev/dto/response/users/UserCreateResponseDTO.java +++ b/src/main/java/com/lions/dev/dto/response/users/UserCreateResponseDTO.java @@ -16,7 +16,8 @@ public class UserCreateResponseDTO { private String nom; // Nom de l'utilisateur private String prenoms; // Prénoms de l'utilisateur private String email; // Email de l'utilisateur - + private String role; // Roğe de l'utilisateur + private String profileImageUrl; // Url de l'image de profil de l'utilisateur /** * Constructeur qui transforme une entité Users en DTO. * @@ -27,6 +28,8 @@ public class UserCreateResponseDTO { this.nom = user.getNom(); this.prenoms = user.getPrenoms(); this.email = user.getEmail(); + this.role = user.getRole(); + this.profileImageUrl = user.getProfileImageUrl(); System.out.println("[LOG] DTO créé pour l'utilisateur : " + this.email); } } diff --git a/src/main/java/com/lions/dev/entity/friends/Friendship.java b/src/main/java/com/lions/dev/entity/friends/Friendship.java new file mode 100644 index 0000000..4e0d126 --- /dev/null +++ b/src/main/java/com/lions/dev/entity/friends/Friendship.java @@ -0,0 +1,54 @@ +package com.lions.dev.entity.friends; + +import com.lions.dev.entity.BaseEntity; // Import de 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; + +/** + * Représentation de l'entité Friendship qui gère les relations d'amitié entre utilisateurs. + */ +@Entity +@Getter +@Setter +@NoArgsConstructor +@AllArgsConstructor +@ToString +@Builder +@Table(name = "friendships") +public class Friendship extends BaseEntity { // Hérite de BaseEntity + + // L'utilisateur qui a initié la demande d'ami + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "user_id", nullable = false) + private Users user; + + // L'ami avec qui la relation est établie + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "friend_id", nullable = false) + private Users friend; + + // Statut de la relation (en attente, acceptée, rejetée) + @Enumerated(EnumType.STRING) + @Column(nullable = false) + private FriendshipStatus status; + + /** + * Log des changements de statut de l'amitié. + */ + public void setStatus(FriendshipStatus newStatus) { + this.status = newStatus; + System.out.println( + "[LOG] Changement de statut pour l'amitié entre " + + this.user.getEmail() + + " et " + + this.friend.getEmail() + + " - Nouveau statut : " + + this.status); + } +} diff --git a/src/main/java/com/lions/dev/entity/friends/FriendshipStatus.java b/src/main/java/com/lions/dev/entity/friends/FriendshipStatus.java new file mode 100644 index 0000000..11c8316 --- /dev/null +++ b/src/main/java/com/lions/dev/entity/friends/FriendshipStatus.java @@ -0,0 +1,7 @@ +package com.lions.dev.entity.friends; + +public enum FriendshipStatus { + PENDING, // Demande envoyée, en attente d'acceptation + ACCEPTED, // Demande acceptée + REJECTED // Demande rejetée +} \ No newline at end of file diff --git a/src/main/java/com/lions/dev/exception/FriendshipNotFoundException.java b/src/main/java/com/lions/dev/exception/FriendshipNotFoundException.java new file mode 100644 index 0000000..8f1a8ce --- /dev/null +++ b/src/main/java/com/lions/dev/exception/FriendshipNotFoundException.java @@ -0,0 +1,15 @@ +package com.lions.dev.exception; + +/** + * Exception levée lorsque la relation d'amitié n'est pas trouvée. + */ +public class FriendshipNotFoundException extends RuntimeException { + + public FriendshipNotFoundException(String message) { + super(message); + } + + public FriendshipNotFoundException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/src/main/java/com/lions/dev/repository/FriendshipRepository.java b/src/main/java/com/lions/dev/repository/FriendshipRepository.java new file mode 100644 index 0000000..a06ccb5 --- /dev/null +++ b/src/main/java/com/lions/dev/repository/FriendshipRepository.java @@ -0,0 +1,80 @@ +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 jakarta.enterprise.context.ApplicationScoped; + +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +/** + * Repository pour gérer les relations d'amitié (Friendship) dans la base de données. + */ +@ApplicationScoped +public class FriendshipRepository implements PanacheRepository { + + /** + * Trouve une relation d'amitié entre deux utilisateurs. + * + * @param user L'utilisateur qui envoie la demande. + * @param friend L'ami qui reçoit la demande. + * @return Une Optional contenant la relation d'amitié, si elle existe. + */ + public Optional 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. + * + * @param user L'utilisateur dont on souhaite récupérer les amis. + * @return Une liste de relations d'amitié. + */ + public List findFriendsByUser(Users user, int page, int size) { + return find("(user = ?1 or friend = ?1) and status = ?2", user, FriendshipStatus.ACCEPTED) + .page(page, size) + .list(); + } + + /** + * 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 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. + * + * @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. + */ + public List findByUserAndStatus(Users user, FriendshipStatus status, int page, int size) { + return find("(user = ?1 or friend = ?1) and status = ?2", user, status) + .page(page, size) + .list(); + } +} diff --git a/src/main/java/com/lions/dev/resource/FriendshipResource.java b/src/main/java/com/lions/dev/resource/FriendshipResource.java new file mode 100644 index 0000000..6e18fe0 --- /dev/null +++ b/src/main/java/com/lions/dev/resource/FriendshipResource.java @@ -0,0 +1,317 @@ +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.service.FriendshipService; +import jakarta.inject.Inject; +import jakarta.validation.Valid; +import jakarta.validation.constraints.NotNull; +import jakarta.ws.rs.*; +import jakarta.ws.rs.core.MediaType; +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; +import org.eclipse.microprofile.openapi.annotations.responses.APIResponses; +import org.eclipse.microprofile.openapi.annotations.tags.Tag; +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. + */ +@Path("/friends") +@Produces(MediaType.APPLICATION_JSON) +@Consumes(MediaType.APPLICATION_JSON) +@Tag(name = "Friendship", description = "Opérations liées à la gestion des amis") +public class FriendshipResource { + + @Inject + FriendshipService friendshipService; + + @Inject + UsersRepository usersRepository; + + 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. + * @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") + @APIResponses({ + @APIResponse( + responseCode = "200", + description = "Demande d'amitié envoyée", + content = + @Content( + mediaType = MediaType.APPLICATION_JSON, + schema = @Schema(implementation = FriendshipResponseDTO.class))), + @APIResponse(responseCode = "400", description = "Requête invalide"), + @APIResponse(responseCode = "500", description = "Erreur interne du serveur") + }) + public Response sendFriendRequest(@Valid @NotNull FriendshipRequestDTO request) { + logger.info( + "[LOG] Reçu une demande pour envoyer une demande d'amitié de l'utilisateur " + + request.getUserId() + + " à l'utilisateur " + + request.getFriendId()); + + try { + Friendship friendship = + friendshipService.sendFriendRequest(request.getUserId(), request.getFriendId()); + logger.info( + "[LOG] Demande d'amitié envoyée avec succès : " + + friendship.getUser().getEmail() + + " à " + + friendship.getFriend().getEmail()); + return Response.ok(new FriendshipResponseDTO(friendship)).build(); + } catch (Exception e) { + logger.error("[ERROR] Erreur lors de l'envoi de la demande d'amitié : " + e.getMessage()); + return Response.status(Response.Status.INTERNAL_SERVER_ERROR) + .entity("{\"message\": \"Erreur lors de l'envoi de la demande d'amitié.\"}") + .build(); + } + } + + /** + * Accepte une demande d'amitié. + * + * @param friendshipId L'ID de la relation d'amitié à accepter. + * @return La relation d'amitié acceptée. + */ + @PATCH + @Path("/{friendshipId}/accept") + @Operation( + summary = "Accepter une demande d'amitié", + description = "Accepte une demande d'amitié en attente") + @APIResponses({ + @APIResponse( + responseCode = "200", + description = "Demande d'amitié acceptée", + content = + @Content( + mediaType = MediaType.APPLICATION_JSON, + schema = @Schema(implementation = FriendshipResponseDTO.class))), + @APIResponse(responseCode = "404", description = "Demande d'amitié non trouvée"), + @APIResponse(responseCode = "500", description = "Erreur interne du serveur") + }) + public Response acceptFriendRequest(@PathParam("friendshipId") UUID friendshipId) { + logger.info( + "[LOG] Reçu une demande pour accepter une demande d'amitié avec l'ID : " + friendshipId); + + try { + Friendship friendship = friendshipService.acceptFriendRequest(friendshipId); + logger.info( + "[LOG] Demande d'amitié acceptée entre " + + friendship.getUser().getEmail() + + " 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(); + } catch (Exception e) { + logger.error( + "[ERROR] Erreur lors de l'acceptation de la demande d'amitié : " + e.getMessage()); + return Response.status(Response.Status.INTERNAL_SERVER_ERROR) + .entity("{\"message\": \"Erreur lors de l'acceptation de la demande d'amitié.\"}") + .build(); + } + } + + /** + * Rejette une demande d'amitié. + * + * @param friendshipId L'ID de la relation d'amitié à rejeter. + * @return Confirmation de la demande rejetée. + */ + @PATCH + @Path("/{friendshipId}/reject") + @Operation( + summary = "Rejeter une demande d'amitié", + description = "Rejette une demande d'amitié en attente") + @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") + }) + public Response rejectFriendRequest(@PathParam("friendshipId") UUID friendshipId) { + logger.info( + "[LOG] Reçu une demande pour rejeter une demande d'amitié avec l'ID : " + friendshipId); + + try { + friendshipService.rejectFriendRequest(friendshipId); + logger.info("[LOG] Demande d'amitié rejetée pour l'ID : " + friendshipId); + 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()); + return Response.status(Response.Status.INTERNAL_SERVER_ERROR) + .entity("{\"message\": \"Erreur lors du rejet de la demande d'amitié.\"}") + .build(); + } + } + + /** + * Supprime une relation d'amitié. + * + * @param friendshipId L'ID de la relation d'amitié à supprimer. + * @return Confirmation de la suppression. + */ + @DELETE + @Path("/{friendshipId}") + @Operation( + summary = "Supprimer une relation d'amitié", + description = "Supprime une relation d'amitié existante") + @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") + }) + public Response removeFriend(@PathParam("friendshipId") UUID friendshipId) { + logger.info( + "[LOG] Reçu une demande pour supprimer la relation d'amitié avec l'ID : " + friendshipId); + + try { + friendshipService.removeFriend(friendshipId); + logger.info("[LOG] Relation d'amitié supprimée avec succès pour l'ID : " + friendshipId); + 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()); + return Response.status(Response.Status.INTERNAL_SERVER_ERROR) + .entity("{\"message\": \"Erreur lors de la suppression de la relation d'amitié.\"}") + .build(); + } + } + + /** + * 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. + */ + @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é") + @APIResponses({ + @APIResponse( + responseCode = "200", + description = "Liste des amis récupérée", + content = + @Content( + mediaType = MediaType.APPLICATION_JSON, + schema = + @Schema( + type = SchemaType.ARRAY, + implementation = FriendshipResponseDTO.class))), + @APIResponse(responseCode = "404", description = "Utilisateur non trouvé"), + @APIResponse(responseCode = "500", description = "Erreur interne du serveur") + }) + public Response listFriends( + @PathParam("userId") UUID userId, + @QueryParam("page") @DefaultValue("1") 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 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(); + } catch (Exception e) { + logger.error( + "[ERROR] Erreur lors de la récupération de la liste des amis : " + e.getMessage()); + return Response.status(Response.Status.INTERNAL_SERVER_ERROR) + .entity("{\"message\": \"Erreur lors de la récupération de la liste des amis.\"}") + .build(); + } + } + + /** + * Endpoint pour 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é. + */ + @GET + @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.") + public Response listFriendRequestsByStatus( + @QueryParam("userId") UUID userId, + @QueryParam("status") FriendshipStatus status, + @QueryParam("page") @DefaultValue("1") int page, + @QueryParam("size") @DefaultValue("10") int size) { + + 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é.\"}") + .build(); + } + + // Ajuste la pagination (Panache commence à 0) + int adjustedPage = page - 1; + if (adjustedPage < 0) adjustedPage = 0; + + List friendships = friendshipService.listFriendRequestsByStatus(user, status, adjustedPage, size); + + // Transformation des entités Friendship en DTOs adaptés + List responseDTOs = friendships.stream() + .map(FriendshipRequestStatusResponseDTO::new) + .toList(); + + return Response.ok(responseDTOs).build(); + } +} diff --git a/src/main/java/com/lions/dev/resource/UsersResource.java b/src/main/java/com/lions/dev/resource/UsersResource.java index 3680539..934a1a5 100644 --- a/src/main/java/com/lions/dev/resource/UsersResource.java +++ b/src/main/java/com/lions/dev/resource/UsersResource.java @@ -1,37 +1,39 @@ package com.lions.dev.resource; -import java.io.File; - -import jakarta.ws.rs.Path; import com.lions.dev.dto.request.users.UserAuthenticateRequestDTO; +import com.lions.dev.dto.request.users.UserCreateRequestDTO; import com.lions.dev.dto.response.users.UserAuthenticateResponseDTO; +import com.lions.dev.dto.response.users.UserCreateResponseDTO; import com.lions.dev.dto.response.users.UserDeleteResponseDto; import com.lions.dev.entity.users.Users; -import com.lions.dev.service.UserService; +import com.lions.dev.service.UsersService; import jakarta.inject.Inject; import jakarta.transaction.Transactional; +import jakarta.validation.Valid; +import jakarta.validation.constraints.NotNull; import jakarta.ws.rs.*; +import jakarta.ws.rs.core.MediaType; import jakarta.ws.rs.core.Response; +import java.io.File; +import java.util.List; import java.util.UUID; 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 utilisateurs dans le système AfterWork. Cette classe expose - * des endpoints pour créer, authentifier, récupérer et supprimer des utilisateurs. - * - *

Tous les logs nécessaires pour la traçabilité sont intégrés. + * Ressource REST pour la gestion des utilisateurs dans le système AfterWork. + * Cette classe expose des endpoints pour créer, authentifier, récupérer et supprimer des utilisateurs. + * Tous les logs nécessaires pour la traçabilité sont intégrés. */ @Path("/users") -@Produces("application/json") -@Consumes("application/json") +@Produces(MediaType.APPLICATION_JSON) +@Consumes(MediaType.APPLICATION_JSON) @Tag(name = "Users", description = "Opérations liées à la gestion des utilisateurs") public class UsersResource { @Inject - UserService userService; + UsersService userService; private static final Logger LOG = Logger.getLogger(UsersResource.class); @@ -46,17 +48,13 @@ public class UsersResource { @Operation( summary = "Créer un nouvel utilisateur", description = "Crée un nouvel utilisateur et retourne les détails") - public Response createUser( - com.lions.dev.dto.request.users.UserCreateRequestDTO userCreateRequestDTO) { + public Response createUser(@Valid @NotNull UserCreateRequestDTO userCreateRequestDTO) { LOG.info( "Tentative de création d'un nouvel utilisateur avec l'email : " + userCreateRequestDTO.getEmail()); - // Utilisation de UserService pour créer l'utilisateur Users user = userService.createUser(userCreateRequestDTO); - - com.lions.dev.dto.response.users.UserCreateResponseDTO - responseDTO = new com.lions.dev.dto.response.users.UserCreateResponseDTO(user); + UserCreateResponseDTO responseDTO = new UserCreateResponseDTO(user); return Response.status(Response.Status.CREATED).entity(responseDTO).build(); } @@ -71,25 +69,14 @@ public class UsersResource { @Operation( summary = "Authentifier un utilisateur", description = "Vérifie les informations de connexion de l'utilisateur") - public Response authenticateUser(UserAuthenticateRequestDTO userAuthenticateRequestDTO) { - LOG.info( - "Tentative d'authentification pour l'utilisateur avec l'email : " - + userAuthenticateRequestDTO.getEmail()); - - // Utilisation de UserService pour authentifier l'utilisateur - Users user = - userService.authenticateUser( - userAuthenticateRequestDTO.getEmail(), userAuthenticateRequestDTO.getMotDePasse()); + public Response authenticateUser(@Valid @NotNull UserAuthenticateRequestDTO userAuthenticateRequestDTO) { + LOG.info("Tentative d'authentification pour l'utilisateur avec l'email : " + userAuthenticateRequestDTO.getEmail()); + Users user = userService.authenticateUser(userAuthenticateRequestDTO.getEmail(), userAuthenticateRequestDTO.getMotDePasse()); LOG.info("Authentification réussie pour l'utilisateur : " + user.getEmail()); - // Création du DTO de réponse avec les informations supplémentaires de l'utilisateur - UserAuthenticateResponseDTO responseDTO = - new UserAuthenticateResponseDTO( - user.getId(), user.getPrenoms(), user.getNom(), user.getEmail(), user.getRole()); - + UserAuthenticateResponseDTO responseDTO = new UserAuthenticateResponseDTO(user.getId(), user.getPrenoms(), user.getNom(), user.getEmail(), user.getRole()); responseDTO.logResponseDetails(); - return Response.ok(responseDTO).build(); } @@ -107,15 +94,31 @@ public class UsersResource { public Response getUserById(@PathParam("id") UUID id) { LOG.info("Récupération de l'utilisateur avec l'ID : " + id); - // Utilisation de UserService pour récupérer l'utilisateur Users user = userService.getUserById(id); - - com.lions.dev.dto.response.users.UserCreateResponseDTO - responseDTO = new com.lions.dev.dto.response.users.UserCreateResponseDTO(user); + UserCreateResponseDTO responseDTO = new UserCreateResponseDTO(user); LOG.info("Utilisateur trouvé : " + user.getEmail()); return Response.ok(responseDTO).build(); } + /** + * Endpoint pour récupérer tous les utilisateurs avec pagination. + * + * @param page Le numéro de la page à récupérer. + * @param size Le nombre d'utilisateurs par page. + * @return Une réponse HTTP contenant la liste des utilisateurs paginée. + */ + @GET + @Operation( + summary = "Récupérer tous les utilisateurs avec pagination", + description = "Retourne la liste paginée des utilisateurs") + public Response listUsers(@QueryParam("page") @DefaultValue("1") int page, @QueryParam("size") @DefaultValue("10") int size) { + LOG.info("Récupération de la liste des utilisateurs - page : " + page + ", taille : " + size); + + List users = userService.listUsers(page, size); + LOG.info("Liste des utilisateurs récupérée avec succès, taille : " + users.size()); + return Response.ok(users).build(); + } + /** * Endpoint pour supprimer un utilisateur par ID. * @@ -131,7 +134,6 @@ public class UsersResource { public Response deleteUser(@PathParam("id") UUID id) { LOG.info("Tentative de suppression de l'utilisateur avec l'ID : " + id); - // Utilisation de UserService pour supprimer l'utilisateur boolean deleted = userService.deleteUser(id); UserDeleteResponseDto responseDTO = new UserDeleteResponseDto(); @@ -150,6 +152,50 @@ public class UsersResource { } } + /** + * Endpoint pour mettre à jour un utilisateur. + * + * @param id L'ID de l'utilisateur à mettre à jour. + * @param userCreateRequestDTO Les informations mises à jour de l'utilisateur. + * @return Les informations de l'utilisateur mis à jour. + */ + @PUT + @Path("/{id}") + @Transactional + @Operation( + summary = "Mettre à jour un utilisateur", + description = "Met à jour les informations d'un utilisateur existant") + public Response updateUser(@PathParam("id") UUID id, @Valid UserCreateRequestDTO userCreateRequestDTO) { + LOG.info("Tentative de mise à jour de l'utilisateur avec l'ID : " + id); + + // Appel au service avec l'ID et les nouvelles informations + Users updatedUser = userService.updateUser(id, userCreateRequestDTO); + + LOG.info("Utilisateur mis à jour avec succès : " + updatedUser.getEmail()); + UserCreateResponseDTO responseDTO = new UserCreateResponseDTO(updatedUser); + return Response.ok(responseDTO).build(); + } + + /** + * Endpoint pour réinitialiser le mot de passe d'un utilisateur. + * + * @param id L'ID de l'utilisateur. + * @param nouveauMotDePasse Le nouveau mot de passe. + * @return Un message indiquant si la réinitialisation a réussi. + */ + @PATCH + @Path("/{id}/reset-password") + @Transactional + @Operation( + summary = "Réinitialiser le mot de passe d'un utilisateur", + description = "Réinitialise le mot de passe de l'utilisateur et le met à jour dans la base de données") + public Response resetPassword(@PathParam("id") UUID id, @QueryParam("newPassword") String nouveauMotDePasse) { + LOG.info("Réinitialisation du mot de passe pour l'utilisateur avec l'ID : " + id); + + userService.resetPassword(id, nouveauMotDePasse); + return Response.ok("{\"message\": \"Mot de passe réinitialisé avec succès.\"}").build(); + } + /** * Endpoint pour mettre à jour l'image de profil de l'utilisateur. * @@ -158,37 +204,25 @@ public class UsersResource { * @return Un message indiquant si la mise à jour a réussi. */ @PUT - @jakarta.ws.rs.Path("/{id}/profile-image") // Annotation REST avec jakarta.ws.rs.Path + @Path("/{id}/profile-image") + @Operation(summary = "Mettre à jour l'image de profil d'un utilisateur", description = "Met à jour l'image de profil d'un utilisateur.") public String updateUserProfileImage(@PathParam("id") UUID id, String imageFilePath) { try { - // Utiliser File au lieu de Path pour vérifier si le fichier existe File file = new File(imageFilePath); if (!file.exists()) { - System.out.println("[ERROR] Le fichier spécifié n'existe pas : " + imageFilePath); + LOG.error("[ERROR] Le fichier spécifié n'existe pas : " + imageFilePath); return "Le fichier spécifié n'existe pas."; } - // Récupérer l'utilisateur par son ID - Users user = userService.getUserById(id); - if (user == null) { - System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id); - return "Utilisateur non trouvé."; - } - - // Mettre à jour l'URL de l'image de profil - String profileImageUrl = file.getAbsolutePath(); // Obtenir le chemin complet du fichier - user.setProfileImageUrl(profileImageUrl); - - // Mise à jour de l'utilisateur - userService.updateUser(user); - System.out.println("[LOG] Image de profil mise à jour pour l'utilisateur : " + user.getEmail()); + String profileImageUrl = file.getAbsolutePath(); + userService.updateUserProfileImage(id, profileImageUrl); // Appel à la méthode correcte + LOG.info("[LOG] Image de profil mise à jour pour l'utilisateur avec l'ID : " + id); return "Image de profil mise à jour avec succès."; } catch (Exception e) { - System.out.println("[ERROR] Erreur lors de la mise à jour de l'image de profil : " + e.getMessage()); + LOG.error("[ERROR] Erreur lors de la mise à jour de l'image de profil : " + e.getMessage()); return "Erreur lors de la mise à jour de l'image de profil."; } } - } diff --git a/src/main/java/com/lions/dev/service/FriendshipService.java b/src/main/java/com/lions/dev/service/FriendshipService.java new file mode 100644 index 0000000..d8b11ae --- /dev/null +++ b/src/main/java/com/lions/dev/service/FriendshipService.java @@ -0,0 +1,184 @@ +package com.lions.dev.service; + +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.exception.FriendshipNotFoundException; +import com.lions.dev.exception.UserNotFoundException; +import com.lions.dev.repository.FriendshipRepository; +import com.lions.dev.repository.UsersRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.inject.Inject; +import jakarta.transaction.Transactional; +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +/** + * Service de gestion des amitiés. Ce service gère l'envoi, l'acceptation, le rejet et la + * suppression d'amitiés. + */ +@ApplicationScoped +public class FriendshipService { + + @Inject FriendshipRepository friendshipRepository; + + @Inject UsersRepository usersRepository; + + /** + * 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é. + */ + @Transactional + public Friendship sendFriendRequest(UUID userId, UUID friendId) { + System.out.println( + "[LOG] Envoi de demande d'amitié de l'utilisateur " + + userId + + " à l'utilisateur " + + friendId); + + Users user = usersRepository.findById(userId); + Users friend = usersRepository.findById(friendId); + + 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."); + } + + Optional existingFriendship = friendshipRepository.findByUsers(user, friend); + if (existingFriendship.isPresent()) { + System.out.println("[ERROR] Une relation d'amitié existe déjà entre ces deux utilisateurs."); + throw new IllegalArgumentException("Relation d'amitié déjà existante."); + } + + Friendship friendship = + Friendship.builder().user(user).friend(friend).status(FriendshipStatus.PENDING).build(); + + friendshipRepository.persist(friendship); + System.out.println( + "[LOG] Demande d'amitié envoyée de " + user.getEmail() + " à " + friend.getEmail()); + + return friendship; + } + + /** + * Accepte 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. + */ + @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."); + } + + 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; + } + + /** + * Rejette 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. + */ + @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.setStatus(FriendshipStatus.REJECTED); + friendshipRepository.persist(friendship); + System.out.println( + "[LOG] Demande d'amitié rejetée entre " + + friendship.getUser().getEmail() + + " et " + + friendship.getFriend().getEmail()); + } + + /** + * Supprime 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. + */ + @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) + .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()); + } + + /** + * Récupère la liste des amis d'un utilisateur avec pagination. + * + * @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é. + */ + public List 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); + + 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é."); + } + + return friendshipRepository.findFriendsByUser(user, page, size); + } + + /** + * Récupère toutes 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é. + */ + public List 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); + } + +} diff --git a/src/main/java/com/lions/dev/service/UserService.java b/src/main/java/com/lions/dev/service/UserService.java deleted file mode 100644 index 15f920d..0000000 --- a/src/main/java/com/lions/dev/service/UserService.java +++ /dev/null @@ -1,129 +0,0 @@ -package com.lions.dev.service; - -import com.lions.dev.entity.users.Users; -import com.lions.dev.repository.UsersRepository; -import com.lions.dev.exception.UserNotFoundException; -import jakarta.enterprise.context.ApplicationScoped; -import jakarta.inject.Inject; -import java.util.Optional; -import java.util.UUID; - -/** - * Service de gestion des utilisateurs. - * Ce service contient la logique métier pour la création, récupération et suppression des utilisateurs. - */ -@ApplicationScoped -public class UserService { - - @Inject - UsersRepository usersRepository; - - /** - * Crée un nouvel utilisateur dans le système. - * - * @param userCreateRequestDTO Le DTO contenant les informations de l'utilisateur à créer. - * @return L'utilisateur créé. - */ - public Users createUser(com.lions.dev.dto.request.users.UserCreateRequestDTO userCreateRequestDTO) { - 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 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, par exemple "USER" - } else { - user.setRole(userCreateRequestDTO.getRole()); - } - - usersRepository.persist(user); - System.out.println("[LOG] Utilisateur créé : " + user.getEmail()); - return user; - } - - /** - * Met à jour un utilisateur existant dans le système. - * - * @param user L'utilisateur à mettre à jour. - * @return L'utilisateur mis à jour. - */ - public Users updateUser(Users user) { - try { - Users existingUser = usersRepository.findById(user.getId()); - if (existingUser == null) { - System.out.println("[ERROR] Utilisateur non trouvé pour la mise à jour avec l'ID : " + user.getId()); - throw new UserNotFoundException("Utilisateur non trouvé avec l'ID : " + user.getId()); - } - - // Mettre à jour les champs de l'utilisateur existant - existingUser.setNom(user.getNom()); - existingUser.setPrenoms(user.getPrenoms()); - existingUser.setEmail(user.getEmail()); - existingUser.setMotDePasse(user.getMotDePasse()); // Hachage automatique si nécessaire - existingUser.setRole(user.getRole()); - - usersRepository.persist(existingUser); - System.out.println("[LOG] Utilisateur mis à jour avec succès : " + existingUser.getEmail()); - return existingUser; - } catch (Exception e) { - System.out.println("[ERROR] Erreur lors de la mise à jour de l'utilisateur : " + e.getMessage()); - throw e; - } - } - - - /** - * Authentifie un utilisateur avec son email et son mot de passe. - * - * @param email L'email de l'utilisateur. - * @param motDePasse Le mot de passe de l'utilisateur. - * @return L'utilisateur authentifié. - * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé ou si le mot de passe est incorrect. - */ - public Users authenticateUser(String email, String motDePasse) { - Optional userOptional = usersRepository.findByEmail(email); - if (userOptional.isEmpty() || !userOptional.get().verifierMotDePasse(motDePasse)) { - System.out.println("[ERROR] Échec de l'authentification pour l'email : " + email); - throw new UserNotFoundException("Utilisateur ou mot de passe incorrect."); - } - System.out.println("[LOG] Utilisateur authentifié : " + email); - return userOptional.get(); - } - - /** - * Récupère un utilisateur par son ID. - * - * @param id L'ID de l'utilisateur. - * @return L'utilisateur trouvé. - * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé. - */ - public Users getUserById(UUID id) { - Users user = usersRepository.findById(id); - if (user == null) { - System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id); - throw new UserNotFoundException("Utilisateur non trouvé avec l'ID : " + id); - } - System.out.println("[LOG] Utilisateur trouvé avec l'ID : " + id); - return user; - } - - /** - * Supprime un utilisateur par son ID. - * - * @param id L'ID de l'utilisateur à supprimer. - * @return true si l'utilisateur a été supprimé, false sinon. - */ - public boolean deleteUser(UUID id) { - boolean deleted = usersRepository.deleteById(id); - if (deleted) { - System.out.println("[LOG] Utilisateur supprimé avec succès : " + id); - } else { - System.out.println("[ERROR] Échec de la suppression de l'utilisateur avec l'ID : " + id); - } - return deleted; - } - - -} diff --git a/src/main/java/com/lions/dev/service/UsersService.java b/src/main/java/com/lions/dev/service/UsersService.java new file mode 100644 index 0000000..21678be --- /dev/null +++ b/src/main/java/com/lions/dev/service/UsersService.java @@ -0,0 +1,191 @@ +package com.lions.dev.service; + +import com.lions.dev.dto.request.users.UserCreateRequestDTO; +import com.lions.dev.entity.users.Users; +import com.lions.dev.exception.UserNotFoundException; +import com.lions.dev.repository.UsersRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.inject.Inject; +import jakarta.transaction.Transactional; + +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +/** + * Service de gestion des utilisateurs. + * Ce service contient la logique métier pour la création, récupération et suppression des utilisateurs. + */ +@ApplicationScoped +public class UsersService { + + @Inject + UsersRepository usersRepository; + + /** + * Crée un nouvel utilisateur dans le système. + * + * @param userCreateRequestDTO Le DTO contenant les informations de l'utilisateur à créer. + * @return L'utilisateur créé. + */ + public Users createUser(UserCreateRequestDTO userCreateRequestDTO) { + 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()); + } + + usersRepository.persist(user); + System.out.println("[LOG] Utilisateur créé : " + user.getEmail()); + return user; + } + + /** + * Met à jour un utilisateur existant dans le système. + * + * @param id L'ID de l'utilisateur à mettre à jour. + * @param userCreateRequestDTO Les nouvelles informations de l'utilisateur. + * @return L'utilisateur mis à jour. + * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé. + */ + @Transactional + public Users updateUser(UUID id, UserCreateRequestDTO userCreateRequestDTO) { + Users existingUser = usersRepository.findById(id); + if (existingUser == null) { + System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id); + throw new UserNotFoundException("Utilisateur non trouvé avec l'ID : " + id); + } + + // Mettre à jour les champs de l'utilisateur existant + existingUser.setNom(userCreateRequestDTO.getNom()); + existingUser.setPrenoms(userCreateRequestDTO.getPrenoms()); + existingUser.setEmail(userCreateRequestDTO.getEmail()); + existingUser.setMotDePasse(userCreateRequestDTO.getMotDePasse()); // Hachage automatique si nécessaire + existingUser.setRole(userCreateRequestDTO.getRole()); + existingUser.setProfileImageUrl(userCreateRequestDTO.getProfileImageUrl()); + + usersRepository.persist(existingUser); + System.out.println("[LOG] Utilisateur mis à jour avec succès : " + existingUser.getEmail()); + return existingUser; + } + /** + * Met à jour l'image de profil d'un utilisateur existant dans le système. + * + * @param id L'ID de l'utilisateur à mettre à jour. + * @param profileImageUrl Les nouvelles informations de l'utilisateur. + * @return L'utilisateur mis à jour. + * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé. + */ + @Transactional + public Users updateUserProfileImage(UUID id, String profileImageUrl) { + Users existingUser = usersRepository.findById(id); + if (existingUser == null) { + System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id); + throw new UserNotFoundException("Utilisateur non trouvé avec l'ID : " + id); + } + + // Mettre à jour les champs de l'utilisateur existant + existingUser.setProfileImageUrl(profileImageUrl); + + usersRepository.persist(existingUser); + System.out.println("[LOG] L'image de profile de l\'Utilisateur mis à jour avec succès : " + existingUser.getEmail()); + return existingUser; + } + + /** + * Liste tous les utilisateurs avec pagination. + * + * @param page Le numéro de la page à récupérer. + * @param size Le nombre d'utilisateurs par page. + * @return La liste des utilisateurs paginée. + */ + public List listUsers(int page, int size) { + return usersRepository.findAll().page(page - 1, size).list(); + } + + /** + * Authentifie un utilisateur avec son email et son mot de passe. + * + * @param email L'email de l'utilisateur. + * @param motDePasse Le mot de passe de l'utilisateur. + * @return L'utilisateur authentifié. + * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé ou si le mot de passe est incorrect. + */ + public Users authenticateUser(String email, String motDePasse) { + Optional userOptional = usersRepository.findByEmail(email); + if (userOptional.isEmpty() || !userOptional.get().verifierMotDePasse(motDePasse)) { + System.out.println("[ERROR] Échec de l'authentification pour l'email : " + email); + throw new UserNotFoundException("Utilisateur ou mot de passe incorrect."); + } + System.out.println("[LOG] Utilisateur authentifié : " + email); + return userOptional.get(); + } + + /** + * Récupère un utilisateur par son ID. + * + * @param id L'ID de l'utilisateur. + * @return L'utilisateur trouvé. + * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé. + */ + public Users getUserById(UUID id) { + Users user = usersRepository.findById(id); + if (user == null) { + System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id); + throw new UserNotFoundException("Utilisateur non trouvé avec l'ID : " + id); + } + System.out.println("[LOG] Utilisateur trouvé avec l'ID : " + id); + return user; + } + + /** + * Réinitialise le mot de passe d'un utilisateur. + * + * @param id L'ID de l'utilisateur. + * @param newPassword Le nouveau mot de passe à définir. + * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé. + */ + @Transactional + public void resetPassword(UUID id, String newPassword) { + Users user = usersRepository.findById(id); + if (user == null) { + System.out.println("[ERROR] Utilisateur non trouvé avec l'ID : " + id); + throw new UserNotFoundException("Utilisateur non trouvé."); + } + + user.setMotDePasse(newPassword); // Hachage automatique + usersRepository.persist(user); + System.out.println("[LOG] Mot de passe réinitialisé pour l'utilisateur : " + user.getEmail()); + } + + /** + * Supprime un utilisateur par son ID. + * + * @param id L'ID de l'utilisateur à supprimer. + * @return true si l'utilisateur a été supprimé, false sinon. + */ + public boolean deleteUser(UUID id) { + boolean deleted = usersRepository.deleteById(id); + if (deleted) { + System.out.println("[LOG] Utilisateur supprimé avec succès : " + id); + } else { + System.out.println("[ERROR] Échec de la suppression de l'utilisateur avec l'ID : " + id); + } + return deleted; + } +}