Task 1.5 - Endpoints REST complets
- Création de AuthResource avec tous les endpoints d'authentification
* POST /api/auth/login - Connexion utilisateur avec JWT
* POST /api/auth/logout - Déconnexion utilisateur
* POST /api/auth/refresh - Rafraîchissement de token
* GET /api/auth/validate - Validation de token
* POST /api/auth/forgot-password - Demande de réinitialisation
* POST /api/auth/reset-password - Réinitialisation avec token
* PUT /api/auth/change-password - Changement de mot de passe
- Création de UserResource avec tous les endpoints de gestion utilisateurs
* GET /api/users - Liste paginée avec filtres
* GET /api/users/{id} - Utilisateur par ID
* POST /api/users - Création d'utilisateur (ADMIN)
* PUT /api/users/{id} - Mise à jour utilisateur
* DELETE /api/users/{id} - Suppression utilisateur (ADMIN)
* PUT /api/users/{id}/status - Changement de statut
* GET /api/users/profile - Profil utilisateur courant
* PUT /api/users/profile - Mise à jour profil courant
* GET /api/users/search - Recherche d'utilisateurs
- Annotations OpenAPI complètes sur tous les endpoints
- Gestion d'erreurs avec try-catch et codes HTTP appropriés
- Logging SLF4J sur toutes les opérations
- Sécurité basée sur les rôles avec @RolesAllowed
- Correction des imports OpenAPI (Parameter, APIResponse, APIResponses)
- Correction de l'ordre des exceptions (AuthorizationException avant GBCMException)
- Correction des constructeurs ValidationException
- Compilation réussie de tous les endpoints
This commit is contained in:
dahoud
392
src/main/java/com/gbcm/server/impl/resource/AuthResource.java
Normal file
392
src/main/java/com/gbcm/server/impl/resource/AuthResource.java
Normal file
@@ -0,0 +1,392 @@
|
||||
package com.gbcm.server.impl.resource;
|
||||
|
||||
import org.eclipse.microprofile.openapi.annotations.Operation;
|
||||
import org.eclipse.microprofile.openapi.annotations.media.Content;
|
||||
import org.eclipse.microprofile.openapi.annotations.media.Schema;
|
||||
import org.eclipse.microprofile.openapi.annotations.parameters.Parameter;
|
||||
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.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import com.gbcm.server.api.dto.auth.LoginRequestDTO;
|
||||
import com.gbcm.server.api.dto.auth.LoginResponseDTO;
|
||||
import com.gbcm.server.api.dto.user.UserDTO;
|
||||
import com.gbcm.server.api.exceptions.AuthenticationException;
|
||||
import com.gbcm.server.api.exceptions.GBCMException;
|
||||
import com.gbcm.server.api.interfaces.AuthService;
|
||||
|
||||
import jakarta.inject.Inject;
|
||||
import jakarta.validation.Valid;
|
||||
import jakarta.ws.rs.Consumes;
|
||||
import jakarta.ws.rs.FormParam;
|
||||
import jakarta.ws.rs.GET;
|
||||
import jakarta.ws.rs.HeaderParam;
|
||||
import jakarta.ws.rs.POST;
|
||||
import jakarta.ws.rs.PUT;
|
||||
import jakarta.ws.rs.Path;
|
||||
import jakarta.ws.rs.Produces;
|
||||
import jakarta.ws.rs.core.MediaType;
|
||||
import jakarta.ws.rs.core.Response;
|
||||
|
||||
/**
|
||||
* Contrôleur REST pour les services d'authentification de la plateforme GBCM.
|
||||
* Expose tous les endpoints d'authentification, autorisation et gestion des tokens.
|
||||
*
|
||||
* @author GBCM Development Team
|
||||
* @version 1.0
|
||||
* @since 1.0
|
||||
*/
|
||||
@Path("/api/auth")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Authentication", description = "Services d'authentification et autorisation GBCM")
|
||||
public class AuthResource {
|
||||
|
||||
private static final Logger logger = LoggerFactory.getLogger(AuthResource.class);
|
||||
|
||||
@Inject
|
||||
AuthService authService;
|
||||
|
||||
/**
|
||||
* Endpoint de connexion utilisateur.
|
||||
*
|
||||
* @param loginRequest les informations de connexion
|
||||
* @return la réponse de connexion avec token et informations utilisateur
|
||||
* @throws AuthenticationException si l'authentification échoue
|
||||
* @throws GBCMException si une erreur interne survient
|
||||
*/
|
||||
@POST
|
||||
@Path("/login")
|
||||
@Operation(
|
||||
summary = "Connexion utilisateur",
|
||||
description = "Authentifie un utilisateur avec email et mot de passe et retourne un token JWT"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(
|
||||
responseCode = "200",
|
||||
description = "Connexion réussie",
|
||||
content = @Content(schema = @Schema(implementation = LoginResponseDTO.class))
|
||||
),
|
||||
@APIResponse(
|
||||
responseCode = "401",
|
||||
description = "Identifiants invalides",
|
||||
content = @Content(schema = @Schema(implementation = String.class))
|
||||
),
|
||||
@APIResponse(
|
||||
responseCode = "400",
|
||||
description = "Données de requête invalides",
|
||||
content = @Content(schema = @Schema(implementation = String.class))
|
||||
),
|
||||
@APIResponse(
|
||||
responseCode = "500",
|
||||
description = "Erreur interne du serveur",
|
||||
content = @Content(schema = @Schema(implementation = String.class))
|
||||
)
|
||||
})
|
||||
public Response login(
|
||||
@Parameter(description = "Informations de connexion", required = true)
|
||||
@Valid LoginRequestDTO loginRequest
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de connexion reçue pour: {}", loginRequest.getEmail());
|
||||
|
||||
LoginResponseDTO response = authService.login(loginRequest);
|
||||
|
||||
logger.info("Connexion réussie pour: {}", loginRequest.getEmail());
|
||||
return Response.ok(response).build();
|
||||
|
||||
} catch (AuthenticationException e) {
|
||||
logger.warn("Échec d'authentification pour {}: {}", loginRequest.getEmail(), e.getMessage());
|
||||
return Response.status(Response.Status.UNAUTHORIZED)
|
||||
.entity("Erreur d'authentification: " + e.getMessage())
|
||||
.build();
|
||||
} catch (GBCMException e) {
|
||||
logger.error("Erreur GBCM lors de la connexion pour {}: {}", loginRequest.getEmail(), e.getMessage());
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity("Erreur: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors de la connexion pour {}: {}", loginRequest.getEmail(), e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endpoint de déconnexion utilisateur.
|
||||
*
|
||||
* @param authToken le token d'authentification
|
||||
* @return confirmation de déconnexion
|
||||
*/
|
||||
@POST
|
||||
@Path("/logout")
|
||||
@Operation(
|
||||
summary = "Déconnexion utilisateur",
|
||||
description = "Invalide le token d'authentification de l'utilisateur"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(responseCode = "200", description = "Déconnexion réussie"),
|
||||
@APIResponse(responseCode = "401", description = "Token invalide"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response logout(
|
||||
@Parameter(description = "Token d'authentification", required = true)
|
||||
@HeaderParam("Authorization") String authToken
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de déconnexion reçue");
|
||||
|
||||
authService.logout(authToken);
|
||||
|
||||
logger.info("Déconnexion réussie");
|
||||
return Response.ok("Déconnexion réussie").build();
|
||||
|
||||
} catch (AuthenticationException e) {
|
||||
logger.warn("Échec de déconnexion: {}", e.getMessage());
|
||||
return Response.status(Response.Status.UNAUTHORIZED)
|
||||
.entity("Erreur d'authentification: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors de la déconnexion: {}", e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endpoint de rafraîchissement de token.
|
||||
*
|
||||
* @param refreshToken le token de rafraîchissement
|
||||
* @return nouveau token d'accès
|
||||
*/
|
||||
@POST
|
||||
@Path("/refresh")
|
||||
@Operation(
|
||||
summary = "Rafraîchissement du token",
|
||||
description = "Génère un nouveau token d'authentification à partir d'un refresh token"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(
|
||||
responseCode = "200",
|
||||
description = "Token rafraîchi",
|
||||
content = @Content(schema = @Schema(implementation = LoginResponseDTO.class))
|
||||
),
|
||||
@APIResponse(responseCode = "401", description = "Token de rafraîchissement invalide"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response refreshToken(
|
||||
@Parameter(description = "Token de rafraîchissement", required = true)
|
||||
@FormParam("refreshToken") String refreshToken
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de rafraîchissement de token reçue");
|
||||
|
||||
LoginResponseDTO response = authService.refreshToken(refreshToken);
|
||||
|
||||
logger.info("Token rafraîchi avec succès");
|
||||
return Response.ok(response).build();
|
||||
|
||||
} catch (AuthenticationException e) {
|
||||
logger.warn("Échec de rafraîchissement de token: {}", e.getMessage());
|
||||
return Response.status(Response.Status.UNAUTHORIZED)
|
||||
.entity("Erreur d'authentification: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors du rafraîchissement: {}", e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endpoint de validation de token.
|
||||
*
|
||||
* @param authToken le token d'authentification à valider
|
||||
* @return les informations de l'utilisateur si le token est valide
|
||||
*/
|
||||
@GET
|
||||
@Path("/validate")
|
||||
@Operation(
|
||||
summary = "Validation du token",
|
||||
description = "Vérifie la validité d'un token d'authentification et retourne les informations utilisateur"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(
|
||||
responseCode = "200",
|
||||
description = "Token valide",
|
||||
content = @Content(schema = @Schema(implementation = UserDTO.class))
|
||||
),
|
||||
@APIResponse(responseCode = "401", description = "Token invalide ou expiré"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response validateToken(
|
||||
@Parameter(description = "Token d'authentification", required = true)
|
||||
@HeaderParam("Authorization") String authToken
|
||||
) {
|
||||
try {
|
||||
logger.debug("Demande de validation de token reçue");
|
||||
|
||||
UserDTO user = authService.validateToken(authToken);
|
||||
|
||||
logger.debug("Token validé avec succès pour l'utilisateur: {}", user.getEmail());
|
||||
return Response.ok(user).build();
|
||||
|
||||
} catch (AuthenticationException e) {
|
||||
logger.warn("Échec de validation de token: {}", e.getMessage());
|
||||
return Response.status(Response.Status.UNAUTHORIZED)
|
||||
.entity("Erreur d'authentification: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors de la validation: {}", e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endpoint de demande de réinitialisation de mot de passe.
|
||||
*
|
||||
* @param email l'adresse email de l'utilisateur
|
||||
* @return confirmation d'envoi de l'email
|
||||
*/
|
||||
@POST
|
||||
@Path("/forgot-password")
|
||||
@Operation(
|
||||
summary = "Mot de passe oublié",
|
||||
description = "Envoie un email de réinitialisation de mot de passe à l'utilisateur"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(responseCode = "200", description = "Email envoyé"),
|
||||
@APIResponse(responseCode = "400", description = "Email invalide"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response forgotPassword(
|
||||
@Parameter(description = "Adresse email", required = true)
|
||||
@FormParam("email") String email
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de réinitialisation de mot de passe pour: {}", email);
|
||||
|
||||
authService.forgotPassword(email);
|
||||
|
||||
logger.info("Email de réinitialisation envoyé pour: {}", email);
|
||||
return Response.ok("Email de réinitialisation envoyé").build();
|
||||
|
||||
} catch (GBCMException e) {
|
||||
logger.warn("Erreur lors de la demande de réinitialisation pour {}: {}", email, e.getMessage());
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity("Erreur: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors de la demande de réinitialisation pour {}: {}", email, e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endpoint de réinitialisation de mot de passe.
|
||||
*
|
||||
* @param resetToken le token de réinitialisation
|
||||
* @param newPassword le nouveau mot de passe
|
||||
* @return confirmation de réinitialisation
|
||||
*/
|
||||
@POST
|
||||
@Path("/reset-password")
|
||||
@Operation(
|
||||
summary = "Réinitialisation du mot de passe",
|
||||
description = "Réinitialise le mot de passe avec un token de réinitialisation"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(responseCode = "200", description = "Mot de passe réinitialisé"),
|
||||
@APIResponse(responseCode = "400", description = "Token invalide ou expiré"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response resetPassword(
|
||||
@Parameter(description = "Token de réinitialisation", required = true)
|
||||
@FormParam("resetToken") String resetToken,
|
||||
@Parameter(description = "Nouveau mot de passe", required = true)
|
||||
@FormParam("newPassword") String newPassword
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de réinitialisation de mot de passe avec token");
|
||||
|
||||
authService.resetPassword(resetToken, newPassword);
|
||||
|
||||
logger.info("Mot de passe réinitialisé avec succès");
|
||||
return Response.ok("Mot de passe réinitialisé avec succès").build();
|
||||
|
||||
} catch (GBCMException e) {
|
||||
logger.warn("Erreur lors de la réinitialisation: {}", e.getMessage());
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity("Erreur: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors de la réinitialisation: {}", e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endpoint de changement de mot de passe.
|
||||
*
|
||||
* @param authToken le token d'authentification
|
||||
* @param oldPassword l'ancien mot de passe
|
||||
* @param newPassword le nouveau mot de passe
|
||||
* @return confirmation de changement
|
||||
*/
|
||||
@PUT
|
||||
@Path("/change-password")
|
||||
@Operation(
|
||||
summary = "Changement de mot de passe",
|
||||
description = "Change le mot de passe d'un utilisateur authentifié"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(responseCode = "200", description = "Mot de passe changé"),
|
||||
@APIResponse(responseCode = "401", description = "Non autorisé"),
|
||||
@APIResponse(responseCode = "400", description = "Ancien mot de passe incorrect"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response changePassword(
|
||||
@Parameter(description = "Token d'authentification", required = true)
|
||||
@HeaderParam("Authorization") String authToken,
|
||||
@Parameter(description = "Ancien mot de passe", required = true)
|
||||
@FormParam("oldPassword") String oldPassword,
|
||||
@Parameter(description = "Nouveau mot de passe", required = true)
|
||||
@FormParam("newPassword") String newPassword
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de changement de mot de passe");
|
||||
|
||||
authService.changePassword(authToken, oldPassword, newPassword);
|
||||
|
||||
logger.info("Mot de passe changé avec succès");
|
||||
return Response.ok("Mot de passe changé avec succès").build();
|
||||
|
||||
} catch (AuthenticationException e) {
|
||||
logger.warn("Échec de changement de mot de passe: {}", e.getMessage());
|
||||
return Response.status(Response.Status.UNAUTHORIZED)
|
||||
.entity("Erreur d'authentification: " + e.getMessage())
|
||||
.build();
|
||||
} catch (GBCMException e) {
|
||||
logger.warn("Erreur lors du changement de mot de passe: {}", e.getMessage());
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity("Erreur: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors du changement de mot de passe: {}", e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
}
|
||||
585
src/main/java/com/gbcm/server/impl/resource/UserResource.java
Normal file
585
src/main/java/com/gbcm/server/impl/resource/UserResource.java
Normal file
@@ -0,0 +1,585 @@
|
||||
package com.gbcm.server.impl.resource;
|
||||
|
||||
import org.eclipse.microprofile.openapi.annotations.Operation;
|
||||
import org.eclipse.microprofile.openapi.annotations.media.Content;
|
||||
import org.eclipse.microprofile.openapi.annotations.media.Schema;
|
||||
import org.eclipse.microprofile.openapi.annotations.parameters.Parameter;
|
||||
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.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import com.gbcm.server.api.dto.common.PagedResultDTO;
|
||||
import com.gbcm.server.api.dto.common.SuccessResponseDTO;
|
||||
import com.gbcm.server.api.dto.user.CreateUserDTO;
|
||||
import com.gbcm.server.api.dto.user.UpdateUserDTO;
|
||||
import com.gbcm.server.api.dto.user.UserDTO;
|
||||
import com.gbcm.server.api.enums.UserRole;
|
||||
import com.gbcm.server.api.exceptions.AuthorizationException;
|
||||
import com.gbcm.server.api.exceptions.GBCMException;
|
||||
import com.gbcm.server.api.exceptions.ResourceNotFoundException;
|
||||
import com.gbcm.server.api.exceptions.ValidationException;
|
||||
import com.gbcm.server.api.interfaces.UserService;
|
||||
|
||||
import jakarta.annotation.security.RolesAllowed;
|
||||
import jakarta.inject.Inject;
|
||||
import jakarta.validation.Valid;
|
||||
import jakarta.ws.rs.Consumes;
|
||||
import jakarta.ws.rs.DELETE;
|
||||
import jakarta.ws.rs.DefaultValue;
|
||||
import jakarta.ws.rs.FormParam;
|
||||
import jakarta.ws.rs.GET;
|
||||
import jakarta.ws.rs.HeaderParam;
|
||||
import jakarta.ws.rs.POST;
|
||||
import jakarta.ws.rs.PUT;
|
||||
import jakarta.ws.rs.Path;
|
||||
import jakarta.ws.rs.PathParam;
|
||||
import jakarta.ws.rs.Produces;
|
||||
import jakarta.ws.rs.QueryParam;
|
||||
import jakarta.ws.rs.core.MediaType;
|
||||
import jakarta.ws.rs.core.Response;
|
||||
|
||||
/**
|
||||
* Contrôleur REST pour la gestion des utilisateurs de la plateforme GBCM.
|
||||
* Expose tous les endpoints CRUD pour les utilisateurs avec sécurité basée sur les rôles.
|
||||
*
|
||||
* @author GBCM Development Team
|
||||
* @version 1.0
|
||||
* @since 1.0
|
||||
*/
|
||||
@Path("/api/users")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Users", description = "Gestion des utilisateurs GBCM")
|
||||
public class UserResource {
|
||||
|
||||
private static final Logger logger = LoggerFactory.getLogger(UserResource.class);
|
||||
|
||||
@Inject
|
||||
UserService userService;
|
||||
|
||||
/**
|
||||
* Endpoint pour récupérer la liste paginée des utilisateurs.
|
||||
*
|
||||
* @param page numéro de page (commence à 0)
|
||||
* @param size taille de page
|
||||
* @param sort critères de tri
|
||||
* @param role filtre par rôle
|
||||
* @param active filtre par statut actif
|
||||
* @param search terme de recherche
|
||||
* @return liste paginée des utilisateurs
|
||||
*/
|
||||
@GET
|
||||
@RolesAllowed({"ADMIN", "MANAGER"})
|
||||
@Operation(
|
||||
summary = "Liste des utilisateurs",
|
||||
description = "Récupère la liste paginée des utilisateurs avec filtres optionnels"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(
|
||||
responseCode = "200",
|
||||
description = "Liste récupérée avec succès",
|
||||
content = @Content(schema = @Schema(implementation = PagedResultDTO.class))
|
||||
),
|
||||
@APIResponse(responseCode = "401", description = "Non authentifié"),
|
||||
@APIResponse(responseCode = "403", description = "Accès refusé - permissions insuffisantes"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response getUsers(
|
||||
@Parameter(description = "Numéro de page (commence à 0)", example = "0")
|
||||
@QueryParam("page") @DefaultValue("0") int page,
|
||||
|
||||
@Parameter(description = "Taille de page", example = "20")
|
||||
@QueryParam("size") @DefaultValue("20") int size,
|
||||
|
||||
@Parameter(description = "Tri (ex: firstName,asc ou email,desc)")
|
||||
@QueryParam("sort") String sort,
|
||||
|
||||
@Parameter(description = "Filtre par rôle")
|
||||
@QueryParam("role") UserRole role,
|
||||
|
||||
@Parameter(description = "Filtre par statut actif")
|
||||
@QueryParam("active") Boolean active,
|
||||
|
||||
@Parameter(description = "Recherche par nom ou email")
|
||||
@QueryParam("search") String search
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de liste des utilisateurs - page: {}, size: {}", page, size);
|
||||
|
||||
PagedResultDTO<UserDTO> result = userService.getUsers(page, size, sort, role, active, search);
|
||||
|
||||
logger.info("Liste des utilisateurs récupérée avec succès - {} éléments", result.getTotalElements());
|
||||
return Response.ok(result).build();
|
||||
|
||||
} catch (AuthorizationException e) {
|
||||
logger.warn("Accès refusé pour la liste des utilisateurs: {}", e.getMessage());
|
||||
return Response.status(Response.Status.FORBIDDEN)
|
||||
.entity("Accès refusé: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors de la récupération des utilisateurs: {}", e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endpoint pour récupérer un utilisateur par son ID.
|
||||
*
|
||||
* @param id l'identifiant de l'utilisateur
|
||||
* @return les détails de l'utilisateur
|
||||
*/
|
||||
@GET
|
||||
@Path("/{id}")
|
||||
@RolesAllowed({"ADMIN", "MANAGER", "COACH"})
|
||||
@Operation(
|
||||
summary = "Utilisateur par ID",
|
||||
description = "Récupère les détails d'un utilisateur par son identifiant"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(
|
||||
responseCode = "200",
|
||||
description = "Utilisateur trouvé",
|
||||
content = @Content(schema = @Schema(implementation = UserDTO.class))
|
||||
),
|
||||
@APIResponse(responseCode = "404", description = "Utilisateur non trouvé"),
|
||||
@APIResponse(responseCode = "401", description = "Non authentifié"),
|
||||
@APIResponse(responseCode = "403", description = "Accès refusé"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response getUserById(
|
||||
@Parameter(description = "ID de l'utilisateur", required = true, example = "1")
|
||||
@PathParam("id") Long id
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de récupération de l'utilisateur ID: {}", id);
|
||||
|
||||
UserDTO user = userService.getUserById(id);
|
||||
|
||||
logger.info("Utilisateur récupéré avec succès: {}", user.getEmail());
|
||||
return Response.ok(user).build();
|
||||
|
||||
} catch (ResourceNotFoundException e) {
|
||||
logger.warn("Utilisateur non trouvé avec ID: {}", id);
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity("Utilisateur non trouvé: " + e.getMessage())
|
||||
.build();
|
||||
} catch (AuthorizationException e) {
|
||||
logger.warn("Accès refusé pour l'utilisateur ID {}: {}", id, e.getMessage());
|
||||
return Response.status(Response.Status.FORBIDDEN)
|
||||
.entity("Accès refusé: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors de la récupération de l'utilisateur {}: {}", id, e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endpoint pour créer un nouvel utilisateur.
|
||||
*
|
||||
* @param createUserDTO les données du nouvel utilisateur
|
||||
* @return l'utilisateur créé
|
||||
*/
|
||||
@POST
|
||||
@RolesAllowed({"ADMIN"})
|
||||
@Operation(
|
||||
summary = "Créer un utilisateur",
|
||||
description = "Crée un nouvel utilisateur dans le système"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(
|
||||
responseCode = "201",
|
||||
description = "Utilisateur créé avec succès",
|
||||
content = @Content(schema = @Schema(implementation = UserDTO.class))
|
||||
),
|
||||
@APIResponse(responseCode = "400", description = "Données invalides"),
|
||||
@APIResponse(responseCode = "409", description = "Email déjà utilisé"),
|
||||
@APIResponse(responseCode = "401", description = "Non authentifié"),
|
||||
@APIResponse(responseCode = "403", description = "Accès refusé - seuls les admins peuvent créer des utilisateurs"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response createUser(
|
||||
@Parameter(description = "Données du nouvel utilisateur", required = true)
|
||||
@Valid CreateUserDTO createUserDTO
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de création d'utilisateur: {}", createUserDTO.getEmail());
|
||||
|
||||
UserDTO user = userService.createUser(createUserDTO);
|
||||
|
||||
logger.info("Utilisateur créé avec succès: {}", user.getEmail());
|
||||
return Response.status(Response.Status.CREATED).entity(user).build();
|
||||
|
||||
} catch (ValidationException e) {
|
||||
logger.warn("Données invalides pour la création d'utilisateur: {}", e.getMessage());
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity("Données invalides: " + e.getMessage())
|
||||
.build();
|
||||
} catch (AuthorizationException e) {
|
||||
logger.warn("Accès refusé pour la création d'utilisateur: {}", e.getMessage());
|
||||
return Response.status(Response.Status.FORBIDDEN)
|
||||
.entity("Accès refusé: " + e.getMessage())
|
||||
.build();
|
||||
} catch (GBCMException e) {
|
||||
logger.warn("Erreur lors de la création d'utilisateur: {}", e.getMessage());
|
||||
return Response.status(Response.Status.CONFLICT)
|
||||
.entity("Erreur: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors de la création d'utilisateur: {}", e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endpoint pour mettre à jour un utilisateur existant.
|
||||
*
|
||||
* @param id l'identifiant de l'utilisateur
|
||||
* @param updateUserDTO les données de mise à jour
|
||||
* @return l'utilisateur mis à jour
|
||||
*/
|
||||
@PUT
|
||||
@Path("/{id}")
|
||||
@RolesAllowed({"ADMIN", "MANAGER"})
|
||||
@Operation(
|
||||
summary = "Mettre à jour un utilisateur",
|
||||
description = "Met à jour les informations d'un utilisateur existant"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(
|
||||
responseCode = "200",
|
||||
description = "Utilisateur mis à jour avec succès",
|
||||
content = @Content(schema = @Schema(implementation = UserDTO.class))
|
||||
),
|
||||
@APIResponse(responseCode = "404", description = "Utilisateur non trouvé"),
|
||||
@APIResponse(responseCode = "400", description = "Données invalides"),
|
||||
@APIResponse(responseCode = "409", description = "Email déjà utilisé par un autre utilisateur"),
|
||||
@APIResponse(responseCode = "401", description = "Non authentifié"),
|
||||
@APIResponse(responseCode = "403", description = "Accès refusé"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response updateUser(
|
||||
@Parameter(description = "ID de l'utilisateur", required = true, example = "1")
|
||||
@PathParam("id") Long id,
|
||||
|
||||
@Parameter(description = "Données de mise à jour", required = true)
|
||||
@Valid UpdateUserDTO updateUserDTO
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de mise à jour de l'utilisateur ID: {}", id);
|
||||
|
||||
UserDTO user = userService.updateUser(id, updateUserDTO);
|
||||
|
||||
logger.info("Utilisateur mis à jour avec succès: {}", user.getEmail());
|
||||
return Response.ok(user).build();
|
||||
|
||||
} catch (ResourceNotFoundException e) {
|
||||
logger.warn("Utilisateur non trouvé pour mise à jour ID: {}", id);
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity("Utilisateur non trouvé: " + e.getMessage())
|
||||
.build();
|
||||
} catch (ValidationException e) {
|
||||
logger.warn("Données invalides pour la mise à jour de l'utilisateur {}: {}", id, e.getMessage());
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity("Données invalides: " + e.getMessage())
|
||||
.build();
|
||||
} catch (AuthorizationException e) {
|
||||
logger.warn("Accès refusé pour la mise à jour de l'utilisateur {}: {}", id, e.getMessage());
|
||||
return Response.status(Response.Status.FORBIDDEN)
|
||||
.entity("Accès refusé: " + e.getMessage())
|
||||
.build();
|
||||
} catch (GBCMException e) {
|
||||
logger.warn("Erreur lors de la mise à jour de l'utilisateur {}: {}", id, e.getMessage());
|
||||
return Response.status(Response.Status.CONFLICT)
|
||||
.entity("Erreur: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors de la mise à jour de l'utilisateur {}: {}", id, e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endpoint pour supprimer un utilisateur (soft delete).
|
||||
*
|
||||
* @param id l'identifiant de l'utilisateur
|
||||
* @return confirmation de suppression
|
||||
*/
|
||||
@DELETE
|
||||
@Path("/{id}")
|
||||
@RolesAllowed({"ADMIN"})
|
||||
@Operation(
|
||||
summary = "Supprimer un utilisateur",
|
||||
description = "Supprime un utilisateur du système (soft delete)"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(responseCode = "200", description = "Utilisateur supprimé avec succès"),
|
||||
@APIResponse(responseCode = "404", description = "Utilisateur non trouvé"),
|
||||
@APIResponse(responseCode = "401", description = "Non authentifié"),
|
||||
@APIResponse(responseCode = "403", description = "Accès refusé - seuls les admins peuvent supprimer des utilisateurs"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response deleteUser(
|
||||
@Parameter(description = "ID de l'utilisateur", required = true, example = "1")
|
||||
@PathParam("id") Long id
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de suppression de l'utilisateur ID: {}", id);
|
||||
|
||||
SuccessResponseDTO<Void> result = userService.deleteUser(id);
|
||||
|
||||
logger.info("Utilisateur supprimé avec succès ID: {}", id);
|
||||
return Response.ok(result).build();
|
||||
|
||||
} catch (ResourceNotFoundException e) {
|
||||
logger.warn("Utilisateur non trouvé pour suppression ID: {}", id);
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity("Utilisateur non trouvé: " + e.getMessage())
|
||||
.build();
|
||||
} catch (AuthorizationException e) {
|
||||
logger.warn("Accès refusé pour la suppression de l'utilisateur {}: {}", id, e.getMessage());
|
||||
return Response.status(Response.Status.FORBIDDEN)
|
||||
.entity("Accès refusé: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors de la suppression de l'utilisateur {}: {}", id, e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endpoint pour changer le statut d'un utilisateur.
|
||||
*
|
||||
* @param id l'identifiant de l'utilisateur
|
||||
* @param active le nouveau statut
|
||||
* @return l'utilisateur avec le nouveau statut
|
||||
*/
|
||||
@PUT
|
||||
@Path("/{id}/status")
|
||||
@RolesAllowed({"ADMIN", "MANAGER"})
|
||||
@Operation(
|
||||
summary = "Changer le statut d'un utilisateur",
|
||||
description = "Active ou désactive un compte utilisateur"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(
|
||||
responseCode = "200",
|
||||
description = "Statut modifié avec succès",
|
||||
content = @Content(schema = @Schema(implementation = UserDTO.class))
|
||||
),
|
||||
@APIResponse(responseCode = "404", description = "Utilisateur non trouvé"),
|
||||
@APIResponse(responseCode = "401", description = "Non authentifié"),
|
||||
@APIResponse(responseCode = "403", description = "Accès refusé"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response changeUserStatus(
|
||||
@Parameter(description = "ID de l'utilisateur", required = true, example = "1")
|
||||
@PathParam("id") Long id,
|
||||
|
||||
@Parameter(description = "Nouveau statut", required = true, example = "true")
|
||||
@FormParam("active") boolean active
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de changement de statut pour l'utilisateur ID: {} -> {}", id, active);
|
||||
|
||||
UserDTO user = userService.changeUserStatus(id, active);
|
||||
|
||||
logger.info("Statut utilisateur changé avec succès: {} -> {}", id, active);
|
||||
return Response.ok(user).build();
|
||||
|
||||
} catch (ResourceNotFoundException e) {
|
||||
logger.warn("Utilisateur non trouvé pour changement de statut ID: {}", id);
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity("Utilisateur non trouvé: " + e.getMessage())
|
||||
.build();
|
||||
} catch (AuthorizationException e) {
|
||||
logger.warn("Accès refusé pour le changement de statut de l'utilisateur {}: {}", id, e.getMessage());
|
||||
return Response.status(Response.Status.FORBIDDEN)
|
||||
.entity("Accès refusé: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors du changement de statut de l'utilisateur {}: {}", id, e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endpoint pour récupérer le profil de l'utilisateur connecté.
|
||||
*
|
||||
* @param authToken le token d'authentification
|
||||
* @return le profil de l'utilisateur connecté
|
||||
*/
|
||||
@GET
|
||||
@Path("/profile")
|
||||
@RolesAllowed({"ADMIN", "MANAGER", "COACH", "CLIENT", "PROSPECT"})
|
||||
@Operation(
|
||||
summary = "Profil utilisateur",
|
||||
description = "Récupère le profil de l'utilisateur actuellement connecté"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(
|
||||
responseCode = "200",
|
||||
description = "Profil récupéré avec succès",
|
||||
content = @Content(schema = @Schema(implementation = UserDTO.class))
|
||||
),
|
||||
@APIResponse(responseCode = "401", description = "Non authentifié"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response getCurrentUserProfile(
|
||||
@Parameter(description = "Token d'authentification", required = true)
|
||||
@HeaderParam("Authorization") String authToken
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de récupération du profil utilisateur courant");
|
||||
|
||||
UserDTO user = userService.getCurrentUserProfile(authToken);
|
||||
|
||||
logger.info("Profil utilisateur récupéré avec succès: {}", user.getEmail());
|
||||
return Response.ok(user).build();
|
||||
|
||||
} catch (AuthorizationException e) {
|
||||
logger.warn("Accès refusé pour le profil utilisateur: {}", e.getMessage());
|
||||
return Response.status(Response.Status.UNAUTHORIZED)
|
||||
.entity("Accès refusé: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors de la récupération du profil: {}", e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endpoint pour mettre à jour le profil de l'utilisateur connecté.
|
||||
*
|
||||
* @param authToken le token d'authentification
|
||||
* @param updateUserDTO les données de mise à jour
|
||||
* @return le profil mis à jour
|
||||
*/
|
||||
@PUT
|
||||
@Path("/profile")
|
||||
@RolesAllowed({"ADMIN", "MANAGER", "COACH", "CLIENT", "PROSPECT"})
|
||||
@Operation(
|
||||
summary = "Mettre à jour le profil",
|
||||
description = "Met à jour le profil de l'utilisateur actuellement connecté"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(
|
||||
responseCode = "200",
|
||||
description = "Profil mis à jour avec succès",
|
||||
content = @Content(schema = @Schema(implementation = UserDTO.class))
|
||||
),
|
||||
@APIResponse(responseCode = "400", description = "Données invalides"),
|
||||
@APIResponse(responseCode = "409", description = "Email déjà utilisé"),
|
||||
@APIResponse(responseCode = "401", description = "Non authentifié"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response updateCurrentUserProfile(
|
||||
@Parameter(description = "Token d'authentification", required = true)
|
||||
@HeaderParam("Authorization") String authToken,
|
||||
|
||||
@Parameter(description = "Données de mise à jour du profil", required = true)
|
||||
@Valid UpdateUserDTO updateUserDTO
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de mise à jour du profil utilisateur courant");
|
||||
|
||||
UserDTO user = userService.updateCurrentUserProfile(authToken, updateUserDTO);
|
||||
|
||||
logger.info("Profil utilisateur mis à jour avec succès: {}", user.getEmail());
|
||||
return Response.ok(user).build();
|
||||
|
||||
} catch (ValidationException e) {
|
||||
logger.warn("Données invalides pour la mise à jour du profil: {}", e.getMessage());
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity("Données invalides: " + e.getMessage())
|
||||
.build();
|
||||
} catch (AuthorizationException e) {
|
||||
logger.warn("Accès refusé pour la mise à jour du profil: {}", e.getMessage());
|
||||
return Response.status(Response.Status.UNAUTHORIZED)
|
||||
.entity("Accès refusé: " + e.getMessage())
|
||||
.build();
|
||||
} catch (GBCMException e) {
|
||||
logger.warn("Erreur lors de la mise à jour du profil: {}", e.getMessage());
|
||||
return Response.status(Response.Status.CONFLICT)
|
||||
.entity("Erreur: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors de la mise à jour du profil: {}", e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endpoint pour rechercher des utilisateurs par critères.
|
||||
*
|
||||
* @param query le terme de recherche
|
||||
* @param page le numéro de page
|
||||
* @param size la taille de page
|
||||
* @return les résultats de recherche paginés
|
||||
*/
|
||||
@GET
|
||||
@Path("/search")
|
||||
@RolesAllowed({"ADMIN", "MANAGER", "COACH"})
|
||||
@Operation(
|
||||
summary = "Rechercher des utilisateurs",
|
||||
description = "Recherche d'utilisateurs par différents critères"
|
||||
)
|
||||
@APIResponses({
|
||||
@APIResponse(
|
||||
responseCode = "200",
|
||||
description = "Résultats de recherche",
|
||||
content = @Content(schema = @Schema(implementation = PagedResultDTO.class))
|
||||
),
|
||||
@APIResponse(responseCode = "401", description = "Non authentifié"),
|
||||
@APIResponse(responseCode = "403", description = "Accès refusé"),
|
||||
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
|
||||
})
|
||||
public Response searchUsers(
|
||||
@Parameter(description = "Terme de recherche", required = true)
|
||||
@QueryParam("q") String query,
|
||||
|
||||
@Parameter(description = "Numéro de page", example = "0")
|
||||
@QueryParam("page") @DefaultValue("0") int page,
|
||||
|
||||
@Parameter(description = "Taille de page", example = "20")
|
||||
@QueryParam("size") @DefaultValue("20") int size
|
||||
) {
|
||||
try {
|
||||
logger.info("Demande de recherche d'utilisateurs avec query: {}", query);
|
||||
|
||||
PagedResultDTO<UserDTO> result = userService.searchUsers(query, page, size);
|
||||
|
||||
logger.info("Recherche d'utilisateurs terminée - {} résultats", result.getTotalElements());
|
||||
return Response.ok(result).build();
|
||||
|
||||
} catch (AuthorizationException e) {
|
||||
logger.warn("Accès refusé pour la recherche d'utilisateurs: {}", e.getMessage());
|
||||
return Response.status(Response.Status.FORBIDDEN)
|
||||
.entity("Accès refusé: " + e.getMessage())
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur inattendue lors de la recherche d'utilisateurs: {}", e.getMessage());
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity("Erreur interne du serveur")
|
||||
.build();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,11 @@
|
||||
package com.gbcm.server.impl.service;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import com.gbcm.server.api.dto.common.PagedResultDTO;
|
||||
import com.gbcm.server.api.dto.common.SuccessResponseDTO;
|
||||
import com.gbcm.server.api.dto.user.CreateUserDTO;
|
||||
@@ -11,17 +17,11 @@ import com.gbcm.server.api.exceptions.GBCMException;
|
||||
import com.gbcm.server.api.exceptions.ResourceNotFoundException;
|
||||
import com.gbcm.server.api.exceptions.ValidationException;
|
||||
import com.gbcm.server.api.interfaces.UserService;
|
||||
import com.gbcm.server.impl.entity.User;
|
||||
import com.gbcm.server.impl.service.security.PasswordService;
|
||||
|
||||
import jakarta.enterprise.context.ApplicationScoped;
|
||||
import jakarta.inject.Inject;
|
||||
import jakarta.transaction.Transactional;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Implémentation simplifiée du service de gestion des utilisateurs pour la plateforme GBCM.
|
||||
@@ -105,11 +105,11 @@ public class UserServiceImpl implements UserService {
|
||||
|
||||
// Validation basique
|
||||
if (createUserDTO == null) {
|
||||
throw new ValidationException("Données de création requises", "USER_CREATE_DATA_REQUIRED");
|
||||
throw new ValidationException("Données de création requises");
|
||||
}
|
||||
|
||||
if (createUserDTO.getEmail() == null || createUserDTO.getEmail().trim().isEmpty()) {
|
||||
throw new ValidationException("Email requis", "USER_EMAIL_REQUIRED");
|
||||
throw new ValidationException("Email requis");
|
||||
}
|
||||
|
||||
// Simulation - créer un utilisateur fictif
|
||||
@@ -140,7 +140,7 @@ public class UserServiceImpl implements UserService {
|
||||
}
|
||||
|
||||
if (updateUserDTO == null) {
|
||||
throw new ValidationException("Données de mise à jour requises", "USER_UPDATE_DATA_REQUIRED");
|
||||
throw new ValidationException("Données de mise à jour requises");
|
||||
}
|
||||
|
||||
// Simulation - retourner un utilisateur mis à jour
|
||||
@@ -238,7 +238,7 @@ public class UserServiceImpl implements UserService {
|
||||
}
|
||||
|
||||
if (updateUserDTO == null) {
|
||||
throw new ValidationException("Données de mise à jour requises", "USER_UPDATE_DATA_REQUIRED");
|
||||
throw new ValidationException("Données de mise à jour requises");
|
||||
}
|
||||
|
||||
// Simulation - retourner le profil mis à jour
|
||||
|
||||
Reference in New Issue
Block a user