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

Refactoring et amélioration des endpoints friendship

Browse Source
This commit is contained in:
DahoudG
2024-10-10 00:39:01 +00:00
parent 800fdd4d12
commit 2c7d671588
16 changed files with 1101 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

317
src/main/java/com/lions/dev/resource/FriendshipResource.java Normal file
View File

@@ -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<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();
} 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<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();
}
}

148
src/main/java/com/lions/dev/resource/UsersResource.java
View File

@@ -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.
*
* <p>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> 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.";
}
}
}