From 95c2552c26277e64fdae5f0b0c5d25dc124fd6c9 Mon Sep 17 00:00:00 2001 From: dahoud Date: Mon, 6 Oct 2025 18:47:05 +0000 Subject: [PATCH] Initial commit: GBCM Server API with DTOs, interfaces and enums --- .gitignore | 82 ++++++++ README.md | 152 +++++++++++++++ pom.xml | 95 ++++++++++ .../server/api/dto/auth/LoginRequestDTO.java | 77 ++++++++ .../server/api/dto/auth/LoginResponseDTO.java | 118 ++++++++++++ .../com/gbcm/server/api/dto/user/UserDTO.java | 178 ++++++++++++++++++ .../com/gbcm/server/api/enums/UserRole.java | 107 +++++++++++ .../server/api/interfaces/AuthService.java | 144 ++++++++++++++ 8 files changed, 953 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 pom.xml create mode 100644 src/main/java/com/gbcm/server/api/dto/auth/LoginRequestDTO.java create mode 100644 src/main/java/com/gbcm/server/api/dto/auth/LoginResponseDTO.java create mode 100644 src/main/java/com/gbcm/server/api/dto/user/UserDTO.java create mode 100644 src/main/java/com/gbcm/server/api/enums/UserRole.java create mode 100644 src/main/java/com/gbcm/server/api/interfaces/AuthService.java diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3410bf9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,82 @@ +# Compiled class file +*.class + +# Log file +*.log + +# BlueJ files +*.ctxt + +# Mobile Tools for Java (J2ME) +.mtj.tmp/ + +# Package Files # +*.jar +*.war +*.nar +*.ear +*.zip +*.tar.gz +*.rar + +# virtual machine crash logs +hs_err_pid* + +# Maven +target/ +pom.xml.tag +pom.xml.releaseBackup +pom.xml.versionsBackup +pom.xml.next +release.properties +dependency-reduced-pom.xml +buildNumber.properties +.mvn/timing.properties +.mvn/wrapper/maven-wrapper.jar + +# Gradle +.gradle +build/ +!gradle/wrapper/gradle-wrapper.jar + +# IntelliJ IDEA +.idea/ +*.iws +*.iml +*.ipr +out/ + +# Eclipse +.apt_generated +.classpath +.factorypath +.project +.settings +.springBeans +.sts4-cache +bin/ + +# NetBeans +/nbproject/private/ +/nbbuild/ +/dist/ +/nbdist/ +/.nb-gradle/ + +# VS Code +.vscode/ + +# Mac +.DS_Store + +# Windows +Thumbs.db +ehthumbs.db +Desktop.ini + +# Generated sources +src/gen/ + +# Temporary files +*.tmp +*.temp diff --git a/README.md b/README.md new file mode 100644 index 0000000..dd675ee --- /dev/null +++ b/README.md @@ -0,0 +1,152 @@ +# GBCM Server API + +Contrats d'API et DTOs pour la plateforme GBCM (Global Business Consulting and Management). + +## Description + +Ce module contient les définitions d'interfaces, DTOs (Data Transfer Objects), énumérations et exceptions partagées entre le client et le serveur GBCM. + +## Technologies + +- **Java 17** - Langage de programmation +- **Jakarta Validation 3.0** - Validation des données +- **Jakarta REST 3.1** - Annotations REST +- **Jackson** - Sérialisation JSON +- **Swagger/OpenAPI 3** - Documentation API +- **Maven** - Gestion des dépendances + +## Structure du projet + +``` +src/main/java/com/gbcm/server/api/ +├── dto/ # Data Transfer Objects +│ ├── auth/ # DTOs authentification +│ ├── user/ # DTOs utilisateurs +│ ├── coaching/ # DTOs coaching +│ ├── workshop/ # DTOs ateliers +│ ├── billing/ # DTOs facturation +│ └── common/ # DTOs communs +├── interfaces/ # Interfaces de service +│ ├── AuthService.java +│ ├── UserService.java +│ ├── CoachingService.java +│ └── WorkshopService.java +├── enums/ # Énumérations +│ ├── UserRole.java +│ ├── ServiceType.java +│ └── PaymentStatus.java +└── exceptions/ # Exceptions métier + ├── GBCMException.java + ├── AuthenticationException.java + └── ValidationException.java +``` + +## Installation + +```bash +git clone https://git.lions.dev/gbcm/gbcm-server-api.git +cd gbcm-server-api +mvn clean install +``` + +## Utilisation + +Ce module est une dépendance partagée utilisée par : +- `gbcm-client-impl-quarkus` - Interface web +- `gbcm-server-impl-quarkus` - Implémentation serveur +- `gbcm-mobile-app` - Application mobile (via REST) + +### Ajout de la dépendance + +```xml + + com.gbcm + gbcm-server-api + 1.0.0-SNAPSHOT + +``` + +## DTOs Principaux + +### Authentification +- `LoginRequestDTO` - Requête de connexion +- `LoginResponseDTO` - Réponse de connexion +- `UserDTO` - Informations utilisateur + +### Services +- `WorkshopDTO` - Informations atelier +- `CoachingSessionDTO` - Session de coaching +- `InvoiceDTO` - Facturation + +## Interfaces de Service + +### AuthService +- `login()` - Authentification +- `logout()` - Déconnexion +- `refreshToken()` - Rafraîchissement token +- `validateToken()` - Validation token + +### UserService +- `createUser()` - Création utilisateur +- `updateUser()` - Mise à jour +- `getUserById()` - Récupération par ID + +## Énumérations + +### UserRole +- `ADMIN` - Administrateur +- `COACH` - Coach/Consultant +- `CLIENT` - Client +- `PROSPECT` - Prospect +- `MANAGER` - Manager + +## Validation + +Toutes les DTOs incluent des annotations de validation Jakarta : +- `@NotNull`, `@NotBlank` - Champs obligatoires +- `@Email` - Format email +- `@Size` - Taille des chaînes +- `@Valid` - Validation en cascade + +## Documentation OpenAPI + +La documentation API est générée automatiquement via les annotations Swagger : +- Descriptions des endpoints +- Schémas des DTOs +- Exemples de requêtes/réponses + +## Tests + +```bash +mvn test +``` + +## Build + +```bash +# Build standard +mvn clean package + +# Installation locale +mvn clean install + +# Déploiement (si configuré) +mvn deploy +``` + +## Versioning + +Ce module suit le versioning sémantique : +- `MAJOR.MINOR.PATCH` +- Changements breaking = MAJOR +- Nouvelles fonctionnalités = MINOR +- Corrections de bugs = PATCH + +## Support + +- Email: support@gbcm.com +- Documentation: https://docs.gbcm.com/api + +## Licence + +Propriétaire - GBCM LLC © 2024 diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..0543fd3 --- /dev/null +++ b/pom.xml @@ -0,0 +1,95 @@ + + + 4.0.0 + + com.gbcm + gbcm-server-api + 1.0.0-SNAPSHOT + jar + + GBCM Server API + Contrats d'API et DTOs pour les services GBCM + + + 17 + 17 + UTF-8 + + + 3.0.2 + 3.1.0 + 2.15.2 + 2.2.15 + + + + + + jakarta.validation + jakarta.validation-api + ${jakarta.validation.version} + + + + + jakarta.ws.rs + jakarta.ws.rs-api + ${jakarta.ws.rs.version} + + + + + com.fasterxml.jackson.core + jackson-annotations + ${jackson.version} + + + + + io.swagger.core.v3 + swagger-annotations + ${swagger.version} + + + + + org.junit.jupiter + junit-jupiter + 5.10.0 + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.11.0 + + + + + org.openapitools + openapi-generator-maven-plugin + 7.0.1 + + + + generate + + + ${project.basedir}/src/main/resources/META-INF/openapi.yaml + java + + src/gen/java/main + + + + + + + + diff --git a/src/main/java/com/gbcm/server/api/dto/auth/LoginRequestDTO.java b/src/main/java/com/gbcm/server/api/dto/auth/LoginRequestDTO.java new file mode 100644 index 0000000..8dd15ab --- /dev/null +++ b/src/main/java/com/gbcm/server/api/dto/auth/LoginRequestDTO.java @@ -0,0 +1,77 @@ +package com.gbcm.server.api.dto.auth; + +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.v3.oas.annotations.media.Schema; +import jakarta.validation.constraints.Email; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.Size; + +/** + * DTO pour les requêtes de connexion + */ +@Schema(description = "Requête de connexion utilisateur") +public class LoginRequestDTO { + + @Schema(description = "Adresse email de l'utilisateur", example = "user@gbcm.com") + @JsonProperty("email") + @NotBlank(message = "L'email est obligatoire") + @Email(message = "Format d'email invalide") + private String email; + + @Schema(description = "Mot de passe", example = "password123") + @JsonProperty("password") + @NotBlank(message = "Le mot de passe est obligatoire") + @Size(min = 6, max = 100, message = "Le mot de passe doit contenir entre 6 et 100 caractères") + private String password; + + @Schema(description = "Se souvenir de moi", example = "true") + @JsonProperty("rememberMe") + private boolean rememberMe = false; + + // Constructeurs + public LoginRequestDTO() {} + + public LoginRequestDTO(String email, String password) { + this.email = email; + this.password = password; + } + + public LoginRequestDTO(String email, String password, boolean rememberMe) { + this.email = email; + this.password = password; + this.rememberMe = rememberMe; + } + + // Getters et Setters + public String getEmail() { + return email; + } + + public void setEmail(String email) { + this.email = email; + } + + public String getPassword() { + return password; + } + + public void setPassword(String password) { + this.password = password; + } + + public boolean isRememberMe() { + return rememberMe; + } + + public void setRememberMe(boolean rememberMe) { + this.rememberMe = rememberMe; + } + + @Override + public String toString() { + return "LoginRequestDTO{" + + "email='" + email + '\'' + + ", rememberMe=" + rememberMe + + '}'; + } +} diff --git a/src/main/java/com/gbcm/server/api/dto/auth/LoginResponseDTO.java b/src/main/java/com/gbcm/server/api/dto/auth/LoginResponseDTO.java new file mode 100644 index 0000000..527cc9e --- /dev/null +++ b/src/main/java/com/gbcm/server/api/dto/auth/LoginResponseDTO.java @@ -0,0 +1,118 @@ +package com.gbcm.server.api.dto.auth; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.gbcm.server.api.dto.user.UserDTO; +import io.swagger.v3.oas.annotations.media.Schema; + +import java.time.LocalDateTime; + +/** + * DTO pour les réponses de connexion + */ +@Schema(description = "Réponse de connexion utilisateur") +public class LoginResponseDTO { + + @Schema(description = "Succès de la connexion", example = "true") + @JsonProperty("success") + private boolean success; + + @Schema(description = "Message de réponse", example = "Connexion réussie") + @JsonProperty("message") + private String message; + + @Schema(description = "Token d'authentification JWT") + @JsonProperty("token") + private String token; + + @Schema(description = "Date d'expiration du token") + @JsonProperty("expiresAt") + private LocalDateTime expiresAt; + + @Schema(description = "Informations utilisateur") + @JsonProperty("user") + private UserDTO user; + + @Schema(description = "Token de rafraîchissement") + @JsonProperty("refreshToken") + private String refreshToken; + + // Constructeurs + public LoginResponseDTO() {} + + public LoginResponseDTO(boolean success, String message) { + this.success = success; + this.message = message; + } + + public static LoginResponseDTO success(String token, LocalDateTime expiresAt, UserDTO user) { + LoginResponseDTO response = new LoginResponseDTO(true, "Connexion réussie"); + response.setToken(token); + response.setExpiresAt(expiresAt); + response.setUser(user); + return response; + } + + public static LoginResponseDTO failure(String message) { + return new LoginResponseDTO(false, message); + } + + // Getters et Setters + public boolean isSuccess() { + return success; + } + + public void setSuccess(boolean success) { + this.success = success; + } + + public String getMessage() { + return message; + } + + public void setMessage(String message) { + this.message = message; + } + + public String getToken() { + return token; + } + + public void setToken(String token) { + this.token = token; + } + + public LocalDateTime getExpiresAt() { + return expiresAt; + } + + public void setExpiresAt(LocalDateTime expiresAt) { + this.expiresAt = expiresAt; + } + + public UserDTO getUser() { + return user; + } + + public void setUser(UserDTO user) { + this.user = user; + } + + public String getRefreshToken() { + return refreshToken; + } + + public void setRefreshToken(String refreshToken) { + this.refreshToken = refreshToken; + } + + @Override + public String toString() { + return "LoginResponseDTO{" + + "success=" + success + + ", message='" + message + '\'' + + ", token='" + (token != null ? "[PROTECTED]" : null) + '\'' + + ", expiresAt=" + expiresAt + + ", user=" + user + + '}'; + } +} diff --git a/src/main/java/com/gbcm/server/api/dto/user/UserDTO.java b/src/main/java/com/gbcm/server/api/dto/user/UserDTO.java new file mode 100644 index 0000000..f39d578 --- /dev/null +++ b/src/main/java/com/gbcm/server/api/dto/user/UserDTO.java @@ -0,0 +1,178 @@ +package com.gbcm.server.api.dto.user; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.gbcm.server.api.enums.UserRole; +import io.swagger.v3.oas.annotations.media.Schema; +import jakarta.validation.constraints.Email; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; + +import java.time.LocalDateTime; + +/** + * DTO pour les informations utilisateur + */ +@Schema(description = "Informations utilisateur") +public class UserDTO { + + @Schema(description = "Identifiant unique", example = "1") + @JsonProperty("id") + private Long id; + + @Schema(description = "Prénom", example = "John") + @JsonProperty("firstName") + @NotBlank(message = "Le prénom est obligatoire") + private String firstName; + + @Schema(description = "Nom de famille", example = "Doe") + @JsonProperty("lastName") + @NotBlank(message = "Le nom est obligatoire") + private String lastName; + + @Schema(description = "Adresse email", example = "john.doe@gbcm.com") + @JsonProperty("email") + @NotBlank(message = "L'email est obligatoire") + @Email(message = "Format d'email invalide") + private String email; + + @Schema(description = "Numéro de téléphone", example = "+1234567890") + @JsonProperty("phone") + private String phone; + + @Schema(description = "Rôle utilisateur") + @JsonProperty("role") + @NotNull(message = "Le rôle est obligatoire") + private UserRole role; + + @Schema(description = "Statut actif", example = "true") + @JsonProperty("active") + private boolean active = true; + + @Schema(description = "Date de création") + @JsonProperty("createdAt") + private LocalDateTime createdAt; + + @Schema(description = "Date de dernière modification") + @JsonProperty("updatedAt") + private LocalDateTime updatedAt; + + @Schema(description = "Date de dernière connexion") + @JsonProperty("lastLoginAt") + private LocalDateTime lastLoginAt; + + // Constructeurs + public UserDTO() {} + + public UserDTO(String firstName, String lastName, String email, UserRole role) { + this.firstName = firstName; + this.lastName = lastName; + this.email = email; + this.role = role; + } + + // Méthodes utilitaires + public String getFullName() { + return firstName + " " + lastName; + } + + public String getInitials() { + String firstInitial = firstName != null && !firstName.isEmpty() ? + firstName.substring(0, 1).toUpperCase() : ""; + String lastInitial = lastName != null && !lastName.isEmpty() ? + lastName.substring(0, 1).toUpperCase() : ""; + return firstInitial + lastInitial; + } + + // Getters et Setters + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public String getLastName() { + return lastName; + } + + public void setLastName(String lastName) { + this.lastName = lastName; + } + + public String getEmail() { + return email; + } + + public void setEmail(String email) { + this.email = email; + } + + public String getPhone() { + return phone; + } + + public void setPhone(String phone) { + this.phone = phone; + } + + public UserRole getRole() { + return role; + } + + public void setRole(UserRole role) { + this.role = role; + } + + public boolean isActive() { + return active; + } + + public void setActive(boolean active) { + this.active = active; + } + + public LocalDateTime getCreatedAt() { + return createdAt; + } + + public void setCreatedAt(LocalDateTime createdAt) { + this.createdAt = createdAt; + } + + public LocalDateTime getUpdatedAt() { + return updatedAt; + } + + public void setUpdatedAt(LocalDateTime updatedAt) { + this.updatedAt = updatedAt; + } + + public LocalDateTime getLastLoginAt() { + return lastLoginAt; + } + + public void setLastLoginAt(LocalDateTime lastLoginAt) { + this.lastLoginAt = lastLoginAt; + } + + @Override + public String toString() { + return "UserDTO{" + + "id=" + id + + ", firstName='" + firstName + '\'' + + ", lastName='" + lastName + '\'' + + ", email='" + email + '\'' + + ", role=" + role + + ", active=" + active + + '}'; + } +} diff --git a/src/main/java/com/gbcm/server/api/enums/UserRole.java b/src/main/java/com/gbcm/server/api/enums/UserRole.java new file mode 100644 index 0000000..d9c2cc1 --- /dev/null +++ b/src/main/java/com/gbcm/server/api/enums/UserRole.java @@ -0,0 +1,107 @@ +package com.gbcm.server.api.enums; + +import com.fasterxml.jackson.annotation.JsonValue; + +/** + * Énumération des rôles utilisateur dans GBCM + */ +public enum UserRole { + + /** + * Administrateur système - Accès complet + */ + ADMIN("ADMIN", "Administrateur", "Accès complet au système"), + + /** + * Coach/Consultant - Gestion des clients et programmes + */ + COACH("COACH", "Coach", "Gestion des clients et programmes de coaching"), + + /** + * Client - Accès aux services souscrits + */ + CLIENT("CLIENT", "Client", "Accès aux services et programmes souscrits"), + + /** + * Prospect - Accès limité pour découverte + */ + PROSPECT("PROSPECT", "Prospect", "Accès limité aux ressources de découverte"), + + /** + * Manager - Gestion opérationnelle + */ + MANAGER("MANAGER", "Manager", "Gestion opérationnelle et supervision"); + + private final String code; + private final String displayName; + private final String description; + + UserRole(String code, String displayName, String description) { + this.code = code; + this.displayName = displayName; + this.description = description; + } + + @JsonValue + public String getCode() { + return code; + } + + public String getDisplayName() { + return displayName; + } + + public String getDescription() { + return description; + } + + /** + * Trouve un rôle par son code + */ + public static UserRole fromCode(String code) { + if (code == null) { + return null; + } + + for (UserRole role : values()) { + if (role.code.equalsIgnoreCase(code)) { + return role; + } + } + + throw new IllegalArgumentException("Rôle inconnu: " + code); + } + + /** + * Vérifie si le rôle a des privilèges administrateur + */ + public boolean isAdmin() { + return this == ADMIN; + } + + /** + * Vérifie si le rôle peut gérer des clients + */ + public boolean canManageClients() { + return this == ADMIN || this == COACH || this == MANAGER; + } + + /** + * Vérifie si le rôle peut accéder aux services + */ + public boolean canAccessServices() { + return this == CLIENT || this == COACH || this == ADMIN || this == MANAGER; + } + + /** + * Vérifie si le rôle peut voir les rapports + */ + public boolean canViewReports() { + return this == ADMIN || this == MANAGER; + } + + @Override + public String toString() { + return displayName; + } +} diff --git a/src/main/java/com/gbcm/server/api/interfaces/AuthService.java b/src/main/java/com/gbcm/server/api/interfaces/AuthService.java new file mode 100644 index 0000000..199d105 --- /dev/null +++ b/src/main/java/com/gbcm/server/api/interfaces/AuthService.java @@ -0,0 +1,144 @@ +package com.gbcm.server.api.interfaces; + +import com.gbcm.server.api.dto.auth.LoginRequestDTO; +import com.gbcm.server.api.dto.auth.LoginResponseDTO; +import com.gbcm.server.api.dto.user.UserDTO; +import com.gbcm.server.api.exceptions.AuthenticationException; +import com.gbcm.server.api.exceptions.GBCMException; + +import jakarta.ws.rs.*; +import jakarta.ws.rs.core.MediaType; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import io.swagger.v3.oas.annotations.tags.Tag; + +/** + * Interface de service pour l'authentification + */ +@Path("/auth") +@Produces(MediaType.APPLICATION_JSON) +@Consumes(MediaType.APPLICATION_JSON) +@Tag(name = "Authentication", description = "Services d'authentification et autorisation") +public interface AuthService { + + /** + * Connexion utilisateur + */ + @POST + @Path("/login") + @Operation( + summary = "Connexion utilisateur", + description = "Authentifie un utilisateur avec email et mot de passe" + ) + @ApiResponse(responseCode = "200", description = "Connexion réussie") + @ApiResponse(responseCode = "401", description = "Identifiants invalides") + @ApiResponse(responseCode = "400", description = "Données de requête invalides") + LoginResponseDTO login( + @Parameter(description = "Informations de connexion", required = true) + LoginRequestDTO loginRequest + ) throws AuthenticationException, GBCMException; + + /** + * Déconnexion utilisateur + */ + @POST + @Path("/logout") + @Operation( + summary = "Déconnexion utilisateur", + description = "Invalide le token d'authentification" + ) + @ApiResponse(responseCode = "200", description = "Déconnexion réussie") + @ApiResponse(responseCode = "401", description = "Token invalide") + void logout( + @Parameter(description = "Token d'authentification", required = true) + @HeaderParam("Authorization") String authToken + ) throws AuthenticationException; + + /** + * Rafraîchissement du token + */ + @POST + @Path("/refresh") + @Operation( + summary = "Rafraîchissement du token", + description = "Génère un nouveau token d'authentification" + ) + @ApiResponse(responseCode = "200", description = "Token rafraîchi") + @ApiResponse(responseCode = "401", description = "Token de rafraîchissement invalide") + LoginResponseDTO refreshToken( + @Parameter(description = "Token de rafraîchissement", required = true) + @FormParam("refreshToken") String refreshToken + ) throws AuthenticationException; + + /** + * Validation du token + */ + @GET + @Path("/validate") + @Operation( + summary = "Validation du token", + description = "Vérifie la validité d'un token d'authentification" + ) + @ApiResponse(responseCode = "200", description = "Token valide") + @ApiResponse(responseCode = "401", description = "Token invalide ou expiré") + UserDTO validateToken( + @Parameter(description = "Token d'authentification", required = true) + @HeaderParam("Authorization") String authToken + ) throws AuthenticationException; + + /** + * Demande de réinitialisation de mot de passe + */ + @POST + @Path("/forgot-password") + @Operation( + summary = "Mot de passe oublié", + description = "Envoie un email de réinitialisation de mot de passe" + ) + @ApiResponse(responseCode = "200", description = "Email envoyé") + @ApiResponse(responseCode = "404", description = "Utilisateur non trouvé") + void forgotPassword( + @Parameter(description = "Adresse email", required = true) + @FormParam("email") String email + ) throws GBCMException; + + /** + * Réinitialisation du mot de passe + */ + @POST + @Path("/reset-password") + @Operation( + summary = "Réinitialisation du mot de passe", + description = "Réinitialise le mot de passe avec un token de réinitialisation" + ) + @ApiResponse(responseCode = "200", description = "Mot de passe réinitialisé") + @ApiResponse(responseCode = "400", description = "Token invalide ou expiré") + void resetPassword( + @Parameter(description = "Token de réinitialisation", required = true) + @FormParam("resetToken") String resetToken, + @Parameter(description = "Nouveau mot de passe", required = true) + @FormParam("newPassword") String newPassword + ) throws GBCMException; + + /** + * Changement de mot de passe + */ + @PUT + @Path("/change-password") + @Operation( + summary = "Changement de mot de passe", + description = "Change le mot de passe d'un utilisateur authentifié" + ) + @ApiResponse(responseCode = "200", description = "Mot de passe changé") + @ApiResponse(responseCode = "401", description = "Non autorisé") + @ApiResponse(responseCode = "400", description = "Ancien mot de passe incorrect") + void changePassword( + @Parameter(description = "Token d'authentification", required = true) + @HeaderParam("Authorization") String authToken, + @Parameter(description = "Ancien mot de passe", required = true) + @FormParam("oldPassword") String oldPassword, + @Parameter(description = "Nouveau mot de passe", required = true) + @FormParam("newPassword") String newPassword + ) throws AuthenticationException, GBCMException; +}