528 lines
22 KiB
Java
528 lines
22 KiB
Java
package com.lions.dev.resource;
|
|
|
|
import com.lions.dev.dto.PasswordResetRequest;
|
|
import com.lions.dev.dto.request.users.AssignRoleRequestDTO;
|
|
import com.lions.dev.dto.request.users.SetUserActiveRequestDTO;
|
|
import com.lions.dev.dto.request.users.UpdateProfileImageRequestDTO;
|
|
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.exception.UserNotFoundException;
|
|
import com.lions.dev.service.JwtService;
|
|
import com.lions.dev.service.PasswordResetService;
|
|
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 org.eclipse.microprofile.config.inject.ConfigProperty;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Optional;
|
|
import java.util.UUID;
|
|
import java.util.stream.Collectors;
|
|
import org.eclipse.microprofile.openapi.annotations.Operation;
|
|
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
|
|
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.
|
|
*/
|
|
@Path("/users")
|
|
@Produces(MediaType.APPLICATION_JSON)
|
|
@Consumes(MediaType.APPLICATION_JSON)
|
|
@Tag(name = "Users", description = "Opérations liées à la gestion des utilisateurs")
|
|
public class UsersResource {
|
|
|
|
@Inject
|
|
UsersService userService;
|
|
|
|
@Inject
|
|
JwtService jwtService;
|
|
|
|
@Inject
|
|
PasswordResetService passwordResetService;
|
|
|
|
@ConfigProperty(name = "afterwork.super-admin.api-key", defaultValue = "")
|
|
Optional<String> superAdminApiKey;
|
|
|
|
private static final Logger LOG = Logger.getLogger(UsersResource.class);
|
|
|
|
private static final String SUPER_ADMIN_KEY_HEADER = "X-Super-Admin-Key";
|
|
|
|
/**
|
|
* Endpoint pour créer un nouvel utilisateur.
|
|
*
|
|
* @param userCreateRequestDTO Le DTO contenant les informations de l'utilisateur à créer.
|
|
* @return Une réponse HTTP contenant l'utilisateur créé ou un message d'erreur.
|
|
*/
|
|
@POST
|
|
@Transactional
|
|
@Operation(
|
|
summary = "Créer un nouvel utilisateur",
|
|
description = "Crée un nouvel utilisateur et retourne les détails")
|
|
public Response createUser(@Valid @NotNull UserCreateRequestDTO userCreateRequestDTO) {
|
|
LOG.info(
|
|
"Tentative de création d'un nouvel utilisateur avec l'email : "
|
|
+ userCreateRequestDTO.getEmail());
|
|
|
|
Users user = userService.createUser(userCreateRequestDTO);
|
|
UserCreateResponseDTO responseDTO = new UserCreateResponseDTO(user);
|
|
return Response.status(Response.Status.CREATED).entity(responseDTO).build();
|
|
}
|
|
|
|
/**
|
|
* Endpoint pour authentifier un utilisateur (v2.0).
|
|
*
|
|
* @param userAuthenticateRequestDTO Le DTO contenant les informations d'authentification.
|
|
* @return Une réponse HTTP indiquant si l'authentification a réussi ou échoué.
|
|
*/
|
|
@POST
|
|
@Path("/authenticate")
|
|
@Operation(
|
|
summary = "Authentifier un utilisateur",
|
|
description = "Vérifie les informations de connexion de l'utilisateur")
|
|
public Response authenticateUser(@Valid @NotNull UserAuthenticateRequestDTO userAuthenticateRequestDTO) {
|
|
LOG.info("Tentative d'authentification pour l'utilisateur avec l'email : " + userAuthenticateRequestDTO.getEmail());
|
|
|
|
// v2.0 - Utiliser getPassword() qui gère la compatibilité v1.0 et v2.0
|
|
Users user = userService.authenticateUser(userAuthenticateRequestDTO.getEmail(), userAuthenticateRequestDTO.getPassword());
|
|
LOG.info("Authentification réussie pour l'utilisateur : " + user.getEmail());
|
|
|
|
// v2.0 - Utiliser les nouveaux noms de champs
|
|
UserAuthenticateResponseDTO responseDTO = new UserAuthenticateResponseDTO(
|
|
user.getId(),
|
|
user.getFirstName(), // v2.0
|
|
user.getLastName(), // v2.0
|
|
user.getEmail(),
|
|
user.getRole()
|
|
);
|
|
responseDTO.setToken(jwtService.generateToken(user));
|
|
responseDTO.logResponseDetails();
|
|
return Response.ok(responseDTO).build();
|
|
}
|
|
|
|
/**
|
|
* Endpoint pour récupérer les détails d'un utilisateur par ID.
|
|
*
|
|
* @param id L'ID de l'utilisateur.
|
|
* @return Une réponse HTTP contenant les informations de l'utilisateur.
|
|
*/
|
|
@GET
|
|
@Path("/{id}")
|
|
@Operation(
|
|
summary = "Récupérer un utilisateur par ID",
|
|
description = "Retourne les détails de l'utilisateur demandé")
|
|
public Response getUserById(@PathParam("id") UUID id) {
|
|
LOG.info("Récupération de l'utilisateur avec l'ID : " + id);
|
|
|
|
Users user = userService.getUserById(id);
|
|
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);
|
|
List<UserCreateResponseDTO> responseDTOs = users.stream()
|
|
.map(UserCreateResponseDTO::new)
|
|
.collect(Collectors.toList());
|
|
LOG.info("Liste des utilisateurs récupérée avec succès, taille : " + responseDTOs.size());
|
|
return Response.ok(responseDTOs).build();
|
|
}
|
|
|
|
/**
|
|
* Endpoint pour supprimer un utilisateur par ID.
|
|
*
|
|
* @param id L'ID de l'utilisateur à supprimer.
|
|
* @return Une réponse HTTP avec le statut de suppression.
|
|
*/
|
|
@DELETE
|
|
@Path("/{id}")
|
|
@Transactional
|
|
@Operation(
|
|
summary = "Supprimer un utilisateur",
|
|
description = "Supprime un utilisateur de la base de données")
|
|
public Response deleteUser(@PathParam("id") UUID id) {
|
|
LOG.info("Tentative de suppression de l'utilisateur avec l'ID : " + id);
|
|
|
|
boolean deleted = userService.deleteUser(id);
|
|
|
|
UserDeleteResponseDto responseDTO = new UserDeleteResponseDto();
|
|
if (deleted) {
|
|
LOG.info("Utilisateur supprimé avec succès.");
|
|
responseDTO.setSuccess(true);
|
|
responseDTO.setMessage("Utilisateur supprimé avec succès.");
|
|
responseDTO.logResponseDetails();
|
|
return Response.ok(responseDTO).build();
|
|
} else {
|
|
LOG.warn("Échec de la suppression : utilisateur introuvable avec l'ID : " + id);
|
|
responseDTO.setSuccess(false);
|
|
responseDTO.setMessage("Utilisateur non trouvé.");
|
|
responseDTO.logResponseDetails();
|
|
return Response.status(Response.Status.NOT_FOUND).entity(responseDTO).build();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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(Map.of("message", "Mot de passe réinitialisé avec succès.")).build();
|
|
}
|
|
|
|
/**
|
|
* Endpoint pour mettre à jour l'image de profil de l'utilisateur.
|
|
* Accepte un JSON avec {@code profileImageUrl} (URL retournée par l'upload de médias).
|
|
* Réponse toujours en JSON (utilisateur mis à jour ou message d'erreur).
|
|
*
|
|
* @param id L'identifiant de l'utilisateur.
|
|
* @param request Corps JSON : { "profileImageUrl": "https://..." }
|
|
* @return Réponse JSON : utilisateur mis à jour (200) ou message d'erreur (4xx/5xx).
|
|
*/
|
|
@PUT
|
|
@Path("/{id}/profile-image")
|
|
@Operation(summary = "Mettre à jour l'image de profil d'un utilisateur", description = "Met à jour l'URL de l'image de profil (après upload). Corps JSON : profileImageUrl.")
|
|
public Response updateUserProfileImage(@PathParam("id") UUID id, @Valid @NotNull UpdateProfileImageRequestDTO request) {
|
|
try {
|
|
String profileImageUrl = request.getProfileImageUrl();
|
|
if (profileImageUrl == null || profileImageUrl.isBlank()) {
|
|
return Response.status(Response.Status.BAD_REQUEST)
|
|
.entity(Map.of("message", "L'URL de l'image de profil est obligatoire."))
|
|
.build();
|
|
}
|
|
Users updatedUser = userService.updateUserProfileImage(id, profileImageUrl.trim());
|
|
LOG.info("[LOG] Image de profil mise à jour pour l'utilisateur avec l'ID : " + id);
|
|
UserCreateResponseDTO responseDTO = new UserCreateResponseDTO(updatedUser);
|
|
return Response.ok(responseDTO).build();
|
|
} catch (UserNotFoundException e) {
|
|
LOG.warn("Utilisateur non trouvé pour mise à jour image de profil : " + id);
|
|
return Response.status(Response.Status.NOT_FOUND)
|
|
.entity(Map.of("message", e.getMessage()))
|
|
.build();
|
|
} catch (Exception e) {
|
|
LOG.error("[ERROR] Erreur lors de la mise à jour de l'image de profil : " + e.getMessage(), e);
|
|
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
|
.entity(Map.of("message", "Erreur lors de la mise à jour de l'image de profil."))
|
|
.build();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Endpoint pour rechercher un utilisateur par email.
|
|
*
|
|
* @param email L'email de l'utilisateur à rechercher.
|
|
* @return Une réponse HTTP contenant les informations de l'utilisateur.
|
|
*/
|
|
@GET
|
|
@Path("/search")
|
|
@Operation(
|
|
summary = "Rechercher un utilisateur par email",
|
|
description = "Retourne les détails de l'utilisateur correspondant à l'email fourni")
|
|
public Response searchUserByEmail(@QueryParam("email") String email) {
|
|
if (email == null || email.isBlank()) {
|
|
LOG.warn("Tentative de recherche avec un email vide ou null");
|
|
return Response.status(Response.Status.BAD_REQUEST)
|
|
.entity("{\"message\": \"L'email est requis pour la recherche.\"}")
|
|
.build();
|
|
}
|
|
|
|
LOG.info("Recherche de l'utilisateur avec l'email : " + email);
|
|
|
|
try {
|
|
Users user = userService.getUserByEmail(email);
|
|
UserCreateResponseDTO responseDTO = new UserCreateResponseDTO(user);
|
|
LOG.info("Utilisateur trouvé : " + user.getEmail());
|
|
return Response.ok(responseDTO).build();
|
|
} catch (UserNotFoundException e) {
|
|
LOG.warn("Utilisateur non trouvé avec l'email : " + email);
|
|
return Response.status(Response.Status.NOT_FOUND)
|
|
.entity("{\"message\": \"Utilisateur non trouvé avec cet email.\"}")
|
|
.build();
|
|
} catch (Exception e) {
|
|
LOG.error("[ERROR] Erreur lors de la recherche de l'utilisateur : " + e.getMessage(), e);
|
|
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
|
.entity("{\"message\": \"Erreur lors de la recherche de l'utilisateur.\"}")
|
|
.build();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Endpoint pour demander une réinitialisation de mot de passe par email.
|
|
*
|
|
* @param request Le DTO contenant l'email de l'utilisateur.
|
|
* @return Une réponse HTTP indiquant que l'email a été envoyé (ou non, pour ne pas révéler si l'email existe).
|
|
*/
|
|
@POST
|
|
@Path("/forgot-password")
|
|
@Operation(summary = "Demander une reinitialisation de mot de passe par email",
|
|
description = "Envoie un email de reinitialisation si un compte existe avec cet email")
|
|
@APIResponse(responseCode = "200", description = "Email de reinitialisation envoye si le compte existe")
|
|
@APIResponse(responseCode = "400", description = "Email invalide")
|
|
public Response requestPasswordReset(@Valid PasswordResetRequest request) {
|
|
LOG.info("Demande de reinitialisation de mot de passe pour l'email : " + request.getEmail());
|
|
|
|
try {
|
|
// Le service gère tout : création du token et envoi de l'email
|
|
passwordResetService.initiatePasswordReset(request.getEmail());
|
|
|
|
// Toujours retourner 200 pour ne pas reveler si l'email existe
|
|
return Response.ok()
|
|
.entity(Map.of("message", "Si un compte existe avec cet email, un lien de reinitialisation a ete envoye"))
|
|
.build();
|
|
} catch (Exception e) {
|
|
LOG.error("Erreur lors de la demande de reinitialisation de mot de passe", e);
|
|
// Toujours retourner 200 pour ne pas reveler si l'email existe
|
|
return Response.ok()
|
|
.entity(Map.of("message", "Si un compte existe avec cet email, un lien de reinitialisation a ete envoye"))
|
|
.build();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Endpoint pour réinitialiser le mot de passe avec un token valide.
|
|
*
|
|
* @param token Le token de réinitialisation reçu par email.
|
|
* @param newPassword Le nouveau mot de passe.
|
|
* @return Une réponse HTTP indiquant si la réinitialisation a réussi.
|
|
*/
|
|
@POST
|
|
@Path("/reset-password")
|
|
@Operation(summary = "Réinitialiser le mot de passe avec un token",
|
|
description = "Réinitialise le mot de passe en utilisant le token reçu par email")
|
|
@APIResponse(responseCode = "200", description = "Mot de passe réinitialisé avec succès")
|
|
@APIResponse(responseCode = "400", description = "Token invalide ou expiré")
|
|
public Response resetPasswordWithToken(
|
|
@QueryParam("token") String token,
|
|
@QueryParam("newPassword") String newPassword) {
|
|
|
|
if (token == null || token.isBlank()) {
|
|
return Response.status(Response.Status.BAD_REQUEST)
|
|
.entity(Map.of("message", "Le token est requis"))
|
|
.build();
|
|
}
|
|
|
|
if (newPassword == null || newPassword.length() < 8) {
|
|
return Response.status(Response.Status.BAD_REQUEST)
|
|
.entity(Map.of("message", "Le mot de passe doit contenir au moins 8 caractères"))
|
|
.build();
|
|
}
|
|
|
|
boolean success = passwordResetService.resetPassword(token, newPassword);
|
|
|
|
if (success) {
|
|
LOG.info("Mot de passe réinitialisé avec succès via token");
|
|
return Response.ok()
|
|
.entity(Map.of("message", "Votre mot de passe a été réinitialisé avec succès"))
|
|
.build();
|
|
} else {
|
|
LOG.warn("Échec de réinitialisation : token invalide ou expiré");
|
|
return Response.status(Response.Status.BAD_REQUEST)
|
|
.entity(Map.of("message", "Le lien de réinitialisation est invalide ou a expiré"))
|
|
.build();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Attribue un rôle à un utilisateur (réservé au super administrateur).
|
|
* Requiert le header X-Super-Admin-Key correspondant à afterwork.super-admin.api-key.
|
|
*
|
|
* @param id L'ID de l'utilisateur.
|
|
* @param request Le DTO contenant le nouveau rôle.
|
|
* @param apiKeyHeader Valeur du header X-Super-Admin-Key (injecté via @HeaderParam).
|
|
* @return L'utilisateur mis à jour.
|
|
*/
|
|
@PUT
|
|
@Path("/{id}/role")
|
|
@Transactional
|
|
@Operation(summary = "Attribuer un rôle à un utilisateur (super admin)",
|
|
description = "Modifie le rôle d'un utilisateur. Réservé au super administrateur (header X-Super-Admin-Key).")
|
|
@APIResponse(responseCode = "200", description = "Rôle mis à jour")
|
|
@APIResponse(responseCode = "403", description = "Clé super admin invalide ou absente")
|
|
@APIResponse(responseCode = "404", description = "Utilisateur non trouvé")
|
|
public Response assignRole(
|
|
@PathParam("id") UUID id,
|
|
@Valid AssignRoleRequestDTO request,
|
|
@HeaderParam(SUPER_ADMIN_KEY_HEADER) String apiKeyHeader) {
|
|
|
|
String key = superAdminApiKey.orElse("");
|
|
if (key.isBlank()) {
|
|
LOG.warn("Opération assignRole refusée : afterwork.super-admin.api-key non configurée");
|
|
return Response.status(Response.Status.FORBIDDEN)
|
|
.entity("{\"message\": \"Opération non autorisée : clé super admin non configurée.\"}")
|
|
.build();
|
|
}
|
|
if (apiKeyHeader == null || !apiKeyHeader.equals(key)) {
|
|
LOG.warn("Opération assignRole refusée : clé super admin invalide ou absente");
|
|
return Response.status(Response.Status.FORBIDDEN)
|
|
.entity("{\"message\": \"Clé super administrateur invalide ou absente.\"}")
|
|
.build();
|
|
}
|
|
|
|
try {
|
|
Users user = userService.assignRole(id, request.getRole());
|
|
UserCreateResponseDTO responseDTO = new UserCreateResponseDTO(user);
|
|
return Response.ok(responseDTO).build();
|
|
} catch (UserNotFoundException e) {
|
|
return Response.status(Response.Status.NOT_FOUND)
|
|
.entity("{\"message\": \"" + e.getMessage() + "\"}")
|
|
.build();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Génère un token temporaire d'impersonation (Super Admin se connecte en tant qu'un autre utilisateur).
|
|
* Le client envoie ce token (ex: Authorization: Bearer <token>) pour les requêtes suivantes.
|
|
* La validation du token côté backend (filter) est à implémenter si nécessaire.
|
|
*
|
|
* @param id L'ID de l'utilisateur à impersonner.
|
|
* @param apiKeyHeader X-Super-Admin-Key.
|
|
* @return JSON avec impersonationToken, expiresInSeconds, userId.
|
|
*/
|
|
@POST
|
|
@Path("/{id}/impersonate")
|
|
@Operation(summary = "Impersonation (Super Admin)",
|
|
description = "Génère un token temporaire pour se connecter en tant que cet utilisateur. Header X-Super-Admin-Key requis.")
|
|
public Response impersonate(
|
|
@PathParam("id") UUID id,
|
|
@HeaderParam(SUPER_ADMIN_KEY_HEADER) String apiKeyHeader) {
|
|
|
|
String key = superAdminApiKey.orElse("");
|
|
if (key.isBlank()) {
|
|
return Response.status(Response.Status.FORBIDDEN)
|
|
.entity("{\"message\": \"Opération non autorisée : clé super admin non configurée.\"}")
|
|
.build();
|
|
}
|
|
if (apiKeyHeader == null || !apiKeyHeader.equals(key)) {
|
|
return Response.status(Response.Status.FORBIDDEN)
|
|
.entity("{\"message\": \"Clé super administrateur invalide ou absente.\"}")
|
|
.build();
|
|
}
|
|
|
|
try {
|
|
Users user = userService.getUserById(id);
|
|
// Token temporaire (UUID) — à valider côté backend via un filter si besoin
|
|
String token = UUID.randomUUID().toString();
|
|
int expiresInSeconds = 900; // 15 min
|
|
return Response.ok(Map.of(
|
|
"impersonationToken", token,
|
|
"expiresInSeconds", expiresInSeconds,
|
|
"userId", user.getId().toString(),
|
|
"email", user.getEmail()
|
|
)).build();
|
|
} catch (UserNotFoundException e) {
|
|
return Response.status(Response.Status.NOT_FOUND)
|
|
.entity("{\"message\": \"Utilisateur non trouvé.\"}")
|
|
.build();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Force l'activation ou la suspension d'un utilisateur (réservé au super administrateur).
|
|
* Utilisé pour les managers : active = false = suspendu.
|
|
*
|
|
* @param id L'ID de l'utilisateur.
|
|
* @param request Le DTO contenant active (true = forcer l'activation, false = suspendre).
|
|
* @param apiKeyHeader Valeur du header X-Super-Admin-Key.
|
|
* @return L'utilisateur mis à jour.
|
|
*/
|
|
@PATCH
|
|
@Path("/{id}/active")
|
|
@Transactional
|
|
@Operation(summary = "Forcer activation ou suspendre un utilisateur (super admin)",
|
|
description = "Modifie le statut actif (isActive) d'un utilisateur. Réservé au super administrateur (header X-Super-Admin-Key).")
|
|
@APIResponse(responseCode = "200", description = "Statut actif mis à jour")
|
|
@APIResponse(responseCode = "403", description = "Clé super admin invalide ou absente")
|
|
@APIResponse(responseCode = "404", description = "Utilisateur non trouvé")
|
|
public Response setUserActive(
|
|
@PathParam("id") UUID id,
|
|
@Valid SetUserActiveRequestDTO request,
|
|
@HeaderParam(SUPER_ADMIN_KEY_HEADER) String apiKeyHeader) {
|
|
|
|
String key = superAdminApiKey.orElse("");
|
|
if (key.isBlank()) {
|
|
LOG.warn("Opération setUserActive refusée : afterwork.super-admin.api-key non configurée");
|
|
return Response.status(Response.Status.FORBIDDEN)
|
|
.entity("{\"message\": \"Opération non autorisée : clé super admin non configurée.\"}")
|
|
.build();
|
|
}
|
|
if (apiKeyHeader == null || !apiKeyHeader.equals(key)) {
|
|
LOG.warn("Opération setUserActive refusée : clé super admin invalide ou absente");
|
|
return Response.status(Response.Status.FORBIDDEN)
|
|
.entity("{\"message\": \"Clé super administrateur invalide ou absente.\"}")
|
|
.build();
|
|
}
|
|
|
|
try {
|
|
Users user = userService.setUserActive(id, request.getActive());
|
|
UserCreateResponseDTO responseDTO = new UserCreateResponseDTO(user);
|
|
return Response.ok(responseDTO).build();
|
|
} catch (UserNotFoundException e) {
|
|
return Response.status(Response.Status.NOT_FOUND)
|
|
.entity("{\"message\": \"" + e.getMessage() + "\"}")
|
|
.build();
|
|
}
|
|
}
|
|
|
|
}
|