feat: v2.0 – réorg docker/scripts, prod, résas, abonnements Wave, Flyway base vierge

src/main/java/com/lions/dev/resource/UsersResource.java

@@ -1,6 +1,7 @@
 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.UserAuthenticateRequestDTO;
 import com.lions.dev.dto.request.users.UserCreateRequestDTO;
 import com.lions.dev.dto.response.users.UserAuthenticateResponseDTO;
@@ -16,9 +17,11 @@ 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.io.File;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.UUID;
 import org.eclipse.microprofile.openapi.annotations.Operation;
 import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
@@ -39,8 +42,13 @@ public class UsersResource {
   @Inject
   UsersService userService;
 
+  @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.
    *
@@ -296,11 +304,11 @@ public class UsersResource {
       Users user = userService.findByEmail(request.getEmail());
 
       if (user != null) {
-        // TODO: Generer un token de reset et l'envoyer par email
-        // Pour l'instant, on retourne success pour ne pas reveler si l'email existe
-        // String resetToken = generateResetToken();
-        // emailService.sendPasswordResetEmail(user.getEmail(), resetToken);
-        LOG.info("Utilisateur trouve, email de reinitialisation devrait etre envoye : " + request.getEmail());
+        // En standby : pas encore de service d'envoi de mail. Quand disponible :
+        // - generer un token de reset (table dédiée ou champ user avec expiration)
+        // - appeler emailService.sendPasswordResetEmail(user.getEmail(), resetToken)
+        // Pour l'instant, on retourne success pour ne pas reveler si l'email existe.
+        LOG.info("Utilisateur trouve, email de reinitialisation (en standby - pas de mail service) : " + request.getEmail());
       } else {
         LOG.info("Aucun utilisateur trouve avec cet email (ne pas reveler) : " + request.getEmail());
       }
@@ -318,4 +326,98 @@ public class UsersResource {
     }
   }
 
+  /**
+   * 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 &lt;token&gt;) 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();
+    }
+  }
+
 }