Initial commit

src/main/java/dev/lions/btpxpress/presentation/controller/EmployeController.java

@@ -0,0 +1,423 @@
+package dev.lions.btpxpress.presentation.controller;
+
+import dev.lions.btpxpress.application.service.EmployeService;
+import dev.lions.btpxpress.domain.core.entity.Employe;
+import dev.lions.btpxpress.domain.core.entity.StatutEmploye;
+import jakarta.inject.Inject;
+import jakarta.validation.Valid;
+import jakarta.ws.rs.*;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import org.eclipse.microprofile.openapi.annotations.tags.Tag;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/** Controller REST pour la gestion des employés */
+@Path("/api/employes")
+@Produces(MediaType.APPLICATION_JSON)
+@Consumes(MediaType.APPLICATION_JSON)
+@Tag(name = "Employés", description = "Gestion des employés")
+public class EmployeController {
+
+  private static final Logger logger = LoggerFactory.getLogger(EmployeController.class);
+
+  @Inject EmployeService employeService;
+
+  /** Récupère tous les employés */
+  @GET
+  public Response getAllEmployes() {
+    try {
+      List<Employe> employes = employeService.findAll();
+      return Response.ok(employes).build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la récupération des employés", e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
+          .build();
+    }
+  }
+
+  /** Récupère un employé par son ID */
+  @GET
+  @Path("/{id}")
+  public Response getEmployeById(@PathParam("id") UUID id) {
+    try {
+      Optional<Employe> employeOpt = employeService.findById(id);
+      if (employeOpt.isEmpty()) {
+        return Response.status(Response.Status.NOT_FOUND)
+            .entity(Map.of("error", "Employé non trouvé"))
+            .build();
+      }
+      return Response.ok(employeOpt.get()).build();
+    } catch (NotFoundException e) {
+      return Response.status(Response.Status.NOT_FOUND)
+          .entity(Map.of("error", e.getMessage()))
+          .build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la récupération de l'employé: " + id, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la récupération de l'employé"))
+          .build();
+    }
+  }
+
+  /** Récupère les employés par statut */
+  @GET
+  @Path("/statut/{statut}")
+  public Response getEmployesByStatut(@PathParam("statut") StatutEmploye statut) {
+    try {
+      List<Employe> employes = employeService.findByStatut(statut);
+      return Response.ok(employes).build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la récupération des employés par statut: " + statut, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
+          .build();
+    }
+  }
+
+  /** Récupère les employés actifs */
+  @GET
+  @Path("/actifs")
+  public Response getEmployesActifs() {
+    try {
+      List<Employe> employes = employeService.findActifs();
+      return Response.ok(employes).build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la récupération des employés actifs", e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
+          .build();
+    }
+  }
+
+  /** Récupère un employé par email */
+  @GET
+  @Path("/email/{email}")
+  public Response getEmployeByEmail(@PathParam("email") String email) {
+    try {
+      Optional<Employe> employeOpt = employeService.findByEmail(email);
+      if (employeOpt.isEmpty()) {
+        return Response.status(Response.Status.NOT_FOUND)
+            .entity(Map.of("error", "Employé non trouvé"))
+            .build();
+      }
+      return Response.ok(employeOpt.get()).build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la récupération de l'employé par email: " + email, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la récupération de l'employé"))
+          .build();
+    }
+  }
+
+  /** Recherche des employés par nom ou prénom */
+  @GET
+  @Path("/search/nom")
+  public Response searchEmployesByNom(@QueryParam("nom") String searchTerm) {
+    try {
+      if (searchTerm == null || searchTerm.trim().isEmpty()) {
+        return Response.status(Response.Status.BAD_REQUEST)
+            .entity(Map.of("error", "Terme de recherche requis"))
+            .build();
+      }
+      List<Employe> employes = employeService.searchByNom(searchTerm);
+      return Response.ok(employes).build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la recherche par nom: " + searchTerm, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la recherche"))
+          .build();
+    }
+  }
+
+  /** Récupère les employés par métier */
+  @GET
+  @Path("/metier/{metier}")
+  public Response getEmployesByMetier(@PathParam("metier") String metier) {
+    try {
+      List<Employe> employes = employeService.findByMetier(metier);
+      return Response.ok(employes).build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la récupération des employés par métier: " + metier, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
+          .build();
+    }
+  }
+
+  /** Récupère les employés par équipe */
+  @GET
+  @Path("/equipe/{equipeId}")
+  public Response getEmployesByEquipe(@PathParam("equipeId") UUID equipeId) {
+    try {
+      List<Employe> employes = employeService.findByEquipe(equipeId);
+      return Response.ok(employes).build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la récupération des employés par équipe: " + equipeId, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
+          .build();
+    }
+  }
+
+  /** Récupère les employés disponibles pour une période */
+  @GET
+  @Path("/disponibles")
+  public Response getEmployesDisponibles(
+      @QueryParam("dateDebut") String dateDebut, @QueryParam("dateFin") String dateFin) {
+    try {
+      List<Employe> employes = employeService.findDisponibles(dateDebut, dateFin);
+      return Response.ok(employes).build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la récupération des employés disponibles", e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
+          .build();
+    }
+  }
+
+  /** Récupère les employés avec certifications */
+  @GET
+  @Path("/avec-certifications")
+  public Response getEmployesAvecCertifications() {
+    try {
+      List<Employe> employes = employeService.findAvecCertifications();
+      return Response.ok(employes).build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la récupération des employés avec certifications", e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
+          .build();
+    }
+  }
+
+  /** Récupère les employés par niveau d'expérience */
+  @GET
+  @Path("/experience/{niveau}")
+  public Response getEmployesByExperience(@PathParam("niveau") String niveau) {
+    try {
+      List<Employe> employes = employeService.findByNiveauExperience(niveau);
+      return Response.ok(employes).build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la récupération des employés par expérience: " + niveau, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
+          .build();
+    }
+  }
+
+  /** Crée un nouveau employé */
+  @POST
+  public Response createEmploye(@Valid Employe employe) {
+    try {
+      Employe nouvelEmploye = employeService.create(employe);
+      return Response.status(Response.Status.CREATED).entity(nouvelEmploye).build();
+    } catch (IllegalArgumentException e) {
+      return Response.status(Response.Status.BAD_REQUEST)
+          .entity(Map.of("error", e.getMessage()))
+          .build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la création de l'employé", e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la création de l'employé"))
+          .build();
+    }
+  }
+
+  /** Met à jour un employé */
+  @PUT
+  @Path("/{id}")
+  public Response updateEmploye(@PathParam("id") UUID id, @Valid Employe employeData) {
+    try {
+      Employe employe = employeService.update(id, employeData);
+      return Response.ok(employe).build();
+    } catch (NotFoundException e) {
+      return Response.status(Response.Status.NOT_FOUND)
+          .entity(Map.of("error", e.getMessage()))
+          .build();
+    } catch (IllegalArgumentException e) {
+      return Response.status(Response.Status.BAD_REQUEST)
+          .entity(Map.of("error", e.getMessage()))
+          .build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la mise à jour de l'employé: " + id, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la mise à jour de l'employé"))
+          .build();
+    }
+  }
+
+  /** Active un employé */
+  @POST
+  @Path("/{id}/activer")
+  public Response activerEmploye(@PathParam("id") UUID id) {
+    try {
+      Employe employe = employeService.activerEmploye(id);
+      return Response.ok(employe).build();
+    } catch (NotFoundException e) {
+      return Response.status(Response.Status.NOT_FOUND)
+          .entity(Map.of("error", e.getMessage()))
+          .build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de l'activation de l'employé: " + id, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de l'activation de l'employé"))
+          .build();
+    }
+  }
+
+  /** Désactive un employé */
+  @POST
+  @Path("/{id}/desactiver")
+  public Response desactiverEmploye(@PathParam("id") UUID id, Map<String, String> payload) {
+    try {
+      String motif = payload != null ? payload.get("motif") : null;
+      Employe employe = employeService.desactiverEmploye(id, motif);
+      return Response.ok(employe).build();
+    } catch (NotFoundException e) {
+      return Response.status(Response.Status.NOT_FOUND)
+          .entity(Map.of("error", e.getMessage()))
+          .build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la désactivation de l'employé: " + id, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la désactivation de l'employé"))
+          .build();
+    }
+  }
+
+  /** Affecte un employé à une équipe */
+  @POST
+  @Path("/{id}/affecter-equipe")
+  public Response affecterEquipe(@PathParam("id") UUID employeId, Map<String, Object> payload) {
+    try {
+      UUID equipeId =
+          payload.get("equipeId") != null
+              ? UUID.fromString(payload.get("equipeId").toString())
+              : null;
+
+      Employe employe = employeService.affecterEquipe(employeId, equipeId);
+      return Response.ok(employe).build();
+    } catch (NotFoundException e) {
+      return Response.status(Response.Status.NOT_FOUND)
+          .entity(Map.of("error", e.getMessage()))
+          .build();
+    } catch (IllegalArgumentException e) {
+      return Response.status(Response.Status.BAD_REQUEST)
+          .entity(Map.of("error", e.getMessage()))
+          .build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de l'affectation d'équipe: " + employeId, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de l'affectation d'équipe"))
+          .build();
+    }
+  }
+
+  /** Supprime un employé */
+  @DELETE
+  @Path("/{id}")
+  public Response deleteEmploye(@PathParam("id") UUID id) {
+    try {
+      employeService.delete(id);
+      return Response.noContent().build();
+    } catch (NotFoundException e) {
+      return Response.status(Response.Status.NOT_FOUND)
+          .entity(Map.of("error", e.getMessage()))
+          .build();
+    } catch (IllegalStateException e) {
+      return Response.status(Response.Status.BAD_REQUEST)
+          .entity(Map.of("error", e.getMessage()))
+          .build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la suppression de l'employé: " + id, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la suppression de l'employé"))
+          .build();
+    }
+  }
+
+  /** Recherche d'employés par multiple critères */
+  @GET
+  @Path("/search")
+  public Response searchEmployes(@QueryParam("term") String searchTerm) {
+    try {
+      if (searchTerm == null || searchTerm.trim().isEmpty()) {
+        return Response.status(Response.Status.BAD_REQUEST)
+            .entity(Map.of("error", "Terme de recherche requis"))
+            .build();
+      }
+      List<Employe> employes = employeService.searchEmployes(searchTerm);
+      return Response.ok(employes).build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la recherche d'employés: " + searchTerm, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la recherche"))
+          .build();
+    }
+  }
+
+  /** Récupère les statistiques des employés */
+  @GET
+  @Path("/statistiques")
+  public Response getStatistiques() {
+    try {
+      Map<String, Object> stats = employeService.getStatistiques();
+      return Response.ok(stats).build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la récupération des statistiques", e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la récupération des statistiques"))
+          .build();
+    }
+  }
+
+  /** Récupère le planning d'un employé */
+  @GET
+  @Path("/{id}/planning")
+  public Response getPlanningEmploye(
+      @PathParam("id") UUID id,
+      @QueryParam("dateDebut") String dateDebut,
+      @QueryParam("dateFin") String dateFin) {
+    try {
+      LocalDate debut = LocalDate.parse(dateDebut);
+      LocalDate fin = LocalDate.parse(dateFin);
+      List<Object> planning = employeService.getPlanningEmploye(id, debut, fin);
+      return Response.ok(planning).build();
+    } catch (NotFoundException e) {
+      return Response.status(Response.Status.NOT_FOUND)
+          .entity(Map.of("error", e.getMessage()))
+          .build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la récupération du planning: " + id, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la récupération du planning"))
+          .build();
+    }
+  }
+
+  /** Récupère les compétences d'un employé */
+  @GET
+  @Path("/{id}/competences")
+  public Response getCompetencesEmploye(@PathParam("id") UUID id) {
+    try {
+      List<Object> competences = employeService.getCompetencesEmploye(id);
+      return Response.ok(competences).build();
+    } catch (NotFoundException e) {
+      return Response.status(Response.Status.NOT_FOUND)
+          .entity(Map.of("error", e.getMessage()))
+          .build();
+    } catch (Exception e) {
+      logger.error("Erreur lors de la récupération des compétences: " + id, e);
+      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+          .entity(Map.of("error", "Erreur lors de la récupération des compétences"))
+          .build();
+    }
+  }
+}