Refactor: Backend Frontend-Centric Auth - Suppression OIDC, validation JWT
Architecture modifiée pour Frontend-Centric Authentication: 1. **Suppression des dépendances OIDC** - quarkus-oidc → quarkus-smallrye-jwt - quarkus-keycloak-authorization → quarkus-smallrye-jwt-build - Le backend ne gère plus l'authentification OAuth 2. **Configuration JWT simple** - Validation des tokens JWT envoyés par le frontend - mp.jwt.verify.publickey.location (JWKS de Keycloak) - mp.jwt.verify.issuer (Keycloak realm) - Authentification via Authorization: Bearer header 3. **Suppression configurations OIDC** - application.properties: Suppression %dev.quarkus.oidc.* - application.properties: Suppression %prod.quarkus.oidc.* - application-prod.properties: Remplacement par mp.jwt.* - Logging: io.quarkus.oidc → io.quarkus.smallrye.jwt 4. **Sécurité simplifiée** - quarkus.security.auth.proactive=false - @Authenticated sur les endpoints - CORS configuré pour le frontend - Endpoints publics: /q/*, /openapi, /swagger-ui/* Flux d'authentification: 1️⃣ Frontend → Keycloak (OAuth login) 2️⃣ Frontend ← Keycloak (access_token) 3️⃣ Frontend → Backend (Authorization: Bearer token) 4️⃣ Backend valide le token JWT (signature + issuer) 5️⃣ Backend → Frontend (données API) Avantages: ✅ Pas de secret backend à gérer ✅ Pas de client btpxpress-backend dans Keycloak ✅ Séparation claire frontend/backend ✅ Backend devient une API REST stateless ✅ Tokens gérés par le frontend (localStorage/sessionStorage) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
DahoudG
@@ -1,11 +1,11 @@
|
||||
package dev.lions.btpxpress;
|
||||
|
||||
import io.quarkus.runtime.Quarkus;
|
||||
import io.quarkus.runtime.annotations.QuarkusMain;
|
||||
|
||||
@QuarkusMain
|
||||
public class BtpXpressApplication {
|
||||
public static void main(String[] args) {
|
||||
Quarkus.run(args);
|
||||
}
|
||||
}
|
||||
package dev.lions.btpxpress;
|
||||
|
||||
import io.quarkus.runtime.Quarkus;
|
||||
import io.quarkus.runtime.annotations.QuarkusMain;
|
||||
|
||||
@QuarkusMain
|
||||
public class BtpXpressApplication {
|
||||
public static void main(String[] args) {
|
||||
Quarkus.run(args);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,359 @@
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.application.service.AbonnementService;
|
||||
import dev.lions.btpxpress.domain.core.entity.Abonnement;
|
||||
import dev.lions.btpxpress.domain.core.entity.StatutAbonnement;
|
||||
import dev.lions.btpxpress.domain.core.entity.TypeAbonnement;
|
||||
import io.quarkus.security.Authenticated;
|
||||
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.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
import org.eclipse.microprofile.openapi.annotations.Operation;
|
||||
import org.eclipse.microprofile.openapi.annotations.parameters.Parameter;
|
||||
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
|
||||
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* Resource REST pour la gestion des abonnements
|
||||
* Architecture 2025 : API complète pour la gestion des abonnements
|
||||
*/
|
||||
@Path("/api/v1/abonnements")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Abonnements", description = "Gestion des abonnements d'entreprise")
|
||||
public class AbonnementResource {
|
||||
|
||||
private static final Logger logger = LoggerFactory.getLogger(AbonnementResource.class);
|
||||
|
||||
@Inject AbonnementService abonnementService;
|
||||
|
||||
// === ENDPOINTS DE LECTURE ===
|
||||
|
||||
@GET
|
||||
@Operation(summary = "Récupérer tous les abonnements")
|
||||
@APIResponse(responseCode = "200", description = "Liste des abonnements récupérée avec succès")
|
||||
public Response getAllAbonnements(
|
||||
@Parameter(description = "Statut") @QueryParam("statut") String statut,
|
||||
@Parameter(description = "Type d'abonnement") @QueryParam("type") String type) {
|
||||
logger.debug("GET /abonnements - statut: {}, type: {}", statut, type);
|
||||
|
||||
List<Abonnement> abonnements;
|
||||
|
||||
if (statut != null && !statut.trim().isEmpty()) {
|
||||
try {
|
||||
StatutAbonnement statutEnum = StatutAbonnement.valueOf(statut.toUpperCase());
|
||||
abonnements = abonnementService.findByStatut(statutEnum);
|
||||
} catch (IllegalArgumentException e) {
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity(Map.of("error", "Statut invalide: " + statut))
|
||||
.build();
|
||||
}
|
||||
} else if (type != null && !type.trim().isEmpty()) {
|
||||
try {
|
||||
TypeAbonnement typeEnum = TypeAbonnement.valueOf(type.toUpperCase());
|
||||
abonnements = abonnementService.findByType(typeEnum);
|
||||
} catch (IllegalArgumentException e) {
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity(Map.of("error", "Type invalide: " + type))
|
||||
.build();
|
||||
}
|
||||
} else {
|
||||
abonnements = abonnementService.findAll();
|
||||
}
|
||||
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("abonnements", abonnements);
|
||||
response.put("total", abonnements.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/{id}")
|
||||
@Operation(summary = "Récupérer un abonnement par ID")
|
||||
@APIResponse(responseCode = "200", description = "Abonnement trouvé")
|
||||
@APIResponse(responseCode = "404", description = "Abonnement non trouvé")
|
||||
public Response getAbonnementById(@Parameter(description = "ID de l'abonnement") @PathParam("id") UUID id) {
|
||||
logger.debug("GET /abonnements/{}", id);
|
||||
Abonnement abonnement = abonnementService.findByIdRequired(id);
|
||||
return Response.ok(abonnement).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/actifs")
|
||||
@Operation(summary = "Récupérer tous les abonnements actifs")
|
||||
@APIResponse(responseCode = "200", description = "Liste des abonnements actifs")
|
||||
public Response getAbonnementsActifs() {
|
||||
logger.debug("GET /abonnements/actifs");
|
||||
List<Abonnement> abonnements = abonnementService.findActifs();
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("abonnements", abonnements);
|
||||
response.put("total", abonnements.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/expires")
|
||||
@Operation(summary = "Récupérer tous les abonnements expirés")
|
||||
@APIResponse(responseCode = "200", description = "Liste des abonnements expirés")
|
||||
public Response getAbonnementsExpires() {
|
||||
logger.debug("GET /abonnements/expires");
|
||||
List<Abonnement> abonnements = abonnementService.findExpires();
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("abonnements", abonnements);
|
||||
response.put("total", abonnements.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/bientot-expires")
|
||||
@Operation(summary = "Récupérer les abonnements qui arrivent à expiration")
|
||||
@APIResponse(responseCode = "200", description = "Liste des abonnements bientôt expirés")
|
||||
public Response getAbonnementsBientotExpires(
|
||||
@Parameter(description = "Nombre de jours") @QueryParam("jours") @DefaultValue("7") int jours) {
|
||||
logger.debug("GET /abonnements/bientot-expires - jours: {}", jours);
|
||||
List<Abonnement> abonnements = abonnementService.findBientotExpires(jours);
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("abonnements", abonnements);
|
||||
response.put("total", abonnements.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/entreprise/{entrepriseId}")
|
||||
@Operation(summary = "Récupérer l'abonnement actif d'une entreprise")
|
||||
@APIResponse(responseCode = "200", description = "Abonnement actif trouvé")
|
||||
@APIResponse(responseCode = "404", description = "Aucun abonnement actif pour cette entreprise")
|
||||
public Response getAbonnementActifByEntreprise(
|
||||
@Parameter(description = "ID de l'entreprise") @PathParam("entrepriseId") UUID entrepriseId) {
|
||||
logger.debug("GET /abonnements/entreprise/{}", entrepriseId);
|
||||
|
||||
return abonnementService
|
||||
.findAbonnementActifByEntreprise(entrepriseId)
|
||||
.map(abonnement -> Response.ok(abonnement).build())
|
||||
.orElse(
|
||||
Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Aucun abonnement actif pour cette entreprise"))
|
||||
.build());
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/entreprise/{entrepriseId}/historique")
|
||||
@Operation(summary = "Récupérer l'historique des abonnements d'une entreprise")
|
||||
@APIResponse(responseCode = "200", description = "Historique récupéré avec succès")
|
||||
public Response getHistoriqueByEntreprise(
|
||||
@Parameter(description = "ID de l'entreprise") @PathParam("entrepriseId") UUID entrepriseId) {
|
||||
logger.debug("GET /abonnements/entreprise/{}/historique", entrepriseId);
|
||||
List<Abonnement> abonnements = abonnementService.findByEntreprise(entrepriseId);
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("abonnements", abonnements);
|
||||
response.put("total", abonnements.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/statistics")
|
||||
@Operation(summary = "Récupérer les statistiques des abonnements")
|
||||
@APIResponse(responseCode = "200", description = "Statistiques récupérées avec succès")
|
||||
public Response getStatistics() {
|
||||
logger.debug("GET /abonnements/statistics");
|
||||
Map<String, Object> stats = abonnementService.getStatistics();
|
||||
return Response.ok(stats).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/plans")
|
||||
@Operation(summary = "Récupérer les plans tarifaires disponibles")
|
||||
@APIResponse(responseCode = "200", description = "Plans récupérés avec succès")
|
||||
public Response getPlans() {
|
||||
logger.debug("GET /abonnements/plans");
|
||||
Map<String, Object> plans = abonnementService.getPlans();
|
||||
return Response.ok(plans).build();
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE CRÉATION ===
|
||||
|
||||
@POST
|
||||
@Authenticated
|
||||
@Operation(summary = "Créer un nouvel abonnement")
|
||||
@APIResponse(responseCode = "201", description = "Abonnement créé avec succès")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides")
|
||||
@APIResponse(responseCode = "409", description = "Un abonnement actif existe déjà")
|
||||
public Response createAbonnement(@Valid @NotNull Abonnement abonnement) {
|
||||
logger.info("POST /abonnements - Création d'un abonnement");
|
||||
Abonnement created = abonnementService.create(abonnement);
|
||||
return Response.status(Response.Status.CREATED).entity(created).build();
|
||||
}
|
||||
|
||||
@POST
|
||||
@Path("/mensuel")
|
||||
@Authenticated
|
||||
@Operation(summary = "Créer un abonnement mensuel")
|
||||
@APIResponse(responseCode = "201", description = "Abonnement mensuel créé avec succès")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides")
|
||||
public Response createAbonnementMensuel(
|
||||
@Parameter(description = "ID de l'entreprise") @QueryParam("entrepriseId") @NotNull UUID entrepriseId,
|
||||
@Parameter(description = "Type d'abonnement") @QueryParam("type") @NotNull String type,
|
||||
@Parameter(description = "Méthode de paiement") @QueryParam("methodePaiement") String methodePaiement) {
|
||||
logger.info(
|
||||
"POST /abonnements/mensuel - entrepriseId: {}, type: {}", entrepriseId, type);
|
||||
|
||||
try {
|
||||
TypeAbonnement typeEnum = TypeAbonnement.valueOf(type.toUpperCase());
|
||||
Abonnement created =
|
||||
abonnementService.createAbonnementMensuel(entrepriseId, typeEnum, methodePaiement);
|
||||
return Response.status(Response.Status.CREATED).entity(created).build();
|
||||
} catch (IllegalArgumentException e) {
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity(Map.of("error", "Type d'abonnement invalide: " + type))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@POST
|
||||
@Path("/annuel")
|
||||
@Authenticated
|
||||
@Operation(summary = "Créer un abonnement annuel")
|
||||
@APIResponse(responseCode = "201", description = "Abonnement annuel créé avec succès")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides")
|
||||
public Response createAbonnementAnnuel(
|
||||
@Parameter(description = "ID de l'entreprise") @QueryParam("entrepriseId") @NotNull UUID entrepriseId,
|
||||
@Parameter(description = "Type d'abonnement") @QueryParam("type") @NotNull String type,
|
||||
@Parameter(description = "Méthode de paiement") @QueryParam("methodePaiement") String methodePaiement) {
|
||||
logger.info("POST /abonnements/annuel - entrepriseId: {}, type: {}", entrepriseId, type);
|
||||
|
||||
try {
|
||||
TypeAbonnement typeEnum = TypeAbonnement.valueOf(type.toUpperCase());
|
||||
Abonnement created =
|
||||
abonnementService.createAbonnementAnnuel(entrepriseId, typeEnum, methodePaiement);
|
||||
return Response.status(Response.Status.CREATED).entity(created).build();
|
||||
} catch (IllegalArgumentException e) {
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity(Map.of("error", "Type d'abonnement invalide: " + type))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE MISE À JOUR ===
|
||||
|
||||
@PUT
|
||||
@Path("/{id}")
|
||||
@Authenticated
|
||||
@Operation(summary = "Mettre à jour un abonnement")
|
||||
@APIResponse(responseCode = "200", description = "Abonnement mis à jour avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Abonnement non trouvé")
|
||||
public Response updateAbonnement(
|
||||
@Parameter(description = "ID de l'abonnement") @PathParam("id") UUID id,
|
||||
@Valid @NotNull Abonnement abonnementUpdate) {
|
||||
logger.info("PUT /abonnements/{}", id);
|
||||
Abonnement updated = abonnementService.update(id, abonnementUpdate);
|
||||
return Response.ok(updated).build();
|
||||
}
|
||||
|
||||
@POST
|
||||
@Path("/{id}/renouveler")
|
||||
@Authenticated
|
||||
@Operation(summary = "Renouveler un abonnement")
|
||||
@APIResponse(responseCode = "200", description = "Abonnement renouvelé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Abonnement non trouvé")
|
||||
public Response renouvelerAbonnement(
|
||||
@Parameter(description = "ID de l'abonnement") @PathParam("id") UUID id,
|
||||
@Parameter(description = "Renouvellement annuel") @QueryParam("annuel") @DefaultValue("false") boolean annuel) {
|
||||
logger.info("POST /abonnements/{}/renouveler - annuel: {}", id, annuel);
|
||||
Abonnement renewed = abonnementService.renouveler(id, annuel);
|
||||
return Response.ok(renewed).build();
|
||||
}
|
||||
|
||||
@PUT
|
||||
@Path("/{id}/changer-type")
|
||||
@Authenticated
|
||||
@Operation(summary = "Changer le type d'abonnement (upgrade/downgrade)")
|
||||
@APIResponse(responseCode = "200", description = "Type changé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Abonnement non trouvé")
|
||||
@APIResponse(responseCode = "400", description = "Type invalide")
|
||||
public Response changerType(
|
||||
@Parameter(description = "ID de l'abonnement") @PathParam("id") UUID id,
|
||||
@Parameter(description = "Nouveau type") @QueryParam("type") @NotNull String type) {
|
||||
logger.info("PUT /abonnements/{}/changer-type - nouveauType: {}", id, type);
|
||||
|
||||
try {
|
||||
TypeAbonnement typeEnum = TypeAbonnement.valueOf(type.toUpperCase());
|
||||
Abonnement updated = abonnementService.changerType(id, typeEnum);
|
||||
return Response.ok(updated).build();
|
||||
} catch (IllegalArgumentException e) {
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity(Map.of("error", "Type d'abonnement invalide: " + type))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@PUT
|
||||
@Path("/{id}/toggle-auto-renew")
|
||||
@Authenticated
|
||||
@Operation(summary = "Activer/désactiver le renouvellement automatique")
|
||||
@APIResponse(responseCode = "200", description = "Renouvellement automatique modifié")
|
||||
@APIResponse(responseCode = "404", description = "Abonnement non trouvé")
|
||||
public Response toggleAutoRenew(@Parameter(description = "ID de l'abonnement") @PathParam("id") UUID id) {
|
||||
logger.info("PUT /abonnements/{}/toggle-auto-renew", id);
|
||||
Abonnement updated = abonnementService.toggleAutoRenouvellement(id);
|
||||
return Response.ok(updated).build();
|
||||
}
|
||||
|
||||
@POST
|
||||
@Path("/{id}/annuler")
|
||||
@Authenticated
|
||||
@Operation(summary = "Annuler un abonnement")
|
||||
@APIResponse(responseCode = "204", description = "Abonnement annulé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Abonnement non trouvé")
|
||||
public Response annulerAbonnement(@Parameter(description = "ID de l'abonnement") @PathParam("id") UUID id) {
|
||||
logger.info("POST /abonnements/{}/annuler", id);
|
||||
abonnementService.annuler(id);
|
||||
return Response.status(Response.Status.NO_CONTENT).build();
|
||||
}
|
||||
|
||||
@POST
|
||||
@Path("/{id}/suspendre")
|
||||
@Authenticated
|
||||
@Operation(summary = "Suspendre un abonnement")
|
||||
@APIResponse(responseCode = "204", description = "Abonnement suspendu avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Abonnement non trouvé")
|
||||
public Response suspendreAbonnement(@Parameter(description = "ID de l'abonnement") @PathParam("id") UUID id) {
|
||||
logger.info("POST /abonnements/{}/suspendre", id);
|
||||
abonnementService.suspendre(id);
|
||||
return Response.status(Response.Status.NO_CONTENT).build();
|
||||
}
|
||||
|
||||
@POST
|
||||
@Path("/{id}/reactiver")
|
||||
@Authenticated
|
||||
@Operation(summary = "Réactiver un abonnement suspendu")
|
||||
@APIResponse(responseCode = "204", description = "Abonnement réactivé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Abonnement non trouvé")
|
||||
public Response reactiverAbonnement(@Parameter(description = "ID de l'abonnement") @PathParam("id") UUID id) {
|
||||
logger.info("POST /abonnements/{}/reactiver", id);
|
||||
abonnementService.reactiver(id);
|
||||
return Response.status(Response.Status.NO_CONTENT).build();
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE SUPPRESSION ===
|
||||
|
||||
@DELETE
|
||||
@Path("/{id}")
|
||||
@Authenticated
|
||||
@Operation(summary = "Supprimer définitivement un abonnement")
|
||||
@APIResponse(responseCode = "204", description = "Abonnement supprimé définitivement")
|
||||
@APIResponse(responseCode = "404", description = "Abonnement non trouvé")
|
||||
public Response deleteAbonnement(@Parameter(description = "ID de l'abonnement") @PathParam("id") UUID id) {
|
||||
logger.info("DELETE /abonnements/{}", id);
|
||||
abonnementService.deletePermanently(id);
|
||||
return Response.status(Response.Status.NO_CONTENT).build();
|
||||
}
|
||||
}
|
||||
@@ -9,6 +9,8 @@ import jakarta.ws.rs.core.Context;
|
||||
import jakarta.ws.rs.core.MediaType;
|
||||
import jakarta.ws.rs.core.Response;
|
||||
import jakarta.ws.rs.core.SecurityContext;
|
||||
import java.net.URLEncoder;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.security.Principal;
|
||||
import java.util.Map;
|
||||
import org.eclipse.microprofile.jwt.JsonWebToken;
|
||||
@@ -32,6 +34,52 @@ public class AuthResource {
|
||||
@Inject
|
||||
JsonWebToken jwt;
|
||||
|
||||
/**
|
||||
* Redirige vers Keycloak pour l'authentification
|
||||
* Architecture 2025 : Redirection directe vers https://security.lions.dev pour l'authentification
|
||||
*/
|
||||
@GET
|
||||
@Path("/login")
|
||||
@PermitAll
|
||||
@Operation(
|
||||
summary = "Initier l'authentification Keycloak",
|
||||
description = "Redirige l'utilisateur vers Keycloak (https://security.lions.dev) pour l'authentification OAuth2/OIDC")
|
||||
@APIResponse(responseCode = "302", description = "Redirection vers Keycloak pour authentification")
|
||||
public Response login(@Context SecurityContext securityContext) {
|
||||
try {
|
||||
logger.info("Redirection vers Keycloak pour authentification");
|
||||
|
||||
// Construction de l'URL Keycloak pour l'authentification
|
||||
String keycloakUrl = "https://security.lions.dev/realms/btpxpress/protocol/openid_connect/auth";
|
||||
String clientId = "btpxpress-backend";
|
||||
String redirectUri = "http://localhost:8080/api/v1/auth/callback"; // Peut être configuré dynamiquement
|
||||
String responseType = "code";
|
||||
String scope = "openid profile email";
|
||||
|
||||
// Construction de l'URL complète avec paramètres
|
||||
java.net.URI authUri = java.net.URI.create(
|
||||
String.format(
|
||||
"%s?client_id=%s&redirect_uri=%s&response_type=%s&scope=%s",
|
||||
keycloakUrl,
|
||||
clientId,
|
||||
URLEncoder.encode(redirectUri, StandardCharsets.UTF_8),
|
||||
responseType,
|
||||
URLEncoder.encode(scope, StandardCharsets.UTF_8)
|
||||
)
|
||||
);
|
||||
|
||||
logger.debug("Redirection vers Keycloak: {}", authUri);
|
||||
return Response.status(Response.Status.FOUND)
|
||||
.location(authUri)
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la redirection vers Keycloak", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la redirection vers Keycloak", "message", e.getMessage()))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Récupère les informations de l'utilisateur connecté depuis le token JWT
|
||||
*/
|
||||
|
||||
@@ -0,0 +1,337 @@
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.application.service.BonCommandeService;
|
||||
import dev.lions.btpxpress.domain.core.entity.BonCommande;
|
||||
import dev.lions.btpxpress.domain.core.entity.PrioriteBonCommande;
|
||||
import dev.lions.btpxpress.domain.core.entity.StatutBonCommande;
|
||||
import dev.lions.btpxpress.domain.core.entity.TypeBonCommande;
|
||||
import io.quarkus.security.Authenticated;
|
||||
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.time.LocalDate;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
import org.eclipse.microprofile.openapi.annotations.Operation;
|
||||
import org.eclipse.microprofile.openapi.annotations.parameters.Parameter;
|
||||
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
|
||||
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* Resource REST pour la gestion des bons de commande
|
||||
* Architecture 2025 : API complète pour la gestion des bons de commande BTP
|
||||
*/
|
||||
@Path("/api/v1/bons-commande")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Bons de Commande", description = "Gestion des bons de commande BTP")
|
||||
public class BonCommandeResource {
|
||||
|
||||
private static final Logger logger = LoggerFactory.getLogger(BonCommandeResource.class);
|
||||
|
||||
@Inject BonCommandeService bonCommandeService;
|
||||
|
||||
// === ENDPOINTS DE LECTURE - ARCHITECTURE 2025 ===
|
||||
|
||||
@GET
|
||||
@Operation(summary = "Récupérer tous les bons de commande", description = "Retourne la liste complète des bons de commande")
|
||||
@APIResponse(responseCode = "200", description = "Liste des bons de commande récupérée avec succès")
|
||||
public Response getAllBonsCommande() {
|
||||
logger.debug("GET /bons-commande");
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findAll();
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("bonsCommande", bonsCommande);
|
||||
response.put("total", bonsCommande.size());
|
||||
return Response.ok(response).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des bons de commande", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande", "message", e.getMessage()))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/{id}")
|
||||
@Operation(summary = "Récupérer un bon de commande par ID", description = "Retourne les détails d'un bon de commande")
|
||||
@APIResponse(responseCode = "200", description = "Bon de commande trouvé")
|
||||
@APIResponse(responseCode = "404", description = "Bon de commande non trouvé")
|
||||
public Response getBonCommandeById(@Parameter(description = "ID du bon de commande") @PathParam("id") UUID id) {
|
||||
logger.debug("GET /bons-commande/{}", id);
|
||||
try {
|
||||
BonCommande bonCommande = bonCommandeService.findById(id);
|
||||
return Response.ok(bonCommande).build();
|
||||
} catch (jakarta.ws.rs.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 bon de commande: {}", id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/numero/{numero}")
|
||||
@Operation(summary = "Récupérer un bon de commande par numéro", description = "Recherche un bon de commande par son numéro")
|
||||
@APIResponse(responseCode = "200", description = "Bon de commande trouvé")
|
||||
@APIResponse(responseCode = "404", description = "Bon de commande non trouvé")
|
||||
public Response getBonCommandeByNumero(@Parameter(description = "Numéro du bon de commande") @PathParam("numero") String numero) {
|
||||
logger.debug("GET /bons-commande/numero/{}", numero);
|
||||
try {
|
||||
BonCommande bonCommande = bonCommandeService.findByNumero(numero);
|
||||
if (bonCommande == null) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Bon de commande non trouvé"))
|
||||
.build();
|
||||
}
|
||||
return Response.ok(bonCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération du bon de commande par numéro: {}", numero, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/statut/{statut}")
|
||||
@Operation(summary = "Récupérer les bons de commande par statut", description = "Filtre les bons de commande par statut")
|
||||
@APIResponse(responseCode = "200", description = "Liste des bons de commande filtrés")
|
||||
public Response getBonsCommandeByStatut(@Parameter(description = "Statut du bon de commande") @PathParam("statut") StatutBonCommande statut) {
|
||||
logger.debug("GET /bons-commande/statut/{}", statut);
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findByStatut(statut);
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("bonsCommande", bonsCommande);
|
||||
response.put("total", bonsCommande.size());
|
||||
return Response.ok(response).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des bons de commande par statut: {}", statut, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/urgents")
|
||||
@Operation(summary = "Récupérer les bons de commande urgents", description = "Liste les bons de commande prioritaires")
|
||||
@APIResponse(responseCode = "200", description = "Liste des bons de commande urgents")
|
||||
public Response getBonsCommandeUrgents() {
|
||||
logger.debug("GET /bons-commande/urgents");
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findUrgents();
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("bonsCommande", bonsCommande);
|
||||
response.put("total", bonsCommande.size());
|
||||
return Response.ok(response).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des bons de commande urgents", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/search")
|
||||
@Operation(summary = "Rechercher des bons de commande", description = "Recherche textuelle dans les bons de commande")
|
||||
@APIResponse(responseCode = "200", description = "Résultats de recherche")
|
||||
@APIResponse(responseCode = "400", description = "Terme de recherche requis")
|
||||
public Response searchBonsCommande(@Parameter(description = "Terme de recherche") @QueryParam("term") String searchTerm) {
|
||||
logger.debug("GET /bons-commande/search - term: {}", 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<BonCommande> bonsCommande = bonCommandeService.searchCommandes(searchTerm);
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("bonsCommande", bonsCommande);
|
||||
response.put("total", bonsCommande.size());
|
||||
return Response.ok(response).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la recherche de bons de commande: {}", searchTerm, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la recherche"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/statistiques")
|
||||
@Operation(summary = "Récupérer les statistiques des bons de commande", description = "Retourne des statistiques globales")
|
||||
@APIResponse(responseCode = "200", description = "Statistiques récupérées avec succès")
|
||||
public Response getStatistiques() {
|
||||
logger.debug("GET /bons-commande/statistiques");
|
||||
try {
|
||||
Map<String, Object> stats = bonCommandeService.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();
|
||||
}
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE CRÉATION - ARCHITECTURE 2025 ===
|
||||
|
||||
@POST
|
||||
@Authenticated
|
||||
@Operation(summary = "Créer un nouveau bon de commande", description = "Crée un nouveau bon de commande")
|
||||
@APIResponse(responseCode = "201", description = "Bon de commande créé avec succès")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides")
|
||||
public Response createBonCommande(@Valid @NotNull BonCommande bonCommande) {
|
||||
logger.info("POST /bons-commande - Création d'un bon de commande");
|
||||
try {
|
||||
BonCommande nouveauBonCommande = bonCommandeService.create(bonCommande);
|
||||
return Response.status(Response.Status.CREATED).entity(nouveauBonCommande).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 du bon de commande", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la création du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE MISE À JOUR - ARCHITECTURE 2025 ===
|
||||
|
||||
@PUT
|
||||
@Path("/{id}")
|
||||
@Authenticated
|
||||
@Operation(summary = "Mettre à jour un bon de commande", description = "Met à jour les informations d'un bon de commande")
|
||||
@APIResponse(responseCode = "200", description = "Bon de commande mis à jour avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Bon de commande non trouvé")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides")
|
||||
public Response updateBonCommande(
|
||||
@Parameter(description = "ID du bon de commande") @PathParam("id") UUID id,
|
||||
@Valid @NotNull BonCommande bonCommandeData) {
|
||||
logger.info("PUT /bons-commande/{} - Mise à jour", id);
|
||||
try {
|
||||
BonCommande bonCommande = bonCommandeService.update(id, bonCommandeData);
|
||||
return Response.ok(bonCommande).build();
|
||||
} catch (jakarta.ws.rs.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 du bon de commande: {}", id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la mise à jour du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@POST
|
||||
@Path("/{id}/valider")
|
||||
@Authenticated
|
||||
@Operation(summary = "Valider un bon de commande", description = "Valide un bon de commande en attente")
|
||||
@APIResponse(responseCode = "200", description = "Bon de commande validé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Bon de commande non trouvé")
|
||||
@APIResponse(responseCode = "400", description = "Le bon de commande ne peut pas être validé")
|
||||
public Response validerBonCommande(
|
||||
@Parameter(description = "ID du bon de commande") @PathParam("id") UUID id,
|
||||
Map<String, String> payload) {
|
||||
logger.info("POST /bons-commande/{}/valider", id);
|
||||
try {
|
||||
String commentaires = payload != null ? payload.get("commentaires") : null;
|
||||
BonCommande bonCommande = bonCommandeService.validerBonCommande(id, commentaires);
|
||||
return Response.ok(bonCommande).build();
|
||||
} catch (jakarta.ws.rs.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 validation du bon de commande: {}", id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la validation du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@POST
|
||||
@Path("/{id}/annuler")
|
||||
@Authenticated
|
||||
@Operation(summary = "Annuler un bon de commande", description = "Annule un bon de commande")
|
||||
@APIResponse(responseCode = "200", description = "Bon de commande annulé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Bon de commande non trouvé")
|
||||
@APIResponse(responseCode = "400", description = "Le bon de commande ne peut pas être annulé")
|
||||
public Response annulerBonCommande(
|
||||
@Parameter(description = "ID du bon de commande") @PathParam("id") UUID id,
|
||||
Map<String, String> payload) {
|
||||
logger.info("POST /bons-commande/{}/annuler", id);
|
||||
try {
|
||||
String motif = payload != null ? payload.get("motif") : null;
|
||||
BonCommande bonCommande = bonCommandeService.annulerBonCommande(id, motif);
|
||||
return Response.ok(bonCommande).build();
|
||||
} catch (jakarta.ws.rs.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 l'annulation du bon de commande: {}", id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de l'annulation du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE SUPPRESSION - ARCHITECTURE 2025 ===
|
||||
|
||||
@DELETE
|
||||
@Path("/{id}")
|
||||
@Authenticated
|
||||
@Operation(summary = "Supprimer un bon de commande", description = "Supprime un bon de commande")
|
||||
@APIResponse(responseCode = "204", description = "Bon de commande supprimé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Bon de commande non trouvé")
|
||||
public Response deleteBonCommande(@Parameter(description = "ID du bon de commande") @PathParam("id") UUID id) {
|
||||
logger.info("DELETE /bons-commande/{}", id);
|
||||
try {
|
||||
bonCommandeService.delete(id);
|
||||
return Response.noContent().build();
|
||||
} catch (jakarta.ws.rs.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 du bon de commande: {}", id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la suppression du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
package dev.lions.btpxpress.presentation.rest;
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.application.service.ComparaisonFournisseurService;
|
||||
import dev.lions.btpxpress.domain.core.entity.*;
|
||||
@@ -0,0 +1,322 @@
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.application.service.EntrepriseProfileService;
|
||||
import dev.lions.btpxpress.domain.core.entity.EntrepriseProfile;
|
||||
import dev.lions.btpxpress.domain.core.entity.TypeAbonnement;
|
||||
import io.quarkus.security.Authenticated;
|
||||
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.math.BigDecimal;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
import org.eclipse.microprofile.openapi.annotations.Operation;
|
||||
import org.eclipse.microprofile.openapi.annotations.parameters.Parameter;
|
||||
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
|
||||
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* Resource REST pour la gestion des profils d'entreprise
|
||||
* Architecture 2025 : API complète pour la gestion des profils d'entreprise et leurs notations
|
||||
*/
|
||||
@Path("/api/v1/entreprise-profiles")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Profils d'Entreprise", description = "Gestion des profils d'entreprise")
|
||||
public class EntrepriseProfileResource {
|
||||
|
||||
private static final Logger logger =
|
||||
LoggerFactory.getLogger(EntrepriseProfileResource.class);
|
||||
|
||||
@Inject EntrepriseProfileService entrepriseProfileService;
|
||||
|
||||
// === ENDPOINTS DE LECTURE - ARCHITECTURE 2025 ===
|
||||
|
||||
@GET
|
||||
@Operation(
|
||||
summary = "Récupérer tous les profils d'entreprise visibles",
|
||||
description = "Retourne la liste complète des profils d'entreprise visibles, triés par note")
|
||||
@APIResponse(responseCode = "200", description = "Liste des profils récupérée avec succès")
|
||||
public Response getAllProfiles(
|
||||
@Parameter(description = "Numéro de page (0-based)") @QueryParam("page")
|
||||
@DefaultValue("0")
|
||||
int page,
|
||||
@Parameter(description = "Taille de la page") @QueryParam("size") @DefaultValue("20")
|
||||
int size) {
|
||||
logger.debug("GET /entreprise-profiles - page: {}, size: {}", page, size);
|
||||
|
||||
List<EntrepriseProfile> profiles;
|
||||
if (page == 0 && size == 20) {
|
||||
profiles = entrepriseProfileService.findAll();
|
||||
} else {
|
||||
profiles = entrepriseProfileService.findAll(page, size);
|
||||
}
|
||||
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("profiles", profiles);
|
||||
response.put("total", profiles.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/{id}")
|
||||
@Operation(
|
||||
summary = "Récupérer un profil d'entreprise par ID",
|
||||
description = "Retourne les détails complets d'un profil d'entreprise")
|
||||
@APIResponse(responseCode = "200", description = "Profil trouvé")
|
||||
@APIResponse(responseCode = "404", description = "Profil non trouvé")
|
||||
public Response getProfileById(@Parameter(description = "ID du profil") @PathParam("id") UUID id) {
|
||||
logger.debug("GET /entreprise-profiles/{}", id);
|
||||
|
||||
EntrepriseProfile profile = entrepriseProfileService.findByIdRequired(id);
|
||||
return Response.ok(profile).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/search")
|
||||
@Operation(
|
||||
summary = "Rechercher des profils d'entreprise",
|
||||
description = "Recherche textuelle complète dans les profils")
|
||||
@APIResponse(responseCode = "200", description = "Résultats de recherche")
|
||||
public Response searchProfiles(
|
||||
@Parameter(description = "Terme de recherche") @QueryParam("q") String searchTerm,
|
||||
@Parameter(description = "Zone d'intervention") @QueryParam("zone") String zone,
|
||||
@Parameter(description = "Spécialité") @QueryParam("specialite") String specialite,
|
||||
@Parameter(description = "Région") @QueryParam("region") String region,
|
||||
@Parameter(description = "Ville") @QueryParam("ville") String ville,
|
||||
@Parameter(description = "Certifié uniquement") @QueryParam("certifie") Boolean certifie,
|
||||
@Parameter(description = "Type d'abonnement") @QueryParam("typeAbonnement")
|
||||
TypeAbonnement typeAbonnement) {
|
||||
logger.debug(
|
||||
"GET /entreprise-profiles/search - q: {}, zone: {}, specialite: {}, region: {}, ville: {}, certifie: {}",
|
||||
searchTerm,
|
||||
zone,
|
||||
specialite,
|
||||
region,
|
||||
ville,
|
||||
certifie);
|
||||
|
||||
List<EntrepriseProfile> profiles;
|
||||
|
||||
// Recherche par terme de recherche complet
|
||||
if (searchTerm != null && !searchTerm.trim().isEmpty()) {
|
||||
profiles = entrepriseProfileService.searchFullText(searchTerm);
|
||||
}
|
||||
// Recherche par zone d'intervention
|
||||
else if (zone != null && !zone.trim().isEmpty()) {
|
||||
profiles = entrepriseProfileService.findByZoneIntervention(zone);
|
||||
}
|
||||
// Recherche par spécialité
|
||||
else if (specialite != null && !specialite.trim().isEmpty()) {
|
||||
profiles = entrepriseProfileService.findBySpecialite(specialite);
|
||||
}
|
||||
// Recherche par région
|
||||
else if (region != null && !region.trim().isEmpty()) {
|
||||
profiles = entrepriseProfileService.findByRegion(region);
|
||||
}
|
||||
// Recherche par ville
|
||||
else if (ville != null && !ville.trim().isEmpty()) {
|
||||
profiles = entrepriseProfileService.findByVille(ville);
|
||||
}
|
||||
// Recherche par certification
|
||||
else if (certifie != null) {
|
||||
profiles = entrepriseProfileService.findByCertifie(certifie);
|
||||
}
|
||||
// Recherche par type d'abonnement
|
||||
else if (typeAbonnement != null) {
|
||||
profiles = entrepriseProfileService.findByTypeAbonnement(typeAbonnement);
|
||||
}
|
||||
// Par défaut, retourner tous les profils
|
||||
else {
|
||||
profiles = entrepriseProfileService.findAll();
|
||||
}
|
||||
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("profiles", profiles);
|
||||
response.put("total", profiles.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/top-rated")
|
||||
@Operation(
|
||||
summary = "Récupérer les profils les mieux notés",
|
||||
description = "Retourne les profils d'entreprise avec les meilleures notes")
|
||||
@APIResponse(responseCode = "200", description = "Liste des profils les mieux notés")
|
||||
public Response getTopRated(
|
||||
@Parameter(description = "Nombre de profils à retourner") @QueryParam("limit")
|
||||
@DefaultValue("10")
|
||||
int limit) {
|
||||
logger.debug("GET /entreprise-profiles/top-rated - limit: {}", limit);
|
||||
|
||||
List<EntrepriseProfile> profiles = entrepriseProfileService.findTopRated(limit);
|
||||
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("profiles", profiles);
|
||||
response.put("total", profiles.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/statistics")
|
||||
@Operation(
|
||||
summary = "Récupérer les statistiques des profils",
|
||||
description = "Retourne des statistiques globales sur les profils d'entreprise")
|
||||
@APIResponse(responseCode = "200", description = "Statistiques récupérées avec succès")
|
||||
public Response getStatistics() {
|
||||
logger.debug("GET /entreprise-profiles/statistics");
|
||||
|
||||
Map<String, Object> stats = entrepriseProfileService.getStatistics();
|
||||
return Response.ok(stats).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/user/{userId}")
|
||||
@Operation(
|
||||
summary = "Récupérer le profil d'un utilisateur",
|
||||
description = "Retourne le profil d'entreprise associé à un utilisateur")
|
||||
@APIResponse(responseCode = "200", description = "Profil trouvé")
|
||||
@APIResponse(responseCode = "404", description = "Profil non trouvé pour cet utilisateur")
|
||||
public Response getProfileByUserId(
|
||||
@Parameter(description = "ID de l'utilisateur") @PathParam("userId") UUID userId) {
|
||||
logger.debug("GET /entreprise-profiles/user/{}", userId);
|
||||
|
||||
return entrepriseProfileService
|
||||
.findByUserId(userId)
|
||||
.map(profile -> Response.ok(profile).build())
|
||||
.orElse(Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Profil non trouvé pour cet utilisateur"))
|
||||
.build());
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE CRÉATION - ARCHITECTURE 2025 ===
|
||||
|
||||
@POST
|
||||
@Authenticated
|
||||
@Operation(
|
||||
summary = "Créer un nouveau profil d'entreprise",
|
||||
description = "Crée un nouveau profil d'entreprise pour un utilisateur")
|
||||
@APIResponse(responseCode = "201", description = "Profil créé avec succès")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides")
|
||||
@APIResponse(responseCode = "409", description = "Un profil existe déjà pour cet utilisateur")
|
||||
public Response createProfile(@Valid @NotNull EntrepriseProfile profile) {
|
||||
logger.info("POST /entreprise-profiles - Création d'un profil: {}", profile.getNomCommercial());
|
||||
|
||||
EntrepriseProfile created = entrepriseProfileService.create(profile);
|
||||
return Response.status(Response.Status.CREATED).entity(created).build();
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE MISE À JOUR - ARCHITECTURE 2025 ===
|
||||
|
||||
@PUT
|
||||
@Path("/{id}")
|
||||
@Authenticated
|
||||
@Operation(
|
||||
summary = "Mettre à jour un profil d'entreprise",
|
||||
description = "Met à jour les informations d'un profil d'entreprise existant")
|
||||
@APIResponse(responseCode = "200", description = "Profil mis à jour avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Profil non trouvé")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides")
|
||||
public Response updateProfile(
|
||||
@Parameter(description = "ID du profil") @PathParam("id") UUID id,
|
||||
@Valid @NotNull EntrepriseProfile profileUpdate) {
|
||||
logger.info("PUT /entreprise-profiles/{} - Mise à jour", id);
|
||||
|
||||
EntrepriseProfile updated = entrepriseProfileService.update(id, profileUpdate);
|
||||
return Response.ok(updated).build();
|
||||
}
|
||||
|
||||
@PUT
|
||||
@Path("/{id}/note")
|
||||
@Authenticated
|
||||
@Operation(
|
||||
summary = "Mettre à jour la note d'un profil",
|
||||
description = "Met à jour la note globale et le nombre d'avis d'un profil")
|
||||
@APIResponse(responseCode = "200", description = "Note mise à jour avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Profil non trouvé")
|
||||
public Response updateNote(
|
||||
@Parameter(description = "ID du profil") @PathParam("id") UUID id,
|
||||
@Parameter(description = "Nouvelle note globale") @QueryParam("note")
|
||||
@NotNull
|
||||
BigDecimal note,
|
||||
@Parameter(description = "Nouveau nombre d'avis") @QueryParam("nombreAvis")
|
||||
@DefaultValue("0")
|
||||
int nombreAvis) {
|
||||
logger.info("PUT /entreprise-profiles/{}/note - note: {}, nombreAvis: {}", id, note, nombreAvis);
|
||||
|
||||
EntrepriseProfile updated = entrepriseProfileService.updateNote(id, note, nombreAvis);
|
||||
return Response.ok(updated).build();
|
||||
}
|
||||
|
||||
@PUT
|
||||
@Path("/{id}/increment-projects")
|
||||
@Authenticated
|
||||
@Operation(
|
||||
summary = "Incrémenter le nombre de projets réalisés",
|
||||
description = "Incrémente le compteur de projets réalisés pour un profil")
|
||||
@APIResponse(responseCode = "200", description = "Compteur incrémenté avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Profil non trouvé")
|
||||
public Response incrementProjects(
|
||||
@Parameter(description = "ID du profil") @PathParam("id") UUID id) {
|
||||
logger.debug("PUT /entreprise-profiles/{}/increment-projects", id);
|
||||
|
||||
EntrepriseProfile updated = entrepriseProfileService.incrementerProjets(id);
|
||||
return Response.ok(updated).build();
|
||||
}
|
||||
|
||||
@PUT
|
||||
@Path("/{id}/increment-clients")
|
||||
@Authenticated
|
||||
@Operation(
|
||||
summary = "Incrémenter le nombre de clients servis",
|
||||
description = "Incrémente le compteur de clients servis pour un profil")
|
||||
@APIResponse(responseCode = "200", description = "Compteur incrémenté avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Profil non trouvé")
|
||||
public Response incrementClients(@Parameter(description = "ID du profil") @PathParam("id") UUID id) {
|
||||
logger.debug("PUT /entreprise-profiles/{}/increment-clients", id);
|
||||
|
||||
EntrepriseProfile updated = entrepriseProfileService.incrementerClients(id);
|
||||
return Response.ok(updated).build();
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE SUPPRESSION - ARCHITECTURE 2025 ===
|
||||
|
||||
@DELETE
|
||||
@Path("/{id}")
|
||||
@Authenticated
|
||||
@Operation(
|
||||
summary = "Supprimer un profil d'entreprise",
|
||||
description = "Supprime (désactive) un profil d'entreprise")
|
||||
@APIResponse(responseCode = "204", description = "Profil supprimé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Profil non trouvé")
|
||||
public Response deleteProfile(@Parameter(description = "ID du profil") @PathParam("id") UUID id) {
|
||||
logger.info("DELETE /entreprise-profiles/{}", id);
|
||||
|
||||
entrepriseProfileService.delete(id);
|
||||
return Response.status(Response.Status.NO_CONTENT).build();
|
||||
}
|
||||
|
||||
@DELETE
|
||||
@Path("/{id}/permanent")
|
||||
@Authenticated
|
||||
@Operation(
|
||||
summary = "Supprimer définitivement un profil",
|
||||
description = "Supprime définitivement un profil d'entreprise de la base de données")
|
||||
@APIResponse(responseCode = "204", description = "Profil supprimé définitivement")
|
||||
@APIResponse(responseCode = "404", description = "Profil non trouvé")
|
||||
public Response deleteProfilePermanently(
|
||||
@Parameter(description = "ID du profil") @PathParam("id") UUID id) {
|
||||
logger.info("DELETE /entreprise-profiles/{}/permanent", id);
|
||||
|
||||
entrepriseProfileService.deletePermanently(id);
|
||||
return Response.status(Response.Status.NO_CONTENT).build();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,200 +1,194 @@
|
||||
package dev.lions.btpxpress.application.rest;
|
||||
|
||||
import dev.lions.btpxpress.application.service.FournisseurService;
|
||||
import dev.lions.btpxpress.domain.core.entity.Fournisseur;
|
||||
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 org.eclipse.microprofile.openapi.annotations.Operation;
|
||||
import org.eclipse.microprofile.openapi.annotations.parameters.Parameter;
|
||||
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
|
||||
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* API REST pour la gestion des fournisseurs BTP
|
||||
* Expose les fonctionnalités de création, consultation et administration des fournisseurs
|
||||
*/
|
||||
@Path("/api/v1/fournisseurs")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Fournisseurs", description = "Gestion des fournisseurs BTP")
|
||||
public class FournisseurResource {
|
||||
|
||||
@Inject
|
||||
FournisseurService fournisseurService;
|
||||
|
||||
// ===================================
|
||||
// CONSULTATION DES FOURNISSEURS
|
||||
// ===================================
|
||||
|
||||
@GET
|
||||
@Operation(summary = "Récupère tous les fournisseurs")
|
||||
@APIResponse(responseCode = "200", description = "Liste des fournisseurs")
|
||||
public Response getAllFournisseurs(
|
||||
@QueryParam("page") @DefaultValue("0") int page,
|
||||
@QueryParam("size") @DefaultValue("10") int size,
|
||||
@QueryParam("search") String search) {
|
||||
try {
|
||||
List<Fournisseur> fournisseurs;
|
||||
if (search != null && !search.trim().isEmpty()) {
|
||||
fournisseurs = fournisseurService.searchFournisseurs(search);
|
||||
} else {
|
||||
fournisseurs = fournisseurService.getAllFournisseurs(page, size);
|
||||
}
|
||||
return Response.ok(fournisseurs).build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des fournisseurs"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/{id}")
|
||||
@Operation(summary = "Récupère un fournisseur par ID")
|
||||
@APIResponse(responseCode = "200", description = "Fournisseur trouvé")
|
||||
@APIResponse(responseCode = "404", description = "Fournisseur non trouvé")
|
||||
public Response getFournisseurById(
|
||||
@Parameter(description = "ID du fournisseur") @PathParam("id") UUID id) {
|
||||
try {
|
||||
Fournisseur fournisseur = fournisseurService.getFournisseurById(id);
|
||||
return Response.ok(fournisseur).build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Fournisseur non trouvé"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/search")
|
||||
@Operation(summary = "Recherche des fournisseurs")
|
||||
@APIResponse(responseCode = "200", description = "Résultats de la recherche")
|
||||
public Response searchFournisseurs(@QueryParam("q") String query) {
|
||||
try {
|
||||
List<Fournisseur> fournisseurs = fournisseurService.searchFournisseurs(query);
|
||||
return Response.ok(fournisseurs).build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la recherche"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/stats")
|
||||
@Operation(summary = "Récupère les statistiques des fournisseurs")
|
||||
@APIResponse(responseCode = "200", description = "Statistiques des fournisseurs")
|
||||
public Response getFournisseurStats() {
|
||||
try {
|
||||
Map<String, Object> stats = fournisseurService.getFournisseurStats();
|
||||
return Response.ok(stats).build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors du calcul des statistiques"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
// ===================================
|
||||
// CRÉATION ET MODIFICATION
|
||||
// ===================================
|
||||
|
||||
@POST
|
||||
@Operation(summary = "Crée un nouveau fournisseur")
|
||||
@APIResponse(responseCode = "201", description = "Fournisseur créé avec succès")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides")
|
||||
@APIResponse(responseCode = "409", description = "Conflit - fournisseur existant")
|
||||
public Response createFournisseur(@Valid Fournisseur fournisseur) {
|
||||
try {
|
||||
Fournisseur created = fournisseurService.createFournisseur(fournisseur);
|
||||
return Response.status(Response.Status.CREATED)
|
||||
.entity(created)
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity(Map.of("error", "Erreur lors de la création du fournisseur"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@PUT
|
||||
@Path("/{id}")
|
||||
@Operation(summary = "Met à jour un fournisseur existant")
|
||||
@APIResponse(responseCode = "200", description = "Fournisseur mis à jour avec succès")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides")
|
||||
@APIResponse(responseCode = "404", description = "Fournisseur non trouvé")
|
||||
public Response updateFournisseur(
|
||||
@Parameter(description = "ID du fournisseur") @PathParam("id") UUID id,
|
||||
@Valid Fournisseur fournisseur) {
|
||||
try {
|
||||
Fournisseur updated = fournisseurService.updateFournisseur(id, fournisseur);
|
||||
return Response.ok(updated).build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Fournisseur non trouvé"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@DELETE
|
||||
@Path("/{id}")
|
||||
@Operation(summary = "Supprime un fournisseur")
|
||||
@APIResponse(responseCode = "204", description = "Fournisseur supprimé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Fournisseur non trouvé")
|
||||
public Response deleteFournisseur(
|
||||
@Parameter(description = "ID du fournisseur") @PathParam("id") UUID id) {
|
||||
try {
|
||||
fournisseurService.deleteFournisseur(id);
|
||||
return Response.noContent().build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Fournisseur non trouvé"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
// ===================================
|
||||
// GESTION DES STATUTS
|
||||
// ===================================
|
||||
|
||||
@PUT
|
||||
@Path("/{id}/activate")
|
||||
@Operation(summary = "Active un fournisseur")
|
||||
@APIResponse(responseCode = "200", description = "Fournisseur activé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Fournisseur non trouvé")
|
||||
public Response activateFournisseur(
|
||||
@Parameter(description = "ID du fournisseur") @PathParam("id") UUID id) {
|
||||
try {
|
||||
fournisseurService.activateFournisseur(id);
|
||||
return Response.ok(Map.of("message", "Fournisseur activé avec succès")).build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Fournisseur non trouvé"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@PUT
|
||||
@Path("/{id}/deactivate")
|
||||
@Operation(summary = "Désactive un fournisseur")
|
||||
@APIResponse(responseCode = "200", description = "Fournisseur désactivé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Fournisseur non trouvé")
|
||||
public Response deactivateFournisseur(
|
||||
@Parameter(description = "ID du fournisseur") @PathParam("id") UUID id) {
|
||||
try {
|
||||
fournisseurService.deactivateFournisseur(id);
|
||||
return Response.ok(Map.of("message", "Fournisseur désactivé avec succès")).build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Fournisseur non trouvé"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
}
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.application.service.FournisseurService;
|
||||
import dev.lions.btpxpress.domain.core.entity.Fournisseur;
|
||||
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 org.eclipse.microprofile.openapi.annotations.Operation;
|
||||
import org.eclipse.microprofile.openapi.annotations.parameters.Parameter;
|
||||
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
|
||||
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Resource REST pour la gestion des fournisseurs BTP
|
||||
* Architecture 2025 : API complète pour la gestion des fournisseurs
|
||||
*/
|
||||
@Path("/api/v1/fournisseurs")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Fournisseurs", description = "Gestion des fournisseurs BTP")
|
||||
public class FournisseurResource {
|
||||
|
||||
@Inject
|
||||
FournisseurService fournisseurService;
|
||||
|
||||
// === ENDPOINTS DE LECTURE - ARCHITECTURE 2025 ===
|
||||
|
||||
@GET
|
||||
@Operation(summary = "Récupère tous les fournisseurs")
|
||||
@APIResponse(responseCode = "200", description = "Liste des fournisseurs")
|
||||
public Response getAllFournisseurs(
|
||||
@QueryParam("page") @DefaultValue("0") int page,
|
||||
@QueryParam("size") @DefaultValue("10") int size,
|
||||
@QueryParam("search") String search) {
|
||||
try {
|
||||
List<Fournisseur> fournisseurs;
|
||||
if (search != null && !search.trim().isEmpty()) {
|
||||
fournisseurs = fournisseurService.searchFournisseurs(search);
|
||||
} else {
|
||||
fournisseurs = fournisseurService.getAllFournisseurs(page, size);
|
||||
}
|
||||
return Response.ok(fournisseurs).build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des fournisseurs"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/{id}")
|
||||
@Operation(summary = "Récupère un fournisseur par ID")
|
||||
@APIResponse(responseCode = "200", description = "Fournisseur trouvé")
|
||||
@APIResponse(responseCode = "404", description = "Fournisseur non trouvé")
|
||||
public Response getFournisseurById(
|
||||
@Parameter(description = "ID du fournisseur") @PathParam("id") UUID id) {
|
||||
try {
|
||||
Fournisseur fournisseur = fournisseurService.getFournisseurById(id);
|
||||
return Response.ok(fournisseur).build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Fournisseur non trouvé"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/search")
|
||||
@Operation(summary = "Recherche des fournisseurs")
|
||||
@APIResponse(responseCode = "200", description = "Résultats de la recherche")
|
||||
public Response searchFournisseurs(@QueryParam("q") String query) {
|
||||
try {
|
||||
List<Fournisseur> fournisseurs = fournisseurService.searchFournisseurs(query);
|
||||
return Response.ok(fournisseurs).build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la recherche"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/stats")
|
||||
@Operation(summary = "Récupère les statistiques des fournisseurs")
|
||||
@APIResponse(responseCode = "200", description = "Statistiques des fournisseurs")
|
||||
public Response getFournisseurStats() {
|
||||
try {
|
||||
Map<String, Object> stats = fournisseurService.getFournisseurStats();
|
||||
return Response.ok(stats).build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors du calcul des statistiques"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE CRÉATION - ARCHITECTURE 2025 ===
|
||||
|
||||
@POST
|
||||
@Operation(summary = "Crée un nouveau fournisseur")
|
||||
@APIResponse(responseCode = "201", description = "Fournisseur créé avec succès")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides")
|
||||
@APIResponse(responseCode = "409", description = "Conflit - fournisseur existant")
|
||||
public Response createFournisseur(@Valid Fournisseur fournisseur) {
|
||||
try {
|
||||
Fournisseur created = fournisseurService.createFournisseur(fournisseur);
|
||||
return Response.status(Response.Status.CREATED)
|
||||
.entity(created)
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity(Map.of("error", "Erreur lors de la création du fournisseur"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@PUT
|
||||
@Path("/{id}")
|
||||
@Operation(summary = "Met à jour un fournisseur existant")
|
||||
@APIResponse(responseCode = "200", description = "Fournisseur mis à jour avec succès")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides")
|
||||
@APIResponse(responseCode = "404", description = "Fournisseur non trouvé")
|
||||
public Response updateFournisseur(
|
||||
@Parameter(description = "ID du fournisseur") @PathParam("id") UUID id,
|
||||
@Valid Fournisseur fournisseur) {
|
||||
try {
|
||||
Fournisseur updated = fournisseurService.updateFournisseur(id, fournisseur);
|
||||
return Response.ok(updated).build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Fournisseur non trouvé"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@DELETE
|
||||
@Path("/{id}")
|
||||
@Operation(summary = "Supprime un fournisseur")
|
||||
@APIResponse(responseCode = "204", description = "Fournisseur supprimé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Fournisseur non trouvé")
|
||||
public Response deleteFournisseur(
|
||||
@Parameter(description = "ID du fournisseur") @PathParam("id") UUID id) {
|
||||
try {
|
||||
fournisseurService.deleteFournisseur(id);
|
||||
return Response.noContent().build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Fournisseur non trouvé"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE MODIFICATION - ARCHITECTURE 2025 ===
|
||||
|
||||
@PUT
|
||||
@Path("/{id}/activate")
|
||||
@Operation(summary = "Active un fournisseur")
|
||||
@APIResponse(responseCode = "200", description = "Fournisseur activé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Fournisseur non trouvé")
|
||||
public Response activateFournisseur(
|
||||
@Parameter(description = "ID du fournisseur") @PathParam("id") UUID id) {
|
||||
try {
|
||||
fournisseurService.activateFournisseur(id);
|
||||
return Response.ok(Map.of("message", "Fournisseur activé avec succès")).build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Fournisseur non trouvé"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@PUT
|
||||
@Path("/{id}/deactivate")
|
||||
@Operation(summary = "Désactive un fournisseur")
|
||||
@APIResponse(responseCode = "200", description = "Fournisseur désactivé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Fournisseur non trouvé")
|
||||
public Response deactivateFournisseur(
|
||||
@Parameter(description = "ID du fournisseur") @PathParam("id") UUID id) {
|
||||
try {
|
||||
fournisseurService.deactivateFournisseur(id);
|
||||
return Response.ok(Map.of("message", "Fournisseur désactivé avec succès")).build();
|
||||
} catch (Exception e) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Fournisseur non trouvé"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
package dev.lions.btpxpress.presentation.rest;
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.application.service.LivraisonMaterielService;
|
||||
import dev.lions.btpxpress.domain.core.entity.*;
|
||||
@@ -18,8 +18,8 @@ import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* API REST pour la gestion des livraisons de matériel EXPOSITION: Endpoints pour la logistique et
|
||||
* le suivi des livraisons BTP
|
||||
* Resource REST pour la gestion des livraisons de matériel
|
||||
* Architecture 2025 : API complète pour la logistique et le suivi des livraisons BTP
|
||||
*/
|
||||
@Path("/api/v1/livraisons-materiel")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@@ -30,7 +30,7 @@ public class LivraisonMaterielResource {
|
||||
|
||||
@Inject LivraisonMaterielService livraisonService;
|
||||
|
||||
// === ENDPOINTS DE CONSULTATION ===
|
||||
// === ENDPOINTS DE LECTURE - ARCHITECTURE 2025 ===
|
||||
|
||||
@GET
|
||||
@Path("/")
|
||||
@@ -1,4 +1,4 @@
|
||||
package dev.lions.btpxpress.presentation.rest;
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.application.service.PermissionService;
|
||||
import dev.lions.btpxpress.domain.core.entity.Permission;
|
||||
@@ -1,4 +1,4 @@
|
||||
package dev.lions.btpxpress.application.rest;
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.application.service.PhaseTemplateService;
|
||||
import dev.lions.btpxpress.domain.core.entity.PhaseChantier;
|
||||
@@ -1,4 +1,4 @@
|
||||
package dev.lions.btpxpress.presentation.rest;
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.application.service.PlanningMaterielService;
|
||||
import dev.lions.btpxpress.domain.core.entity.*;
|
||||
@@ -1,4 +1,4 @@
|
||||
package dev.lions.btpxpress.presentation.rest;
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.application.service.ReservationMaterielService;
|
||||
import dev.lions.btpxpress.domain.core.entity.*;
|
||||
@@ -1,4 +1,4 @@
|
||||
package dev.lions.btpxpress.application.rest;
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.domain.core.entity.PhaseTemplate;
|
||||
import dev.lions.btpxpress.domain.core.entity.SousPhaseTemplate;
|
||||
@@ -0,0 +1,385 @@
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.application.service.StockService;
|
||||
import dev.lions.btpxpress.domain.core.entity.CategorieStock;
|
||||
import dev.lions.btpxpress.domain.core.entity.StatutStock;
|
||||
import dev.lions.btpxpress.domain.core.entity.Stock;
|
||||
import io.quarkus.security.Authenticated;
|
||||
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.math.BigDecimal;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
import org.eclipse.microprofile.openapi.annotations.Operation;
|
||||
import org.eclipse.microprofile.openapi.annotations.parameters.Parameter;
|
||||
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
|
||||
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* Resource REST pour la gestion des stocks et inventaires BTP
|
||||
* Architecture 2025 : API complète pour la gestion des stocks, entrées/sorties, réservations
|
||||
*/
|
||||
@Path("/api/v1/stocks")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Stocks", description = "Gestion des stocks et inventaires BTP")
|
||||
public class StockResource {
|
||||
|
||||
private static final Logger logger = LoggerFactory.getLogger(StockResource.class);
|
||||
|
||||
@Inject StockService stockService;
|
||||
|
||||
// === ENDPOINTS DE LECTURE - ARCHITECTURE 2025 ===
|
||||
|
||||
@GET
|
||||
@Operation(summary = "Récupérer tous les stocks", description = "Retourne la liste complète des articles en stock")
|
||||
@APIResponse(responseCode = "200", description = "Liste des stocks récupérée avec succès")
|
||||
public Response getAllStocks() {
|
||||
logger.debug("GET /stocks");
|
||||
try {
|
||||
List<Stock> stocks = stockService.findAll();
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("stocks", stocks);
|
||||
response.put("total", stocks.size());
|
||||
return Response.ok(response).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks", "message", e.getMessage()))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/{id}")
|
||||
@Operation(summary = "Récupérer un stock par ID", description = "Retourne les détails d'un article en stock")
|
||||
@APIResponse(responseCode = "200", description = "Stock trouvé")
|
||||
@APIResponse(responseCode = "404", description = "Stock non trouvé")
|
||||
public Response getStockById(@Parameter(description = "ID du stock") @PathParam("id") UUID id) {
|
||||
logger.debug("GET /stocks/{}", id);
|
||||
try {
|
||||
Stock stock = stockService.findById(id);
|
||||
return Response.ok(stock).build();
|
||||
} catch (jakarta.ws.rs.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 stock: {}", id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/reference/{reference}")
|
||||
@Operation(summary = "Récupérer un stock par référence", description = "Recherche un article en stock par sa référence")
|
||||
@APIResponse(responseCode = "200", description = "Stock trouvé")
|
||||
@APIResponse(responseCode = "404", description = "Stock non trouvé")
|
||||
public Response getStockByReference(@Parameter(description = "Référence du stock") @PathParam("reference") String reference) {
|
||||
logger.debug("GET /stocks/reference/{}", reference);
|
||||
try {
|
||||
Stock stock = stockService.findByReference(reference);
|
||||
if (stock == null) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Stock non trouvé"))
|
||||
.build();
|
||||
}
|
||||
return Response.ok(stock).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération du stock par référence: {}", reference, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/search")
|
||||
@Operation(summary = "Rechercher des stocks", description = "Recherche textuelle dans les stocks")
|
||||
@APIResponse(responseCode = "200", description = "Résultats de recherche")
|
||||
@APIResponse(responseCode = "400", description = "Terme de recherche requis")
|
||||
public Response searchStocks(@Parameter(description = "Terme de recherche") @QueryParam("term") String searchTerm) {
|
||||
logger.debug("GET /stocks/search - term: {}", 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<Stock> stocks = stockService.searchStocks(searchTerm);
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("stocks", stocks);
|
||||
response.put("total", stocks.size());
|
||||
return Response.ok(response).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la recherche de stocks: {}", searchTerm, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la recherche"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/categorie/{categorie}")
|
||||
@Operation(summary = "Récupérer les stocks par catégorie", description = "Filtre les stocks par catégorie")
|
||||
@APIResponse(responseCode = "200", description = "Liste des stocks filtrés")
|
||||
public Response getStocksByCategorie(@Parameter(description = "Catégorie de stock") @PathParam("categorie") String categorieStr) {
|
||||
logger.debug("GET /stocks/categorie/{}", categorieStr);
|
||||
try {
|
||||
CategorieStock categorie = CategorieStock.valueOf(categorieStr.toUpperCase());
|
||||
List<Stock> stocks = stockService.findByCategorie(categorie);
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("stocks", stocks);
|
||||
response.put("total", stocks.size());
|
||||
return Response.ok(response).build();
|
||||
} catch (IllegalArgumentException e) {
|
||||
logger.error("Catégorie invalide: {}", categorieStr, e);
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity(Map.of("error", "Catégorie invalide", "valeurs_acceptees", java.util.Arrays.toString(CategorieStock.values())))
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks par catégorie: {}", categorieStr, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/statut/{statut}")
|
||||
@Operation(summary = "Récupérer les stocks par statut", description = "Filtre les stocks par statut")
|
||||
@APIResponse(responseCode = "200", description = "Liste des stocks filtrés")
|
||||
public Response getStocksByStatut(@Parameter(description = "Statut du stock") @PathParam("statut") StatutStock statut) {
|
||||
logger.debug("GET /stocks/statut/{}", statut);
|
||||
try {
|
||||
List<Stock> stocks = stockService.findByStatut(statut);
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("stocks", stocks);
|
||||
response.put("total", stocks.size());
|
||||
return Response.ok(response).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks par statut: {}", statut, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/rupture")
|
||||
@Operation(summary = "Récupérer les stocks en rupture", description = "Liste les articles en rupture de stock")
|
||||
@APIResponse(responseCode = "200", description = "Liste des stocks en rupture")
|
||||
public Response getStocksEnRupture() {
|
||||
logger.debug("GET /stocks/rupture");
|
||||
try {
|
||||
List<Stock> stocks = stockService.findStocksEnRupture();
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("stocks", stocks);
|
||||
response.put("total", stocks.size());
|
||||
return Response.ok(response).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks en rupture", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/statistiques")
|
||||
@Operation(summary = "Récupérer les statistiques des stocks", description = "Retourne des statistiques globales sur les stocks")
|
||||
@APIResponse(responseCode = "200", description = "Statistiques récupérées avec succès")
|
||||
public Response getStatistiques() {
|
||||
logger.debug("GET /stocks/statistiques");
|
||||
try {
|
||||
Map<String, Object> stats = stockService.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();
|
||||
}
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/valeur-totale")
|
||||
@Operation(summary = "Calculer la valeur totale du stock", description = "Calcule la valeur totale de tous les stocks")
|
||||
@APIResponse(responseCode = "200", description = "Valeur totale calculée")
|
||||
public Response getValeurTotaleStock() {
|
||||
logger.debug("GET /stocks/valeur-totale");
|
||||
try {
|
||||
BigDecimal valeurTotale = stockService.calculateValeurTotaleStock();
|
||||
return Response.ok(Map.of("valeurTotale", valeurTotale)).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors du calcul de la valeur totale", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors du calcul de la valeur totale"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE CRÉATION - ARCHITECTURE 2025 ===
|
||||
|
||||
@POST
|
||||
@Authenticated
|
||||
@Operation(summary = "Créer un nouveau stock", description = "Crée un nouvel article en stock")
|
||||
@APIResponse(responseCode = "201", description = "Stock créé avec succès")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides")
|
||||
public Response createStock(@Valid @NotNull Stock stock) {
|
||||
logger.info("POST /stocks - Création d'un stock: {}", stock.getReference());
|
||||
try {
|
||||
Stock nouveauStock = stockService.create(stock);
|
||||
return Response.status(Response.Status.CREATED).entity(nouveauStock).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 du stock", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la création du stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE MISE À JOUR - ARCHITECTURE 2025 ===
|
||||
|
||||
@PUT
|
||||
@Path("/{id}")
|
||||
@Authenticated
|
||||
@Operation(summary = "Mettre à jour un stock", description = "Met à jour les informations d'un article en stock")
|
||||
@APIResponse(responseCode = "200", description = "Stock mis à jour avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Stock non trouvé")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides")
|
||||
public Response updateStock(
|
||||
@Parameter(description = "ID du stock") @PathParam("id") UUID id,
|
||||
@Valid @NotNull Stock stockData) {
|
||||
logger.info("PUT /stocks/{} - Mise à jour", id);
|
||||
try {
|
||||
Stock stock = stockService.update(id, stockData);
|
||||
return Response.ok(stock).build();
|
||||
} catch (jakarta.ws.rs.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 du stock: {}", id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la mise à jour du stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@POST
|
||||
@Path("/{id}/entree")
|
||||
@Authenticated
|
||||
@Operation(summary = "Enregistrer une entrée de stock", description = "Ajoute une quantité au stock")
|
||||
@APIResponse(responseCode = "200", description = "Entrée enregistrée avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Stock non trouvé")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides")
|
||||
public Response entreeStock(
|
||||
@Parameter(description = "ID du stock") @PathParam("id") UUID id,
|
||||
Map<String, Object> payload) {
|
||||
logger.info("POST /stocks/{}/entree", id);
|
||||
try {
|
||||
BigDecimal quantite = new BigDecimal(payload.get("quantite").toString());
|
||||
String motif = payload.get("motif") != null ? payload.get("motif").toString() : null;
|
||||
String numeroDocument = payload.get("numeroDocument") != null ? payload.get("numeroDocument").toString() : null;
|
||||
|
||||
Stock stock = stockService.entreeStock(id, quantite, motif, numeroDocument);
|
||||
return Response.ok(stock).build();
|
||||
} catch (jakarta.ws.rs.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", "Quantité ou données invalides"))
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de l'entrée de stock: {}", id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de l'entrée de stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@POST
|
||||
@Path("/{id}/sortie")
|
||||
@Authenticated
|
||||
@Operation(summary = "Enregistrer une sortie de stock", description = "Retire une quantité du stock")
|
||||
@APIResponse(responseCode = "200", description = "Sortie enregistrée avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Stock non trouvé")
|
||||
@APIResponse(responseCode = "400", description = "Quantité insuffisante")
|
||||
public Response sortieStock(
|
||||
@Parameter(description = "ID du stock") @PathParam("id") UUID id,
|
||||
Map<String, Object> payload) {
|
||||
logger.info("POST /stocks/{}/sortie", id);
|
||||
try {
|
||||
BigDecimal quantite = new BigDecimal(payload.get("quantite").toString());
|
||||
String motif = payload.get("motif") != null ? payload.get("motif").toString() : null;
|
||||
String numeroDocument = payload.get("numeroDocument") != null ? payload.get("numeroDocument").toString() : null;
|
||||
|
||||
Stock stock = stockService.sortieStock(id, quantite, motif, numeroDocument);
|
||||
return Response.ok(stock).build();
|
||||
} catch (jakarta.ws.rs.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", "Quantité insuffisante ou données invalides"))
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la sortie de stock: {}", id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la sortie de stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE SUPPRESSION - ARCHITECTURE 2025 ===
|
||||
|
||||
@DELETE
|
||||
@Path("/{id}")
|
||||
@Authenticated
|
||||
@Operation(summary = "Supprimer un stock", description = "Supprime un article du stock")
|
||||
@APIResponse(responseCode = "204", description = "Stock supprimé avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Stock non trouvé")
|
||||
public Response deleteStock(@Parameter(description = "ID du stock") @PathParam("id") UUID id) {
|
||||
logger.info("DELETE /stocks/{}", id);
|
||||
try {
|
||||
stockService.delete(id);
|
||||
return Response.noContent().build();
|
||||
} catch (jakarta.ws.rs.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 du stock: {}", id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la suppression du stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
package dev.lions.btpxpress.application.rest;
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.application.service.TacheTemplateService;
|
||||
import dev.lions.btpxpress.domain.core.entity.SousPhaseTemplate;
|
||||
@@ -1,4 +1,4 @@
|
||||
package dev.lions.btpxpress.application.rest;
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.application.service.UserService;
|
||||
import dev.lions.btpxpress.domain.core.entity.User;
|
||||
@@ -0,0 +1,275 @@
|
||||
package dev.lions.btpxpress.adapter.http;
|
||||
|
||||
import dev.lions.btpxpress.application.service.ZoneClimatiqueService;
|
||||
import dev.lions.btpxpress.domain.core.entity.ZoneClimatique;
|
||||
import io.quarkus.security.Authenticated;
|
||||
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.math.BigDecimal;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import org.eclipse.microprofile.openapi.annotations.Operation;
|
||||
import org.eclipse.microprofile.openapi.annotations.parameters.Parameter;
|
||||
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
|
||||
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* Resource REST pour la gestion des zones climatiques africaines
|
||||
* Architecture 2025 : API complète pour la gestion des contraintes climatiques de construction
|
||||
*/
|
||||
@Path("/api/v1/zones-climatiques")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Zones Climatiques", description = "Gestion des zones climatiques et contraintes BTP")
|
||||
public class ZoneClimatiqueResource {
|
||||
|
||||
private static final Logger logger = LoggerFactory.getLogger(ZoneClimatiqueResource.class);
|
||||
|
||||
@Inject ZoneClimatiqueService zoneClimatiqueService;
|
||||
|
||||
// === ENDPOINTS DE LECTURE - ARCHITECTURE 2025 ===
|
||||
|
||||
@GET
|
||||
@Operation(
|
||||
summary = "Récupérer toutes les zones climatiques actives",
|
||||
description = "Retourne la liste complète des zones climatiques actives")
|
||||
@APIResponse(responseCode = "200", description = "Liste des zones climatiques récupérée avec succès")
|
||||
public Response getAllZones() {
|
||||
logger.debug("GET /zones-climatiques");
|
||||
List<ZoneClimatique> zones = zoneClimatiqueService.findAll();
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("zones", zones);
|
||||
response.put("total", zones.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/all")
|
||||
@Operation(
|
||||
summary = "Récupérer toutes les zones (actives et inactives)",
|
||||
description = "Retourne la liste complète incluant les zones désactivées")
|
||||
@APIResponse(responseCode = "200", description = "Liste complète des zones climatiques")
|
||||
public Response getAllZonesIncludingInactive() {
|
||||
logger.debug("Récupération de toutes les zones (actives et inactives)");
|
||||
List<ZoneClimatique> zones = zoneClimatiqueService.findAllIncludingInactive();
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("zones", zones);
|
||||
response.put("total", zones.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/{id}")
|
||||
@Operation(summary = "Récupérer une zone par ID", description = "Retourne les détails d'une zone climatique")
|
||||
@APIResponse(responseCode = "200", description = "Zone climatique trouvée")
|
||||
@APIResponse(responseCode = "404", description = "Zone climatique non trouvée")
|
||||
public Response getZoneById(@Parameter(description = "ID de la zone climatique") @PathParam("id") Long id) {
|
||||
logger.debug("GET /zones-climatiques/{}", id);
|
||||
ZoneClimatique zone = zoneClimatiqueService.findById(id);
|
||||
return Response.ok(zone).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/code/{code}")
|
||||
@Operation(
|
||||
summary = "Récupérer une zone par code",
|
||||
description = "Retourne les détails d'une zone climatique par son code unique")
|
||||
@APIResponse(responseCode = "200", description = "Zone climatique trouvée")
|
||||
@APIResponse(responseCode = "404", description = "Zone climatique non trouvée")
|
||||
public Response getZoneByCode(@PathParam("code") String code) {
|
||||
logger.debug("Récupération de la zone climatique avec code: {}", code);
|
||||
ZoneClimatique zone = zoneClimatiqueService.findByCode(code);
|
||||
return Response.ok(zone).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/temperature-range")
|
||||
@Operation(
|
||||
summary = "Rechercher par plage de température",
|
||||
description = "Retourne les zones dont la température moyenne est dans la plage spécifiée")
|
||||
@APIResponse(responseCode = "200", description = "Zones trouvées")
|
||||
public Response getByTemperatureRange(
|
||||
@Parameter(description = "Température minimale (°C)", example = "15")
|
||||
@QueryParam("min")
|
||||
BigDecimal min,
|
||||
@Parameter(description = "Température maximale (°C)", example = "40")
|
||||
@QueryParam("max")
|
||||
BigDecimal max) {
|
||||
logger.debug("Recherche zones climatiques par température: {} - {}", min, max);
|
||||
List<ZoneClimatique> zones = zoneClimatiqueService.findByTemperatureRange(min, max);
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("zones", zones);
|
||||
response.put("total", zones.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/pluviometrie")
|
||||
@Operation(
|
||||
summary = "Rechercher par pluviométrie",
|
||||
description = "Retourne les zones dont la pluviométrie annuelle est dans la plage spécifiée")
|
||||
@APIResponse(responseCode = "200", description = "Zones trouvées")
|
||||
public Response getByPluviometrie(
|
||||
@Parameter(description = "Pluviométrie minimale (mm)", example = "500") @QueryParam("min")
|
||||
Integer min,
|
||||
@Parameter(description = "Pluviométrie maximale (mm)", example = "2000") @QueryParam("max")
|
||||
Integer max) {
|
||||
logger.debug("Recherche zones climatiques par pluviométrie: {} - {}", min, max);
|
||||
List<ZoneClimatique> zones = zoneClimatiqueService.findByPluviometrie(min, max);
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("zones", zones);
|
||||
response.put("total", zones.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/risque-seisme")
|
||||
@Operation(
|
||||
summary = "Zones avec risque sismique",
|
||||
description = "Retourne toutes les zones présentant un risque sismique")
|
||||
@APIResponse(responseCode = "200", description = "Zones sismiques trouvées")
|
||||
public Response getWithSeismicRisk() {
|
||||
logger.debug("Recherche zones avec risque sismique");
|
||||
List<ZoneClimatique> zones = zoneClimatiqueService.findAvecRisqueSeisme();
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("zones", zones);
|
||||
response.put("total", zones.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/risque-cyclones")
|
||||
@Operation(
|
||||
summary = "Zones avec risque cyclonique",
|
||||
description = "Retourne toutes les zones présentant un risque cyclonique")
|
||||
@APIResponse(responseCode = "200", description = "Zones cycloniques trouvées")
|
||||
public Response getWithCycloneRisk() {
|
||||
logger.debug("Recherche zones avec risque cyclonique");
|
||||
List<ZoneClimatique> zones = zoneClimatiqueService.findAvecRisqueCyclones();
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("zones", zones);
|
||||
response.put("total", zones.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/search")
|
||||
@Operation(
|
||||
summary = "Recherche avancée",
|
||||
description = "Recherche avancée avec critères multiples")
|
||||
@APIResponse(responseCode = "200", description = "Résultats de la recherche")
|
||||
public Response search(
|
||||
@QueryParam("tempMin") BigDecimal tempMin,
|
||||
@QueryParam("tempMax") BigDecimal tempMax,
|
||||
@QueryParam("pluvioMin") Integer pluvioMin,
|
||||
@QueryParam("pluvioMax") Integer pluvioMax,
|
||||
@QueryParam("risqueSeisme") Boolean risqueSeisme,
|
||||
@QueryParam("corrosionMarine") Boolean corrosionMarine,
|
||||
@QueryParam("texte") String texte) {
|
||||
logger.debug(
|
||||
"Recherche avancée - temp: {}-{}, pluvio: {}-{}, seisme: {}, corrosion: {}, texte: {}",
|
||||
tempMin,
|
||||
tempMax,
|
||||
pluvioMin,
|
||||
pluvioMax,
|
||||
risqueSeisme,
|
||||
corrosionMarine,
|
||||
texte);
|
||||
List<ZoneClimatique> zones =
|
||||
zoneClimatiqueService.search(
|
||||
tempMin, tempMax, pluvioMin, pluvioMax, risqueSeisme, corrosionMarine, texte);
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("zones", zones);
|
||||
response.put("total", zones.size());
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@GET
|
||||
@Path("/statistiques")
|
||||
@Operation(
|
||||
summary = "Statistiques des zones climatiques",
|
||||
description = "Retourne des statistiques globales sur les zones climatiques")
|
||||
@APIResponse(responseCode = "200", description = "Statistiques calculées")
|
||||
public Response getStatistics() {
|
||||
logger.debug("Récupération des statistiques des zones climatiques");
|
||||
Map<String, Object> stats = zoneClimatiqueService.getStatistics();
|
||||
return Response.ok(stats).build();
|
||||
}
|
||||
|
||||
// =================== ENDPOINTS DE CRÉATION ===================
|
||||
|
||||
@POST
|
||||
@Authenticated
|
||||
@Operation(summary = "Créer une nouvelle zone climatique", description = "Crée une nouvelle zone climatique")
|
||||
@APIResponse(responseCode = "201", description = "Zone climatique créée avec succès")
|
||||
@APIResponse(responseCode = "400", description = "Données invalides ou code déjà existant")
|
||||
public Response createZone(@Valid @NotNull ZoneClimatique zone) {
|
||||
logger.info("Création d'une nouvelle zone climatique: {}", zone.getCode());
|
||||
ZoneClimatique created = zoneClimatiqueService.create(zone);
|
||||
return Response.status(Response.Status.CREATED).entity(created).build();
|
||||
}
|
||||
|
||||
// === ENDPOINTS DE MODIFICATION - ARCHITECTURE 2025 ===
|
||||
|
||||
@PUT
|
||||
@Path("/{id}")
|
||||
@Authenticated
|
||||
@Operation(summary = "Modifier une zone climatique", description = "Met à jour les informations d'une zone")
|
||||
@APIResponse(responseCode = "200", description = "Zone modifiée avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Zone non trouvée")
|
||||
public Response updateZone(@PathParam("id") Long id, @Valid @NotNull ZoneClimatique zone) {
|
||||
logger.info("PUT /zones-climatiques/{} - Modification", id);
|
||||
ZoneClimatique updated = zoneClimatiqueService.update(id, zone);
|
||||
return Response.ok(updated).build();
|
||||
}
|
||||
|
||||
@PUT
|
||||
@Path("/{id}/activate")
|
||||
@Authenticated
|
||||
@Operation(summary = "Activer une zone climatique", description = "Réactive une zone désactivée")
|
||||
@APIResponse(responseCode = "200", description = "Zone activée avec succès")
|
||||
public Response activateZone(@PathParam("id") Long id) {
|
||||
logger.info("Activation de la zone climatique ID: {}", id);
|
||||
zoneClimatiqueService.activate(id);
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("message", "Zone climatique activée avec succès");
|
||||
response.put("id", id);
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
@PUT
|
||||
@Path("/{id}/deactivate")
|
||||
@Authenticated
|
||||
@Operation(summary = "Désactiver une zone climatique", description = "Désactive une zone")
|
||||
@APIResponse(responseCode = "200", description = "Zone désactivée avec succès")
|
||||
public Response deactivateZone(@PathParam("id") Long id) {
|
||||
logger.info("Désactivation de la zone climatique ID: {}", id);
|
||||
zoneClimatiqueService.deactivate(id);
|
||||
Map<String, Object> response = new HashMap<>();
|
||||
response.put("message", "Zone climatique désactivée avec succès");
|
||||
response.put("id", id);
|
||||
return Response.ok(response).build();
|
||||
}
|
||||
|
||||
// === ENDPOINT DE SUPPRESSION - ARCHITECTURE 2025 ===
|
||||
|
||||
@DELETE
|
||||
@Path("/{id}")
|
||||
@Authenticated
|
||||
@Operation(summary = "Supprimer une zone climatique", description = "Supprime définitivement une zone")
|
||||
@APIResponse(responseCode = "204", description = "Zone supprimée avec succès")
|
||||
@APIResponse(responseCode = "404", description = "Zone non trouvée")
|
||||
public Response deleteZone(@PathParam("id") Long id) {
|
||||
logger.info("DELETE /zones-climatiques/{} - Suppression", id);
|
||||
zoneClimatiqueService.delete(id);
|
||||
return Response.noContent().build();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,395 @@
|
||||
package dev.lions.btpxpress.application.service;
|
||||
|
||||
import dev.lions.btpxpress.domain.core.entity.Abonnement;
|
||||
import dev.lions.btpxpress.domain.core.entity.EntrepriseProfile;
|
||||
import dev.lions.btpxpress.domain.core.entity.StatutAbonnement;
|
||||
import dev.lions.btpxpress.domain.core.entity.TypeAbonnement;
|
||||
import dev.lions.btpxpress.domain.infrastructure.repository.AbonnementRepository;
|
||||
import dev.lions.btpxpress.domain.infrastructure.repository.EntrepriseProfileRepository;
|
||||
import jakarta.enterprise.context.ApplicationScoped;
|
||||
import jakarta.inject.Inject;
|
||||
import jakarta.transaction.Transactional;
|
||||
import jakarta.ws.rs.BadRequestException;
|
||||
import jakarta.ws.rs.NotFoundException;
|
||||
import java.math.BigDecimal;
|
||||
import java.time.LocalDate;
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Optional;
|
||||
import java.util.UUID;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* Service de gestion des abonnements
|
||||
* Architecture 2025 : Service complet pour la gestion du cycle de vie des abonnements
|
||||
*/
|
||||
@ApplicationScoped
|
||||
public class AbonnementService {
|
||||
|
||||
private static final Logger logger = LoggerFactory.getLogger(AbonnementService.class);
|
||||
|
||||
@Inject AbonnementRepository abonnementRepository;
|
||||
|
||||
@Inject EntrepriseProfileRepository entrepriseProfileRepository;
|
||||
|
||||
// === MÉTHODES DE RECHERCHE ===
|
||||
|
||||
/** Récupérer tous les abonnements */
|
||||
public List<Abonnement> findAll() {
|
||||
logger.debug("Recherche de tous les abonnements");
|
||||
return abonnementRepository.listAll();
|
||||
}
|
||||
|
||||
/** Récupérer un abonnement par ID */
|
||||
public Optional<Abonnement> findById(UUID id) {
|
||||
logger.debug("Recherche de l'abonnement avec l'ID: {}", id);
|
||||
return abonnementRepository.findByIdOptional(id);
|
||||
}
|
||||
|
||||
/** Récupérer un abonnement par ID (obligatoire) */
|
||||
public Abonnement findByIdRequired(UUID id) {
|
||||
return findById(id)
|
||||
.orElseThrow(() -> new NotFoundException("Abonnement non trouvé avec l'ID: " + id));
|
||||
}
|
||||
|
||||
/** Récupérer tous les abonnements actifs */
|
||||
public List<Abonnement> findActifs() {
|
||||
logger.debug("Recherche de tous les abonnements actifs");
|
||||
return abonnementRepository.findActifs();
|
||||
}
|
||||
|
||||
/** Récupérer tous les abonnements expirés */
|
||||
public List<Abonnement> findExpires() {
|
||||
logger.debug("Recherche de tous les abonnements expirés");
|
||||
return abonnementRepository.findExpires();
|
||||
}
|
||||
|
||||
/** Récupérer l'abonnement actif d'une entreprise */
|
||||
public Optional<Abonnement> findAbonnementActifByEntreprise(UUID entrepriseId) {
|
||||
logger.debug("Recherche de l'abonnement actif pour l'entreprise: {}", entrepriseId);
|
||||
return abonnementRepository.findAbonnementActifByEntreprise(entrepriseId);
|
||||
}
|
||||
|
||||
/** Récupérer tous les abonnements d'une entreprise */
|
||||
public List<Abonnement> findByEntreprise(UUID entrepriseId) {
|
||||
logger.debug("Recherche des abonnements pour l'entreprise: {}", entrepriseId);
|
||||
return abonnementRepository.findByEntreprise(entrepriseId);
|
||||
}
|
||||
|
||||
/** Récupérer les abonnements par type */
|
||||
public List<Abonnement> findByType(TypeAbonnement type) {
|
||||
logger.debug("Recherche des abonnements de type: {}", type);
|
||||
return abonnementRepository.findByType(type);
|
||||
}
|
||||
|
||||
/** Récupérer les abonnements par statut */
|
||||
public List<Abonnement> findByStatut(StatutAbonnement statut) {
|
||||
logger.debug("Recherche des abonnements avec le statut: {}", statut);
|
||||
return abonnementRepository.findByStatut(statut);
|
||||
}
|
||||
|
||||
/** Récupérer les abonnements qui arrivent à expiration */
|
||||
public List<Abonnement> findBientotExpires(int joursAvantExpiration) {
|
||||
logger.debug("Recherche des abonnements expirant dans {} jours", joursAvantExpiration);
|
||||
return abonnementRepository.findBientotExpires(joursAvantExpiration);
|
||||
}
|
||||
|
||||
/** Récupérer les abonnements avec auto-renouvellement */
|
||||
public List<Abonnement> findWithAutoRenew() {
|
||||
logger.debug("Recherche des abonnements avec auto-renouvellement");
|
||||
return abonnementRepository.findWithAutoRenew();
|
||||
}
|
||||
|
||||
// === MÉTHODES DE CRÉATION ===
|
||||
|
||||
/** Créer un nouvel abonnement */
|
||||
@Transactional
|
||||
public Abonnement create(Abonnement abonnement) {
|
||||
logger.info("Création d'un nouvel abonnement pour l'entreprise: {}", abonnement.getEntreprise().getId());
|
||||
|
||||
// Vérifier que l'entreprise existe
|
||||
if (abonnement.getEntreprise() == null || abonnement.getEntreprise().getId() == null) {
|
||||
throw new BadRequestException("L'entreprise est obligatoire");
|
||||
}
|
||||
|
||||
Optional<EntrepriseProfile> entreprise =
|
||||
entrepriseProfileRepository.findByIdOptional(abonnement.getEntreprise().getId());
|
||||
if (entreprise.isEmpty()) {
|
||||
throw new NotFoundException(
|
||||
"Entreprise non trouvée avec l'ID: " + abonnement.getEntreprise().getId());
|
||||
}
|
||||
|
||||
// Vérifier qu'il n'y a pas déjà un abonnement actif
|
||||
Optional<Abonnement> abonnementActif =
|
||||
findAbonnementActifByEntreprise(abonnement.getEntreprise().getId());
|
||||
if (abonnementActif.isPresent()) {
|
||||
throw new BadRequestException("Cette entreprise a déjà un abonnement actif");
|
||||
}
|
||||
|
||||
// Initialiser les valeurs par défaut
|
||||
if (abonnement.getStatut() == null) {
|
||||
abonnement.setStatut(StatutAbonnement.ACTIF);
|
||||
}
|
||||
if (abonnement.getDateDebut() == null) {
|
||||
abonnement.setDateDebut(LocalDate.now());
|
||||
}
|
||||
if (abonnement.getDateFin() == null) {
|
||||
// Par défaut, abonnement d'un mois
|
||||
abonnement.setDateFin(LocalDate.now().plusMonths(1));
|
||||
}
|
||||
if (abonnement.getPrixPaye() == null) {
|
||||
abonnement.setPrixPaye(abonnement.getTypeAbonnement().getPrixMensuel());
|
||||
}
|
||||
|
||||
abonnementRepository.persist(abonnement);
|
||||
|
||||
// Mettre à jour le profil entreprise
|
||||
entreprise.get().setTypeAbonnement(abonnement.getTypeAbonnement());
|
||||
entrepriseProfileRepository.persist(entreprise.get());
|
||||
|
||||
logger.debug("Abonnement créé avec succès: {}", abonnement.getId());
|
||||
return abonnement;
|
||||
}
|
||||
|
||||
/** Créer un abonnement mensuel */
|
||||
@Transactional
|
||||
public Abonnement createAbonnementMensuel(
|
||||
UUID entrepriseId, TypeAbonnement type, String methodePaiement) {
|
||||
logger.info(
|
||||
"Création d'un abonnement mensuel {} pour l'entreprise: {}", type, entrepriseId);
|
||||
|
||||
EntrepriseProfile entreprise =
|
||||
entrepriseProfileRepository
|
||||
.findByIdOptional(entrepriseId)
|
||||
.orElseThrow(() -> new NotFoundException("Entreprise non trouvée"));
|
||||
|
||||
Abonnement abonnement =
|
||||
new Abonnement(
|
||||
entreprise,
|
||||
type,
|
||||
LocalDate.now(),
|
||||
LocalDate.now().plusMonths(1),
|
||||
type.getPrixMensuel());
|
||||
abonnement.setMethodePaiement(methodePaiement);
|
||||
abonnement.setAutoRenouvellement(true);
|
||||
abonnement.setDateProchainPrelevement(LocalDate.now().plusMonths(1));
|
||||
|
||||
return create(abonnement);
|
||||
}
|
||||
|
||||
/** Créer un abonnement annuel */
|
||||
@Transactional
|
||||
public Abonnement createAbonnementAnnuel(
|
||||
UUID entrepriseId, TypeAbonnement type, String methodePaiement) {
|
||||
logger.info("Création d'un abonnement annuel {} pour l'entreprise: {}", type, entrepriseId);
|
||||
|
||||
EntrepriseProfile entreprise =
|
||||
entrepriseProfileRepository
|
||||
.findByIdOptional(entrepriseId)
|
||||
.orElseThrow(() -> new NotFoundException("Entreprise non trouvée"));
|
||||
|
||||
Abonnement abonnement =
|
||||
new Abonnement(
|
||||
entreprise,
|
||||
type,
|
||||
LocalDate.now(),
|
||||
LocalDate.now().plusYears(1),
|
||||
type.getPrixAnnuel());
|
||||
abonnement.setMethodePaiement(methodePaiement);
|
||||
abonnement.setAutoRenouvellement(true);
|
||||
abonnement.setDateProchainPrelevement(LocalDate.now().plusYears(1));
|
||||
|
||||
return create(abonnement);
|
||||
}
|
||||
|
||||
// === MÉTHODES DE MISE À JOUR ===
|
||||
|
||||
/** Mettre à jour un abonnement */
|
||||
@Transactional
|
||||
public Abonnement update(UUID id, Abonnement abonnementUpdate) {
|
||||
logger.info("Mise à jour de l'abonnement: {}", id);
|
||||
|
||||
Abonnement abonnement = findByIdRequired(id);
|
||||
|
||||
// Mise à jour des champs modifiables
|
||||
if (abonnementUpdate.getTypeAbonnement() != null) {
|
||||
abonnement.setTypeAbonnement(abonnementUpdate.getTypeAbonnement());
|
||||
}
|
||||
if (abonnementUpdate.getDateFin() != null) {
|
||||
abonnement.setDateFin(abonnementUpdate.getDateFin());
|
||||
}
|
||||
if (abonnementUpdate.getMethodePaiement() != null) {
|
||||
abonnement.setMethodePaiement(abonnementUpdate.getMethodePaiement());
|
||||
}
|
||||
if (abonnementUpdate.getNotes() != null) {
|
||||
abonnement.setNotes(abonnementUpdate.getNotes());
|
||||
}
|
||||
|
||||
abonnement.setDateModification(LocalDateTime.now());
|
||||
abonnementRepository.persist(abonnement);
|
||||
|
||||
logger.debug("Abonnement mis à jour avec succès: {}", id);
|
||||
return abonnement;
|
||||
}
|
||||
|
||||
/** Renouveler un abonnement */
|
||||
@Transactional
|
||||
public Abonnement renouveler(UUID id, boolean annuel) {
|
||||
logger.info("Renouvellement de l'abonnement: {} - Annuel: {}", id, annuel);
|
||||
|
||||
Abonnement abonnement = findByIdRequired(id);
|
||||
|
||||
LocalDate nouvelleDateFin;
|
||||
BigDecimal nouveauPrix;
|
||||
|
||||
if (annuel) {
|
||||
nouvelleDateFin = abonnement.getDateFin().plusYears(1);
|
||||
nouveauPrix = abonnement.getTypeAbonnement().getPrixAnnuel();
|
||||
} else {
|
||||
nouvelleDateFin = abonnement.getDateFin().plusMonths(1);
|
||||
nouveauPrix = abonnement.getTypeAbonnement().getPrixMensuel();
|
||||
}
|
||||
|
||||
abonnement.renouveler(nouvelleDateFin, nouveauPrix);
|
||||
abonnementRepository.persist(abonnement);
|
||||
|
||||
logger.debug("Abonnement renouvelé avec succès jusqu'au: {}", nouvelleDateFin);
|
||||
return abonnement;
|
||||
}
|
||||
|
||||
/** Changer le type d'abonnement (upgrade/downgrade) */
|
||||
@Transactional
|
||||
public Abonnement changerType(UUID id, TypeAbonnement nouveauType) {
|
||||
logger.info("Changement de type d'abonnement {} vers {}", id, nouveauType);
|
||||
|
||||
Abonnement abonnement = findByIdRequired(id);
|
||||
abonnement.setTypeAbonnement(nouveauType);
|
||||
abonnement.setDateModification(LocalDateTime.now());
|
||||
|
||||
// Mettre à jour le profil entreprise
|
||||
EntrepriseProfile entreprise = abonnement.getEntreprise();
|
||||
entreprise.setTypeAbonnement(nouveauType);
|
||||
entrepriseProfileRepository.persist(entreprise);
|
||||
|
||||
abonnementRepository.persist(abonnement);
|
||||
|
||||
logger.debug("Type d'abonnement changé vers: {}", nouveauType);
|
||||
return abonnement;
|
||||
}
|
||||
|
||||
/** Activer/désactiver le renouvellement automatique */
|
||||
@Transactional
|
||||
public Abonnement toggleAutoRenouvellement(UUID id) {
|
||||
logger.info("Basculement du renouvellement automatique pour l'abonnement: {}", id);
|
||||
|
||||
Abonnement abonnement = findByIdRequired(id);
|
||||
abonnement.setAutoRenouvellement(!abonnement.isAutoRenouvellement());
|
||||
abonnement.setDateModification(LocalDateTime.now());
|
||||
abonnementRepository.persist(abonnement);
|
||||
|
||||
logger.debug("Renouvellement automatique: {}", abonnement.isAutoRenouvellement());
|
||||
return abonnement;
|
||||
}
|
||||
|
||||
// === MÉTHODES DE GESTION ===
|
||||
|
||||
/** Annuler un abonnement */
|
||||
@Transactional
|
||||
public void annuler(UUID id) {
|
||||
logger.info("Annulation de l'abonnement: {}", id);
|
||||
|
||||
Abonnement abonnement = findByIdRequired(id);
|
||||
abonnement.annuler();
|
||||
abonnementRepository.persist(abonnement);
|
||||
|
||||
logger.debug("Abonnement annulé avec succès");
|
||||
}
|
||||
|
||||
/** Suspendre un abonnement */
|
||||
@Transactional
|
||||
public void suspendre(UUID id) {
|
||||
logger.info("Suspension de l'abonnement: {}", id);
|
||||
|
||||
Abonnement abonnement = findByIdRequired(id);
|
||||
abonnement.suspendre();
|
||||
abonnementRepository.persist(abonnement);
|
||||
|
||||
logger.debug("Abonnement suspendu avec succès");
|
||||
}
|
||||
|
||||
/** Réactiver un abonnement */
|
||||
@Transactional
|
||||
public void reactiver(UUID id) {
|
||||
logger.info("Réactivation de l'abonnement: {}", id);
|
||||
|
||||
Abonnement abonnement = findByIdRequired(id);
|
||||
abonnement.reactiver();
|
||||
abonnementRepository.persist(abonnement);
|
||||
|
||||
logger.debug("Abonnement réactivé avec succès");
|
||||
}
|
||||
|
||||
/** Incrémenter le compteur de mises en relation */
|
||||
@Transactional
|
||||
public void incrementerMisesEnRelation(UUID id) {
|
||||
logger.debug("Incrémentation des mises en relation pour l'abonnement: {}", id);
|
||||
|
||||
Abonnement abonnement = findByIdRequired(id);
|
||||
|
||||
if (abonnement.limiteMisesEnRelationAtteinte()) {
|
||||
throw new BadRequestException("Limite de mises en relation atteinte pour cet abonnement");
|
||||
}
|
||||
|
||||
abonnement.incrementerMisesEnRelation();
|
||||
abonnementRepository.persist(abonnement);
|
||||
}
|
||||
|
||||
// === MÉTHODES DE SUPPRESSION ===
|
||||
|
||||
/** Supprimer définitivement un abonnement */
|
||||
@Transactional
|
||||
public void deletePermanently(UUID id) {
|
||||
logger.info("Suppression définitive de l'abonnement: {}", id);
|
||||
abonnementRepository.deleteById(id);
|
||||
logger.debug("Abonnement supprimé définitivement");
|
||||
}
|
||||
|
||||
// === MÉTHODES DE STATISTIQUES ===
|
||||
|
||||
/** Récupérer les statistiques globales */
|
||||
public Map<String, Object> getStatistics() {
|
||||
logger.debug("Récupération des statistiques des abonnements");
|
||||
|
||||
Map<String, Object> stats = new HashMap<>();
|
||||
stats.put("totalActifs", abonnementRepository.countActifs());
|
||||
stats.put("totalGratuit", abonnementRepository.countActifsByType(TypeAbonnement.GRATUIT));
|
||||
stats.put("totalPremium", abonnementRepository.countActifsByType(TypeAbonnement.PREMIUM));
|
||||
stats.put("totalEnterprise", abonnementRepository.countActifsByType(TypeAbonnement.ENTERPRISE));
|
||||
stats.put("bientotExpires", abonnementRepository.findBientotExpires(7).size());
|
||||
stats.put("autoRenouvellement", abonnementRepository.findWithAutoRenew().size());
|
||||
|
||||
return stats;
|
||||
}
|
||||
|
||||
/** Récupérer les plans tarifaires disponibles */
|
||||
public Map<String, Object> getPlans() {
|
||||
logger.debug("Récupération des plans tarifaires");
|
||||
|
||||
Map<String, Object> plans = new HashMap<>();
|
||||
|
||||
for (TypeAbonnement type : TypeAbonnement.values()) {
|
||||
Map<String, Object> planDetails = new HashMap<>();
|
||||
planDetails.put("libelle", type.getLibelle());
|
||||
planDetails.put("prixMensuel", type.getPrixMensuel());
|
||||
planDetails.put("prixAnnuel", type.getPrixAnnuel());
|
||||
planDetails.put("limiteMisesEnRelation", type.getLimiteMisesEnRelation());
|
||||
planDetails.put("fonctionnalites", type.getFonctionnalites());
|
||||
plans.put(type.name(), planDetails);
|
||||
}
|
||||
|
||||
return plans;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,331 @@
|
||||
package dev.lions.btpxpress.application.service;
|
||||
|
||||
import dev.lions.btpxpress.domain.core.entity.EntrepriseProfile;
|
||||
import dev.lions.btpxpress.domain.core.entity.TypeAbonnement;
|
||||
import dev.lions.btpxpress.domain.core.entity.User;
|
||||
import dev.lions.btpxpress.domain.infrastructure.repository.EntrepriseProfileRepository;
|
||||
import dev.lions.btpxpress.domain.infrastructure.repository.UserRepository;
|
||||
import jakarta.enterprise.context.ApplicationScoped;
|
||||
import jakarta.inject.Inject;
|
||||
import jakarta.transaction.Transactional;
|
||||
import jakarta.ws.rs.BadRequestException;
|
||||
import jakarta.ws.rs.NotFoundException;
|
||||
import java.math.BigDecimal;
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Optional;
|
||||
import java.util.UUID;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* Service de gestion des profils d'entreprise
|
||||
* Architecture 2025 : Service complet pour la gestion des profils d'entreprise et leurs notations
|
||||
*/
|
||||
@ApplicationScoped
|
||||
public class EntrepriseProfileService {
|
||||
|
||||
private static final Logger logger =
|
||||
LoggerFactory.getLogger(EntrepriseProfileService.class);
|
||||
|
||||
@Inject EntrepriseProfileRepository entrepriseProfileRepository;
|
||||
|
||||
@Inject UserRepository userRepository;
|
||||
|
||||
// === MÉTHODES DE RECHERCHE - ARCHITECTURE 2025 ===
|
||||
|
||||
/** Récupérer tous les profils visibles */
|
||||
public List<EntrepriseProfile> findAll() {
|
||||
logger.debug("Recherche de tous les profils d'entreprise visibles");
|
||||
return entrepriseProfileRepository.findVisible();
|
||||
}
|
||||
|
||||
/** Récupérer tous les profils visibles avec pagination */
|
||||
public List<EntrepriseProfile> findAll(int page, int size) {
|
||||
logger.debug("Recherche des profils d'entreprise visibles - page: {}, taille: {}", page, size);
|
||||
return entrepriseProfileRepository.findVisible(page, size);
|
||||
}
|
||||
|
||||
/** Récupérer un profil par ID */
|
||||
public Optional<EntrepriseProfile> findById(UUID id) {
|
||||
logger.debug("Recherche du profil d'entreprise avec l'ID: {}", id);
|
||||
return entrepriseProfileRepository.findByIdOptional(id);
|
||||
}
|
||||
|
||||
/** Récupérer un profil par ID (obligatoire) */
|
||||
public EntrepriseProfile findByIdRequired(UUID id) {
|
||||
return findById(id)
|
||||
.orElseThrow(
|
||||
() -> new NotFoundException("Profil d'entreprise non trouvé avec l'ID: " + id));
|
||||
}
|
||||
|
||||
/** Rechercher par zone d'intervention */
|
||||
public List<EntrepriseProfile> findByZoneIntervention(String zone) {
|
||||
logger.debug("Recherche des profils par zone d'intervention: {}", zone);
|
||||
return entrepriseProfileRepository.findByZoneIntervention(zone);
|
||||
}
|
||||
|
||||
/** Rechercher par spécialité */
|
||||
public List<EntrepriseProfile> findBySpecialite(String specialite) {
|
||||
logger.debug("Recherche des profils par spécialité: {}", specialite);
|
||||
return entrepriseProfileRepository.findBySpecialite(specialite);
|
||||
}
|
||||
|
||||
/** Rechercher par région */
|
||||
public List<EntrepriseProfile> findByRegion(String region) {
|
||||
logger.debug("Recherche des profils par région: {}", region);
|
||||
return entrepriseProfileRepository.findByRegion(region);
|
||||
}
|
||||
|
||||
/** Rechercher les profils certifiés */
|
||||
public List<EntrepriseProfile> findByCertifie(boolean certifie) {
|
||||
logger.debug("Recherche des profils certifiés: {}", certifie);
|
||||
return entrepriseProfileRepository.findByCertifie(certifie);
|
||||
}
|
||||
|
||||
/** Récupérer les mieux notés */
|
||||
public List<EntrepriseProfile> findTopRated(int limit) {
|
||||
logger.debug("Recherche des {} profils les mieux notés", limit);
|
||||
return entrepriseProfileRepository.findTopRated(limit);
|
||||
}
|
||||
|
||||
/** Recherche textuelle complète */
|
||||
public List<EntrepriseProfile> searchFullText(String searchTerm) {
|
||||
logger.debug("Recherche textuelle complète: {}", searchTerm);
|
||||
return entrepriseProfileRepository.searchFullText(searchTerm);
|
||||
}
|
||||
|
||||
/** Rechercher par nom commercial */
|
||||
public List<EntrepriseProfile> searchByNom(String nom) {
|
||||
logger.debug("Recherche par nom commercial: {}", nom);
|
||||
return entrepriseProfileRepository.findByNomContaining(nom);
|
||||
}
|
||||
|
||||
/** Rechercher par ville */
|
||||
public List<EntrepriseProfile> findByVille(String ville) {
|
||||
logger.debug("Recherche par ville: {}", ville);
|
||||
return entrepriseProfileRepository.findByVille(ville);
|
||||
}
|
||||
|
||||
/** Rechercher par type d'abonnement */
|
||||
public List<EntrepriseProfile> findByTypeAbonnement(TypeAbonnement type) {
|
||||
logger.debug("Recherche par type d'abonnement: {}", type);
|
||||
return entrepriseProfileRepository.findByTypeAbonnement(type);
|
||||
}
|
||||
|
||||
/** Rechercher par utilisateur propriétaire */
|
||||
public Optional<EntrepriseProfile> findByUserId(UUID userId) {
|
||||
logger.debug("Recherche du profil pour l'utilisateur: {}", userId);
|
||||
return entrepriseProfileRepository.findByUserId(userId);
|
||||
}
|
||||
|
||||
/** Rechercher par budget de projet */
|
||||
public List<EntrepriseProfile> findByBudgetRange(BigDecimal budgetMin, BigDecimal budgetMax) {
|
||||
logger.debug(
|
||||
"Recherche par budget - min: {}, max: {}", budgetMin, budgetMax);
|
||||
return entrepriseProfileRepository.findByBudgetRange(budgetMin, budgetMax);
|
||||
}
|
||||
|
||||
/** Récupérer les statistiques des profils */
|
||||
public Map<String, Object> getStatistics() {
|
||||
logger.debug("Récupération des statistiques des profils");
|
||||
Map<String, Object> stats = new HashMap<>();
|
||||
stats.put("total", entrepriseProfileRepository.countVisible());
|
||||
stats.put("certifies", entrepriseProfileRepository.countCertifies());
|
||||
stats.put(
|
||||
"recemmentActifs",
|
||||
entrepriseProfileRepository.findRecentlyActive(30).size());
|
||||
stats.put(
|
||||
"avecAbonnementActif",
|
||||
entrepriseProfileRepository.findWithActiveSubscription().size());
|
||||
return stats;
|
||||
}
|
||||
|
||||
// === MÉTHODES DE CRÉATION - ARCHITECTURE 2025 ===
|
||||
|
||||
/** Créer un nouveau profil d'entreprise */
|
||||
@Transactional
|
||||
public EntrepriseProfile create(EntrepriseProfile profile) {
|
||||
logger.info("Création d'un nouveau profil d'entreprise: {}", profile.getNomCommercial());
|
||||
|
||||
// Vérifier que l'utilisateur propriétaire existe
|
||||
if (profile.getProprietaire() == null || profile.getProprietaire().getId() == null) {
|
||||
throw new BadRequestException("Un utilisateur propriétaire doit être spécifié");
|
||||
}
|
||||
|
||||
Optional<User> user =
|
||||
userRepository.findByIdOptional(profile.getProprietaire().getId());
|
||||
if (user.isEmpty()) {
|
||||
throw new NotFoundException(
|
||||
"Utilisateur non trouvé avec l'ID: " + profile.getProprietaire().getId());
|
||||
}
|
||||
|
||||
// Vérifier qu'un profil n'existe pas déjà pour cet utilisateur
|
||||
if (entrepriseProfileRepository.findByUserId(profile.getProprietaire().getId()).isPresent()) {
|
||||
throw new BadRequestException(
|
||||
"Un profil d'entreprise existe déjà pour cet utilisateur");
|
||||
}
|
||||
|
||||
// Initialiser les valeurs par défaut
|
||||
if (profile.getDateCreation() == null) {
|
||||
profile.setDateCreation(LocalDateTime.now());
|
||||
}
|
||||
if (profile.getDateModification() == null) {
|
||||
profile.setDateModification(LocalDateTime.now());
|
||||
}
|
||||
if (profile.getNoteGlobale() == null) {
|
||||
profile.setNoteGlobale(BigDecimal.ZERO);
|
||||
}
|
||||
if (profile.getNombreAvis() == null) {
|
||||
profile.setNombreAvis(0);
|
||||
}
|
||||
if (profile.getVisible() == null) {
|
||||
profile.setVisible(true);
|
||||
}
|
||||
if (profile.getCertifie() == null) {
|
||||
profile.setCertifie(false);
|
||||
}
|
||||
if (profile.getTypeAbonnement() == null) {
|
||||
profile.setTypeAbonnement(TypeAbonnement.GRATUIT);
|
||||
}
|
||||
|
||||
entrepriseProfileRepository.persist(profile);
|
||||
logger.debug("Profil d'entreprise créé avec succès: {}", profile.getId());
|
||||
return profile;
|
||||
}
|
||||
|
||||
// === MÉTHODES DE MISE À JOUR - ARCHITECTURE 2025 ===
|
||||
|
||||
/** Mettre à jour un profil d'entreprise */
|
||||
@Transactional
|
||||
public EntrepriseProfile update(UUID id, EntrepriseProfile profileUpdate) {
|
||||
logger.info("Mise à jour du profil d'entreprise: {}", id);
|
||||
|
||||
EntrepriseProfile profile = findByIdRequired(id);
|
||||
|
||||
// Mise à jour des champs modifiables
|
||||
if (profileUpdate.getNomCommercial() != null) {
|
||||
profile.setNomCommercial(profileUpdate.getNomCommercial());
|
||||
}
|
||||
if (profileUpdate.getDescription() != null) {
|
||||
profile.setDescription(profileUpdate.getDescription());
|
||||
}
|
||||
if (profileUpdate.getSlogan() != null) {
|
||||
profile.setSlogan(profileUpdate.getSlogan());
|
||||
}
|
||||
if (profileUpdate.getSpecialites() != null) {
|
||||
profile.setSpecialites(profileUpdate.getSpecialites());
|
||||
}
|
||||
if (profileUpdate.getCertifications() != null) {
|
||||
profile.setCertifications(profileUpdate.getCertifications());
|
||||
}
|
||||
if (profileUpdate.getAdresseComplete() != null) {
|
||||
profile.setAdresseComplete(profileUpdate.getAdresseComplete());
|
||||
}
|
||||
if (profileUpdate.getCodePostal() != null) {
|
||||
profile.setCodePostal(profileUpdate.getCodePostal());
|
||||
}
|
||||
if (profileUpdate.getVille() != null) {
|
||||
profile.setVille(profileUpdate.getVille());
|
||||
}
|
||||
if (profileUpdate.getDepartement() != null) {
|
||||
profile.setDepartement(profileUpdate.getDepartement());
|
||||
}
|
||||
if (profileUpdate.getRegion() != null) {
|
||||
profile.setRegion(profileUpdate.getRegion());
|
||||
}
|
||||
if (profileUpdate.getZonesIntervention() != null) {
|
||||
profile.setZonesIntervention(profileUpdate.getZonesIntervention());
|
||||
}
|
||||
if (profileUpdate.getSiteWeb() != null) {
|
||||
profile.setSiteWeb(profileUpdate.getSiteWeb());
|
||||
}
|
||||
if (profileUpdate.getEmailContact() != null) {
|
||||
profile.setEmailContact(profileUpdate.getEmailContact());
|
||||
}
|
||||
if (profileUpdate.getTelephoneCommercial() != null) {
|
||||
profile.setTelephoneCommercial(profileUpdate.getTelephoneCommercial());
|
||||
}
|
||||
if (profileUpdate.getLogoUrl() != null) {
|
||||
profile.setLogoUrl(profileUpdate.getLogoUrl());
|
||||
}
|
||||
if (profileUpdate.getPhotosRealisations() != null) {
|
||||
profile.setPhotosRealisations(profileUpdate.getPhotosRealisations());
|
||||
}
|
||||
if (profileUpdate.getVisible() != null) {
|
||||
profile.setVisible(profileUpdate.getVisible());
|
||||
}
|
||||
if (profileUpdate.getCertifie() != null) {
|
||||
profile.setCertifie(profileUpdate.getCertifie());
|
||||
}
|
||||
if (profileUpdate.getBudgetMinProjet() != null) {
|
||||
profile.setBudgetMinProjet(profileUpdate.getBudgetMinProjet());
|
||||
}
|
||||
if (profileUpdate.getBudgetMaxProjet() != null) {
|
||||
profile.setBudgetMaxProjet(profileUpdate.getBudgetMaxProjet());
|
||||
}
|
||||
|
||||
profile.setDateModification(LocalDateTime.now());
|
||||
profile.setDerniereMiseAJour(LocalDateTime.now());
|
||||
|
||||
entrepriseProfileRepository.persist(profile);
|
||||
logger.debug("Profil d'entreprise mis à jour avec succès: {}", id);
|
||||
return profile;
|
||||
}
|
||||
|
||||
/** Mettre à jour la note d'un profil */
|
||||
@Transactional
|
||||
public EntrepriseProfile updateNote(UUID id, BigDecimal nouvelleNote, int nouveauNombreAvis) {
|
||||
logger.info(
|
||||
"Mise à jour de la note du profil {}: note={}, nombreAvis={}",
|
||||
id,
|
||||
nouvelleNote,
|
||||
nouveauNombreAvis);
|
||||
|
||||
EntrepriseProfile profile = findByIdRequired(id);
|
||||
profile.updateNote(nouvelleNote, nouveauNombreAvis);
|
||||
return profile;
|
||||
}
|
||||
|
||||
/** Incrémenter le nombre de projets réalisés */
|
||||
@Transactional
|
||||
public EntrepriseProfile incrementerProjets(UUID id) {
|
||||
logger.debug("Incrémentation des projets pour le profil: {}", id);
|
||||
EntrepriseProfile profile = findByIdRequired(id);
|
||||
profile.incrementerProjets();
|
||||
return profile;
|
||||
}
|
||||
|
||||
/** Incrémenter le nombre de clients servis */
|
||||
@Transactional
|
||||
public EntrepriseProfile incrementerClients(UUID id) {
|
||||
logger.debug("Incrémentation des clients pour le profil: {}", id);
|
||||
EntrepriseProfile profile = findByIdRequired(id);
|
||||
profile.incrementerClients();
|
||||
return profile;
|
||||
}
|
||||
|
||||
// === MÉTHODES DE SUPPRESSION - ARCHITECTURE 2025 ===
|
||||
|
||||
/** Supprimer un profil (soft delete - rendre invisible) */
|
||||
@Transactional
|
||||
public void delete(UUID id) {
|
||||
logger.info("Suppression (soft delete) du profil d'entreprise: {}", id);
|
||||
EntrepriseProfile profile = findByIdRequired(id);
|
||||
profile.setVisible(false);
|
||||
profile.setDateModification(LocalDateTime.now());
|
||||
entrepriseProfileRepository.persist(profile);
|
||||
logger.debug("Profil d'entreprise désactivé avec succès: {}", id);
|
||||
}
|
||||
|
||||
/** Supprimer définitivement un profil */
|
||||
@Transactional
|
||||
public void deletePermanently(UUID id) {
|
||||
logger.info("Suppression définitive du profil d'entreprise: {}", id);
|
||||
entrepriseProfileRepository.deleteById(id);
|
||||
logger.debug("Profil d'entreprise supprimé définitivement: {}", id);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,200 @@
|
||||
package dev.lions.btpxpress.application.service;
|
||||
|
||||
import dev.lions.btpxpress.domain.core.entity.ZoneClimatique;
|
||||
import dev.lions.btpxpress.domain.infrastructure.repository.ZoneClimatiqueRepository;
|
||||
import jakarta.enterprise.context.ApplicationScoped;
|
||||
import jakarta.inject.Inject;
|
||||
import jakarta.transaction.Transactional;
|
||||
import jakarta.ws.rs.NotFoundException;
|
||||
import java.math.BigDecimal;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* Service de gestion des zones climatiques africaines
|
||||
* Architecture 2025 : Service complet pour la gestion des contraintes climatiques de construction
|
||||
*/
|
||||
@ApplicationScoped
|
||||
public class ZoneClimatiqueService {
|
||||
|
||||
private static final Logger logger = LoggerFactory.getLogger(ZoneClimatiqueService.class);
|
||||
|
||||
@Inject ZoneClimatiqueRepository zoneClimatiqueRepository;
|
||||
|
||||
// === MÉTHODES DE RECHERCHE - ARCHITECTURE 2025 ===
|
||||
|
||||
/** Récupérer toutes les zones climatiques actives */
|
||||
public List<ZoneClimatique> findAll() {
|
||||
logger.debug("Recherche de toutes les zones climatiques actives");
|
||||
return zoneClimatiqueRepository.findAllActives();
|
||||
}
|
||||
|
||||
/** Récupérer toutes les zones (actives et inactives) */
|
||||
public List<ZoneClimatique> findAllIncludingInactive() {
|
||||
logger.debug("Recherche de toutes les zones climatiques (actives et inactives)");
|
||||
return zoneClimatiqueRepository.listAll();
|
||||
}
|
||||
|
||||
/** Récupérer une zone par ID */
|
||||
public ZoneClimatique findById(Long id) {
|
||||
logger.debug("Recherche de la zone climatique avec l'ID: {}", id);
|
||||
ZoneClimatique zone = zoneClimatiqueRepository.findById(id);
|
||||
if (zone == null) {
|
||||
throw new NotFoundException("Zone climatique non trouvée avec l'ID: " + id);
|
||||
}
|
||||
return zone;
|
||||
}
|
||||
|
||||
/** Récupérer une zone par code */
|
||||
public ZoneClimatique findByCode(String code) {
|
||||
logger.debug("Recherche de la zone climatique avec le code: {}", code);
|
||||
return zoneClimatiqueRepository
|
||||
.findByCode(code)
|
||||
.orElseThrow(() -> new NotFoundException("Zone climatique non trouvée avec le code: " + code));
|
||||
}
|
||||
|
||||
/** Rechercher par température */
|
||||
public List<ZoneClimatique> findByTemperatureRange(BigDecimal tempMin, BigDecimal tempMax) {
|
||||
return zoneClimatiqueRepository.findByTemperatureRange(tempMin, tempMax);
|
||||
}
|
||||
|
||||
/** Rechercher par pluviométrie */
|
||||
public List<ZoneClimatique> findByPluviometrie(Integer pluvioMin, Integer pluvioMax) {
|
||||
return zoneClimatiqueRepository.findByPluviometrie(pluvioMin, pluvioMax);
|
||||
}
|
||||
|
||||
/** Zones avec risque sismique */
|
||||
public List<ZoneClimatique> findAvecRisqueSeisme() {
|
||||
return zoneClimatiqueRepository.findAvecRisqueSeisme();
|
||||
}
|
||||
|
||||
/** Zones avec risque cyclonique */
|
||||
public List<ZoneClimatique> findAvecRisqueCyclones() {
|
||||
return zoneClimatiqueRepository.findAvecRisqueCyclones();
|
||||
}
|
||||
|
||||
/** Recherche avancée */
|
||||
public List<ZoneClimatique> search(
|
||||
BigDecimal tempMin,
|
||||
BigDecimal tempMax,
|
||||
Integer pluvioMin,
|
||||
Integer pluvioMax,
|
||||
Boolean risqueSeisme,
|
||||
Boolean corrosionMarine,
|
||||
String texte) {
|
||||
return zoneClimatiqueRepository.searchAdvanced(
|
||||
tempMin, tempMax, pluvioMin, pluvioMax, risqueSeisme, corrosionMarine, texte);
|
||||
}
|
||||
|
||||
// === MÉTHODES DE CRÉATION - ARCHITECTURE 2025 ===
|
||||
|
||||
/** Créer une nouvelle zone climatique */
|
||||
@Transactional
|
||||
public ZoneClimatique create(ZoneClimatique zone) {
|
||||
logger.info("Création d'une nouvelle zone climatique: {}", zone.getCode());
|
||||
|
||||
// Vérifier l'unicité du code
|
||||
if (zoneClimatiqueRepository.existsByCode(zone.getCode())) {
|
||||
logger.warn("Tentative de création d'une zone avec un code existant: {}", zone.getCode());
|
||||
throw new IllegalArgumentException("Une zone avec le code '" + zone.getCode() + "' existe déjà");
|
||||
}
|
||||
|
||||
zone.setActif(true);
|
||||
zoneClimatiqueRepository.persist(zone);
|
||||
logger.debug("Zone climatique créée avec succès: {}", zone.getId());
|
||||
return zone;
|
||||
}
|
||||
|
||||
// === MÉTHODES DE MODIFICATION - ARCHITECTURE 2025 ===
|
||||
|
||||
/** Mettre à jour une zone climatique */
|
||||
@Transactional
|
||||
public ZoneClimatique update(Long id, ZoneClimatique zoneData) {
|
||||
logger.info("Modification de la zone climatique ID: {}", id);
|
||||
ZoneClimatique zone = findById(id);
|
||||
|
||||
// Vérifier l'unicłe du code si modifié
|
||||
if (!zone.getCode().equals(zoneData.getCode())
|
||||
&& zoneClimatiqueRepository.existsByCode(zoneData.getCode())) {
|
||||
logger.warn("Tentative de modification vers un code existant: {}", zoneData.getCode());
|
||||
throw new IllegalArgumentException("Une zone avec le code '" + zoneData.getCode() + "' existe déjà");
|
||||
}
|
||||
|
||||
// Mettre à jour les champs
|
||||
zone.setCode(zoneData.getCode());
|
||||
zone.setNom(zoneData.getNom());
|
||||
zone.setDescription(zoneData.getDescription());
|
||||
zone.setTemperatureMin(zoneData.getTemperatureMin());
|
||||
zone.setTemperatureMax(zoneData.getTemperatureMax());
|
||||
zone.setPluviometrieAnnuelle(zoneData.getPluviometrieAnnuelle());
|
||||
zone.setHumiditeMin(zoneData.getHumiditeMin());
|
||||
zone.setHumiditeMax(zoneData.getHumiditeMax());
|
||||
zone.setVentsMaximaux(zoneData.getVentsMaximaux());
|
||||
zone.setRisqueCyclones(zoneData.getRisqueCyclones());
|
||||
zone.setRisqueSeisme(zoneData.getRisqueSeisme());
|
||||
zone.setZoneSeismique(zoneData.getZoneSeismique());
|
||||
zone.setProfondeurFondationsMin(zoneData.getProfondeurFondationsMin());
|
||||
zone.setDrainageObligatoire(zoneData.getDrainageObligatoire());
|
||||
zone.setIsolationThermiqueObligatoire(zoneData.getIsolationThermiqueObligatoire());
|
||||
zone.setVentilationRenforcee(zoneData.getVentilationRenforcee());
|
||||
zone.setProtectionUVObligatoire(zoneData.getProtectionUVObligatoire());
|
||||
zone.setTraitementAntiTermites(zoneData.getTraitementAntiTermites());
|
||||
zone.setResistanceCorrosionMarine(zoneData.getResistanceCorrosionMarine());
|
||||
zone.setNormeSismique(zoneData.getNormeSismique());
|
||||
zone.setNormeCyclonique(zoneData.getNormeCyclonique());
|
||||
zone.setNormeThermique(zoneData.getNormeThermique());
|
||||
zone.setNormePluviale(zoneData.getNormePluviale());
|
||||
zone.setCoefficientNeige(zoneData.getCoefficientNeige());
|
||||
zone.setCoefficientVent(zoneData.getCoefficientVent());
|
||||
zone.setCoefficientSeisme(zoneData.getCoefficientSeisme());
|
||||
zone.setPenteToitureMin(zoneData.getPenteToitureMin());
|
||||
zone.setEvacuationEPMin(zoneData.getEvacuationEPMin());
|
||||
|
||||
logger.debug("Zone climatique mise à jour avec succès: {}", id);
|
||||
return zone;
|
||||
}
|
||||
|
||||
/** Activer une zone */
|
||||
@Transactional
|
||||
public ZoneClimatique activate(Long id) {
|
||||
ZoneClimatique zone = findById(id);
|
||||
zone.setActif(true);
|
||||
return zone;
|
||||
}
|
||||
|
||||
/** Désactiver une zone */
|
||||
@Transactional
|
||||
public ZoneClimatique deactivate(Long id) {
|
||||
ZoneClimatique zone = findById(id);
|
||||
zone.setActif(false);
|
||||
return zone;
|
||||
}
|
||||
|
||||
/** Supprimer une zone */
|
||||
@Transactional
|
||||
public void delete(Long id) {
|
||||
ZoneClimatique zone = findById(id);
|
||||
zoneClimatiqueRepository.delete(zone);
|
||||
}
|
||||
|
||||
// === MÉTHODES STATISTIQUES - ARCHITECTURE 2025 ===
|
||||
|
||||
/** Obtenir les statistiques des zones climatiques */
|
||||
public Map<String, Object> getStatistics() {
|
||||
logger.debug("Calcul des statistiques des zones climatiques");
|
||||
Map<String, Object> stats = new HashMap<>();
|
||||
List<ZoneClimatique> all = findAll();
|
||||
|
||||
stats.put("total", all.size());
|
||||
stats.put("avecRisqueSeisme", findAvecRisqueSeisme().size());
|
||||
stats.put("avecRisqueCyclones", findAvecRisqueCyclones().size());
|
||||
stats.put("avecCorrosionMarine", zoneClimatiqueRepository.findAvecCorrosionMarine().size());
|
||||
stats.put("avecDrainageObligatoire", zoneClimatiqueRepository.findAvecDrainageObligatoire().size());
|
||||
|
||||
return stats;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,316 @@
|
||||
package dev.lions.btpxpress.domain.core.entity;
|
||||
|
||||
import io.quarkus.hibernate.orm.panache.PanacheEntityBase;
|
||||
import jakarta.persistence.*;
|
||||
import jakarta.validation.constraints.NotNull;
|
||||
import java.math.BigDecimal;
|
||||
import java.time.LocalDate;
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.UUID;
|
||||
import org.hibernate.annotations.CreationTimestamp;
|
||||
import org.hibernate.annotations.UpdateTimestamp;
|
||||
|
||||
/**
|
||||
* Entité Abonnement - Représente un abonnement actif d'une entreprise
|
||||
* Architecture 2025 : Gestion complète du cycle de vie des abonnements
|
||||
*/
|
||||
@Entity
|
||||
@Table(name = "abonnements")
|
||||
public class Abonnement extends PanacheEntityBase {
|
||||
|
||||
@Id
|
||||
@GeneratedValue
|
||||
@Column(name = "id", updatable = false, nullable = false)
|
||||
private UUID id;
|
||||
|
||||
/** Entreprise propriétaire de l'abonnement */
|
||||
@ManyToOne(fetch = FetchType.LAZY)
|
||||
@JoinColumn(name = "entreprise_id", nullable = false)
|
||||
@NotNull(message = "L'entreprise est obligatoire")
|
||||
private EntrepriseProfile entreprise;
|
||||
|
||||
/** Type d'abonnement souscrit */
|
||||
@Enumerated(EnumType.STRING)
|
||||
@Column(name = "type_abonnement", nullable = false)
|
||||
@NotNull(message = "Le type d'abonnement est obligatoire")
|
||||
private TypeAbonnement typeAbonnement;
|
||||
|
||||
/** Statut actuel de l'abonnement */
|
||||
@Enumerated(EnumType.STRING)
|
||||
@Column(name = "statut", nullable = false)
|
||||
@NotNull(message = "Le statut est obligatoire")
|
||||
private StatutAbonnement statut;
|
||||
|
||||
/** Date de début de l'abonnement */
|
||||
@Column(name = "date_debut", nullable = false)
|
||||
@NotNull(message = "La date de début est obligatoire")
|
||||
private LocalDate dateDebut;
|
||||
|
||||
/** Date de fin de l'abonnement */
|
||||
@Column(name = "date_fin", nullable = false)
|
||||
@NotNull(message = "La date de fin est obligatoire")
|
||||
private LocalDate dateFin;
|
||||
|
||||
/** Prix payé pour cet abonnement */
|
||||
@Column(name = "prix_paye", nullable = false, precision = 10, scale = 2)
|
||||
@NotNull(message = "Le prix payé est obligatoire")
|
||||
private BigDecimal prixPaye;
|
||||
|
||||
/** Méthode de paiement utilisée */
|
||||
@Column(name = "methode_paiement", length = 50)
|
||||
private String methodePaiement;
|
||||
|
||||
/** Renouvellement automatique activé */
|
||||
@Column(name = "auto_renouvellement", nullable = false)
|
||||
private boolean autoRenouvellement = true;
|
||||
|
||||
/** Référence de transaction de paiement */
|
||||
@Column(name = "reference_paiement", length = 100)
|
||||
private String referencePaiement;
|
||||
|
||||
/** Date de la dernière facture */
|
||||
@Column(name = "date_derniere_facture")
|
||||
private LocalDate dateDerniereFacture;
|
||||
|
||||
/** Date du prochain prélèvement */
|
||||
@Column(name = "date_prochain_prelevement")
|
||||
private LocalDate dateProchainPrelevement;
|
||||
|
||||
/** Nombre de mises en relation utilisées ce mois */
|
||||
@Column(name = "mises_en_relation_utilisees", nullable = false)
|
||||
private int misesEnRelationUtilisees = 0;
|
||||
|
||||
/** Date de création de l'abonnement */
|
||||
@CreationTimestamp
|
||||
@Column(name = "date_creation", nullable = false, updatable = false)
|
||||
private LocalDateTime dateCreation;
|
||||
|
||||
/** Date de dernière modification */
|
||||
@UpdateTimestamp
|
||||
@Column(name = "date_modification", nullable = false)
|
||||
private LocalDateTime dateModification;
|
||||
|
||||
/** Notes administratives */
|
||||
@Column(name = "notes", columnDefinition = "TEXT")
|
||||
private String notes;
|
||||
|
||||
// === CONSTRUCTEURS ===
|
||||
|
||||
public Abonnement() {}
|
||||
|
||||
public Abonnement(
|
||||
EntrepriseProfile entreprise,
|
||||
TypeAbonnement typeAbonnement,
|
||||
LocalDate dateDebut,
|
||||
LocalDate dateFin,
|
||||
BigDecimal prixPaye) {
|
||||
this.entreprise = entreprise;
|
||||
this.typeAbonnement = typeAbonnement;
|
||||
this.dateDebut = dateDebut;
|
||||
this.dateFin = dateFin;
|
||||
this.prixPaye = prixPaye;
|
||||
this.statut = StatutAbonnement.ACTIF;
|
||||
this.autoRenouvellement = true;
|
||||
}
|
||||
|
||||
// === MÉTHODES MÉTIER ===
|
||||
|
||||
/** Vérifie si l'abonnement est actif */
|
||||
public boolean estActif() {
|
||||
return this.statut == StatutAbonnement.ACTIF
|
||||
&& LocalDate.now().isBefore(this.dateFin.plusDays(1));
|
||||
}
|
||||
|
||||
/** Vérifie si l'abonnement est expiré */
|
||||
public boolean estExpire() {
|
||||
return LocalDate.now().isAfter(this.dateFin);
|
||||
}
|
||||
|
||||
/** Vérifie si l'abonnement arrive à expiration (dans les 7 jours) */
|
||||
public boolean bientotExpire() {
|
||||
return estActif()
|
||||
&& LocalDate.now().plusDays(7).isAfter(this.dateFin)
|
||||
&& LocalDate.now().isBefore(this.dateFin.plusDays(1));
|
||||
}
|
||||
|
||||
/** Renouveler l'abonnement */
|
||||
public void renouveler(LocalDate nouvelleDateFin, BigDecimal nouveauPrix) {
|
||||
this.dateFin = nouvelleDateFin;
|
||||
this.prixPaye = nouveauPrix;
|
||||
this.statut = StatutAbonnement.ACTIF;
|
||||
this.dateDerniereFacture = LocalDate.now();
|
||||
this.dateModification = LocalDateTime.now();
|
||||
}
|
||||
|
||||
/** Annuler l'abonnement */
|
||||
public void annuler() {
|
||||
this.statut = StatutAbonnement.ANNULE;
|
||||
this.autoRenouvellement = false;
|
||||
this.dateModification = LocalDateTime.now();
|
||||
}
|
||||
|
||||
/** Suspendre l'abonnement */
|
||||
public void suspendre() {
|
||||
this.statut = StatutAbonnement.SUSPENDU;
|
||||
this.dateModification = LocalDateTime.now();
|
||||
}
|
||||
|
||||
/** Réactiver l'abonnement */
|
||||
public void reactiver() {
|
||||
if (this.statut == StatutAbonnement.SUSPENDU) {
|
||||
this.statut = StatutAbonnement.ACTIF;
|
||||
this.dateModification = LocalDateTime.now();
|
||||
}
|
||||
}
|
||||
|
||||
/** Incrémenter le compteur de mises en relation */
|
||||
public void incrementerMisesEnRelation() {
|
||||
this.misesEnRelationUtilisees++;
|
||||
}
|
||||
|
||||
/** Réinitialiser le compteur de mises en relation (début de mois) */
|
||||
public void reinitialiserCompteurMisesEnRelation() {
|
||||
this.misesEnRelationUtilisees = 0;
|
||||
}
|
||||
|
||||
/** Vérifie si la limite de mises en relation est atteinte */
|
||||
public boolean limiteMisesEnRelationAtteinte() {
|
||||
int limite = this.typeAbonnement.getLimiteMisesEnRelation();
|
||||
return limite != Integer.MAX_VALUE && this.misesEnRelationUtilisees >= limite;
|
||||
}
|
||||
|
||||
/** Calcule le nombre de jours restants */
|
||||
public long joursRestants() {
|
||||
return java.time.temporal.ChronoUnit.DAYS.between(LocalDate.now(), this.dateFin);
|
||||
}
|
||||
|
||||
// === GETTERS ET SETTERS ===
|
||||
|
||||
public UUID getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
public void setId(UUID id) {
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
public EntrepriseProfile getEntreprise() {
|
||||
return entreprise;
|
||||
}
|
||||
|
||||
public void setEntreprise(EntrepriseProfile entreprise) {
|
||||
this.entreprise = entreprise;
|
||||
}
|
||||
|
||||
public TypeAbonnement getTypeAbonnement() {
|
||||
return typeAbonnement;
|
||||
}
|
||||
|
||||
public void setTypeAbonnement(TypeAbonnement typeAbonnement) {
|
||||
this.typeAbonnement = typeAbonnement;
|
||||
}
|
||||
|
||||
public StatutAbonnement getStatut() {
|
||||
return statut;
|
||||
}
|
||||
|
||||
public void setStatut(StatutAbonnement statut) {
|
||||
this.statut = statut;
|
||||
}
|
||||
|
||||
public LocalDate getDateDebut() {
|
||||
return dateDebut;
|
||||
}
|
||||
|
||||
public void setDateDebut(LocalDate dateDebut) {
|
||||
this.dateDebut = dateDebut;
|
||||
}
|
||||
|
||||
public LocalDate getDateFin() {
|
||||
return dateFin;
|
||||
}
|
||||
|
||||
public void setDateFin(LocalDate dateFin) {
|
||||
this.dateFin = dateFin;
|
||||
}
|
||||
|
||||
public BigDecimal getPrixPaye() {
|
||||
return prixPaye;
|
||||
}
|
||||
|
||||
public void setPrixPaye(BigDecimal prixPaye) {
|
||||
this.prixPaye = prixPaye;
|
||||
}
|
||||
|
||||
public String getMethodePaiement() {
|
||||
return methodePaiement;
|
||||
}
|
||||
|
||||
public void setMethodePaiement(String methodePaiement) {
|
||||
this.methodePaiement = methodePaiement;
|
||||
}
|
||||
|
||||
public boolean isAutoRenouvellement() {
|
||||
return autoRenouvellement;
|
||||
}
|
||||
|
||||
public void setAutoRenouvellement(boolean autoRenouvellement) {
|
||||
this.autoRenouvellement = autoRenouvellement;
|
||||
}
|
||||
|
||||
public String getReferencePaiement() {
|
||||
return referencePaiement;
|
||||
}
|
||||
|
||||
public void setReferencePaiement(String referencePaiement) {
|
||||
this.referencePaiement = referencePaiement;
|
||||
}
|
||||
|
||||
public LocalDate getDateDerniereFacture() {
|
||||
return dateDerniereFacture;
|
||||
}
|
||||
|
||||
public void setDateDerniereFacture(LocalDate dateDerniereFacture) {
|
||||
this.dateDerniereFacture = dateDerniereFacture;
|
||||
}
|
||||
|
||||
public LocalDate getDateProchainPrelevement() {
|
||||
return dateProchainPrelevement;
|
||||
}
|
||||
|
||||
public void setDateProchainPrelevement(LocalDate dateProchainPrelevement) {
|
||||
this.dateProchainPrelevement = dateProchainPrelevement;
|
||||
}
|
||||
|
||||
public int getMisesEnRelationUtilisees() {
|
||||
return misesEnRelationUtilisees;
|
||||
}
|
||||
|
||||
public void setMisesEnRelationUtilisees(int misesEnRelationUtilisees) {
|
||||
this.misesEnRelationUtilisees = misesEnRelationUtilisees;
|
||||
}
|
||||
|
||||
public LocalDateTime getDateCreation() {
|
||||
return dateCreation;
|
||||
}
|
||||
|
||||
public void setDateCreation(LocalDateTime dateCreation) {
|
||||
this.dateCreation = dateCreation;
|
||||
}
|
||||
|
||||
public LocalDateTime getDateModification() {
|
||||
return dateModification;
|
||||
}
|
||||
|
||||
public void setDateModification(LocalDateTime dateModification) {
|
||||
this.dateModification = dateModification;
|
||||
}
|
||||
|
||||
public String getNotes() {
|
||||
return notes;
|
||||
}
|
||||
|
||||
public void setNotes(String notes) {
|
||||
this.notes = notes;
|
||||
}
|
||||
}
|
||||
@@ -1,39 +1,22 @@
|
||||
package dev.lions.btpxpress.domain.core.entity;
|
||||
|
||||
/** Énumération des catégories de stock pour le BTP */
|
||||
/**
|
||||
* Enum représentant les catégories de stock prédéfinies
|
||||
*/
|
||||
public enum CategorieStock {
|
||||
MATERIAUX_CONSTRUCTION("Matériaux de construction", "Matériaux de base pour la construction"),
|
||||
OUTILLAGE("Outillage", "Outils et équipements de travail"),
|
||||
QUINCAILLERIE("Quincaillerie", "Petites pièces métalliques et accessoires"),
|
||||
EQUIPEMENTS_SECURITE("Équipements de sécurité", "EPI et matériel de sécurité"),
|
||||
EQUIPEMENTS_TECHNIQUES("Équipements techniques", "Équipements électriques, plomberie, chauffage"),
|
||||
CONSOMMABLES("Consommables", "Produits consommables et d'entretien"),
|
||||
VEHICULES_ENGINS("Véhicules et engins", "Véhicules, engins de chantier"),
|
||||
FOURNITURES_BUREAU("Fournitures de bureau", "Matériel et fournitures administratives"),
|
||||
PRODUITS_CHIMIQUES("Produits chimiques", "Produits chimiques et dangereux"),
|
||||
PIECES_DETACHEES("Pièces détachées", "Pièces de rechange pour équipements"),
|
||||
EQUIPEMENTS_MESURE("Équipements de mesure", "Instruments de mesure et contrôle"),
|
||||
MOBILIER("Mobilier", "Mobilier de chantier et de bureau"),
|
||||
AUTRE("Autre", "Autres catégories");
|
||||
MATERIAUX("Matériaux de construction"),
|
||||
OUTILLAGE("Outillage et équipements"),
|
||||
EQUIPEMENTS("Équipements de chantier"),
|
||||
SECURITE("Équipements de sécurité"),
|
||||
FINITION("Matériaux de finition");
|
||||
|
||||
private final String libelle;
|
||||
private final String description;
|
||||
|
||||
CategorieStock(String libelle, String description) {
|
||||
this.libelle = libelle;
|
||||
CategorieStock(String description) {
|
||||
this.description = description;
|
||||
}
|
||||
|
||||
public String getLibelle() {
|
||||
return libelle;
|
||||
}
|
||||
|
||||
public String getDescription() {
|
||||
return description;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return libelle;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
package dev.lions.btpxpress.domain.core.entity;
|
||||
|
||||
/**
|
||||
* Statuts possibles pour un abonnement
|
||||
* Architecture 2025 : Gestion complète du cycle de vie des abonnements
|
||||
*/
|
||||
public enum StatutAbonnement {
|
||||
|
||||
/** Abonnement actif et opérationnel */
|
||||
ACTIF("Actif", "L'abonnement est actif et toutes les fonctionnalités sont accessibles"),
|
||||
|
||||
/** Abonnement expiré */
|
||||
EXPIRE("Expiré", "L'abonnement a dépassé sa date de fin"),
|
||||
|
||||
/** Abonnement annulé par l'utilisateur */
|
||||
ANNULE("Annulé", "L'abonnement a été annulé et ne peut plus être utilisé"),
|
||||
|
||||
/** Abonnement suspendu temporairement */
|
||||
SUSPENDU(
|
||||
"Suspendu",
|
||||
"L'abonnement est temporairement suspendu (problème de paiement, violation des CGU, etc.)"),
|
||||
|
||||
/** En attente de validation de paiement */
|
||||
EN_ATTENTE_PAIEMENT(
|
||||
"En attente de paiement", "L'abonnement est en attente de confirmation du paiement"),
|
||||
|
||||
/** Période d'essai */
|
||||
ESSAI("Période d'essai", "L'abonnement est en période d'essai gratuite");
|
||||
|
||||
private final String libelle;
|
||||
private final String description;
|
||||
|
||||
StatutAbonnement(String libelle, String description) {
|
||||
this.libelle = libelle;
|
||||
this.description = description;
|
||||
}
|
||||
|
||||
public String getLibelle() {
|
||||
return libelle;
|
||||
}
|
||||
|
||||
public String getDescription() {
|
||||
return description;
|
||||
}
|
||||
|
||||
public boolean estActif() {
|
||||
return this == ACTIF || this == ESSAI;
|
||||
}
|
||||
|
||||
public boolean estInactif() {
|
||||
return this == EXPIRE || this == ANNULE || this == SUSPENDU;
|
||||
}
|
||||
|
||||
public boolean peutEtreReactive() {
|
||||
return this == SUSPENDU || this == EXPIRE;
|
||||
}
|
||||
}
|
||||
@@ -28,39 +28,6 @@ public enum UserRole {
|
||||
return description;
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérification des permissions - COMPATIBILITÉ ASCENDANTE
|
||||
*
|
||||
* @deprecated Utiliser PermissionService.hasPermission() pour le nouveau système
|
||||
*/
|
||||
@Deprecated
|
||||
public boolean hasPermission(String permission) {
|
||||
return switch (this) {
|
||||
case ADMIN -> true; // Admin a tous les droits
|
||||
case MANAGER ->
|
||||
permission.startsWith("dashboard:")
|
||||
|| permission.startsWith("clients:")
|
||||
|| permission.startsWith("chantiers:")
|
||||
|| permission.startsWith("devis:")
|
||||
|| permission.startsWith("factures:");
|
||||
case CHEF_CHANTIER ->
|
||||
permission.startsWith("dashboard:read")
|
||||
|| permission.startsWith("chantiers:")
|
||||
|| permission.startsWith("devis:read");
|
||||
case COMPTABLE ->
|
||||
permission.startsWith("dashboard:read")
|
||||
|| permission.startsWith("factures:")
|
||||
|| permission.startsWith("devis:read");
|
||||
case OUVRIER -> permission.equals("dashboard:read") || permission.equals("chantiers:read");
|
||||
case GESTIONNAIRE_PROJET ->
|
||||
permission.startsWith("dashboard:")
|
||||
|| permission.startsWith("clients:")
|
||||
|| permission.startsWith("chantiers:")
|
||||
|| permission.startsWith("devis:")
|
||||
|| permission.startsWith("factures:read");
|
||||
};
|
||||
}
|
||||
|
||||
/** Vérifie si ce rôle est un rôle de gestion */
|
||||
public boolean isManagementRole() {
|
||||
return this == ADMIN || this == MANAGER || this == GESTIONNAIRE_PROJET;
|
||||
|
||||
@@ -0,0 +1,119 @@
|
||||
package dev.lions.btpxpress.domain.infrastructure.repository;
|
||||
|
||||
import dev.lions.btpxpress.domain.core.entity.Abonnement;
|
||||
import dev.lions.btpxpress.domain.core.entity.StatutAbonnement;
|
||||
import dev.lions.btpxpress.domain.core.entity.TypeAbonnement;
|
||||
import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
|
||||
import jakarta.enterprise.context.ApplicationScoped;
|
||||
import java.time.LocalDate;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Repository pour la gestion des abonnements
|
||||
* Architecture 2025 : Accès aux données avec méthodes de recherche optimisées
|
||||
*/
|
||||
@ApplicationScoped
|
||||
public class AbonnementRepository implements PanacheRepositoryBase<Abonnement, UUID> {
|
||||
|
||||
/** Trouver tous les abonnements actifs */
|
||||
public List<Abonnement> findActifs() {
|
||||
return list(
|
||||
"statut = ?1 AND dateFin >= ?2 ORDER BY dateDebut DESC",
|
||||
StatutAbonnement.ACTIF,
|
||||
LocalDate.now());
|
||||
}
|
||||
|
||||
/** Trouver tous les abonnements expirés */
|
||||
public List<Abonnement> findExpires() {
|
||||
return list(
|
||||
"statut = ?1 OR (statut = ?2 AND dateFin < ?3) ORDER BY dateFin DESC",
|
||||
StatutAbonnement.EXPIRE,
|
||||
StatutAbonnement.ACTIF,
|
||||
LocalDate.now());
|
||||
}
|
||||
|
||||
/** Trouver l'abonnement actif d'une entreprise */
|
||||
public Optional<Abonnement> findAbonnementActifByEntreprise(UUID entrepriseId) {
|
||||
return find(
|
||||
"entreprise.id = ?1 AND statut = ?2 AND dateFin >= ?3 ORDER BY dateDebut DESC",
|
||||
entrepriseId,
|
||||
StatutAbonnement.ACTIF,
|
||||
LocalDate.now())
|
||||
.firstResultOptional();
|
||||
}
|
||||
|
||||
/** Trouver tous les abonnements d'une entreprise */
|
||||
public List<Abonnement> findByEntreprise(UUID entrepriseId) {
|
||||
return list("entreprise.id = ?1 ORDER BY dateDebut DESC", entrepriseId);
|
||||
}
|
||||
|
||||
/** Trouver les abonnements par type */
|
||||
public List<Abonnement> findByType(TypeAbonnement type) {
|
||||
return list("typeAbonnement = ?1 AND statut = ?2 ORDER BY dateDebut DESC", type, StatutAbonnement.ACTIF);
|
||||
}
|
||||
|
||||
/** Trouver les abonnements par statut */
|
||||
public List<Abonnement> findByStatut(StatutAbonnement statut) {
|
||||
return list("statut = ?1 ORDER BY dateDebut DESC", statut);
|
||||
}
|
||||
|
||||
/** Trouver les abonnements qui arrivent à expiration */
|
||||
public List<Abonnement> findBientotExpires(int joursAvantExpiration) {
|
||||
LocalDate dateLimit = LocalDate.now().plusDays(joursAvantExpiration);
|
||||
return list(
|
||||
"statut = ?1 AND dateFin BETWEEN ?2 AND ?3 ORDER BY dateFin ASC",
|
||||
StatutAbonnement.ACTIF,
|
||||
LocalDate.now(),
|
||||
dateLimit);
|
||||
}
|
||||
|
||||
/** Trouver les abonnements avec auto-renouvellement activé */
|
||||
public List<Abonnement> findWithAutoRenew() {
|
||||
return list(
|
||||
"autoRenouvellement = true AND statut = ?1 AND dateFin >= ?2 ORDER BY dateFin ASC",
|
||||
StatutAbonnement.ACTIF,
|
||||
LocalDate.now());
|
||||
}
|
||||
|
||||
/** Trouver les abonnements créés entre deux dates */
|
||||
public List<Abonnement> findByDateCreationBetween(LocalDate dateDebut, LocalDate dateFin) {
|
||||
return list(
|
||||
"DATE(dateCreation) BETWEEN ?1 AND ?2 ORDER BY dateCreation DESC", dateDebut, dateFin);
|
||||
}
|
||||
|
||||
/** Compter les abonnements actifs par type */
|
||||
public long countActifsByType(TypeAbonnement type) {
|
||||
return count(
|
||||
"typeAbonnement = ?1 AND statut = ?2 AND dateFin >= ?3",
|
||||
type,
|
||||
StatutAbonnement.ACTIF,
|
||||
LocalDate.now());
|
||||
}
|
||||
|
||||
/** Compter tous les abonnements actifs */
|
||||
public long countActifs() {
|
||||
return count("statut = ?1 AND dateFin >= ?2", StatutAbonnement.ACTIF, LocalDate.now());
|
||||
}
|
||||
|
||||
/** Trouver les abonnements en attente de renouvellement (prochains 30 jours) */
|
||||
public List<Abonnement> findEnAttenteRenouvellement() {
|
||||
LocalDate dateLimit = LocalDate.now().plusDays(30);
|
||||
return list(
|
||||
"autoRenouvellement = true AND statut = ?1 AND dateFin BETWEEN ?2 AND ?3 ORDER BY dateFin ASC",
|
||||
StatutAbonnement.ACTIF,
|
||||
LocalDate.now(),
|
||||
dateLimit);
|
||||
}
|
||||
|
||||
/** Trouver les abonnements par méthode de paiement */
|
||||
public List<Abonnement> findByMethodePaiement(String methodePaiement) {
|
||||
return list("methodePaiement = ?1 ORDER BY dateDebut DESC", methodePaiement);
|
||||
}
|
||||
|
||||
/** Rechercher les abonnements par référence de paiement */
|
||||
public Optional<Abonnement> findByReferencePaiement(String reference) {
|
||||
return find("referencePaiement = ?1", reference).firstResultOptional();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,137 @@
|
||||
package dev.lions.btpxpress.domain.infrastructure.repository;
|
||||
|
||||
import dev.lions.btpxpress.domain.core.entity.EntrepriseProfile;
|
||||
import dev.lions.btpxpress.domain.core.entity.TypeAbonnement;
|
||||
import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
|
||||
import jakarta.enterprise.context.ApplicationScoped;
|
||||
import java.math.BigDecimal;
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Repository pour les profils d'entreprise
|
||||
* Architecture 2025 : Repository complet pour la gestion des profils d'entreprise
|
||||
*/
|
||||
@ApplicationScoped
|
||||
public class EntrepriseProfileRepository implements PanacheRepositoryBase<EntrepriseProfile, UUID> {
|
||||
|
||||
/** Récupérer tous les profils visibles */
|
||||
public List<EntrepriseProfile> findVisible() {
|
||||
return list("visible = true ORDER BY noteGlobale DESC, nombreAvis DESC");
|
||||
}
|
||||
|
||||
/** Récupérer les profils visibles avec pagination */
|
||||
public List<EntrepriseProfile> findVisible(int page, int size) {
|
||||
return find("visible = true ORDER BY noteGlobale DESC, nombreAvis DESC")
|
||||
.page(page, size)
|
||||
.list();
|
||||
}
|
||||
|
||||
/** Rechercher par zone d'intervention */
|
||||
public List<EntrepriseProfile> findByZoneIntervention(String zone) {
|
||||
return find(
|
||||
"SELECT DISTINCT e FROM EntrepriseProfile e JOIN e.zonesIntervention z WHERE z = ?1 AND e.visible = true ORDER BY e.noteGlobale DESC",
|
||||
zone)
|
||||
.list();
|
||||
}
|
||||
|
||||
/** Rechercher par spécialité */
|
||||
public List<EntrepriseProfile> findBySpecialite(String specialite) {
|
||||
return find(
|
||||
"SELECT DISTINCT e FROM EntrepriseProfile e JOIN e.specialites s WHERE s = ?1 AND e.visible = true ORDER BY e.noteGlobale DESC",
|
||||
specialite)
|
||||
.list();
|
||||
}
|
||||
|
||||
/** Rechercher par région */
|
||||
public List<EntrepriseProfile> findByRegion(String region) {
|
||||
return find("region = ?1 AND visible = true ORDER BY noteGlobale DESC", region).list();
|
||||
}
|
||||
|
||||
/** Rechercher les profils certifiés */
|
||||
public List<EntrepriseProfile> findByCertifie(boolean certifie) {
|
||||
return find("certifie = ?1 AND visible = true ORDER BY noteGlobale DESC", certifie).list();
|
||||
}
|
||||
|
||||
/** Récupérer les mieux notés */
|
||||
public List<EntrepriseProfile> findTopRated(int limit) {
|
||||
return find("visible = true ORDER BY noteGlobale DESC, nombreAvis DESC").page(0, limit).list();
|
||||
}
|
||||
|
||||
/** Rechercher par ville */
|
||||
public List<EntrepriseProfile> findByVille(String ville) {
|
||||
return find(
|
||||
"UPPER(ville) LIKE UPPER(?1) AND visible = true ORDER BY noteGlobale DESC",
|
||||
"%" + ville + "%")
|
||||
.list();
|
||||
}
|
||||
|
||||
/** Rechercher par nom commercial */
|
||||
public List<EntrepriseProfile> findByNomContaining(String nom) {
|
||||
return find(
|
||||
"UPPER(nomCommercial) LIKE UPPER(?1) AND visible = true ORDER BY noteGlobale DESC",
|
||||
"%" + nom + "%")
|
||||
.list();
|
||||
}
|
||||
|
||||
/** Rechercher par type d'abonnement */
|
||||
public List<EntrepriseProfile> findByTypeAbonnement(TypeAbonnement type) {
|
||||
return find(
|
||||
"typeAbonnement = ?1 AND visible = true ORDER BY noteGlobale DESC", type)
|
||||
.list();
|
||||
}
|
||||
|
||||
/** Rechercher par utilisateur propriétaire */
|
||||
public Optional<EntrepriseProfile> findByUserId(UUID userId) {
|
||||
return find("proprietaire.id = ?1", userId).firstResultOptional();
|
||||
}
|
||||
|
||||
/** Recherche textuelle complète */
|
||||
public List<EntrepriseProfile> searchFullText(String searchTerm) {
|
||||
String term = "%" + searchTerm.toLowerCase() + "%";
|
||||
return find(
|
||||
"LOWER(nomCommercial) LIKE ?1 OR LOWER(description) LIKE ?1 OR LOWER(ville) LIKE ?1 OR LOWER(region) LIKE ?1 AND visible = true ORDER BY noteGlobale DESC",
|
||||
term)
|
||||
.list();
|
||||
}
|
||||
|
||||
/** Rechercher par budget de projet */
|
||||
public List<EntrepriseProfile> findByBudgetRange(
|
||||
BigDecimal budgetMin, BigDecimal budgetMax) {
|
||||
return find(
|
||||
"(budgetMinProjet IS NULL OR budgetMinProjet <= ?2) AND (budgetMaxProjet IS NULL OR budgetMaxProjet >= ?1) AND visible = true ORDER BY noteGlobale DESC",
|
||||
budgetMin,
|
||||
budgetMax)
|
||||
.list();
|
||||
}
|
||||
|
||||
/** Compter les profils visibles */
|
||||
public long countVisible() {
|
||||
return count("visible = true");
|
||||
}
|
||||
|
||||
/** Compter les profils certifiés */
|
||||
public long countCertifies() {
|
||||
return count("certifie = true AND visible = true");
|
||||
}
|
||||
|
||||
/** Rechercher les profils actifs récemment */
|
||||
public List<EntrepriseProfile> findRecentlyActive(int nombreJours) {
|
||||
LocalDateTime depuis = LocalDateTime.now().minusDays(nombreJours);
|
||||
return find(
|
||||
"derniereActivite >= ?1 AND visible = true ORDER BY derniereActivite DESC", depuis)
|
||||
.list();
|
||||
}
|
||||
|
||||
/** Rechercher les profils avec abonnement actif */
|
||||
public List<EntrepriseProfile> findWithActiveSubscription() {
|
||||
LocalDateTime now = LocalDateTime.now();
|
||||
return find(
|
||||
"finAbonnement IS NOT NULL AND finAbonnement > ?1 AND visible = true ORDER BY noteGlobale DESC",
|
||||
now)
|
||||
.list();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,588 +0,0 @@
|
||||
package dev.lions.btpxpress.presentation.controller;
|
||||
|
||||
import dev.lions.btpxpress.application.service.BonCommandeService;
|
||||
import dev.lions.btpxpress.domain.core.entity.BonCommande;
|
||||
import dev.lions.btpxpress.domain.core.entity.PrioriteBonCommande;
|
||||
import dev.lions.btpxpress.domain.core.entity.StatutBonCommande;
|
||||
import dev.lions.btpxpress.domain.core.entity.TypeBonCommande;
|
||||
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.UUID;
|
||||
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/** Controller REST pour la gestion des bons de commande */
|
||||
@Path("/api/v1/bons-commande")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Bons de Commande", description = "Gestion des bons de commande")
|
||||
public class BonCommandeController {
|
||||
|
||||
private static final Logger logger = LoggerFactory.getLogger(BonCommandeController.class);
|
||||
|
||||
@Inject BonCommandeService bonCommandeService;
|
||||
|
||||
/** Récupère tous les bons de commande */
|
||||
@GET
|
||||
public Response getAllBonsCommande() {
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findAll();
|
||||
return Response.ok(bonsCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des bons de commande", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère un bon de commande par son ID */
|
||||
@GET
|
||||
@Path("/{id}")
|
||||
public Response getBonCommandeById(@PathParam("id") UUID id) {
|
||||
try {
|
||||
BonCommande bonCommande = bonCommandeService.findById(id);
|
||||
return Response.ok(bonCommande).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 bon de commande: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère un bon de commande par son numéro */
|
||||
@GET
|
||||
@Path("/numero/{numero}")
|
||||
public Response getBonCommandeByNumero(@PathParam("numero") String numero) {
|
||||
try {
|
||||
BonCommande bonCommande = bonCommandeService.findByNumero(numero);
|
||||
if (bonCommande == null) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Bon de commande non trouvé"))
|
||||
.build();
|
||||
}
|
||||
return Response.ok(bonCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération du bon de commande par numéro: " + numero, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les bons de commande par statut */
|
||||
@GET
|
||||
@Path("/statut/{statut}")
|
||||
public Response getBonsCommandeByStatut(@PathParam("statut") StatutBonCommande statut) {
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findByStatut(statut);
|
||||
return Response.ok(bonsCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des bons de commande par statut: " + statut, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les bons de commande par fournisseur */
|
||||
@GET
|
||||
@Path("/fournisseur/{fournisseurId}")
|
||||
public Response getBonsCommandeByFournisseur(@PathParam("fournisseurId") UUID fournisseurId) {
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findByFournisseur(fournisseurId);
|
||||
return Response.ok(bonsCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error(
|
||||
"Erreur lors de la récupération des bons de commande du fournisseur: " + fournisseurId,
|
||||
e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les bons de commande par chantier */
|
||||
@GET
|
||||
@Path("/chantier/{chantierId}")
|
||||
public Response getBonsCommandeByChantier(@PathParam("chantierId") UUID chantierId) {
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findByChantier(chantierId);
|
||||
return Response.ok(bonsCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error(
|
||||
"Erreur lors de la récupération des bons de commande du chantier: " + chantierId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les bons de commande par demandeur */
|
||||
@GET
|
||||
@Path("/demandeur/{demandeurId}")
|
||||
public Response getBonsCommandeByDemandeur(@PathParam("demandeurId") UUID demandeurId) {
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findByDemandeur(demandeurId);
|
||||
return Response.ok(bonsCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error(
|
||||
"Erreur lors de la récupération des bons de commande du demandeur: " + demandeurId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les bons de commande par priorité */
|
||||
@GET
|
||||
@Path("/priorite/{priorite}")
|
||||
public Response getBonsCommandeByPriorite(@PathParam("priorite") PrioriteBonCommande priorite) {
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findByPriorite(priorite);
|
||||
return Response.ok(bonsCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error(
|
||||
"Erreur lors de la récupération des bons de commande par priorité: " + priorite, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les bons de commande urgents */
|
||||
@GET
|
||||
@Path("/urgents")
|
||||
public Response getBonsCommandeUrgents() {
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findUrgents();
|
||||
return Response.ok(bonsCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des bons de commande urgents", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les bons de commande par type */
|
||||
@GET
|
||||
@Path("/type/{type}")
|
||||
public Response getBonsCommandeByType(@PathParam("type") TypeBonCommande type) {
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findByType(type);
|
||||
return Response.ok(bonsCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des bons de commande par type: " + type, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les bons de commande en cours */
|
||||
@GET
|
||||
@Path("/en-cours")
|
||||
public Response getBonsCommandeEnCours() {
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findEnCours();
|
||||
return Response.ok(bonsCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des bons de commande en cours", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les bons de commande en retard */
|
||||
@GET
|
||||
@Path("/en-retard")
|
||||
public Response getBonsCommandeEnRetard() {
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findCommandesEnRetard();
|
||||
return Response.ok(bonsCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des bons de commande en retard", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les bons de commande à livrer prochainement */
|
||||
@GET
|
||||
@Path("/livraisons-prochaines")
|
||||
public Response getLivraisonsProchaines(@QueryParam("nbJours") @DefaultValue("7") int nbJours) {
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findLivraisonsProchainess(nbJours);
|
||||
return Response.ok(bonsCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des livraisons prochaines", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les bons de commande en attente de validation */
|
||||
@GET
|
||||
@Path("/attente-validation")
|
||||
public Response getBonsCommandeAttenteValidation() {
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findEnAttenteValidation();
|
||||
return Response.ok(bonsCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des bons de commande en attente", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les bons de commande validés non envoyés */
|
||||
@GET
|
||||
@Path("/valides-non-envoyes")
|
||||
public Response getBonsCommandeValidesNonEnvoyes() {
|
||||
try {
|
||||
List<BonCommande> bonsCommande = bonCommandeService.findValideesNonEnvoyees();
|
||||
return Response.ok(bonsCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des bons de commande validés non envoyés", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des bons de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Crée un nouveau bon de commande */
|
||||
@POST
|
||||
public Response createBonCommande(@Valid BonCommande bonCommande) {
|
||||
try {
|
||||
BonCommande nouveauBonCommande = bonCommandeService.create(bonCommande);
|
||||
return Response.status(Response.Status.CREATED).entity(nouveauBonCommande).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 du bon de commande", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la création du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Met à jour un bon de commande */
|
||||
@PUT
|
||||
@Path("/{id}")
|
||||
public Response updateBonCommande(@PathParam("id") UUID id, @Valid BonCommande bonCommandeData) {
|
||||
try {
|
||||
BonCommande bonCommande = bonCommandeService.update(id, bonCommandeData);
|
||||
return Response.ok(bonCommande).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 du bon de commande: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la mise à jour du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Valide un bon de commande */
|
||||
@POST
|
||||
@Path("/{id}/valider")
|
||||
public Response validerBonCommande(@PathParam("id") UUID id, Map<String, String> payload) {
|
||||
try {
|
||||
String commentaires = payload != null ? payload.get("commentaires") : null;
|
||||
BonCommande bonCommande = bonCommandeService.validerBonCommande(id, commentaires);
|
||||
return Response.ok(bonCommande).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 validation du bon de commande: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la validation du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Rejette un bon de commande */
|
||||
@POST
|
||||
@Path("/{id}/rejeter")
|
||||
public Response rejeterBonCommande(@PathParam("id") UUID id, Map<String, String> payload) {
|
||||
try {
|
||||
String motif = payload != null ? payload.get("motif") : null;
|
||||
BonCommande bonCommande = bonCommandeService.rejeterBonCommande(id, motif);
|
||||
return Response.ok(bonCommande).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 du rejet du bon de commande: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors du rejet du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Envoie un bon de commande */
|
||||
@POST
|
||||
@Path("/{id}/envoyer")
|
||||
public Response envoyerBonCommande(@PathParam("id") UUID id) {
|
||||
try {
|
||||
BonCommande bonCommande = bonCommandeService.envoyerBonCommande(id);
|
||||
return Response.ok(bonCommande).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 l'envoi du bon de commande: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de l'envoi du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Confirme la réception d'un accusé de réception */
|
||||
@POST
|
||||
@Path("/{id}/accuse-reception")
|
||||
public Response confirmerAccuseReception(@PathParam("id") UUID id) {
|
||||
try {
|
||||
BonCommande bonCommande = bonCommandeService.confirmerAccuseReception(id);
|
||||
return Response.ok(bonCommande).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 confirmation d'accusé de réception: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la confirmation d'accusé de réception"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Marque un bon de commande comme livré */
|
||||
@POST
|
||||
@Path("/{id}/livrer")
|
||||
public Response livrerBonCommande(@PathParam("id") UUID id, Map<String, Object> payload) {
|
||||
try {
|
||||
LocalDate dateLivraison =
|
||||
payload != null && payload.get("dateLivraison") != null
|
||||
? LocalDate.parse(payload.get("dateLivraison").toString())
|
||||
: LocalDate.now();
|
||||
String commentaires =
|
||||
payload != null && payload.get("commentaires") != null
|
||||
? payload.get("commentaires").toString()
|
||||
: null;
|
||||
|
||||
BonCommande bonCommande =
|
||||
bonCommandeService.livrerBonCommande(id, dateLivraison, commentaires);
|
||||
return Response.ok(bonCommande).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 livraison du bon de commande: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la livraison du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Annule un bon de commande */
|
||||
@POST
|
||||
@Path("/{id}/annuler")
|
||||
public Response annulerBonCommande(@PathParam("id") UUID id, Map<String, String> payload) {
|
||||
try {
|
||||
String motif = payload != null ? payload.get("motif") : null;
|
||||
BonCommande bonCommande = bonCommandeService.annulerBonCommande(id, motif);
|
||||
return Response.ok(bonCommande).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 l'annulation du bon de commande: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de l'annulation du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Clôture un bon de commande */
|
||||
@POST
|
||||
@Path("/{id}/cloturer")
|
||||
public Response cloturerBonCommande(@PathParam("id") UUID id, Map<String, String> payload) {
|
||||
try {
|
||||
String commentaires = payload != null ? payload.get("commentaires") : null;
|
||||
BonCommande bonCommande = bonCommandeService.cloturerBonCommande(id, commentaires);
|
||||
return Response.ok(bonCommande).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 clôture du bon de commande: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la clôture du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Supprime un bon de commande */
|
||||
@DELETE
|
||||
@Path("/{id}")
|
||||
public Response deleteBonCommande(@PathParam("id") UUID id) {
|
||||
try {
|
||||
bonCommandeService.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 du bon de commande: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la suppression du bon de commande"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Recherche de bons de commande par multiple critères */
|
||||
@GET
|
||||
@Path("/search")
|
||||
public Response searchBonsCommande(@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<BonCommande> bonsCommande = bonCommandeService.searchCommandes(searchTerm);
|
||||
return Response.ok(bonsCommande).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la recherche de bons de commande: " + 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 bons de commande */
|
||||
@GET
|
||||
@Path("/statistiques")
|
||||
public Response getStatistiques() {
|
||||
try {
|
||||
Map<String, Object> stats = bonCommandeService.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();
|
||||
}
|
||||
}
|
||||
|
||||
/** Génère le prochain numéro de commande */
|
||||
@GET
|
||||
@Path("/numero-suivant")
|
||||
public Response getProchainNumero(@QueryParam("prefixe") @DefaultValue("BC") String prefixe) {
|
||||
try {
|
||||
String numeroSuivant = bonCommandeService.genererProchainNumero(prefixe);
|
||||
return Response.ok(Map.of("numeroSuivant", numeroSuivant)).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la génération du numéro suivant", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la génération du numéro"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les top fournisseurs par montant de commandes */
|
||||
@GET
|
||||
@Path("/top-fournisseurs")
|
||||
public Response getTopFournisseurs(@QueryParam("limit") @DefaultValue("10") int limit) {
|
||||
try {
|
||||
List<Object[]> topFournisseurs = bonCommandeService.findTopFournisseursByMontant(limit);
|
||||
return Response.ok(topFournisseurs).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des top fournisseurs", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des top fournisseurs"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les statistiques mensuelles */
|
||||
@GET
|
||||
@Path("/statistiques/mensuelles/{annee}")
|
||||
public Response getStatistiquesMensuelles(@PathParam("annee") int annee) {
|
||||
try {
|
||||
List<Object[]> stats = bonCommandeService.findStatistiquesMensuelles(annee);
|
||||
return Response.ok(stats).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des statistiques mensuelles", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des statistiques"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,411 +0,0 @@
|
||||
package dev.lions.btpxpress.presentation.controller;
|
||||
|
||||
import dev.lions.btpxpress.application.service.ChantierService;
|
||||
import dev.lions.btpxpress.domain.core.entity.Chantier;
|
||||
import dev.lions.btpxpress.domain.core.entity.StatutChantier;
|
||||
import dev.lions.btpxpress.domain.shared.dto.ChantierCreateDTO;
|
||||
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.math.BigDecimal;
|
||||
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 chantiers */
|
||||
@Path("/api/v1/chantiers-controller") // Contrôleur alternatif pour éviter conflit
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Chantiers", description = "Gestion des chantiers BTP")
|
||||
public class ChantierController {
|
||||
|
||||
private static final Logger logger = LoggerFactory.getLogger(ChantierController.class);
|
||||
|
||||
@Inject ChantierService chantierService;
|
||||
|
||||
/** Récupère tous les chantiers */
|
||||
@GET
|
||||
public Response getAllChantiers() {
|
||||
try {
|
||||
List<Chantier> chantiers = chantierService.findAll();
|
||||
return Response.ok(chantiers).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des chantiers", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des chantiers"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère un chantier par son ID */
|
||||
@GET
|
||||
@Path("/{id}")
|
||||
public Response getChantierById(@PathParam("id") UUID id) {
|
||||
try {
|
||||
Optional<Chantier> chantierOpt = chantierService.findById(id);
|
||||
if (chantierOpt.isEmpty()) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Chantier non trouvé"))
|
||||
.build();
|
||||
}
|
||||
return Response.ok(chantierOpt.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 du chantier: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du chantier"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les chantiers par statut */
|
||||
@GET
|
||||
@Path("/statut/{statut}")
|
||||
public Response getChantiersByStatut(@PathParam("statut") StatutChantier statut) {
|
||||
try {
|
||||
List<Chantier> chantiers = chantierService.findByStatut(statut);
|
||||
return Response.ok(chantiers).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des chantiers par statut: " + statut, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des chantiers"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les chantiers actifs */
|
||||
@GET
|
||||
@Path("/actifs")
|
||||
public Response getChantiersActifs() {
|
||||
try {
|
||||
List<Chantier> chantiers = chantierService.findActifs();
|
||||
return Response.ok(chantiers).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des chantiers actifs", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des chantiers"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les chantiers par client */
|
||||
@GET
|
||||
@Path("/client/{clientId}")
|
||||
public Response getChantiersByClient(@PathParam("clientId") UUID clientId) {
|
||||
try {
|
||||
List<Chantier> chantiers = chantierService.findByClient(clientId);
|
||||
return Response.ok(chantiers).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des chantiers du client: " + clientId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des chantiers"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les chantiers par chef de chantier */
|
||||
@GET
|
||||
@Path("/chef-chantier/{chefId}")
|
||||
public Response getChantiersByChefChantier(@PathParam("chefId") UUID chefId) {
|
||||
try {
|
||||
List<Chantier> chantiers = chantierService.findByChefChantier(chefId);
|
||||
return Response.ok(chantiers).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des chantiers du chef: " + chefId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des chantiers"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les chantiers en retard */
|
||||
@GET
|
||||
@Path("/en-retard")
|
||||
public Response getChantiersEnRetard() {
|
||||
try {
|
||||
List<Chantier> chantiers = chantierService.findChantiersEnRetard();
|
||||
return Response.ok(chantiers).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des chantiers en retard", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des chantiers"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les chantiers à démarrer prochainement */
|
||||
@GET
|
||||
@Path("/prochains-demarrages")
|
||||
public Response getProchainsDemarrages(@QueryParam("nbJours") @DefaultValue("30") int nbJours) {
|
||||
try {
|
||||
List<Chantier> chantiers = chantierService.findProchainsDemarrages(nbJours);
|
||||
return Response.ok(chantiers).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des prochains démarrages", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des chantiers"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les chantiers par ville */
|
||||
@GET
|
||||
@Path("/ville/{ville}")
|
||||
public Response getChantiersByVille(@PathParam("ville") String ville) {
|
||||
try {
|
||||
List<Chantier> chantiers = chantierService.findByVille(ville);
|
||||
return Response.ok(chantiers).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des chantiers par ville: " + ville, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des chantiers"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Crée un nouveau chantier */
|
||||
@POST
|
||||
public Response createChantier(@Valid ChantierCreateDTO chantierDto) {
|
||||
try {
|
||||
Chantier nouveauChantier = chantierService.create(chantierDto);
|
||||
return Response.status(Response.Status.CREATED).entity(nouveauChantier).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 du chantier", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la création du chantier"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Met à jour un chantier */
|
||||
@PUT
|
||||
@Path("/{id}")
|
||||
public Response updateChantier(@PathParam("id") UUID id, @Valid ChantierCreateDTO chantierDto) {
|
||||
try {
|
||||
Chantier chantier = chantierService.update(id, chantierDto);
|
||||
return Response.ok(chantier).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 du chantier: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la mise à jour du chantier"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Démarre un chantier */
|
||||
@POST
|
||||
@Path("/{id}/demarrer")
|
||||
public Response demarrerChantier(@PathParam("id") UUID id) {
|
||||
try {
|
||||
Chantier chantier = chantierService.demarrerChantier(id);
|
||||
return Response.ok(chantier).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 du démarrage du chantier: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors du démarrage du chantier"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Suspend un chantier */
|
||||
@POST
|
||||
@Path("/{id}/suspendre")
|
||||
public Response suspendreChantier(@PathParam("id") UUID id, Map<String, String> payload) {
|
||||
try {
|
||||
String motif = payload != null ? payload.get("motif") : null;
|
||||
Chantier chantier = chantierService.suspendreChantier(id, motif);
|
||||
return Response.ok(chantier).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 suspension du chantier: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la suspension du chantier"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Termine un chantier */
|
||||
@POST
|
||||
@Path("/{id}/terminer")
|
||||
public Response terminerChantier(@PathParam("id") UUID id, Map<String, Object> payload) {
|
||||
try {
|
||||
LocalDate dateFinReelle =
|
||||
payload != null && payload.get("dateFinReelle") != null
|
||||
? LocalDate.parse(payload.get("dateFinReelle").toString())
|
||||
: LocalDate.now();
|
||||
String commentaires =
|
||||
payload != null && payload.get("commentaires") != null
|
||||
? payload.get("commentaires").toString()
|
||||
: null;
|
||||
|
||||
Chantier chantier = chantierService.terminerChantier(id, dateFinReelle, commentaires);
|
||||
return Response.ok(chantier).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 terminaison du chantier: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la terminaison du chantier"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Met à jour l'avancement global du chantier */
|
||||
@POST
|
||||
@Path("/{id}/avancement")
|
||||
public Response updateAvancementGlobal(@PathParam("id") UUID id, Map<String, Object> payload) {
|
||||
try {
|
||||
BigDecimal pourcentage = new BigDecimal(payload.get("pourcentage").toString());
|
||||
Chantier chantier = chantierService.updateAvancementGlobal(id, pourcentage);
|
||||
return Response.ok(chantier).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", "Pourcentage invalide"))
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la mise à jour de l'avancement: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la mise à jour de l'avancement"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Supprime un chantier */
|
||||
@DELETE
|
||||
@Path("/{id}")
|
||||
public Response deleteChantier(@PathParam("id") UUID id) {
|
||||
try {
|
||||
chantierService.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 du chantier: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la suppression du chantier"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Recherche de chantiers par multiple critères */
|
||||
@GET
|
||||
@Path("/search")
|
||||
public Response searchChantiers(@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<Chantier> chantiers = chantierService.searchChantiers(searchTerm);
|
||||
return Response.ok(chantiers).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la recherche de chantiers: " + 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 chantiers */
|
||||
@GET
|
||||
@Path("/statistiques")
|
||||
public Response getStatistiques() {
|
||||
try {
|
||||
Map<String, Object> stats = chantierService.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();
|
||||
}
|
||||
}
|
||||
|
||||
/** Calcule le chiffre d'affaires total des chantiers */
|
||||
@GET
|
||||
@Path("/chiffre-affaires")
|
||||
public Response getChiffreAffaires(@QueryParam("annee") Integer annee) {
|
||||
try {
|
||||
Map<String, Object> ca = chantierService.calculerChiffreAffaires(annee);
|
||||
return Response.ok(Map.of("chiffreAffaires", ca)).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors du calcul du chiffre d'affaires", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors du calcul du chiffre d'affaires"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère le tableau de bord du chantier */
|
||||
@GET
|
||||
@Path("/{id}/dashboard")
|
||||
public Response getDashboardChantier(@PathParam("id") UUID id) {
|
||||
try {
|
||||
Map<String, Object> dashboard = chantierService.getDashboardChantier(id);
|
||||
return Response.ok(dashboard).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 dashboard: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du dashboard"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,423 +0,0 @@
|
||||
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();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,452 +0,0 @@
|
||||
package dev.lions.btpxpress.presentation.controller;
|
||||
|
||||
import dev.lions.btpxpress.application.service.EquipeService;
|
||||
import dev.lions.btpxpress.domain.core.entity.Equipe;
|
||||
import dev.lions.btpxpress.domain.core.entity.StatutEquipe;
|
||||
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 équipes */
|
||||
@Path("/api/v1/equipes-controller")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Équipes", description = "Gestion des équipes de travail BTP")
|
||||
public class EquipeController {
|
||||
|
||||
private static final Logger logger = LoggerFactory.getLogger(EquipeController.class);
|
||||
|
||||
@Inject EquipeService equipeService;
|
||||
|
||||
/** Récupère toutes les équipes */
|
||||
@GET
|
||||
public Response getAllEquipes() {
|
||||
try {
|
||||
List<Equipe> equipes = equipeService.findAll();
|
||||
return Response.ok(equipes).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des équipes", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des équipes"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère une équipe par son ID */
|
||||
@GET
|
||||
@Path("/{id}")
|
||||
public Response getEquipeById(@PathParam("id") UUID id) {
|
||||
try {
|
||||
Optional<Equipe> equipeOpt = equipeService.findById(id);
|
||||
if (equipeOpt.isEmpty()) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Équipe non trouvée"))
|
||||
.build();
|
||||
}
|
||||
return Response.ok(equipeOpt.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'équipe: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération de l'équipe"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les équipes par statut */
|
||||
@GET
|
||||
@Path("/statut/{statut}")
|
||||
public Response getEquipesByStatut(@PathParam("statut") StatutEquipe statut) {
|
||||
try {
|
||||
List<Equipe> equipes = equipeService.findByStatut(statut);
|
||||
return Response.ok(equipes).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des équipes par statut: " + statut, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des équipes"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les équipes actives */
|
||||
@GET
|
||||
@Path("/actives")
|
||||
public Response getEquipesActives() {
|
||||
try {
|
||||
List<Equipe> equipes = equipeService.findActives();
|
||||
return Response.ok(equipes).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des équipes actives", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des équipes"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les équipes par chef d'équipe */
|
||||
@GET
|
||||
@Path("/chef/{chefId}")
|
||||
public Response getEquipesByChef(@PathParam("chefId") UUID chefId) {
|
||||
try {
|
||||
List<Equipe> equipes = equipeService.findByChef(chefId);
|
||||
return Response.ok(equipes).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des équipes du chef: " + chefId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des équipes"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les équipes par spécialité */
|
||||
@GET
|
||||
@Path("/specialite/{specialite}")
|
||||
public Response getEquipesBySpecialite(@PathParam("specialite") String specialite) {
|
||||
try {
|
||||
List<Equipe> equipes = equipeService.findBySpecialite(specialite);
|
||||
return Response.ok(equipes).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des équipes par spécialité: " + specialite, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des équipes"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les équipes disponibles pour une période */
|
||||
@GET
|
||||
@Path("/disponibles")
|
||||
public Response getEquipesDisponibles(
|
||||
@QueryParam("dateDebut") String dateDebut, @QueryParam("dateFin") String dateFin) {
|
||||
try {
|
||||
LocalDate debut = LocalDate.parse(dateDebut);
|
||||
LocalDate fin = LocalDate.parse(dateFin);
|
||||
List<Equipe> equipes = equipeService.findDisponibles(debut, fin);
|
||||
return Response.ok(equipes).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des équipes disponibles", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des équipes"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les équipes par taille minimum */
|
||||
@GET
|
||||
@Path("/taille-minimum/{taille}")
|
||||
public Response getEquipesByTailleMinimum(@PathParam("taille") int taille) {
|
||||
try {
|
||||
List<Equipe> equipes = equipeService.findByTailleMinimum(taille);
|
||||
return Response.ok(equipes).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des équipes par taille: " + taille, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des équipes"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les équipes par niveau d'expérience */
|
||||
@GET
|
||||
@Path("/experience/{niveau}")
|
||||
public Response getEquipesByExperience(@PathParam("niveau") String niveau) {
|
||||
try {
|
||||
List<Equipe> equipes = equipeService.findByNiveauExperience(niveau);
|
||||
return Response.ok(equipes).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des équipes 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 équipes"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Crée une nouvelle équipe */
|
||||
@POST
|
||||
public Response createEquipe(@Valid Equipe equipe) {
|
||||
try {
|
||||
Equipe nouvelleEquipe = equipeService.create(equipe);
|
||||
return Response.status(Response.Status.CREATED).entity(nouvelleEquipe).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'équipe", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la création de l'équipe"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Met à jour une équipe */
|
||||
@PUT
|
||||
@Path("/{id}")
|
||||
public Response updateEquipe(@PathParam("id") UUID id, @Valid Equipe equipeData) {
|
||||
try {
|
||||
Equipe equipe = equipeService.update(id, equipeData);
|
||||
return Response.ok(equipe).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'équipe: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la mise à jour de l'équipe"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Active une équipe */
|
||||
@POST
|
||||
@Path("/{id}/activer")
|
||||
public Response activerEquipe(@PathParam("id") UUID id) {
|
||||
try {
|
||||
Equipe equipe = equipeService.activerEquipe(id);
|
||||
return Response.ok(equipe).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'équipe: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de l'activation de l'équipe"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Désactive une équipe */
|
||||
@POST
|
||||
@Path("/{id}/desactiver")
|
||||
public Response desactiverEquipe(@PathParam("id") UUID id, Map<String, String> payload) {
|
||||
try {
|
||||
String motif = payload != null ? payload.get("motif") : null;
|
||||
Equipe equipe = equipeService.desactiverEquipe(id, motif);
|
||||
return Response.ok(equipe).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'équipe: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la désactivation de l'équipe"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Ajoute un membre à l'équipe */
|
||||
@POST
|
||||
@Path("/{id}/ajouter-membre")
|
||||
public Response ajouterMembre(@PathParam("id") UUID equipeId, Map<String, Object> payload) {
|
||||
try {
|
||||
UUID employeId = UUID.fromString(payload.get("employeId").toString());
|
||||
String role = payload.get("role") != null ? payload.get("role").toString() : null;
|
||||
|
||||
Equipe equipe = equipeService.ajouterMembre(equipeId, employeId, role);
|
||||
return Response.ok(equipe).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'ajout de membre: " + equipeId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de l'ajout de membre"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Retire un membre de l'équipe */
|
||||
@POST
|
||||
@Path("/{id}/retirer-membre")
|
||||
public Response retirerMembre(@PathParam("id") UUID equipeId, Map<String, Object> payload) {
|
||||
try {
|
||||
UUID employeId = UUID.fromString(payload.get("employeId").toString());
|
||||
|
||||
Equipe equipe = equipeService.retirerMembre(equipeId, employeId);
|
||||
return Response.ok(equipe).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 du retrait de membre: " + equipeId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors du retrait de membre"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Change le chef d'équipe */
|
||||
@POST
|
||||
@Path("/{id}/changer-chef")
|
||||
public Response changerChef(@PathParam("id") UUID equipeId, Map<String, Object> payload) {
|
||||
try {
|
||||
UUID nouveauChefId = UUID.fromString(payload.get("nouveauChefId").toString());
|
||||
|
||||
Equipe equipe = equipeService.changerChef(equipeId, nouveauChefId);
|
||||
return Response.ok(equipe).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 du changement de chef: " + equipeId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors du changement de chef"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Supprime une équipe */
|
||||
@DELETE
|
||||
@Path("/{id}")
|
||||
public Response deleteEquipe(@PathParam("id") UUID id) {
|
||||
try {
|
||||
equipeService.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'équipe: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la suppression de l'équipe"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Recherche d'équipes par multiple critères */
|
||||
@GET
|
||||
@Path("/search")
|
||||
public Response searchEquipes(@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<Equipe> equipes = equipeService.searchEquipes(searchTerm);
|
||||
return Response.ok(equipes).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la recherche d'équipes: " + 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 équipes */
|
||||
@GET
|
||||
@Path("/statistiques")
|
||||
public Response getStatistiques() {
|
||||
try {
|
||||
Map<String, Object> stats = equipeService.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 les membres d'une équipe */
|
||||
@GET
|
||||
@Path("/{id}/membres")
|
||||
public Response getMembresEquipe(@PathParam("id") UUID id) {
|
||||
try {
|
||||
List<Object> membres = equipeService.getMembresEquipe(id);
|
||||
return Response.ok(membres).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 membres: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des membres"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère le planning d'une équipe */
|
||||
@GET
|
||||
@Path("/{id}/planning")
|
||||
public Response getPlanningEquipe(
|
||||
@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 = equipeService.getPlanningEquipe(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 performances d'une équipe */
|
||||
@GET
|
||||
@Path("/{id}/performances")
|
||||
public Response getPerformancesEquipe(@PathParam("id") UUID id) {
|
||||
try {
|
||||
Map<String, Object> performances = equipeService.getPerformancesEquipe(id);
|
||||
return Response.ok(performances).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 performances: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des performances"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,479 +0,0 @@
|
||||
package dev.lions.btpxpress.presentation.controller;
|
||||
|
||||
import dev.lions.btpxpress.application.service.MaterielService;
|
||||
import dev.lions.btpxpress.domain.core.entity.Materiel;
|
||||
import dev.lions.btpxpress.domain.core.entity.StatutMateriel;
|
||||
import dev.lions.btpxpress.domain.core.entity.TypeMateriel;
|
||||
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 du matériel */
|
||||
@Path("/api/materiel")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Matériels", description = "Gestion des matériels et équipements")
|
||||
public class MaterielController {
|
||||
|
||||
private static final Logger logger = LoggerFactory.getLogger(MaterielController.class);
|
||||
|
||||
@Inject MaterielService materielService;
|
||||
|
||||
/** Récupère tout le matériel */
|
||||
@GET
|
||||
public Response getAllMateriel() {
|
||||
try {
|
||||
List<Materiel> materiel = materielService.findAll();
|
||||
return Response.ok(materiel).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération du matériel", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du matériel"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère un matériel par son ID */
|
||||
@GET
|
||||
@Path("/{id}")
|
||||
public Response getMaterielById(@PathParam("id") UUID id) {
|
||||
try {
|
||||
Optional<Materiel> materielOpt = materielService.findById(id);
|
||||
if (materielOpt.isEmpty()) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Matériel non trouvé"))
|
||||
.build();
|
||||
}
|
||||
return Response.ok(materielOpt.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 du matériel: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du matériel"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère le matériel par statut */
|
||||
@GET
|
||||
@Path("/statut/{statut}")
|
||||
public Response getMaterielByStatut(@PathParam("statut") StatutMateriel statut) {
|
||||
try {
|
||||
List<Materiel> materiel = materielService.findByStatut(statut);
|
||||
return Response.ok(materiel).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération du matériel par statut: " + statut, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du matériel"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère le matériel disponible */
|
||||
@GET
|
||||
@Path("/disponible")
|
||||
public Response getMaterielDisponible() {
|
||||
try {
|
||||
List<Materiel> materiel = materielService.findDisponible();
|
||||
return Response.ok(materiel).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération du matériel disponible", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du matériel"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère le matériel par type */
|
||||
@GET
|
||||
@Path("/type/{type}")
|
||||
public Response getMaterielByType(@PathParam("type") String type) {
|
||||
try {
|
||||
TypeMateriel typeMateriel = TypeMateriel.valueOf(type.toUpperCase());
|
||||
List<Materiel> materiel = materielService.findByType(typeMateriel);
|
||||
return Response.ok(materiel).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération du matériel par type: " + type, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du matériel"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère le matériel par chantier */
|
||||
@GET
|
||||
@Path("/chantier/{chantierId}")
|
||||
public Response getMaterielByChantier(@PathParam("chantierId") UUID chantierId) {
|
||||
try {
|
||||
List<Materiel> materiel = materielService.findByChantier(chantierId);
|
||||
return Response.ok(materiel).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération du matériel du chantier: " + chantierId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du matériel"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère le matériel par marque */
|
||||
@GET
|
||||
@Path("/marque/{marque}")
|
||||
public Response getMaterielByMarque(@PathParam("marque") String marque) {
|
||||
try {
|
||||
List<Materiel> materiel = materielService.findByMarque(marque);
|
||||
return Response.ok(materiel).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération du matériel par marque: " + marque, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du matériel"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère le matériel nécessitant une maintenance */
|
||||
@GET
|
||||
@Path("/maintenance-requise")
|
||||
public Response getMaterielMaintenanceRequise() {
|
||||
try {
|
||||
List<Materiel> materiel = materielService.findMaintenanceRequise();
|
||||
return Response.ok(materiel).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération du matériel nécessitant maintenance", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du matériel"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère le matériel en panne */
|
||||
@GET
|
||||
@Path("/en-panne")
|
||||
public Response getMaterielEnPanne() {
|
||||
try {
|
||||
List<Materiel> materiel = materielService.findEnPanne();
|
||||
return Response.ok(materiel).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération du matériel en panne", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du matériel"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère le matériel disponible pour une période */
|
||||
@GET
|
||||
@Path("/disponible-periode")
|
||||
public Response getMaterielDisponiblePeriode(
|
||||
@QueryParam("dateDebut") String dateDebut, @QueryParam("dateFin") String dateFin) {
|
||||
try {
|
||||
LocalDate debut = LocalDate.parse(dateDebut);
|
||||
LocalDate fin = LocalDate.parse(dateFin);
|
||||
List<Materiel> materiel = materielService.findDisponiblePeriode(debut, fin);
|
||||
return Response.ok(materiel).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération du matériel disponible pour la période", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du matériel"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Crée un nouveau matériel */
|
||||
@POST
|
||||
public Response createMateriel(@Valid Materiel materiel) {
|
||||
try {
|
||||
Materiel nouveauMateriel = materielService.create(materiel);
|
||||
return Response.status(Response.Status.CREATED).entity(nouveauMateriel).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 du matériel", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la création du matériel"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Met à jour un matériel */
|
||||
@PUT
|
||||
@Path("/{id}")
|
||||
public Response updateMateriel(@PathParam("id") UUID id, @Valid Materiel materielData) {
|
||||
try {
|
||||
Materiel materiel = materielService.update(id, materielData);
|
||||
return Response.ok(materiel).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 du matériel: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la mise à jour du matériel"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Affecte un matériel à un chantier */
|
||||
@POST
|
||||
@Path("/{id}/affecter-chantier")
|
||||
public Response affecterChantier(@PathParam("id") UUID materielId, Map<String, Object> payload) {
|
||||
try {
|
||||
UUID chantierId = UUID.fromString(payload.get("chantierId").toString());
|
||||
LocalDate dateDebut = LocalDate.parse(payload.get("dateDebut").toString());
|
||||
LocalDate dateFin =
|
||||
payload.get("dateFin") != null
|
||||
? LocalDate.parse(payload.get("dateFin").toString())
|
||||
: null;
|
||||
|
||||
Materiel materiel =
|
||||
materielService.affecterChantier(materielId, chantierId, dateDebut, dateFin);
|
||||
return Response.ok(materiel).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 au chantier: " + materielId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de l'affectation au chantier"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Libère un matériel du chantier */
|
||||
@POST
|
||||
@Path("/{id}/liberer-chantier")
|
||||
public Response libererChantier(@PathParam("id") UUID materielId) {
|
||||
try {
|
||||
Materiel materiel = materielService.libererChantier(materielId);
|
||||
return Response.ok(materiel).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 libération du chantier: " + materielId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la libération du chantier"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Marque un matériel en maintenance */
|
||||
@POST
|
||||
@Path("/{id}/maintenance")
|
||||
public Response marquerMaintenance(@PathParam("id") UUID id, Map<String, Object> payload) {
|
||||
try {
|
||||
String description =
|
||||
payload.get("description") != null ? payload.get("description").toString() : null;
|
||||
LocalDate datePrevue =
|
||||
payload.get("datePrevue") != null
|
||||
? LocalDate.parse(payload.get("datePrevue").toString())
|
||||
: null;
|
||||
|
||||
Materiel materiel = materielService.marquerMaintenance(id, description, datePrevue);
|
||||
return Response.ok(materiel).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 du marquage en maintenance: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors du marquage en maintenance"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Marque un matériel en panne */
|
||||
@POST
|
||||
@Path("/{id}/panne")
|
||||
public Response marquerPanne(@PathParam("id") UUID id, Map<String, String> payload) {
|
||||
try {
|
||||
String description = payload != null ? payload.get("description") : null;
|
||||
Materiel materiel = materielService.marquerPanne(id, description);
|
||||
return Response.ok(materiel).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 du marquage en panne: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors du marquage en panne"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Répare un matériel */
|
||||
@POST
|
||||
@Path("/{id}/reparer")
|
||||
public Response reparerMateriel(@PathParam("id") UUID id, Map<String, Object> payload) {
|
||||
try {
|
||||
String description =
|
||||
payload != null && payload.get("description") != null
|
||||
? payload.get("description").toString()
|
||||
: null;
|
||||
LocalDate dateReparation =
|
||||
payload != null && payload.get("dateReparation") != null
|
||||
? LocalDate.parse(payload.get("dateReparation").toString())
|
||||
: LocalDate.now();
|
||||
|
||||
Materiel materiel = materielService.reparer(id, description, dateReparation);
|
||||
return Response.ok(materiel).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éparation: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la réparation"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Retire définitivement un matériel */
|
||||
@POST
|
||||
@Path("/{id}/retirer")
|
||||
public Response retirerMateriel(@PathParam("id") UUID id, Map<String, String> payload) {
|
||||
try {
|
||||
String motif = payload != null ? payload.get("motif") : null;
|
||||
Materiel materiel = materielService.retirerDefinitivement(id, motif);
|
||||
return Response.ok(materiel).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 du retrait définitif: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors du retrait définitif"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Supprime un matériel */
|
||||
@DELETE
|
||||
@Path("/{id}")
|
||||
public Response deleteMateriel(@PathParam("id") UUID id) {
|
||||
try {
|
||||
materielService.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 du matériel: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la suppression du matériel"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Recherche de matériel par multiple critères */
|
||||
@GET
|
||||
@Path("/search")
|
||||
public Response searchMateriel(@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<Materiel> materiel = materielService.searchMateriel(searchTerm);
|
||||
return Response.ok(materiel).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la recherche de matériel: " + 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 du matériel */
|
||||
@GET
|
||||
@Path("/statistiques")
|
||||
public Response getStatistiques() {
|
||||
try {
|
||||
Map<String, Object> stats = materielService.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 l'historique d'utilisation d'un matériel */
|
||||
@GET
|
||||
@Path("/{id}/historique")
|
||||
public Response getHistoriqueUtilisation(@PathParam("id") UUID id) {
|
||||
try {
|
||||
List<Object> historique = materielService.getHistoriqueUtilisation(id);
|
||||
return Response.ok(historique).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'historique: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération de l'historique"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère le planning d'utilisation d'un matériel */
|
||||
@GET
|
||||
@Path("/{id}/planning")
|
||||
public Response getPlanningMateriel(
|
||||
@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 = materielService.getPlanningMateriel(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();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,406 +0,0 @@
|
||||
package dev.lions.btpxpress.presentation.controller;
|
||||
|
||||
import dev.lions.btpxpress.application.service.PhaseChantierService;
|
||||
import dev.lions.btpxpress.domain.core.entity.PhaseChantier;
|
||||
import dev.lions.btpxpress.domain.core.entity.StatutPhaseChantier;
|
||||
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.math.BigDecimal;
|
||||
import java.time.LocalDate;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* Contrôleur REST pour la gestion des phases de chantier Permet de suivre l'avancement détaillé de
|
||||
* chaque phase d'un chantier
|
||||
*/
|
||||
@Path("/api/v1/phases")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Phases de Chantier", description = "Gestion des phases et jalons de chantiers BTP")
|
||||
public class PhaseChantierController {
|
||||
|
||||
private static final Logger logger = LoggerFactory.getLogger(PhaseChantierController.class);
|
||||
|
||||
@Inject PhaseChantierService phaseChantierService;
|
||||
|
||||
/** Récupère toutes les phases */
|
||||
@GET
|
||||
public Response getAllPhases() {
|
||||
try {
|
||||
List<PhaseChantier> phases = phaseChantierService.findAll();
|
||||
return Response.ok(phases).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des phases", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des phases"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère une phase par son ID */
|
||||
@GET
|
||||
@Path("/{id}")
|
||||
public Response getPhaseById(@PathParam("id") UUID id) {
|
||||
try {
|
||||
PhaseChantier phase = phaseChantierService.findById(id);
|
||||
return Response.ok(phase).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 la phase: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération de la phase"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les phases d'un chantier */
|
||||
@GET
|
||||
@Path("/chantier/{chantierId}")
|
||||
public Response getPhasesByChantier(@PathParam("chantierId") UUID chantierId) {
|
||||
try {
|
||||
List<PhaseChantier> phases = phaseChantierService.findByChantier(chantierId);
|
||||
return Response.ok(phases).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des phases du chantier: " + chantierId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des phases"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les phases par statut */
|
||||
@GET
|
||||
@Path("/statut/{statut}")
|
||||
public Response getPhasesByStatut(@PathParam("statut") StatutPhaseChantier statut) {
|
||||
try {
|
||||
List<PhaseChantier> phases = phaseChantierService.findByStatut(statut);
|
||||
return Response.ok(phases).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des phases par statut: " + statut, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des phases"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les phases en retard */
|
||||
@GET
|
||||
@Path("/en-retard")
|
||||
public Response getPhasesEnRetard() {
|
||||
try {
|
||||
List<PhaseChantier> phases = phaseChantierService.findPhasesEnRetard();
|
||||
return Response.ok(phases).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des phases en retard", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des phases"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les phases en cours */
|
||||
@GET
|
||||
@Path("/en-cours")
|
||||
public Response getPhasesEnCours() {
|
||||
try {
|
||||
List<PhaseChantier> phases = phaseChantierService.findPhasesEnCours();
|
||||
return Response.ok(phases).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des phases en cours", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des phases"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les phases critiques */
|
||||
@GET
|
||||
@Path("/critiques")
|
||||
public Response getPhasesCritiques() {
|
||||
try {
|
||||
List<PhaseChantier> phases = phaseChantierService.findPhasesCritiques();
|
||||
return Response.ok(phases).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des phases critiques", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des phases"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les phases nécessitant une attention */
|
||||
@GET
|
||||
@Path("/attention")
|
||||
public Response getPhasesNecessitantAttention() {
|
||||
try {
|
||||
List<PhaseChantier> phases = phaseChantierService.findPhasesNecessitantAttention();
|
||||
return Response.ok(phases).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des phases nécessitant attention", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des phases"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Crée une nouvelle phase */
|
||||
@POST
|
||||
public Response createPhase(@Valid PhaseChantier phase) {
|
||||
try {
|
||||
PhaseChantier nouvellephase = phaseChantierService.create(phase);
|
||||
return Response.status(Response.Status.CREATED).entity(nouvellephase).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 la phase", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la création de la phase"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Met à jour une phase */
|
||||
@PUT
|
||||
@Path("/{id}")
|
||||
public Response updatePhase(@PathParam("id") UUID id, @Valid PhaseChantier phaseData) {
|
||||
try {
|
||||
PhaseChantier phase = phaseChantierService.update(id, phaseData);
|
||||
return Response.ok(phase).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 la phase: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la mise à jour de la phase"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Démarre une phase */
|
||||
@POST
|
||||
@Path("/{id}/demarrer")
|
||||
public Response demarrerPhase(@PathParam("id") UUID id) {
|
||||
try {
|
||||
PhaseChantier phase = phaseChantierService.demarrerPhase(id);
|
||||
return Response.ok(phase).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 du démarrage de la phase: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors du démarrage de la phase"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Termine une phase */
|
||||
@POST
|
||||
@Path("/{id}/terminer")
|
||||
public Response terminerPhase(@PathParam("id") UUID id) {
|
||||
try {
|
||||
PhaseChantier phase = phaseChantierService.terminerPhase(id);
|
||||
return Response.ok(phase).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 terminaison de la phase: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la terminaison de la phase"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Suspend une phase */
|
||||
@POST
|
||||
@Path("/{id}/suspendre")
|
||||
public Response suspendrePhase(@PathParam("id") UUID id, Map<String, String> payload) {
|
||||
try {
|
||||
String motif = payload.get("motif");
|
||||
PhaseChantier phase = phaseChantierService.suspendrPhase(id, motif);
|
||||
return Response.ok(phase).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 suspension de la phase: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la suspension de la phase"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Reprend une phase suspendue */
|
||||
@POST
|
||||
@Path("/{id}/reprendre")
|
||||
public Response reprendrePhase(@PathParam("id") UUID id) {
|
||||
try {
|
||||
PhaseChantier phase = phaseChantierService.reprendrePhase(id);
|
||||
return Response.ok(phase).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 reprise de la phase: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la reprise de la phase"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Met à jour l'avancement d'une phase */
|
||||
@POST
|
||||
@Path("/{id}/avancement")
|
||||
public Response updateAvancement(@PathParam("id") UUID id, Map<String, Object> payload) {
|
||||
try {
|
||||
BigDecimal pourcentage = new BigDecimal(payload.get("pourcentage").toString());
|
||||
PhaseChantier phase = phaseChantierService.updateAvancement(id, pourcentage);
|
||||
return Response.ok(phase).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", "Pourcentage invalide"))
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la mise à jour de l'avancement: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la mise à jour de l'avancement"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Affecte une équipe à une phase */
|
||||
@POST
|
||||
@Path("/{id}/affecter-equipe")
|
||||
public Response affecterEquipe(@PathParam("id") UUID phaseId, Map<String, Object> payload) {
|
||||
try {
|
||||
UUID equipeId =
|
||||
payload.get("equipeId") != null
|
||||
? UUID.fromString(payload.get("equipeId").toString())
|
||||
: null;
|
||||
UUID chefEquipeId =
|
||||
payload.get("chefEquipeId") != null
|
||||
? UUID.fromString(payload.get("chefEquipeId").toString())
|
||||
: null;
|
||||
|
||||
PhaseChantier phase = phaseChantierService.affecterEquipe(phaseId, equipeId, chefEquipeId);
|
||||
return Response.ok(phase).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: " + phaseId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de l'affectation d'équipe"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Planifie automatiquement les phases d'un chantier */
|
||||
@POST
|
||||
@Path("/chantier/{chantierId}/planifier")
|
||||
public Response planifierPhasesAutomatique(
|
||||
@PathParam("chantierId") UUID chantierId, Map<String, String> payload) {
|
||||
try {
|
||||
LocalDate dateDebut = LocalDate.parse(payload.get("dateDebut"));
|
||||
List<PhaseChantier> phases =
|
||||
phaseChantierService.planifierPhasesAutomatique(chantierId, dateDebut);
|
||||
return Response.ok(phases).build();
|
||||
} catch (IllegalArgumentException e) {
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity(Map.of("error", "Date de début invalide"))
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la planification automatique: " + chantierId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la planification automatique"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Supprime une phase */
|
||||
@DELETE
|
||||
@Path("/{id}")
|
||||
public Response deletePhase(@PathParam("id") UUID id) {
|
||||
try {
|
||||
phaseChantierService.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 la phase: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la suppression de la phase"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les statistiques des phases */
|
||||
@GET
|
||||
@Path("/statistiques")
|
||||
public Response getStatistiques() {
|
||||
try {
|
||||
Map<String, Object> stats = phaseChantierService.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();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,564 +0,0 @@
|
||||
package dev.lions.btpxpress.presentation.controller;
|
||||
|
||||
import dev.lions.btpxpress.application.service.StockService;
|
||||
import dev.lions.btpxpress.domain.core.entity.CategorieStock;
|
||||
import dev.lions.btpxpress.domain.core.entity.StatutStock;
|
||||
import dev.lions.btpxpress.domain.core.entity.Stock;
|
||||
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.math.BigDecimal;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* Contrôleur REST pour la gestion des stocks et inventaires Permet de gérer les entrées, sorties,
|
||||
* réservations et suivi des stocks BTP
|
||||
*/
|
||||
@Path("/api/v1/stocks")
|
||||
@Produces(MediaType.APPLICATION_JSON)
|
||||
@Consumes(MediaType.APPLICATION_JSON)
|
||||
@Tag(name = "Stocks", description = "Gestion des stocks et inventaires BTP")
|
||||
public class StockController {
|
||||
|
||||
private static final Logger logger = LoggerFactory.getLogger(StockController.class);
|
||||
|
||||
@Inject StockService stockService;
|
||||
|
||||
/** Récupère tous les stocks */
|
||||
@GET
|
||||
public Response getAllStocks() {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findAll();
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère un stock par son ID */
|
||||
@GET
|
||||
@Path("/{id}")
|
||||
public Response getStockById(@PathParam("id") UUID id) {
|
||||
try {
|
||||
Stock stock = stockService.findById(id);
|
||||
return Response.ok(stock).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 stock: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère un stock par sa référence */
|
||||
@GET
|
||||
@Path("/reference/{reference}")
|
||||
public Response getStockByReference(@PathParam("reference") String reference) {
|
||||
try {
|
||||
Stock stock = stockService.findByReference(reference);
|
||||
if (stock == null) {
|
||||
return Response.status(Response.Status.NOT_FOUND)
|
||||
.entity(Map.of("error", "Stock non trouvé"))
|
||||
.build();
|
||||
}
|
||||
return Response.ok(stock).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération du stock par référence: " + reference, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération du stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Recherche des stocks par désignation */
|
||||
@GET
|
||||
@Path("/search/designation")
|
||||
public Response searchByDesignation(@QueryParam("designation") String designation) {
|
||||
try {
|
||||
if (designation == null || designation.trim().isEmpty()) {
|
||||
return Response.status(Response.Status.BAD_REQUEST)
|
||||
.entity(Map.of("error", "Désignation requise"))
|
||||
.build();
|
||||
}
|
||||
List<Stock> stocks = stockService.searchByDesignation(designation);
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la recherche par désignation: " + designation, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la recherche"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les stocks par catégorie */
|
||||
@GET
|
||||
@Path("/categorie/{categorie}")
|
||||
public Response getStocksByCategorie(@PathParam("categorie") CategorieStock categorie) {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findByCategorie(categorie);
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks par catégorie: " + categorie, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les stocks par statut */
|
||||
@GET
|
||||
@Path("/statut/{statut}")
|
||||
public Response getStocksByStatut(@PathParam("statut") StatutStock statut) {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findByStatut(statut);
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks par statut: " + statut, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les stocks actifs */
|
||||
@GET
|
||||
@Path("/actifs")
|
||||
public Response getStocksActifs() {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findActifs();
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks actifs", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les stocks par fournisseur */
|
||||
@GET
|
||||
@Path("/fournisseur/{fournisseurId}")
|
||||
public Response getStocksByFournisseur(@PathParam("fournisseurId") UUID fournisseurId) {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findByFournisseur(fournisseurId);
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks du fournisseur: " + fournisseurId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les stocks par chantier */
|
||||
@GET
|
||||
@Path("/chantier/{chantierId}")
|
||||
public Response getStocksByChantier(@PathParam("chantierId") UUID chantierId) {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findByChantier(chantierId);
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks du chantier: " + chantierId, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les stocks en rupture */
|
||||
@GET
|
||||
@Path("/rupture")
|
||||
public Response getStocksEnRupture() {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findStocksEnRupture();
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks en rupture", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les stocks sous quantité minimum */
|
||||
@GET
|
||||
@Path("/sous-minimum")
|
||||
public Response getStocksSousQuantiteMinimum() {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findStocksSousQuantiteMinimum();
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks sous minimum", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les stocks sous quantité de sécurité */
|
||||
@GET
|
||||
@Path("/sous-securite")
|
||||
public Response getStocksSousQuantiteSecurite() {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findStocksSousQuantiteSecurite();
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks sous sécurité", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les stocks à commander */
|
||||
@GET
|
||||
@Path("/a-commander")
|
||||
public Response getStocksACommander() {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findStocksACommander();
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks à commander", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les stocks périmés */
|
||||
@GET
|
||||
@Path("/perimes")
|
||||
public Response getStocksPerimes() {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findStocksPerimes();
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks périmés", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les stocks proches de la péremption */
|
||||
@GET
|
||||
@Path("/proches-peremption")
|
||||
public Response getStocksProchesPeremption(
|
||||
@QueryParam("nbJours") @DefaultValue("30") int nbJours) {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findStocksProchesPeremption(nbJours);
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks proches péremption", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les stocks avec réservations */
|
||||
@GET
|
||||
@Path("/avec-reservations")
|
||||
public Response getStocksAvecReservations() {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findStocksAvecReservations();
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des stocks avec réservations", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Crée un nouveau stock */
|
||||
@POST
|
||||
public Response createStock(@Valid Stock stock) {
|
||||
try {
|
||||
Stock nouveauStock = stockService.create(stock);
|
||||
return Response.status(Response.Status.CREATED).entity(nouveauStock).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 du stock", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la création du stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Met à jour un stock */
|
||||
@PUT
|
||||
@Path("/{id}")
|
||||
public Response updateStock(@PathParam("id") UUID id, @Valid Stock stockData) {
|
||||
try {
|
||||
Stock stock = stockService.update(id, stockData);
|
||||
return Response.ok(stock).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 du stock: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la mise à jour du stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Entrée de stock */
|
||||
@POST
|
||||
@Path("/{id}/entree")
|
||||
public Response entreeStock(@PathParam("id") UUID id, Map<String, Object> payload) {
|
||||
try {
|
||||
BigDecimal quantite = new BigDecimal(payload.get("quantite").toString());
|
||||
String motif = payload.get("motif") != null ? payload.get("motif").toString() : null;
|
||||
String numeroDocument =
|
||||
payload.get("numeroDocument") != null ? payload.get("numeroDocument").toString() : null;
|
||||
|
||||
Stock stock = stockService.entreeStock(id, quantite, motif, numeroDocument);
|
||||
return Response.ok(stock).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", "Quantité ou données invalides"))
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de l'entrée de stock: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de l'entrée de stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Sortie de stock */
|
||||
@POST
|
||||
@Path("/{id}/sortie")
|
||||
public Response sortieStock(@PathParam("id") UUID id, Map<String, Object> payload) {
|
||||
try {
|
||||
BigDecimal quantite = new BigDecimal(payload.get("quantite").toString());
|
||||
String motif = payload.get("motif") != null ? payload.get("motif").toString() : null;
|
||||
String numeroDocument =
|
||||
payload.get("numeroDocument") != null ? payload.get("numeroDocument").toString() : null;
|
||||
|
||||
Stock stock = stockService.sortieStock(id, quantite, motif, numeroDocument);
|
||||
return Response.ok(stock).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", "Quantité insuffisante ou données invalides"))
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la sortie de stock: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la sortie de stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Réservation de stock */
|
||||
@POST
|
||||
@Path("/{id}/reserver")
|
||||
public Response reserverStock(@PathParam("id") UUID id, Map<String, Object> payload) {
|
||||
try {
|
||||
BigDecimal quantite = new BigDecimal(payload.get("quantite").toString());
|
||||
String motif = payload.get("motif") != null ? payload.get("motif").toString() : null;
|
||||
|
||||
Stock stock = stockService.reserverStock(id, quantite, motif);
|
||||
return Response.ok(stock).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", "Quantité insuffisante ou données invalides"))
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la réservation de stock: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la réservation de stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Libération de réservation */
|
||||
@POST
|
||||
@Path("/{id}/liberer-reservation")
|
||||
public Response libererReservation(@PathParam("id") UUID id, Map<String, Object> payload) {
|
||||
try {
|
||||
BigDecimal quantite = new BigDecimal(payload.get("quantite").toString());
|
||||
|
||||
Stock stock = stockService.libererReservation(id, quantite);
|
||||
return Response.ok(stock).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", "Quantité invalide"))
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la libération de réservation: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la libération de réservation"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Inventaire d'un stock */
|
||||
@POST
|
||||
@Path("/{id}/inventaire")
|
||||
public Response inventaireStock(@PathParam("id") UUID id, Map<String, Object> payload) {
|
||||
try {
|
||||
BigDecimal quantiteReelle = new BigDecimal(payload.get("quantiteReelle").toString());
|
||||
String motif = payload.get("motif") != null ? payload.get("motif").toString() : "Inventaire";
|
||||
|
||||
Stock stock = stockService.inventaireStock(id, quantiteReelle, motif);
|
||||
return Response.ok(stock).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", "Quantité invalide"))
|
||||
.build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de l'inventaire du stock: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de l'inventaire du stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Supprime un stock */
|
||||
@DELETE
|
||||
@Path("/{id}")
|
||||
public Response deleteStock(@PathParam("id") UUID id) {
|
||||
try {
|
||||
stockService.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 du stock: " + id, e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la suppression du stock"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Recherche de stocks par multiple critères */
|
||||
@GET
|
||||
@Path("/search")
|
||||
public Response searchStocks(@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<Stock> stocks = stockService.searchStocks(searchTerm);
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la recherche de stocks: " + 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 stocks */
|
||||
@GET
|
||||
@Path("/statistiques")
|
||||
public Response getStatistiques() {
|
||||
try {
|
||||
Map<String, Object> stats = stockService.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();
|
||||
}
|
||||
}
|
||||
|
||||
/** Calcule la valeur totale du stock */
|
||||
@GET
|
||||
@Path("/valeur-totale")
|
||||
public Response getValeurTotaleStock() {
|
||||
try {
|
||||
BigDecimal valeurTotale = stockService.calculateValeurTotaleStock();
|
||||
return Response.ok(Map.of("valeurTotale", valeurTotale)).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors du calcul de la valeur totale", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors du calcul de la valeur totale"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les top stocks par valeur */
|
||||
@GET
|
||||
@Path("/top-valeur")
|
||||
public Response getTopStocksByValeur(@QueryParam("limit") @DefaultValue("10") int limit) {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findTopStocksByValeur(limit);
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des top stocks par valeur", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
/** Récupère les top stocks par quantité */
|
||||
@GET
|
||||
@Path("/top-quantite")
|
||||
public Response getTopStocksByQuantite(@QueryParam("limit") @DefaultValue("10") int limit) {
|
||||
try {
|
||||
List<Stock> stocks = stockService.findTopStocksByQuantite(limit);
|
||||
return Response.ok(stocks).build();
|
||||
} catch (Exception e) {
|
||||
logger.error("Erreur lors de la récupération des top stocks par quantité", e);
|
||||
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
|
||||
.entity(Map.of("error", "Erreur lors de la récupération des stocks"))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
}
|
||||
30
src/main/resources/application-dev.properties
Normal file
30
src/main/resources/application-dev.properties
Normal file
@@ -0,0 +1,30 @@
|
||||
# Configuration OIDC spécifique au mode développement
|
||||
# Ce fichier surcharge application.properties pour le profil %dev
|
||||
|
||||
# Activation de OIDC
|
||||
quarkus.oidc.enabled=true
|
||||
quarkus.oidc.auth-server-url=https://security.lions.dev/realms/btpxpress
|
||||
quarkus.oidc.client-id=btpxpress-backend
|
||||
quarkus.oidc.credentials.secret=${KEYCLOAK_CLIENT_SECRET:fCSqFPsnyrUUljAAGY8ailGKp1u6mutv}
|
||||
|
||||
# Type d'application: web-app pour gérer les sessions
|
||||
quarkus.oidc.application-type=web-app
|
||||
|
||||
# Configuration TLS
|
||||
quarkus.oidc.tls.verification=required
|
||||
|
||||
# Configuration des redirections
|
||||
quarkus.oidc.authentication.redirect-path=/
|
||||
quarkus.oidc.authentication.restore-path-after-redirect=true
|
||||
|
||||
# Configuration des cookies pour cross-origin (localhost:3000 -> localhost:8080)
|
||||
quarkus.oidc.authentication.cookie-path=/
|
||||
quarkus.oidc.authentication.cookie-domain=localhost
|
||||
quarkus.oidc.authentication.session-age-extension=PT30M
|
||||
|
||||
# Configuration Keycloak
|
||||
quarkus.oidc.token.issuer=https://security.lions.dev/realms/btpxpress
|
||||
quarkus.oidc.discovery-enabled=true
|
||||
|
||||
# Activation de la sécurité en mode dev
|
||||
quarkus.security.auth.enabled=true
|
||||
@@ -1,12 +1,10 @@
|
||||
# Configuration de production pour BTP Xpress avec Keycloak
|
||||
# Configuration de production pour BTP Xpress - Frontend-Centric Auth
|
||||
# Variables d'environnement requises :
|
||||
# - DB_URL : URL de la base de données PostgreSQL
|
||||
# - DB_USERNAME : Nom d'utilisateur de la base de données
|
||||
# - DB_PASSWORD : Mot de passe de la base de données
|
||||
# - KEYCLOAK_SERVER_URL : URL du serveur Keycloak
|
||||
# - KEYCLOAK_REALM : Nom du realm Keycloak
|
||||
# - KEYCLOAK_CLIENT_ID : ID du client Keycloak
|
||||
# - KEYCLOAK_CLIENT_SECRET : Secret du client Keycloak
|
||||
# Le frontend gère l'authentification OAuth avec Keycloak
|
||||
# Le backend valide simplement les tokens JWT envoyés par le frontend
|
||||
|
||||
# Base de données
|
||||
quarkus.datasource.jdbc.url=${DB_URL:jdbc:postgresql://postgres:5432/btpxpress}
|
||||
@@ -32,23 +30,22 @@ quarkus.http.cors.exposed-headers=Content-Disposition
|
||||
quarkus.http.cors.access-control-max-age=24H
|
||||
quarkus.http.cors.access-control-allow-credentials=true
|
||||
|
||||
# Configuration Keycloak OIDC
|
||||
quarkus.oidc.auth-server-url=${KEYCLOAK_SERVER_URL:https://security.lions.dev}/realms/${KEYCLOAK_REALM:btpxpress}
|
||||
quarkus.oidc.client-id=${KEYCLOAK_CLIENT_ID:btpxpress-backend}
|
||||
quarkus.oidc.credentials.secret=${KEYCLOAK_CLIENT_SECRET}
|
||||
quarkus.oidc.tls.verification=required
|
||||
quarkus.oidc.authentication.redirect-path=/login
|
||||
quarkus.oidc.authentication.restore-path-after-redirect=true
|
||||
# JWT validation - Tokens envoyés par le frontend
|
||||
mp.jwt.verify.publickey.location=https://security.lions.dev/realms/btpxpress/protocol/openid-connect/certs
|
||||
mp.jwt.verify.issuer=https://security.lions.dev/realms/btpxpress
|
||||
quarkus.smallrye-jwt.enabled=true
|
||||
quarkus.smallrye-jwt.auth-mechanism=MP-JWT
|
||||
quarkus.smallrye-jwt.require-named-principal=false
|
||||
|
||||
# Sécurité
|
||||
quarkus.security.auth.enabled=true
|
||||
quarkus.security.auth.proactive=true
|
||||
quarkus.security.auth.proactive=false
|
||||
|
||||
# Permissions pour accès public aux endpoints de documentation et santé
|
||||
quarkus.http.auth.permission.public.paths=/q/*,/openapi,/swagger-ui/*
|
||||
quarkus.http.auth.permission.public.policy=permit
|
||||
|
||||
# Authentification requise pour tous les autres endpoints
|
||||
# Authentification JWT requise pour tous les autres endpoints
|
||||
quarkus.http.auth.permission.authenticated.paths=/*
|
||||
quarkus.http.auth.permission.authenticated.policy=authenticated
|
||||
|
||||
@@ -57,7 +54,7 @@ quarkus.log.level=INFO
|
||||
quarkus.log.category."dev.lions.btpxpress".level=INFO
|
||||
quarkus.log.category."org.hibernate".level=WARN
|
||||
quarkus.log.category."io.quarkus".level=INFO
|
||||
quarkus.log.category."io.quarkus.oidc".level=DEBUG
|
||||
quarkus.log.category."io.quarkus.smallrye.jwt".level=INFO
|
||||
|
||||
# Métriques et monitoring
|
||||
quarkus.micrometer.export.prometheus.enabled=true
|
||||
|
||||
@@ -3,14 +3,14 @@
|
||||
|
||||
# Base de données PostgreSQL pour développement et production
|
||||
quarkus.datasource.db-kind=postgresql
|
||||
quarkus.datasource.jdbc.url=${DB_URL:jdbc:postgresql://localhost:5434/btpxpress}
|
||||
quarkus.datasource.username=${DB_USERNAME:btpxpress}
|
||||
quarkus.datasource.jdbc.url=${DB_URL:jdbc:postgresql://localhost:5433/btpxpress}
|
||||
quarkus.datasource.username=${DB_USERNAME:btpxpress_user}
|
||||
quarkus.datasource.password=${DB_PASSWORD:?DB_PASSWORD must be set}
|
||||
|
||||
# Configuration de performance et optimisation
|
||||
quarkus.hibernate-orm.sql-load-script=no-file
|
||||
quarkus.hibernate-orm.database.generation=none
|
||||
quarkus.hibernate-orm.log.sql=false
|
||||
quarkus.hibernate-orm.database.generation=drop-and-create
|
||||
quarkus.hibernate-orm.log.sql=true
|
||||
quarkus.hibernate-orm.log.bind-parameters=false
|
||||
|
||||
# Optimisation des connexions de base de données
|
||||
@@ -72,6 +72,7 @@ quarkus.redis.devservices.enabled=false
|
||||
# Serveur HTTP
|
||||
quarkus.http.port=${SERVER_PORT:8080}
|
||||
quarkus.http.host=0.0.0.0
|
||||
quarkus.http.non-application-root-path=/q
|
||||
|
||||
# CORS pour développement
|
||||
quarkus.http.cors=true
|
||||
@@ -82,17 +83,18 @@ quarkus.http.cors.exposed-headers=Content-Disposition
|
||||
quarkus.http.cors.access-control-max-age=24H
|
||||
quarkus.http.cors.access-control-allow-credentials=true
|
||||
|
||||
# Configuration Keycloak OIDC pour développement (désactivé en mode dev)
|
||||
%dev.quarkus.oidc.auth-server-url=https://security.lions.dev/realms/btpxpress
|
||||
%dev.quarkus.oidc.client-id=btpxpress-backend
|
||||
%dev.quarkus.oidc.credentials.secret=${KEYCLOAK_CLIENT_SECRET:dev-secret-change-me}
|
||||
%dev.quarkus.oidc.tls.verification=required
|
||||
%dev.quarkus.oidc.authentication.redirect-path=/login
|
||||
%dev.quarkus.oidc.authentication.restore-path-after-redirect=true
|
||||
%dev.quarkus.oidc.token.issuer=https://security.lions.dev/realms/btpxpress
|
||||
%dev.quarkus.oidc.discovery-enabled=true
|
||||
# JWT validation - Le frontend envoie les tokens Keycloak
|
||||
mp.jwt.verify.publickey.location=https://security.lions.dev/realms/btpxpress/protocol/openid-connect/certs
|
||||
mp.jwt.verify.issuer=https://security.lions.dev/realms/btpxpress
|
||||
quarkus.smallrye-jwt.enabled=true
|
||||
quarkus.smallrye-jwt.auth-mechanism=MP-JWT
|
||||
quarkus.smallrye-jwt.require-named-principal=false
|
||||
|
||||
# Sécurité - Désactivée en mode développement
|
||||
# Base de données - Mode développement avec création automatique du schéma
|
||||
%dev.quarkus.hibernate-orm.database.generation=drop-and-create
|
||||
%dev.quarkus.hibernate-orm.log.sql=true
|
||||
|
||||
# Sécurité - Désactivée en mode développement pour faciliter les tests
|
||||
%dev.quarkus.security.auth.enabled=false
|
||||
%prod.quarkus.security.auth.enabled=true
|
||||
quarkus.security.auth.proactive=false
|
||||
@@ -112,8 +114,7 @@ quarkus.dev.ui.enabled=true
|
||||
|
||||
# OpenAPI/Swagger
|
||||
quarkus.swagger-ui.always-include=true
|
||||
quarkus.swagger-ui.path=/swagger-ui
|
||||
quarkus.smallrye-openapi.path=/openapi
|
||||
quarkus.smallrye-openapi.path=/q/openapi
|
||||
quarkus.smallrye-openapi.info-title=BTP Xpress API
|
||||
quarkus.smallrye-openapi.info-version=1.0.0
|
||||
quarkus.smallrye-openapi.info-description=Backend REST API for BTP Xpress application
|
||||
@@ -136,7 +137,7 @@ quarkus.log.category."dev.lions.btpxpress".level=DEBUG
|
||||
quarkus.log.category."io.agroal".level=DEBUG
|
||||
quarkus.log.category."io.vertx.core.impl.BlockedThreadChecker".level=WARN
|
||||
quarkus.log.category."org.hibernate".level=DEBUG
|
||||
quarkus.log.category."io.quarkus.oidc".level=DEBUG
|
||||
quarkus.log.category."io.quarkus.smallrye.jwt".level=DEBUG
|
||||
quarkus.log.console.format=%d{HH:mm:ss} %-5p [%c{2.}] (%t) %s%e%n
|
||||
quarkus.log.console.color=true
|
||||
quarkus.log.async=true
|
||||
@@ -146,26 +147,12 @@ quarkus.log.async.queue-length=16384
|
||||
quarkus.micrometer.export.prometheus.enabled=true
|
||||
quarkus.smallrye-health.ui.enable=true
|
||||
|
||||
# Configuration Keycloak OIDC pour production - SECRETS VIA VARIABLES D'ENVIRONNEMENT
|
||||
%prod.quarkus.oidc.auth-server-url=${KEYCLOAK_AUTH_SERVER_URL:https://security.lions.dev/realms/btpxpress}
|
||||
%prod.quarkus.oidc.client-id=${KEYCLOAK_CLIENT_ID:btpxpress-backend}
|
||||
%prod.quarkus.oidc.credentials.secret=${KEYCLOAK_CLIENT_SECRET:?KEYCLOAK_CLIENT_SECRET must be set}
|
||||
%prod.quarkus.oidc.tls.verification=required
|
||||
%prod.quarkus.oidc.authentication.redirect-path=/login
|
||||
%prod.quarkus.oidc.authentication.restore-path-after-redirect=true
|
||||
%prod.quarkus.oidc.token.issuer=https://security.lions.dev/realms/btpxpress
|
||||
%prod.quarkus.oidc.discovery-enabled=true
|
||||
%prod.quarkus.oidc.introspection-path=/protocol/openid-connect/token/introspect
|
||||
%prod.quarkus.oidc.jwks-path=/protocol/openid-connect/certs
|
||||
%prod.quarkus.oidc.token-path=/protocol/openid-connect/token
|
||||
%prod.quarkus.oidc.authorization-path=/protocol/openid-connect/auth
|
||||
%prod.quarkus.oidc.end-session-path=/protocol/openid-connect/logout
|
||||
|
||||
# Configuration de la sécurité CORS pour production avec nouvelle URL API
|
||||
%prod.quarkus.http.cors.origins=https://btpxpress.lions.dev,https://security.lions.dev,https://api.lions.dev
|
||||
|
||||
# Configuration Keycloak OIDC pour tests (désactivé)
|
||||
%test.quarkus.oidc.auth-server-url=https://security.lions.dev/realms/btpxpress
|
||||
%test.quarkus.oidc.client-id=btpxpress-backend
|
||||
%test.quarkus.oidc.credentials.secret=${KEYCLOAK_CLIENT_SECRET:test-secret}
|
||||
# JWT validation en production - Mêmes paramètres que dev
|
||||
%prod.mp.jwt.verify.publickey.location=https://security.lions.dev/realms/btpxpress/protocol/openid-connect/certs
|
||||
%prod.mp.jwt.verify.issuer=https://security.lions.dev/realms/btpxpress
|
||||
|
||||
# Configuration pour les tests
|
||||
%test.quarkus.security.auth.enabled=false
|
||||
|
||||
@@ -1 +1 @@
|
||||
public class MainControllerTest {}
|
||||
public class MainControllerTest {}
|
||||
|
||||
Reference in New Issue
Block a user