From 04b4aa47f842c469e0a5a150fe0a9f07df47d2fa Mon Sep 17 00:00:00 2001 From: dahoud Date: Sun, 9 Nov 2025 17:06:04 +0000 Subject: [PATCH] feat: Module server-api initial MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Module d'API pour lions-user-manager Contenu: - DTOs (User, Role, Audit, Search) - Enums (StatutUser, TypeRole, TypeActionAudit) - Service interfaces (UserService, RoleService, AuditService, SyncService) - ValidationConstants Statut: ✅ 100% complété 🤖 Generated with Claude Code Co-Authored-By: Claude --- pom.xml | 65 +++++ .../user/manager/dto/audit/AuditLogDTO.java | 178 ++++++++++++++ .../lions/user/manager/dto/base/BaseDTO.java | 47 ++++ .../manager/dto/role/RoleAssignmentDTO.java | 101 ++++++++ .../lions/user/manager/dto/role/RoleDTO.java | 144 +++++++++++ .../lions/user/manager/dto/user/UserDTO.java | 209 ++++++++++++++++ .../dto/user/UserSearchCriteriaDTO.java | 190 +++++++++++++++ .../manager/dto/user/UserSearchResultDTO.java | 105 ++++++++ .../manager/enums/audit/TypeActionAudit.java | 108 +++++++++ .../user/manager/enums/role/TypeRole.java | 60 +++++ .../user/manager/enums/user/StatutUser.java | 79 ++++++ .../user/manager/service/AuditService.java | 219 +++++++++++++++++ .../user/manager/service/RoleService.java | 226 ++++++++++++++++++ .../user/manager/service/SyncService.java | 65 +++++ .../user/manager/service/UserService.java | 185 ++++++++++++++ .../validation/ValidationConstants.java | 72 ++++++ .../AuditLogDTO$AuditLogDTOBuilder.class | Bin 0 -> 9706 bytes .../AuditLogDTO$AuditLogDTOBuilderImpl.class | Bin 0 -> 1338 bytes .../user/manager/dto/audit/AuditLogDTO.class | Bin 0 -> 27779 bytes .../dto/base/BaseDTO$BaseDTOBuilder.class | Bin 0 -> 3341 bytes .../lions/user/manager/dto/base/BaseDTO.class | Bin 0 -> 6571 bytes ...signmentDTO$RoleAssignmentDTOBuilder.class | Bin 0 -> 5189 bytes .../manager/dto/role/RoleAssignmentDTO.class | Bin 0 -> 12917 bytes ...CompositeDTO$RoleCompositeDTOBuilder.class | Bin 0 -> 3225 bytes ...ositeDTO$RoleCompositeDTOBuilderImpl.class | Bin 0 -> 1588 bytes .../dto/role/RoleDTO$RoleCompositeDTO.class | Bin 0 -> 5802 bytes .../dto/role/RoleDTO$RoleDTOBuilder.class | Bin 0 -> 6570 bytes .../dto/role/RoleDTO$RoleDTOBuilderImpl.class | Bin 0 -> 1239 bytes .../lions/user/manager/dto/role/RoleDTO.class | Bin 0 -> 15965 bytes ...ntityDTO$FederatedIdentityDTOBuilder.class | Bin 0 -> 2629 bytes ...yDTO$FederatedIdentityDTOBuilderImpl.class | Bin 0 -> 1676 bytes .../user/UserDTO$FederatedIdentityDTO.class | Bin 0 -> 4610 bytes .../dto/user/UserDTO$UserDTOBuilder.class | Bin 0 -> 10068 bytes .../dto/user/UserDTO$UserDTOBuilderImpl.class | Bin 0 -> 1239 bytes .../lions/user/manager/dto/user/UserDTO.class | Bin 0 -> 28831 bytes ...eriaDTO$UserSearchCriteriaDTOBuilder.class | Bin 0 -> 10496 bytes .../dto/user/UserSearchCriteriaDTO.class | Bin 0 -> 28552 bytes ...ResultDTO$UserSearchResultDTOBuilder.class | Bin 0 -> 5073 bytes .../dto/user/UserSearchResultDTO.class | Bin 0 -> 14061 bytes .../manager/enums/audit/TypeActionAudit.class | Bin 0 -> 5803 bytes .../user/manager/enums/role/TypeRole.class | Bin 0 -> 2480 bytes .../user/manager/enums/user/StatutUser.class | Bin 0 -> 2958 bytes .../user/manager/service/AuditService.class | Bin 0 -> 3296 bytes .../user/manager/service/RoleService.class | Bin 0 -> 4135 bytes .../user/manager/service/SyncService.class | Bin 0 -> 948 bytes .../user/manager/service/UserService.class | Bin 0 -> 2962 bytes .../validation/ValidationConstants.class | Bin 0 -> 2864 bytes .../lions-user-manager-server-api-1.0.0.jar | Bin 0 -> 80459 bytes target/maven-archiver/pom.properties | 3 + .../compile/default-compile/createdFiles.lst | 31 +++ .../compile/default-compile/inputFiles.lst | 15 ++ 51 files changed, 2102 insertions(+) create mode 100644 pom.xml create mode 100644 src/main/java/dev/lions/user/manager/dto/audit/AuditLogDTO.java create mode 100644 src/main/java/dev/lions/user/manager/dto/base/BaseDTO.java create mode 100644 src/main/java/dev/lions/user/manager/dto/role/RoleAssignmentDTO.java create mode 100644 src/main/java/dev/lions/user/manager/dto/role/RoleDTO.java create mode 100644 src/main/java/dev/lions/user/manager/dto/user/UserDTO.java create mode 100644 src/main/java/dev/lions/user/manager/dto/user/UserSearchCriteriaDTO.java create mode 100644 src/main/java/dev/lions/user/manager/dto/user/UserSearchResultDTO.java create mode 100644 src/main/java/dev/lions/user/manager/enums/audit/TypeActionAudit.java create mode 100644 src/main/java/dev/lions/user/manager/enums/role/TypeRole.java create mode 100644 src/main/java/dev/lions/user/manager/enums/user/StatutUser.java create mode 100644 src/main/java/dev/lions/user/manager/service/AuditService.java create mode 100644 src/main/java/dev/lions/user/manager/service/RoleService.java create mode 100644 src/main/java/dev/lions/user/manager/service/SyncService.java create mode 100644 src/main/java/dev/lions/user/manager/service/UserService.java create mode 100644 src/main/java/dev/lions/user/manager/validation/ValidationConstants.java create mode 100644 target/classes/dev/lions/user/manager/dto/audit/AuditLogDTO$AuditLogDTOBuilder.class create mode 100644 target/classes/dev/lions/user/manager/dto/audit/AuditLogDTO$AuditLogDTOBuilderImpl.class create mode 100644 target/classes/dev/lions/user/manager/dto/audit/AuditLogDTO.class create mode 100644 target/classes/dev/lions/user/manager/dto/base/BaseDTO$BaseDTOBuilder.class create mode 100644 target/classes/dev/lions/user/manager/dto/base/BaseDTO.class create mode 100644 target/classes/dev/lions/user/manager/dto/role/RoleAssignmentDTO$RoleAssignmentDTOBuilder.class create mode 100644 target/classes/dev/lions/user/manager/dto/role/RoleAssignmentDTO.class create mode 100644 target/classes/dev/lions/user/manager/dto/role/RoleDTO$RoleCompositeDTO$RoleCompositeDTOBuilder.class create mode 100644 target/classes/dev/lions/user/manager/dto/role/RoleDTO$RoleCompositeDTO$RoleCompositeDTOBuilderImpl.class create mode 100644 target/classes/dev/lions/user/manager/dto/role/RoleDTO$RoleCompositeDTO.class create mode 100644 target/classes/dev/lions/user/manager/dto/role/RoleDTO$RoleDTOBuilder.class create mode 100644 target/classes/dev/lions/user/manager/dto/role/RoleDTO$RoleDTOBuilderImpl.class create mode 100644 target/classes/dev/lions/user/manager/dto/role/RoleDTO.class create mode 100644 target/classes/dev/lions/user/manager/dto/user/UserDTO$FederatedIdentityDTO$FederatedIdentityDTOBuilder.class create mode 100644 target/classes/dev/lions/user/manager/dto/user/UserDTO$FederatedIdentityDTO$FederatedIdentityDTOBuilderImpl.class create mode 100644 target/classes/dev/lions/user/manager/dto/user/UserDTO$FederatedIdentityDTO.class create mode 100644 target/classes/dev/lions/user/manager/dto/user/UserDTO$UserDTOBuilder.class create mode 100644 target/classes/dev/lions/user/manager/dto/user/UserDTO$UserDTOBuilderImpl.class create mode 100644 target/classes/dev/lions/user/manager/dto/user/UserDTO.class create mode 100644 target/classes/dev/lions/user/manager/dto/user/UserSearchCriteriaDTO$UserSearchCriteriaDTOBuilder.class create mode 100644 target/classes/dev/lions/user/manager/dto/user/UserSearchCriteriaDTO.class create mode 100644 target/classes/dev/lions/user/manager/dto/user/UserSearchResultDTO$UserSearchResultDTOBuilder.class create mode 100644 target/classes/dev/lions/user/manager/dto/user/UserSearchResultDTO.class create mode 100644 target/classes/dev/lions/user/manager/enums/audit/TypeActionAudit.class create mode 100644 target/classes/dev/lions/user/manager/enums/role/TypeRole.class create mode 100644 target/classes/dev/lions/user/manager/enums/user/StatutUser.class create mode 100644 target/classes/dev/lions/user/manager/service/AuditService.class create mode 100644 target/classes/dev/lions/user/manager/service/RoleService.class create mode 100644 target/classes/dev/lions/user/manager/service/SyncService.class create mode 100644 target/classes/dev/lions/user/manager/service/UserService.class create mode 100644 target/classes/dev/lions/user/manager/validation/ValidationConstants.class create mode 100644 target/lions-user-manager-server-api-1.0.0.jar create mode 100644 target/maven-archiver/pom.properties create mode 100644 target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst create mode 100644 target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..73aa689 --- /dev/null +++ b/pom.xml @@ -0,0 +1,65 @@ + + + 4.0.0 + + + dev.lions.user.manager + lions-user-manager-parent + 1.0.0 + + + lions-user-manager-server-api + jar + + Lions User Manager - Server API + Contrats API: DTOs, interfaces de services, enums et validations + + + + + org.projectlombok + lombok + + + + + jakarta.validation + jakarta.validation-api + + + + jakarta.ws.rs + jakarta.ws.rs-api + + + + + com.fasterxml.jackson.core + jackson-annotations + + + + + org.eclipse.microprofile.openapi + microprofile-openapi-api + + + + + org.junit.jupiter + junit-jupiter + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + + + diff --git a/src/main/java/dev/lions/user/manager/dto/audit/AuditLogDTO.java b/src/main/java/dev/lions/user/manager/dto/audit/AuditLogDTO.java new file mode 100644 index 0000000..5c42f39 --- /dev/null +++ b/src/main/java/dev/lions/user/manager/dto/audit/AuditLogDTO.java @@ -0,0 +1,178 @@ +package dev.lions.user.manager.dto.audit; + +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.annotation.JsonInclude; +import dev.lions.user.manager.dto.base.BaseDTO; +import dev.lions.user.manager.enums.audit.TypeActionAudit; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; +import lombok.experimental.SuperBuilder; +import org.eclipse.microprofile.openapi.annotations.media.Schema; + +import java.time.LocalDateTime; +import java.util.Map; + +/** + * DTO représentant une entrée d'audit + * Enregistre toutes les actions effectuées via l'API de gestion + */ +@Data +@SuperBuilder +@NoArgsConstructor +@AllArgsConstructor +@EqualsAndHashCode(callSuper = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@Schema(description = "Entrée d'audit des actions utilisateur") +public class AuditLogDTO extends BaseDTO { + + private static final long serialVersionUID = 1L; + + // Qui a fait l'action + @Schema(description = "ID de l'utilisateur qui a effectué l'action", example = "f47ac10b-58cc-4372-a567-0e02b2c3d479") + private String acteurUserId; + + @Schema(description = "Username de l'utilisateur qui a effectué l'action", example = "admin@lions.dev") + private String acteurUsername; + + @Schema(description = "Nom complet de l'acteur", example = "Admin Principal") + private String acteurNomComplet; + + @Schema(description = "Rôles de l'acteur au moment de l'action") + private String acteurRoles; + + // Quand + @Schema(description = "Date et heure de l'action", example = "2025-01-15T10:30:00") + @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss") + private LocalDateTime dateAction; + + // Quoi + @Schema(description = "Type d'action effectuée", example = "USER_CREATE") + private TypeActionAudit typeAction; + + @Schema(description = "Type de ressource affectée", example = "USER") + private String ressourceType; + + @Schema(description = "ID de la ressource affectée", example = "a1b2c3d4-e5f6-7890-1234-567890abcdef") + private String ressourceId; + + @Schema(description = "Nom/Identifiant de la ressource", example = "jdupont") + private String ressourceName; + + // Où + @Schema(description = "Nom du Realm", example = "btpxpress") + private String realmName; + + @Schema(description = "Adresse IP de l'acteur", example = "192.168.1.100") + private String ipAddress; + + @Schema(description = "User-Agent du client", example = "Mozilla/5.0...") + private String userAgent; + + @Schema(description = "Localisation géographique", example = "Abidjan, Côte d'Ivoire") + private String geolocation; + + // Comment + @Schema(description = "Endpoint API appelé", example = "/api/users/create") + private String apiEndpoint; + + @Schema(description = "Méthode HTTP", example = "POST") + private String httpMethod; + + // Détails + @Schema(description = "Description de l'action", example = "Création d'un nouvel utilisateur") + private String description; + + @Schema(description = "Détails de l'action au format JSON") + private String detailsJson; + + @Schema(description = "Ancienne valeur (avant modification)") + private String oldValue; + + @Schema(description = "Nouvelle valeur (après modification)") + private String newValue; + + @Schema(description = "Différences entre ancienne et nouvelle valeur") + private String diff; + + // Résultat + @Schema(description = "Succès de l'opération", example = "true") + private Boolean success; + + @Schema(description = "Code d'erreur (si échec)", example = "USER_ALREADY_EXISTS") + private String errorCode; + + @Schema(description = "Message d'erreur (si échec)") + private String errorMessage; + + @Schema(description = "Trace d'erreur complète (si échec)") + private String stackTrace; + + // Métadonnées + @Schema(description = "Durée d'exécution en millisecondes", example = "145") + private Long executionTimeMs; + + @Schema(description = "ID de session/transaction", example = "sess_abc123") + private String sessionId; + + @Schema(description = "ID de corrélation (pour tracer requêtes liées)", example = "corr_xyz789") + private String correlationId; + + @Schema(description = "Raison de l'action", example = "Demande du manager") + private String raison; + + @Schema(description = "Commentaires administratifs", example = "Promotion suite à évaluation annuelle") + private String commentaires; + + @Schema(description = "Métadonnées supplémentaires") + private Map metadata; + + // Flags + @Schema(description = "Indique si l'action est critique", example = "false") + private Boolean critique; + + @Schema(description = "Indique si l'action nécessite une alerte", example = "false") + private Boolean requiresAlert; + + @Schema(description = "Indique si l'action a été notifiée", example = "true") + private Boolean notified; + + /** + * Détermine si l'action a réussi + * @return true si success = true + */ + public boolean isSuccessful() { + return Boolean.TRUE.equals(success); + } + + /** + * Détermine si l'action a échoué + * @return true si success = false + */ + public boolean isFailed() { + return Boolean.FALSE.equals(success); + } + + /** + * Détermine si l'action est critique + * @return true si critique = true ou si typeAction est critique + */ + public boolean isCritique() { + return Boolean.TRUE.equals(critique) || (typeAction != null && typeAction.isCritical()); + } + + /** + * Retourne un résumé court de l'action + * @return résumé + */ + public String getSummary() { + return String.format("%s: %s effectué par %s sur %s %s", + dateAction, + typeAction != null ? typeAction.getLibelle() : "Action inconnue", + acteurUsername != null ? acteurUsername : "Inconnu", + ressourceType != null ? ressourceType : "Ressource", + ressourceName != null ? ressourceName : ressourceId + ); + } +} diff --git a/src/main/java/dev/lions/user/manager/dto/base/BaseDTO.java b/src/main/java/dev/lions/user/manager/dto/base/BaseDTO.java new file mode 100644 index 0000000..cbfae0b --- /dev/null +++ b/src/main/java/dev/lions/user/manager/dto/base/BaseDTO.java @@ -0,0 +1,47 @@ +package dev.lions.user.manager.dto.base; + +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.annotation.JsonInclude; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import lombok.experimental.SuperBuilder; +import org.eclipse.microprofile.openapi.annotations.media.Schema; + +import java.io.Serializable; +import java.time.LocalDateTime; + +/** + * DTO de base pour tous les objets métier + * Contient les attributs communs (id, dates, audit) + */ +@Data +@SuperBuilder +@NoArgsConstructor +@AllArgsConstructor +@JsonInclude(JsonInclude.Include.NON_NULL) +@Schema(description = "DTO de base contenant les attributs communs à tous les objets") +public abstract class BaseDTO implements Serializable { + + private static final long serialVersionUID = 1L; + + @Schema(description = "Identifiant unique (UUID Keycloak)", example = "f47ac10b-58cc-4372-a567-0e02b2c3d479") + private String id; + + @Schema(description = "Date de création", example = "2025-01-15T10:30:00") + @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss") + private LocalDateTime dateCreation; + + @Schema(description = "Date de dernière modification", example = "2025-01-15T14:20:00") + @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss") + private LocalDateTime dateModification; + + @Schema(description = "Utilisateur ayant créé l'entité", example = "admin@lions.dev") + private String creeParUsername; + + @Schema(description = "Utilisateur ayant modifié l'entité", example = "superadmin@lions.dev") + private String modifieParUsername; + + @Schema(description = "Numéro de version pour gestion optimiste", example = "1") + private Long version; +} diff --git a/src/main/java/dev/lions/user/manager/dto/role/RoleAssignmentDTO.java b/src/main/java/dev/lions/user/manager/dto/role/RoleAssignmentDTO.java new file mode 100644 index 0000000..f2da065 --- /dev/null +++ b/src/main/java/dev/lions/user/manager/dto/role/RoleAssignmentDTO.java @@ -0,0 +1,101 @@ +package dev.lions.user.manager.dto.role; + +import com.fasterxml.jackson.annotation.JsonInclude; +import dev.lions.user.manager.enums.role.TypeRole; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotEmpty; +import jakarta.validation.constraints.NotNull; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.eclipse.microprofile.openapi.annotations.media.Schema; + +import java.io.Serializable; +import java.util.List; + +/** + * DTO pour assigner ou révoquer des rôles à un utilisateur + * Utilisé dans les opérations d'attribution de rôles + */ +@Data +@Builder +@NoArgsConstructor +@AllArgsConstructor +@JsonInclude(JsonInclude.Include.NON_NULL) +@Schema(description = "Attribution ou révocation de rôles") +public class RoleAssignmentDTO implements Serializable { + + private static final long serialVersionUID = 1L; + + @NotBlank(message = "L'ID utilisateur est obligatoire") + @Schema(description = "ID de l'utilisateur cible", example = "f47ac10b-58cc-4372-a567-0e02b2c3d479", required = true) + private String userId; + + @Schema(description = "Username de l'utilisateur cible (optionnel)", example = "jdupont") + private String username; + + @NotEmpty(message = "Au moins un rôle doit être spécifié") + @Schema(description = "Liste des noms de rôles à attribuer ou révoquer", required = true) + private List roleNames; + + @Schema(description = "Liste des IDs de rôles à attribuer ou révoquer") + private List roleIds; + + @NotNull(message = "Le type de rôle est obligatoire") + @Schema(description = "Type de rôle", example = "REALM_ROLE", required = true) + private TypeRole typeRole; + + @Schema(description = "Nom du Realm", example = "btpxpress") + private String realmName; + + @Schema(description = "Nom du Client (requis si typeRole = CLIENT_ROLE)", example = "btpxpress-app") + private String clientName; + + @Schema(description = "ID du Client (optionnel)") + private String clientId; + + @Schema(description = "Raison de l'attribution/révocation", example = "Promotion au poste de gestionnaire") + private String raison; + + @Schema(description = "Commentaires administratifs", example = "Demandé par le manager") + private String commentaires; + + @Schema(description = "Indique si c'est une attribution temporaire", example = "false") + private Boolean temporaire; + + @Schema(description = "Date d'expiration de l'attribution temporaire", example = "2025-12-31T23:59:59") + private String dateExpiration; + + @Schema(description = "Indique si les rôles composites doivent être inclus", example = "true") + @Builder.Default + private Boolean includeComposites = true; + + @Schema(description = "Indique si l'opération doit notifier l'utilisateur", example = "true") + @Builder.Default + private Boolean notifyUser = false; + + /** + * Valide que les données nécessaires sont présentes pour un rôle client + * @return true si valide + */ + public boolean isValidForClientRole() { + return typeRole == TypeRole.CLIENT_ROLE && clientName != null && !clientName.isBlank(); + } + + /** + * Valide que les données nécessaires sont présentes pour un rôle realm + * @return true si valide + */ + public boolean isValidForRealmRole() { + return typeRole == TypeRole.REALM_ROLE; + } + + /** + * Retourne le nombre de rôles à assigner/révoquer + * @return nombre de rôles + */ + public int getRoleCount() { + return roleNames != null ? roleNames.size() : 0; + } +} diff --git a/src/main/java/dev/lions/user/manager/dto/role/RoleDTO.java b/src/main/java/dev/lions/user/manager/dto/role/RoleDTO.java new file mode 100644 index 0000000..90e1958 --- /dev/null +++ b/src/main/java/dev/lions/user/manager/dto/role/RoleDTO.java @@ -0,0 +1,144 @@ +package dev.lions.user.manager.dto.role; + +import com.fasterxml.jackson.annotation.JsonInclude; +import dev.lions.user.manager.dto.base.BaseDTO; +import dev.lions.user.manager.enums.role.TypeRole; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.Pattern; +import jakarta.validation.constraints.Size; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; +import lombok.experimental.SuperBuilder; +import org.eclipse.microprofile.openapi.annotations.media.Schema; + +import java.util.List; +import java.util.Map; + +/** + * DTO représentant un rôle Keycloak + * Mappé depuis RoleRepresentation de Keycloak Admin API + */ +@Data +@SuperBuilder +@NoArgsConstructor +@AllArgsConstructor +@EqualsAndHashCode(callSuper = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@Schema(description = "Rôle Keycloak (Realm ou Client)") +public class RoleDTO extends BaseDTO { + + private static final long serialVersionUID = 1L; + + @NotBlank(message = "Le nom du rôle est obligatoire") + @Size(min = 2, max = 100, message = "Le nom du rôle doit contenir entre 2 et 100 caractères") + @Pattern(regexp = "^[a-zA-Z0-9_-]+$", message = "Le nom du rôle ne peut contenir que des lettres, chiffres, underscores et tirets") + @Schema(description = "Nom du rôle", example = "admin_btpxpress", required = true) + private String name; + + @Schema(description = "Description du rôle", example = "Administrateur avec tous les privilèges") + private String description; + + @Schema(description = "Type de rôle", example = "REALM_ROLE") + private TypeRole typeRole; + + @Schema(description = "Indique si c'est un rôle composite", example = "false") + private Boolean composite; + + @Schema(description = "ID du conteneur (Realm ou Client)", example = "btpxpress") + private String containerId; + + @Schema(description = "Nom du Realm", example = "btpxpress") + private String realmName; + + @Schema(description = "Nom du Client (si rôle client)", example = "btpxpress-app") + private String clientName; + + @Schema(description = "ID du Client (si rôle client)") + private String clientId; + + @Schema(description = "Rôles composites inclus dans ce rôle") + private List compositeRoles; + + @Schema(description = "Rôles Realm composites") + private List compositeRealmRoles; + + @Schema(description = "Rôles Client composites par client") + private Map> compositeClientRoles; + + @Schema(description = "Attributs personnalisés du rôle") + private Map> attributes; + + @Schema(description = "Nombre d'utilisateurs ayant ce rôle", example = "15") + private Integer userCount; + + @Schema(description = "Indique si le rôle est un rôle système", example = "false") + private Boolean systemRole; + + @Schema(description = "Indique si le rôle peut être supprimé", example = "true") + private Boolean deletable; + + /** + * Détermine si c'est un rôle Realm + * @return true si typeRole est REALM_ROLE + */ + public boolean isRealmRole() { + return typeRole == TypeRole.REALM_ROLE; + } + + /** + * Détermine si c'est un rôle Client + * @return true si typeRole est CLIENT_ROLE + */ + public boolean isClientRole() { + return typeRole == TypeRole.CLIENT_ROLE; + } + + /** + * Détermine si le rôle est composite + * @return true si composite = true et a des rôles composites + */ + public boolean isComposite() { + return Boolean.TRUE.equals(composite) + && ((compositeRoles != null && !compositeRoles.isEmpty()) + || (compositeRealmRoles != null && !compositeRealmRoles.isEmpty()) + || (compositeClientRoles != null && !compositeClientRoles.isEmpty())); + } + + /** + * Retourne le nom complet du rôle (avec préfixe client si applicable) + * @return nom complet + */ + public String getFullName() { + if (isClientRole() && clientName != null) { + return clientName + ":" + name; + } + return name; + } + + /** + * DTO pour rôle composite + */ + @Data + @NoArgsConstructor + @AllArgsConstructor + @SuperBuilder + @Schema(description = "Rôle composite") + public static class RoleCompositeDTO { + @Schema(description = "ID du rôle", example = "f47ac10b-58cc-4372-a567-0e02b2c3d479") + private String id; + + @Schema(description = "Nom du rôle", example = "gestionnaire") + private String name; + + @Schema(description = "Description du rôle") + private String description; + + @Schema(description = "Type de rôle", example = "REALM_ROLE") + private TypeRole typeRole; + + @Schema(description = "Nom du client (si client role)") + private String clientName; + } +} diff --git a/src/main/java/dev/lions/user/manager/dto/user/UserDTO.java b/src/main/java/dev/lions/user/manager/dto/user/UserDTO.java new file mode 100644 index 0000000..544fc34 --- /dev/null +++ b/src/main/java/dev/lions/user/manager/dto/user/UserDTO.java @@ -0,0 +1,209 @@ +package dev.lions.user.manager.dto.user; + +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.annotation.JsonInclude; +import dev.lions.user.manager.dto.base.BaseDTO; +import dev.lions.user.manager.enums.user.StatutUser; +import jakarta.validation.constraints.Email; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.Pattern; +import jakarta.validation.constraints.Size; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; +import lombok.experimental.SuperBuilder; +import org.eclipse.microprofile.openapi.annotations.media.Schema; + +import java.time.LocalDateTime; +import java.util.List; +import java.util.Map; + +/** + * DTO représentant un utilisateur Keycloak + * Mappé depuis la représentation UserRepresentation de Keycloak Admin API + */ +@Data +@SuperBuilder +@NoArgsConstructor +@AllArgsConstructor +@EqualsAndHashCode(callSuper = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@Schema(description = "Utilisateur Keycloak") +public class UserDTO extends BaseDTO { + + private static final long serialVersionUID = 1L; + + // Informations de base + @NotBlank(message = "Le nom d'utilisateur est obligatoire") + @Size(min = 3, max = 100, message = "Le nom d'utilisateur doit contenir entre 3 et 100 caractères") + @Pattern(regexp = "^[a-zA-Z0-9._-]+$", message = "Le nom d'utilisateur ne peut contenir que des lettres, chiffres, points, tirets et underscores") + @Schema(description = "Nom d'utilisateur unique", example = "jdupont", required = true) + private String username; + + @NotBlank(message = "L'email est obligatoire") + @Email(message = "Format d'email invalide") + @Schema(description = "Adresse email", example = "jean.dupont@lions.dev", required = true) + private String email; + + @Schema(description = "Email vérifié", example = "true") + private Boolean emailVerified; + + @NotBlank(message = "Le prénom est obligatoire") + @Size(min = 2, max = 100, message = "Le prénom doit contenir entre 2 et 100 caractères") + @Schema(description = "Prénom", example = "Jean", required = true) + private String prenom; + + @NotBlank(message = "Le nom est obligatoire") + @Size(min = 2, max = 100, message = "Le nom doit contenir entre 2 et 100 caractères") + @Schema(description = "Nom de famille", example = "Dupont", required = true) + private String nom; + + // Statut + @Schema(description = "Statut de l'utilisateur", example = "ACTIF") + private StatutUser statut; + + @Schema(description = "Compte activé", example = "true") + private Boolean enabled; + + // Informations supplémentaires + @Schema(description = "Numéro de téléphone", example = "+225 07 12 34 56 78") + private String telephone; + + @Schema(description = "Organisation/Entreprise", example = "Lions Dev") + private String organisation; + + @Schema(description = "Département", example = "IT") + private String departement; + + @Schema(description = "Fonction/Poste", example = "Développeur Senior") + private String fonction; + + @Schema(description = "Pays", example = "Côte d'Ivoire") + private String pays; + + @Schema(description = "Ville", example = "Abidjan") + private String ville; + + @Schema(description = "Langue préférée", example = "fr") + private String langue; + + @Schema(description = "Fuseau horaire", example = "Africa/Abidjan") + private String timezone; + + // Realm et rôles + @Schema(description = "Realm Keycloak", example = "btpxpress") + private String realmName; + + @Schema(description = "Liste des rôles Realm assignés") + private List realmRoles; + + @Schema(description = "Liste des rôles Client assignés") + private Map> clientRoles; + + @Schema(description = "Liste des groupes auxquels appartient l'utilisateur") + private List groups; + + // Dates importantes + @Schema(description = "Date de dernière connexion", example = "2025-01-15T10:30:00") + @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss") + private LocalDateTime derniereConnexion; + + @Schema(description = "Date d'expiration du compte", example = "2026-01-15T23:59:59") + @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss") + private LocalDateTime dateExpiration; + + @Schema(description = "Date de verrouillage du compte", example = "2025-01-15T16:00:00") + @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss") + private LocalDateTime dateVerrouillage; + + // Attributs personnalisés Keycloak + @Schema(description = "Attributs personnalisés Keycloak") + private Map> attributes; + + // Actions requises + @Schema(description = "Actions requises (ex: UPDATE_PASSWORD, VERIFY_EMAIL)") + private List requiredActions; + + // Fédération + @Schema(description = "Fournisseur d'identité fédéré", example = "google") + private String federatedIdentityProvider; + + @Schema(description = "Lien d'identité fédérée") + private List federatedIdentities; + + // Crédentiels temporaires + @Schema(description = "Mot de passe temporaire (création uniquement)") + private String temporaryPassword; + + @Schema(description = "Indique si le mot de passe est temporaire") + private Boolean temporaryPasswordFlag; + + // Informations de session + @Schema(description = "Nombre de sessions actives", example = "2") + private Integer activeSessions; + + @Schema(description = "Nombre d'échecs de connexion", example = "0") + private Integer failedLoginAttempts; + + // Audit + @Schema(description = "Raison de la dernière modification") + private String raisonModification; + + @Schema(description = "Commentaires administratifs") + private String commentaires; + + /** + * Retourne le nom complet de l'utilisateur + * @return prénom + nom + */ + public String getNomComplet() { + if (prenom != null && nom != null) { + return prenom + " " + nom; + } + return username; + } + + /** + * Détermine si l'utilisateur est actif + * @return true si statut ACTIF et enabled + */ + public boolean isActif() { + return statut == StatutUser.ACTIF && Boolean.TRUE.equals(enabled); + } + + /** + * Détermine si le compte a expiré + * @return true si dateExpiration est passée + */ + public boolean isExpire() { + return dateExpiration != null && dateExpiration.isBefore(LocalDateTime.now()); + } + + /** + * Détermine si l'utilisateur a des actions requises + * @return true si des actions sont requises + */ + public boolean hasRequiredActions() { + return requiredActions != null && !requiredActions.isEmpty(); + } + + /** + * DTO pour identité fédérée + */ + @Data + @NoArgsConstructor + @AllArgsConstructor + @SuperBuilder + @Schema(description = "Identité fédérée") + public static class FederatedIdentityDTO { + @Schema(description = "Fournisseur d'identité", example = "google") + private String identityProvider; + + @Schema(description = "ID utilisateur chez le fournisseur") + private String userId; + + @Schema(description = "Nom d'utilisateur chez le fournisseur") + private String userName; + } +} diff --git a/src/main/java/dev/lions/user/manager/dto/user/UserSearchCriteriaDTO.java b/src/main/java/dev/lions/user/manager/dto/user/UserSearchCriteriaDTO.java new file mode 100644 index 0000000..429e68a --- /dev/null +++ b/src/main/java/dev/lions/user/manager/dto/user/UserSearchCriteriaDTO.java @@ -0,0 +1,190 @@ +package dev.lions.user.manager.dto.user; + +import com.fasterxml.jackson.annotation.JsonInclude; +import dev.lions.user.manager.enums.user.StatutUser; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.eclipse.microprofile.openapi.annotations.media.Schema; + +import java.io.Serializable; +import java.time.LocalDateTime; +import java.util.List; + +/** + * Critères de recherche pour les utilisateurs + * Utilisé pour filtrer les utilisateurs via l'API Keycloak Admin + */ +@Data +@Builder +@NoArgsConstructor +@AllArgsConstructor +@JsonInclude(JsonInclude.Include.NON_NULL) +@Schema(description = "Critères de recherche d'utilisateurs") +public class UserSearchCriteriaDTO implements Serializable { + + private static final long serialVersionUID = 1L; + + // Recherche textuelle + @Schema(description = "Terme de recherche générale (username, email, nom, prénom)", example = "dupont") + private String searchTerm; + + @Schema(description = "Nom d'utilisateur exact", example = "jdupont") + private String username; + + @Schema(description = "Email exact", example = "jean.dupont@lions.dev") + private String email; + + @Schema(description = "Prénom", example = "Jean") + private String prenom; + + @Schema(description = "Nom de famille", example = "Dupont") + private String nom; + + // Filtres de statut + @Schema(description = "Statut de l'utilisateur", example = "ACTIF") + private StatutUser statut; + + @Schema(description = "Compte activé", example = "true") + private Boolean enabled; + + @Schema(description = "Email vérifié", example = "true") + private Boolean emailVerified; + + // Filtres de rôle et groupe + @Schema(description = "Liste des rôles Realm à filtrer") + private List realmRoles; + + @Schema(description = "Liste des rôles Client à filtrer") + private List clientRoles; + + @Schema(description = "Liste des groupes à filtrer") + private List groups; + + @Schema(description = "Nom du client pour filtrer par rôles client", example = "btpxpress-app") + private String clientName; + + // Filtres organisationnels + @Schema(description = "Organisation/Entreprise", example = "Lions Dev") + private String organisation; + + @Schema(description = "Département", example = "IT") + private String departement; + + @Schema(description = "Fonction/Poste", example = "Développeur") + private String fonction; + + @Schema(description = "Pays", example = "Côte d'Ivoire") + private String pays; + + @Schema(description = "Ville", example = "Abidjan") + private String ville; + + // Filtres temporels + @Schema(description = "Date de création minimum", example = "2025-01-01T00:00:00") + private LocalDateTime dateCreationMin; + + @Schema(description = "Date de création maximum", example = "2025-12-31T23:59:59") + private LocalDateTime dateCreationMax; + + @Schema(description = "Date de dernière connexion minimum", example = "2025-01-01T00:00:00") + private LocalDateTime derniereConnexionMin; + + @Schema(description = "Date de dernière connexion maximum", example = "2025-01-31T23:59:59") + private LocalDateTime derniereConnexionMax; + + // Filtres spéciaux + @Schema(description = "Utilisateurs avec actions requises uniquement", example = "true") + private Boolean hasRequiredActions; + + @Schema(description = "Utilisateurs verrouillés uniquement", example = "false") + private Boolean isLocked; + + @Schema(description = "Utilisateurs expirés uniquement", example = "false") + private Boolean isExpired; + + @Schema(description = "Utilisateurs avec sessions actives uniquement", example = "true") + private Boolean hasActiveSessions; + + // Realm + @Schema(description = "Nom du Realm à filtrer", example = "btpxpress") + private String realmName; + + // Pagination + @Schema(description = "Numéro de page (commence à 0)", example = "0", defaultValue = "0") + @Builder.Default + private Integer page = 0; + + @Schema(description = "Taille de la page", example = "20", defaultValue = "20") + @Builder.Default + private Integer pageSize = 20; + + @Schema(description = "Nombre maximum de résultats", example = "100") + private Integer maxResults; + + // Tri + @Schema(description = "Champ de tri (username, email, prenom, nom, dateCreation, derniereConnexion)", example = "username") + @Builder.Default + private String sortBy = "username"; + + @Schema(description = "Ordre de tri (ASC ou DESC)", example = "ASC") + @Builder.Default + private String sortOrder = "ASC"; + + // Options d'inclusion + @Schema(description = "Inclure les rôles dans les résultats", example = "true") + @Builder.Default + private Boolean includeRoles = false; + + @Schema(description = "Inclure les groupes dans les résultats", example = "true") + @Builder.Default + private Boolean includeGroups = false; + + @Schema(description = "Inclure les attributs personnalisés", example = "false") + @Builder.Default + private Boolean includeAttributes = false; + + @Schema(description = "Inclure les informations de session", example = "false") + @Builder.Default + private Boolean includeSessionInfo = false; + + /** + * Détermine si des filtres de recherche sont appliqués + * @return true si au moins un filtre est défini + */ + public boolean hasFilters() { + return searchTerm != null + || username != null + || email != null + || prenom != null + || nom != null + || statut != null + || enabled != null + || emailVerified != null + || (realmRoles != null && !realmRoles.isEmpty()) + || (clientRoles != null && !clientRoles.isEmpty()) + || (groups != null && !groups.isEmpty()) + || organisation != null + || departement != null + || fonction != null + || pays != null + || ville != null + || dateCreationMin != null + || dateCreationMax != null + || derniereConnexionMin != null + || derniereConnexionMax != null + || hasRequiredActions != null + || isLocked != null + || isExpired != null + || hasActiveSessions != null; + } + + /** + * Calcule l'offset pour la pagination Keycloak + * @return offset calculé à partir de page et pageSize + */ + public int getOffset() { + return page * pageSize; + } +} diff --git a/src/main/java/dev/lions/user/manager/dto/user/UserSearchResultDTO.java b/src/main/java/dev/lions/user/manager/dto/user/UserSearchResultDTO.java new file mode 100644 index 0000000..150681b --- /dev/null +++ b/src/main/java/dev/lions/user/manager/dto/user/UserSearchResultDTO.java @@ -0,0 +1,105 @@ +package dev.lions.user.manager.dto.user; + +import com.fasterxml.jackson.annotation.JsonInclude; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.eclipse.microprofile.openapi.annotations.media.Schema; + +import java.io.Serializable; +import java.util.List; + +/** + * Résultat paginé de recherche d'utilisateurs + * Contient la liste des utilisateurs et les métadonnées de pagination + */ +@Data +@Builder +@NoArgsConstructor +@AllArgsConstructor +@JsonInclude(JsonInclude.Include.NON_NULL) +@Schema(description = "Résultat paginé de recherche d'utilisateurs") +public class UserSearchResultDTO implements Serializable { + + private static final long serialVersionUID = 1L; + + @Schema(description = "Liste des utilisateurs trouvés") + private List users; + + @Schema(description = "Nombre total d'utilisateurs correspondant aux critères", example = "156") + private Long totalCount; + + @Schema(description = "Numéro de la page actuelle (commence à 0)", example = "0") + private Integer currentPage; + + @Schema(description = "Taille de la page", example = "20") + private Integer pageSize; + + @Schema(description = "Nombre total de pages", example = "8") + private Integer totalPages; + + @Schema(description = "Indique s'il y a une page suivante", example = "true") + private Boolean hasNextPage; + + @Schema(description = "Indique s'il y a une page précédente", example = "false") + private Boolean hasPreviousPage; + + @Schema(description = "Index du premier élément de la page", example = "0") + private Integer firstElement; + + @Schema(description = "Index du dernier élément de la page", example = "19") + private Integer lastElement; + + @Schema(description = "Indique si la page est vide", example = "false") + private Boolean isEmpty; + + @Schema(description = "Indique si c'est la première page", example = "true") + private Boolean isFirstPage; + + @Schema(description = "Indique si c'est la dernière page", example = "false") + private Boolean isLastPage; + + @Schema(description = "Critères de recherche utilisés") + private UserSearchCriteriaDTO criteria; + + @Schema(description = "Temps d'exécution de la recherche en millisecondes", example = "145") + private Long executionTimeMs; + + /** + * Construit un résultat de recherche à partir d'une liste d'utilisateurs + * @param users liste des utilisateurs + * @param criteria critères de recherche + * @param totalCount nombre total de résultats + * @return UserSearchResultDTO + */ + public static UserSearchResultDTO of(List users, UserSearchCriteriaDTO criteria, Long totalCount) { + int pageSize = criteria.getPageSize(); + int currentPage = criteria.getPage(); + long totalPages = (totalCount + pageSize - 1) / pageSize; + + return UserSearchResultDTO.builder() + .users(users) + .totalCount(totalCount) + .currentPage(currentPage) + .pageSize(pageSize) + .totalPages((int) totalPages) + .hasNextPage(currentPage < totalPages - 1) + .hasPreviousPage(currentPage > 0) + .firstElement(currentPage * pageSize) + .lastElement(Math.min((currentPage + 1) * pageSize - 1, totalCount.intValue())) + .isEmpty(users == null || users.isEmpty()) + .isFirstPage(currentPage == 0) + .isLastPage(currentPage >= totalPages - 1) + .criteria(criteria) + .build(); + } + + /** + * Retourne le nombre d'utilisateurs dans la page courante + * @return nombre d'utilisateurs + */ + public int getCurrentPageSize() { + return users != null ? users.size() : 0; + } +} diff --git a/src/main/java/dev/lions/user/manager/enums/audit/TypeActionAudit.java b/src/main/java/dev/lions/user/manager/enums/audit/TypeActionAudit.java new file mode 100644 index 0000000..add7505 --- /dev/null +++ b/src/main/java/dev/lions/user/manager/enums/audit/TypeActionAudit.java @@ -0,0 +1,108 @@ +package dev.lions.user.manager.enums.audit; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import org.eclipse.microprofile.openapi.annotations.media.Schema; + +/** + * Type d'action effectuée sur une ressource + * Utilisé pour l'audit trail + */ +@Getter +@RequiredArgsConstructor +@Schema(description = "Type d'action pour l'audit") +public enum TypeActionAudit { + + // Actions Utilisateur + USER_CREATE("Création utilisateur", "USER", "CREATE"), + USER_UPDATE("Modification utilisateur", "USER", "UPDATE"), + USER_DELETE("Suppression utilisateur", "USER", "DELETE"), + USER_ACTIVATE("Activation utilisateur", "USER", "ACTIVATE"), + USER_DEACTIVATE("Désactivation utilisateur", "USER", "DEACTIVATE"), + USER_SUSPEND("Suspension utilisateur", "USER", "SUSPEND"), + USER_UNLOCK("Déverrouillage utilisateur", "USER", "UNLOCK"), + USER_PASSWORD_RESET("Réinitialisation mot de passe", "USER", "PASSWORD_RESET"), + USER_EMAIL_VERIFY("Vérification email", "USER", "EMAIL_VERIFY"), + USER_FORCE_LOGOUT("Déconnexion forcée", "USER", "FORCE_LOGOUT"), + + // Actions Rôle + ROLE_CREATE("Création rôle", "ROLE", "CREATE"), + ROLE_UPDATE("Modification rôle", "ROLE", "UPDATE"), + ROLE_DELETE("Suppression rôle", "ROLE", "DELETE"), + ROLE_ASSIGN("Attribution rôle", "ROLE", "ASSIGN"), + ROLE_REVOKE("Révocation rôle", "ROLE", "REVOKE"), + ROLE_ADD_COMPOSITE("Ajout rôle composite", "ROLE", "ADD_COMPOSITE"), + ROLE_REMOVE_COMPOSITE("Retrait rôle composite", "ROLE", "REMOVE_COMPOSITE"), + + // Actions Groupe + GROUP_CREATE("Création groupe", "GROUP", "CREATE"), + GROUP_UPDATE("Modification groupe", "GROUP", "UPDATE"), + GROUP_DELETE("Suppression groupe", "GROUP", "DELETE"), + GROUP_ADD_MEMBER("Ajout membre groupe", "GROUP", "ADD_MEMBER"), + GROUP_REMOVE_MEMBER("Retrait membre groupe", "GROUP", "REMOVE_MEMBER"), + + // Actions Realm + REALM_SYNC("Synchronisation realm", "REALM", "SYNC"), + REALM_EXPORT("Export realm", "REALM", "EXPORT"), + REALM_IMPORT("Import realm", "REALM", "IMPORT"), + + // Actions Session + SESSION_CREATE("Création session", "SESSION", "CREATE"), + SESSION_DELETE("Suppression session", "SESSION", "DELETE"), + SESSION_REVOKE_ALL("Révocation toutes sessions", "SESSION", "REVOKE_ALL"), + + // Actions Système + SYSTEM_BACKUP("Sauvegarde système", "SYSTEM", "BACKUP"), + SYSTEM_RESTORE("Restauration système", "SYSTEM", "RESTORE"), + SYSTEM_CONFIG_CHANGE("Modification configuration", "SYSTEM", "CONFIG_CHANGE"); + + private final String libelle; + private final String ressourceType; + private final String actionType; + + /** + * Détermine si l'action concerne un utilisateur + */ + public boolean isUserAction() { + return ressourceType.equals("USER"); + } + + /** + * Détermine si l'action concerne un rôle + */ + public boolean isRoleAction() { + return ressourceType.equals("ROLE"); + } + + /** + * Détermine si l'action est une création + */ + public boolean isCreateAction() { + return actionType.equals("CREATE"); + } + + /** + * Détermine si l'action est une modification + */ + public boolean isUpdateAction() { + return actionType.equals("UPDATE"); + } + + /** + * Détermine si l'action est une suppression + */ + public boolean isDeleteAction() { + return actionType.equals("DELETE"); + } + + /** + * Détermine si l'action est critique (nécessite alerte) + */ + public boolean isCritical() { + return this == USER_DELETE + || this == ROLE_DELETE + || this == USER_SUSPEND + || this == SESSION_REVOKE_ALL + || this == SYSTEM_RESTORE; + } +} diff --git a/src/main/java/dev/lions/user/manager/enums/role/TypeRole.java b/src/main/java/dev/lions/user/manager/enums/role/TypeRole.java new file mode 100644 index 0000000..d1cc603 --- /dev/null +++ b/src/main/java/dev/lions/user/manager/enums/role/TypeRole.java @@ -0,0 +1,60 @@ +package dev.lions.user.manager.enums.role; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import org.eclipse.microprofile.openapi.annotations.media.Schema; + +/** + * Type de rôle dans Keycloak + * Distingue les rôles au niveau Realm vs Client + */ +@Getter +@RequiredArgsConstructor +@Schema(description = "Type de rôle Keycloak") +public enum TypeRole { + + /** + * Rôle global au niveau du Realm + * Applicable à tous les clients du realm + */ + REALM_ROLE("Realm Role", "Rôle global applicable à tous les clients du realm", "realm-role"), + + /** + * Rôle spécifique à un client + * Limité au scope d'un client particulier + */ + CLIENT_ROLE("Client Role", "Rôle spécifique à un client particulier", "client-role"), + + /** + * Rôle composite (contient d'autres rôles) + */ + COMPOSITE_ROLE("Composite Role", "Rôle composite contenant d'autres rôles", "composite-role"); + + private final String libelle; + private final String description; + private final String codeKeycloak; + + /** + * Détermine si le rôle est au niveau realm + * @return true si c'est un realm role + */ + public boolean isRealmRole() { + return this == REALM_ROLE; + } + + /** + * Détermine si le rôle est au niveau client + * @return true si c'est un client role + */ + public boolean isClientRole() { + return this == CLIENT_ROLE; + } + + /** + * Détermine si le rôle est composite + * @return true si c'est un composite role + */ + public boolean isComposite() { + return this == COMPOSITE_ROLE; + } +} diff --git a/src/main/java/dev/lions/user/manager/enums/user/StatutUser.java b/src/main/java/dev/lions/user/manager/enums/user/StatutUser.java new file mode 100644 index 0000000..bcf0834 --- /dev/null +++ b/src/main/java/dev/lions/user/manager/enums/user/StatutUser.java @@ -0,0 +1,79 @@ +package dev.lions.user.manager.enums.user; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import org.eclipse.microprofile.openapi.annotations.media.Schema; + +/** + * Statut d'un utilisateur dans Keycloak + * Mappé depuis le champ "enabled" et attributs personnalisés + */ +@Getter +@RequiredArgsConstructor +@Schema(description = "Statut d'un utilisateur") +public enum StatutUser { + + /** + * Utilisateur actif et opérationnel + */ + ACTIF("Actif", "Utilisateur actif avec accès complet", true), + + /** + * Utilisateur désactivé temporairement (peut être réactivé) + */ + INACTIF("Inactif", "Utilisateur désactivé temporairement", false), + + /** + * Utilisateur suspendu suite à une action administrative + */ + SUSPENDU("Suspendu", "Compte suspendu par un administrateur", false), + + /** + * Utilisateur en attente de validation + */ + EN_ATTENTE("En attente", "Compte en attente de validation", false), + + /** + * Utilisateur verrouillé suite à des tentatives échouées + */ + VERROUILLE("Verrouillé", "Compte verrouillé suite à plusieurs échecs d'authentification", false), + + /** + * Utilisateur dont le compte a expiré + */ + EXPIRE("Expiré", "Compte expiré et nécessite une réactivation", false), + + /** + * Utilisateur supprimé (soft delete) + */ + SUPPRIME("Supprimé", "Compte supprimé logiquement", false); + + private final String libelle; + private final String description; + private final boolean enabled; + + /** + * Convertit un statut Keycloak "enabled" en StatutUser + * @param enabled état enabled de Keycloak + * @return ACTIF si enabled=true, INACTIF sinon + */ + public static StatutUser fromEnabled(boolean enabled) { + return enabled ? ACTIF : INACTIF; + } + + /** + * Détermine si l'utilisateur peut se connecter + * @return true si le statut permet la connexion + */ + public boolean peutSeConnecter() { + return this == ACTIF; + } + + /** + * Détermine si l'utilisateur peut être réactivé + * @return true si le statut permet la réactivation + */ + public boolean peutEtreReactive() { + return this == INACTIF || this == SUSPENDU || this == EXPIRE; + } +} diff --git a/src/main/java/dev/lions/user/manager/service/AuditService.java b/src/main/java/dev/lions/user/manager/service/AuditService.java new file mode 100644 index 0000000..ee6d729 --- /dev/null +++ b/src/main/java/dev/lions/user/manager/service/AuditService.java @@ -0,0 +1,219 @@ +package dev.lions.user.manager.service; + +import dev.lions.user.manager.dto.audit.AuditLogDTO; +import dev.lions.user.manager.enums.audit.TypeActionAudit; +import jakarta.validation.Valid; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; + +import java.time.LocalDateTime; +import java.util.List; +import java.util.Map; + +/** + * Service de gestion des logs d'audit + * Enregistre toutes les actions effectuées via l'API + */ +public interface AuditService { + + /** + * Enregistre une entrée d'audit + * @param auditLog entrée d'audit + * @return entrée enregistrée avec son ID + */ + AuditLogDTO logAction(@Valid @NotNull AuditLogDTO auditLog); + + /** + * Enregistre une action réussie + * @param typeAction type d'action + * @param ressourceType type de ressource + * @param ressourceId ID de la ressource + * @param ressourceName nom de la ressource + * @param realmName nom du realm + * @param acteurUserId ID de l'acteur + * @param description description + */ + void logSuccess(@NotNull TypeActionAudit typeAction, + @NotBlank String ressourceType, + String ressourceId, + String ressourceName, + @NotBlank String realmName, + @NotBlank String acteurUserId, + String description); + + /** + * Enregistre une action échouée + * @param typeAction type d'action + * @param ressourceType type de ressource + * @param ressourceId ID de la ressource + * @param ressourceName nom de la ressource + * @param realmName nom du realm + * @param acteurUserId ID de l'acteur + * @param errorCode code d'erreur + * @param errorMessage message d'erreur + */ + void logFailure(@NotNull TypeActionAudit typeAction, + @NotBlank String ressourceType, + String ressourceId, + String ressourceName, + @NotBlank String realmName, + @NotBlank String acteurUserId, + String errorCode, + String errorMessage); + + /** + * Recherche les logs d'audit par utilisateur acteur + * @param acteurUserId ID de l'utilisateur acteur + * @param dateDebut date de début + * @param dateFin date de fin + * @param page numéro de page + * @param pageSize taille de la page + * @return liste des logs + */ + List findByActeur(@NotBlank String acteurUserId, + LocalDateTime dateDebut, + LocalDateTime dateFin, + int page, + int pageSize); + + /** + * Recherche les logs d'audit par ressource + * @param ressourceType type de ressource + * @param ressourceId ID de la ressource + * @param dateDebut date de début + * @param dateFin date de fin + * @param page numéro de page + * @param pageSize taille de la page + * @return liste des logs + */ + List findByRessource(@NotBlank String ressourceType, + @NotBlank String ressourceId, + LocalDateTime dateDebut, + LocalDateTime dateFin, + int page, + int pageSize); + + /** + * Recherche les logs d'audit par type d'action + * @param typeAction type d'action + * @param realmName nom du realm + * @param dateDebut date de début + * @param dateFin date de fin + * @param page numéro de page + * @param pageSize taille de la page + * @return liste des logs + */ + List findByTypeAction(@NotNull TypeActionAudit typeAction, + @NotBlank String realmName, + LocalDateTime dateDebut, + LocalDateTime dateFin, + int page, + int pageSize); + + /** + * Recherche les logs d'audit par realm + * @param realmName nom du realm + * @param dateDebut date de début + * @param dateFin date de fin + * @param page numéro de page + * @param pageSize taille de la page + * @return liste des logs + */ + List findByRealm(@NotBlank String realmName, + LocalDateTime dateDebut, + LocalDateTime dateFin, + int page, + int pageSize); + + /** + * Recherche les actions échouées + * @param realmName nom du realm + * @param dateDebut date de début + * @param dateFin date de fin + * @param page numéro de page + * @param pageSize taille de la page + * @return liste des logs d'échec + */ + List findFailures(@NotBlank String realmName, + LocalDateTime dateDebut, + LocalDateTime dateFin, + int page, + int pageSize); + + /** + * Recherche les actions critiques + * @param realmName nom du realm + * @param dateDebut date de début + * @param dateFin date de fin + * @param page numéro de page + * @param pageSize taille de la page + * @return liste des logs critiques + */ + List findCriticalActions(@NotBlank String realmName, + LocalDateTime dateDebut, + LocalDateTime dateFin, + int page, + int pageSize); + + /** + * Compte les actions par type + * @param realmName nom du realm + * @param dateDebut date de début + * @param dateFin date de fin + * @return map type d'action -> nombre + */ + Map countByActionType(@NotBlank String realmName, + LocalDateTime dateDebut, + LocalDateTime dateFin); + + /** + * Compte les actions par utilisateur + * @param realmName nom du realm + * @param dateDebut date de début + * @param dateFin date de fin + * @return map username -> nombre d'actions + */ + Map countByActeur(@NotBlank String realmName, + LocalDateTime dateDebut, + LocalDateTime dateFin); + + /** + * Compte les actions réussies vs échouées + * @param realmName nom du realm + * @param dateDebut date de début + * @param dateFin date de fin + * @return map "success" -> count, "failure" -> count + */ + Map countSuccessVsFailure(@NotBlank String realmName, + LocalDateTime dateDebut, + LocalDateTime dateFin); + + /** + * Exporte les logs d'audit au format CSV + * @param realmName nom du realm + * @param dateDebut date de début + * @param dateFin date de fin + * @return contenu CSV + */ + String exportToCSV(@NotBlank String realmName, + LocalDateTime dateDebut, + LocalDateTime dateFin); + + /** + * Supprime les logs d'audit plus anciens qu'une date + * @param dateLimite date limite (logs antérieurs seront supprimés) + * @return nombre de logs supprimés + */ + long purgeOldLogs(@NotNull LocalDateTime dateLimite); + + /** + * Récupère les statistiques d'audit pour un dashboard + * @param realmName nom du realm + * @param dateDebut date de début + * @param dateFin date de fin + * @return map de statistiques + */ + Map getAuditStatistics(@NotBlank String realmName, + LocalDateTime dateDebut, + LocalDateTime dateFin); +} diff --git a/src/main/java/dev/lions/user/manager/service/RoleService.java b/src/main/java/dev/lions/user/manager/service/RoleService.java new file mode 100644 index 0000000..b38d361 --- /dev/null +++ b/src/main/java/dev/lions/user/manager/service/RoleService.java @@ -0,0 +1,226 @@ +package dev.lions.user.manager.service; + +import dev.lions.user.manager.dto.role.RoleAssignmentDTO; +import dev.lions.user.manager.dto.role.RoleDTO; +import dev.lions.user.manager.enums.role.TypeRole; +import jakarta.validation.Valid; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; + +import java.util.List; +import java.util.Optional; + +/** + * Service de gestion des rôles Keycloak + * Utilise uniquement l'API Admin Keycloak (AUCUN accès direct à la DB) + */ +public interface RoleService { + + /** + * Récupère tous les rôles d'un realm + * @param realmName nom du realm + * @return liste des rôles + */ + List getAllRealmRoles(@NotBlank String realmName); + + /** + * Récupère tous les rôles d'un client + * @param realmName nom du realm + * @param clientName nom du client + * @return liste des rôles + */ + List getAllClientRoles(@NotBlank String realmName, @NotBlank String clientName); + + /** + * Récupère un rôle par son ID + * @param roleId ID du rôle + * @param realmName nom du realm + * @param typeRole type de rôle (REALM ou CLIENT) + * @param clientName nom du client (si CLIENT_ROLE) + * @return rôle ou Optional vide + */ + Optional getRoleById(@NotBlank String roleId, + @NotBlank String realmName, + @NotNull TypeRole typeRole, + String clientName); + + /** + * Récupère un rôle par son nom + * @param roleName nom du rôle + * @param realmName nom du realm + * @param typeRole type de rôle (REALM ou CLIENT) + * @param clientName nom du client (si CLIENT_ROLE) + * @return rôle ou Optional vide + */ + Optional getRoleByName(@NotBlank String roleName, + @NotBlank String realmName, + @NotNull TypeRole typeRole, + String clientName); + + /** + * Crée un nouveau rôle realm + * @param role données du rôle + * @param realmName nom du realm + * @return rôle créé + */ + RoleDTO createRealmRole(@Valid @NotNull RoleDTO role, @NotBlank String realmName); + + /** + * Crée un nouveau rôle client + * @param role données du rôle + * @param realmName nom du realm + * @param clientName nom du client + * @return rôle créé + */ + RoleDTO createClientRole(@Valid @NotNull RoleDTO role, + @NotBlank String realmName, + @NotBlank String clientName); + + /** + * Met à jour un rôle + * @param roleId ID du rôle + * @param role données modifiées + * @param realmName nom du realm + * @param typeRole type de rôle + * @param clientName nom du client (si CLIENT_ROLE) + * @return rôle mis à jour + */ + RoleDTO updateRole(@NotBlank String roleId, + @Valid @NotNull RoleDTO role, + @NotBlank String realmName, + @NotNull TypeRole typeRole, + String clientName); + + /** + * Supprime un rôle + * @param roleId ID du rôle + * @param realmName nom du realm + * @param typeRole type de rôle + * @param clientName nom du client (si CLIENT_ROLE) + */ + void deleteRole(@NotBlank String roleId, + @NotBlank String realmName, + @NotNull TypeRole typeRole, + String clientName); + + /** + * Assigne des rôles à un utilisateur + * @param assignment données d'attribution + */ + void assignRolesToUser(@Valid @NotNull RoleAssignmentDTO assignment); + + /** + * Révoque des rôles d'un utilisateur + * @param assignment données de révocation + */ + void revokeRolesFromUser(@Valid @NotNull RoleAssignmentDTO assignment); + + /** + * Récupère les rôles realm d'un utilisateur + * @param userId ID de l'utilisateur + * @param realmName nom du realm + * @return liste des rôles + */ + List getUserRealmRoles(@NotBlank String userId, @NotBlank String realmName); + + /** + * Récupère les rôles client d'un utilisateur + * @param userId ID de l'utilisateur + * @param realmName nom du realm + * @param clientName nom du client + * @return liste des rôles + */ + List getUserClientRoles(@NotBlank String userId, + @NotBlank String realmName, + @NotBlank String clientName); + + /** + * Récupère tous les rôles d'un utilisateur (realm + clients) + * @param userId ID de l'utilisateur + * @param realmName nom du realm + * @return liste des rôles + */ + List getAllUserRoles(@NotBlank String userId, @NotBlank String realmName); + + /** + * Ajoute un rôle composite + * @param parentRoleId ID du rôle parent + * @param childRoleIds IDs des rôles enfants à ajouter + * @param realmName nom du realm + * @param typeRole type du rôle parent + * @param clientName nom du client (si CLIENT_ROLE) + */ + void addCompositeRoles(@NotBlank String parentRoleId, + @NotNull List childRoleIds, + @NotBlank String realmName, + @NotNull TypeRole typeRole, + String clientName); + + /** + * Retire un rôle composite + * @param parentRoleId ID du rôle parent + * @param childRoleIds IDs des rôles enfants à retirer + * @param realmName nom du realm + * @param typeRole type du rôle parent + * @param clientName nom du client (si CLIENT_ROLE) + */ + void removeCompositeRoles(@NotBlank String parentRoleId, + @NotNull List childRoleIds, + @NotBlank String realmName, + @NotNull TypeRole typeRole, + String clientName); + + /** + * Récupère les rôles composites d'un rôle + * @param roleId ID du rôle + * @param realmName nom du realm + * @param typeRole type de rôle + * @param clientName nom du client (si CLIENT_ROLE) + * @return liste des rôles composites + */ + List getCompositeRoles(@NotBlank String roleId, + @NotBlank String realmName, + @NotNull TypeRole typeRole, + String clientName); + + /** + * Compte le nombre d'utilisateurs ayant un rôle + * @param roleId ID du rôle + * @param realmName nom du realm + * @param typeRole type de rôle + * @param clientName nom du client (si CLIENT_ROLE) + * @return nombre d'utilisateurs + */ + long countUsersWithRole(@NotBlank String roleId, + @NotBlank String realmName, + @NotNull TypeRole typeRole, + String clientName); + + /** + * Vérifie si un rôle existe + * @param roleName nom du rôle + * @param realmName nom du realm + * @param typeRole type de rôle + * @param clientName nom du client (si CLIENT_ROLE) + * @return true si existe + */ + boolean roleExists(@NotBlank String roleName, + @NotBlank String realmName, + @NotNull TypeRole typeRole, + String clientName); + + /** + * Vérifie si un utilisateur a un rôle spécifique + * @param userId ID de l'utilisateur + * @param roleName nom du rôle + * @param realmName nom du realm + * @param typeRole type de rôle + * @param clientName nom du client (si CLIENT_ROLE) + * @return true si l'utilisateur a le rôle + */ + boolean userHasRole(@NotBlank String userId, + @NotBlank String roleName, + @NotBlank String realmName, + @NotNull TypeRole typeRole, + String clientName); +} diff --git a/src/main/java/dev/lions/user/manager/service/SyncService.java b/src/main/java/dev/lions/user/manager/service/SyncService.java new file mode 100644 index 0000000..b0cfb91 --- /dev/null +++ b/src/main/java/dev/lions/user/manager/service/SyncService.java @@ -0,0 +1,65 @@ +package dev.lions.user.manager.service; + +import jakarta.validation.constraints.NotBlank; + +import java.util.Map; + +/** + * Service de synchronisation avec Keycloak + * Permet la synchronisation des données entre différents realms + */ +public interface SyncService { + + /** + * Synchronise les utilisateurs d'un realm + * @param realmName nom du realm à synchroniser + * @return nombre d'utilisateurs synchronisés + */ + int syncUsersFromRealm(@NotBlank String realmName); + + /** + * Synchronise les rôles d'un realm + * @param realmName nom du realm à synchroniser + * @return nombre de rôles synchronisés + */ + int syncRolesFromRealm(@NotBlank String realmName); + + /** + * Synchronise tous les realms configurés + * @return map realm -> nombre d'éléments synchronisés + */ + Map syncAllRealms(); + + /** + * Vérifie la cohérence des données entre cache local et Keycloak + * @param realmName nom du realm + * @return rapport de cohérence + */ + Map checkDataConsistency(@NotBlank String realmName); + + /** + * Force la resynchronisation complète d'un realm + * @param realmName nom du realm + * @return statistiques de synchronisation + */ + Map forceSyncRealm(@NotBlank String realmName); + + /** + * Récupère le statut de la dernière synchronisation + * @param realmName nom du realm + * @return statut de synchronisation + */ + Map getLastSyncStatus(@NotBlank String realmName); + + /** + * Vérifie la disponibilité de Keycloak + * @return true si Keycloak est disponible + */ + boolean isKeycloakAvailable(); + + /** + * Récupère les informations de santé de Keycloak + * @return informations de santé + */ + Map getKeycloakHealthInfo(); +} diff --git a/src/main/java/dev/lions/user/manager/service/UserService.java b/src/main/java/dev/lions/user/manager/service/UserService.java new file mode 100644 index 0000000..acbce8b --- /dev/null +++ b/src/main/java/dev/lions/user/manager/service/UserService.java @@ -0,0 +1,185 @@ +package dev.lions.user.manager.service; + +import dev.lions.user.manager.dto.user.UserDTO; +import dev.lions.user.manager.dto.user.UserSearchCriteriaDTO; +import dev.lions.user.manager.dto.user.UserSearchResultDTO; +import jakarta.validation.Valid; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; + +import java.util.List; +import java.util.Optional; + +/** + * Service de gestion des utilisateurs Keycloak + * Utilise uniquement l'API Admin Keycloak (AUCUN accès direct à la DB) + */ +public interface UserService { + + /** + * Recherche des utilisateurs selon des critères + * @param criteria critères de recherche + * @return résultat paginé + */ + UserSearchResultDTO searchUsers(@Valid @NotNull UserSearchCriteriaDTO criteria); + + /** + * Récupère un utilisateur par son ID + * @param userId ID de l'utilisateur + * @param realmName nom du realm + * @return utilisateur ou Optional vide + */ + Optional getUserById(@NotBlank String userId, @NotBlank String realmName); + + /** + * Récupère un utilisateur par son username + * @param username username + * @param realmName nom du realm + * @return utilisateur ou Optional vide + */ + Optional getUserByUsername(@NotBlank String username, @NotBlank String realmName); + + /** + * Récupère un utilisateur par son email + * @param email email + * @param realmName nom du realm + * @return utilisateur ou Optional vide + */ + Optional getUserByEmail(@NotBlank String email, @NotBlank String realmName); + + /** + * Crée un nouvel utilisateur + * @param user données de l'utilisateur + * @param realmName nom du realm + * @return utilisateur créé avec son ID + */ + UserDTO createUser(@Valid @NotNull UserDTO user, @NotBlank String realmName); + + /** + * Met à jour un utilisateur existant + * @param userId ID de l'utilisateur + * @param user données modifiées + * @param realmName nom du realm + * @return utilisateur mis à jour + */ + UserDTO updateUser(@NotBlank String userId, @Valid @NotNull UserDTO user, @NotBlank String realmName); + + /** + * Supprime un utilisateur (soft ou hard delete selon configuration) + * @param userId ID de l'utilisateur + * @param realmName nom du realm + * @param hardDelete true pour suppression définitive, false pour soft delete + */ + void deleteUser(@NotBlank String userId, @NotBlank String realmName, boolean hardDelete); + + /** + * Active un utilisateur + * @param userId ID de l'utilisateur + * @param realmName nom du realm + */ + void activateUser(@NotBlank String userId, @NotBlank String realmName); + + /** + * Désactive un utilisateur + * @param userId ID de l'utilisateur + * @param realmName nom du realm + * @param raison raison de la désactivation + */ + void deactivateUser(@NotBlank String userId, @NotBlank String realmName, String raison); + + /** + * Suspend un utilisateur + * @param userId ID de l'utilisateur + * @param realmName nom du realm + * @param raison raison de la suspension + * @param duree durée de la suspension en jours (0 = indéfinie) + */ + void suspendUser(@NotBlank String userId, @NotBlank String realmName, String raison, int duree); + + /** + * Déverrouille un utilisateur + * @param userId ID de l'utilisateur + * @param realmName nom du realm + */ + void unlockUser(@NotBlank String userId, @NotBlank String realmName); + + /** + * Réinitialise le mot de passe d'un utilisateur + * @param userId ID de l'utilisateur + * @param realmName nom du realm + * @param temporaryPassword mot de passe temporaire + * @param temporary true si le mot de passe doit être changé à la prochaine connexion + */ + void resetPassword(@NotBlank String userId, @NotBlank String realmName, + @NotBlank String temporaryPassword, boolean temporary); + + /** + * Envoie un email de vérification + * @param userId ID de l'utilisateur + * @param realmName nom du realm + */ + void sendVerificationEmail(@NotBlank String userId, @NotBlank String realmName); + + /** + * Force la déconnexion de toutes les sessions d'un utilisateur + * @param userId ID de l'utilisateur + * @param realmName nom du realm + * @return nombre de sessions révoquées + */ + int logoutAllSessions(@NotBlank String userId, @NotBlank String realmName); + + /** + * Récupère les sessions actives d'un utilisateur + * @param userId ID de l'utilisateur + * @param realmName nom du realm + * @return liste des informations de session + */ + List getActiveSessions(@NotBlank String userId, @NotBlank String realmName); + + /** + * Compte le nombre d'utilisateurs selon des critères + * @param criteria critères de recherche + * @return nombre d'utilisateurs + */ + long countUsers(@NotNull UserSearchCriteriaDTO criteria); + + /** + * Récupère tous les utilisateurs d'un realm (avec pagination) + * @param realmName nom du realm + * @param page numéro de page + * @param pageSize taille de la page + * @return liste paginée d'utilisateurs + */ + UserSearchResultDTO getAllUsers(@NotBlank String realmName, int page, int pageSize); + + /** + * Vérifie si un username existe déjà + * @param username username à vérifier + * @param realmName nom du realm + * @return true si existe + */ + boolean usernameExists(@NotBlank String username, @NotBlank String realmName); + + /** + * Vérifie si un email existe déjà + * @param email email à vérifier + * @param realmName nom du realm + * @return true si existe + */ + boolean emailExists(@NotBlank String email, @NotBlank String realmName); + + /** + * Exporte les utilisateurs au format CSV + * @param criteria critères de recherche + * @return contenu CSV + */ + String exportUsersToCSV(@NotNull UserSearchCriteriaDTO criteria); + + /** + * Importe des utilisateurs depuis un CSV + * @param csvContent contenu CSV + * @param realmName nom du realm + * @return nombre d'utilisateurs importés + */ + int importUsersFromCSV(@NotBlank String csvContent, @NotBlank String realmName); +} diff --git a/src/main/java/dev/lions/user/manager/validation/ValidationConstants.java b/src/main/java/dev/lions/user/manager/validation/ValidationConstants.java new file mode 100644 index 0000000..54b007d --- /dev/null +++ b/src/main/java/dev/lions/user/manager/validation/ValidationConstants.java @@ -0,0 +1,72 @@ +package dev.lions.user.manager.validation; + +/** + * Constantes de validation pour les DTOs + * Centralise les règles de validation communes + */ +public final class ValidationConstants { + + private ValidationConstants() { + // Classe utilitaire, pas d'instanciation + } + + // Username + public static final int USERNAME_MIN_LENGTH = 3; + public static final int USERNAME_MAX_LENGTH = 100; + public static final String USERNAME_PATTERN = "^[a-zA-Z0-9._-]+$"; + public static final String USERNAME_PATTERN_MESSAGE = "Le nom d'utilisateur ne peut contenir que des lettres, chiffres, points, tirets et underscores"; + + // Email + public static final String EMAIL_PATTERN = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"; + public static final String EMAIL_PATTERN_MESSAGE = "Format d'email invalide"; + + // Nom et Prénom + public static final int NAME_MIN_LENGTH = 2; + public static final int NAME_MAX_LENGTH = 100; + public static final String NAME_PATTERN = "^[a-zA-ZÀ-ÿ\\s'-]+$"; + public static final String NAME_PATTERN_MESSAGE = "Le nom ne peut contenir que des lettres, espaces, apostrophes et tirets"; + + // Téléphone + public static final String PHONE_PATTERN = "^\\+?[0-9\\s.-]{8,20}$"; + public static final String PHONE_PATTERN_MESSAGE = "Format de téléphone invalide"; + + // Mot de passe + public static final int PASSWORD_MIN_LENGTH = 8; + public static final int PASSWORD_MAX_LENGTH = 100; + public static final String PASSWORD_PATTERN = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&])[A-Za-z\\d@$!%*?&]{8,}$"; + public static final String PASSWORD_PATTERN_MESSAGE = "Le mot de passe doit contenir au moins 8 caractères, une majuscule, une minuscule, un chiffre et un caractère spécial"; + + // Role + public static final int ROLE_NAME_MIN_LENGTH = 2; + public static final int ROLE_NAME_MAX_LENGTH = 100; + public static final String ROLE_NAME_PATTERN = "^[a-zA-Z0-9_-]+$"; + public static final String ROLE_NAME_PATTERN_MESSAGE = "Le nom du rôle ne peut contenir que des lettres, chiffres, underscores et tirets"; + + // Realm + public static final String REALM_NAME_PATTERN = "^[a-zA-Z0-9_-]+$"; + public static final String REALM_NAME_PATTERN_MESSAGE = "Le nom du realm ne peut contenir que des lettres, chiffres, underscores et tirets"; + + // UUID + public static final String UUID_PATTERN = "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"; + public static final String UUID_PATTERN_MESSAGE = "Format UUID invalide"; + + // Messages d'erreur génériques + public static final String REQUIRED_FIELD = "Ce champ est obligatoire"; + public static final String INVALID_FORMAT = "Format invalide"; + public static final String TOO_SHORT = "Valeur trop courte"; + public static final String TOO_LONG = "Valeur trop longue"; + + // Pagination + public static final int DEFAULT_PAGE_SIZE = 20; + public static final int MAX_PAGE_SIZE = 100; + public static final int MIN_PAGE_SIZE = 1; + + // Audit + public static final int MAX_DESCRIPTION_LENGTH = 500; + public static final int MAX_COMMENT_LENGTH = 1000; + public static final int MAX_ERROR_MESSAGE_LENGTH = 2000; + + // IP Address + public static final String IP_ADDRESS_PATTERN = "^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"; + public static final String IP_ADDRESS_PATTERN_MESSAGE = "Format d'adresse IP invalide"; +} diff --git a/target/classes/dev/lions/user/manager/dto/audit/AuditLogDTO$AuditLogDTOBuilder.class b/target/classes/dev/lions/user/manager/dto/audit/AuditLogDTO$AuditLogDTOBuilder.class new file mode 100644 index 0000000000000000000000000000000000000000..312e69f43b0e1851101b1e8550d36b8b0b065ea3 GIT binary patch literal 9706 zcmeHNX?q+;5w4MCOImeo#rKgoc4AwSuMLm{BH0eo`cjbOV97Fx6T)b>C66^bv!0oi zZ6G8egd~IzZo++=8xn913<-SZXYfOKcx!sJJL_&OGuR*F=V^6yb$7khcfGUz*MF|R zM?{C|pIy{p(L)uvSacoV3ybwo2F0rF+4IONkzcgy6(=f=@ZWKN{^<0nT`76A?zj~h zbWx{85415dYlpHpia*>x$&0pi?*Gv zdy!L>W8R_@IW(pN_9VxR>i?%2?7_>OebDyLC`=|Xg+)@XR&_%Z{RUcDM7^Ech- z5YHZL+!n|%^y@)cavfZ0lz9@GwUe>$J%O~{Y9c$ekxGS|ThznrH8L+f9?ZP-U3jYe z@3m{rF|Shd9j+^!kD}UyjL!Qo-dmAjIdE!8!-|Y-#|A@0RtTXJ0D+5e%H#Vd* z=SX(%kmEVg5sOv~49-~8$um-*6?C7Vd+7u0o8!sJdUaL?(>69U?_l0yGj`x`IZ<{- z=N$}cWVsEN^?1VXjji^v;}VRqn>BuDx->jJI?R)EWH9W6Mx(fs&)ihT{SyGQ(OTXuHfH+ ziHQT1O8<2K$&*9X>QET+3_K!8&}|l78dz>s+ueD$VoDzT|B#c-GA(E|t>KZ(2e3)-Tj3xc*P$rZFs zNuHoPlvERRC-0$|^yXf=N^iwfZ8jQCW+D=_o$lh9SQNBFd30IOP9=R>(B16YRN6#* zE#C^qHt1FpuRbT}9@@oTJtJth^5ye__9*EKg8G&8ML`4X-|56s?hV~wG~?Sa zn2g~|f(B_XkKxOL4yZZ)ilBo^`l_HJ-DT0r0d9|cmLn*O?#+2yaaWiqA@7cS^<-JJ z9#*vAi65TV1bvIXU7+vL54!04cy4cOCFqCrBU}QD{PdrivuICxkxtECkmYFDV0cOeN8$Fet$OF&xT=pS~S%D zV6`D8I9mI%cOK>tr(>D<8PQ`)!afd^@z7$_N$mh8M6k&mWPk-#9KUlP@d9yg)qQ4*$4yW#gm#UmAkZ7nnRY-*b1v#E>OCl{OalS@sG$)yH6s>5JoOE7$X-Nl#vT5&d9|SY2;#)HF7CM8&$Ev8@aed99dpsj&UPTx0O^o~XSZOo*PA--gcsxK#vuPuMGXt#FG zOed#{-UW?l-xPFJ9W#UylQN7>`eD?$6Svt4yzM)wgZULoT_|zhjl6>?k){JV(sZCn znhq2~(;+O^bO_Kj9YS?YhoD{4A$-?#2;?;#LV8Vy;9k=q%-3`X_%$6ue@zDxpy@yd zG#!Y6rUOOLbO_uv9YT0bhhSdQA*|PQ2)Q*Kf^SWSFkI6iAlGyV%{3iDV(glI@!r{g z!(Kv=thGnDtmzOq-=OP986Q;e_k*xJg4{yBa_`&pp*J9`p!@Ncogpx`2k=*@2J~V2 z2ucsOXogTiR87O^ryM=h;wVErfzkR9>KJc#OjH6d=yj%epW zRIj%QaZ`50avnq#8<-F`XGfHI5LM)1Lfn!aaXt^Cifc@WTeBlNc@S09WJ27Q9dRKK zqKe5(h<9X1tmZ*f5uXY1&g_VO9z+#Snh>|s#l~wDw12I_Jcue=$1?(AcHIuD}aAST2; z*%6=3gQyse39&yr;&XWr6@M}z4rE7sJ`bW|XC}l!dZDp%UetEZV`=L1QXWL+epXDj znzV?i57VMS+K)O5Ka^y?eO}Ikt+=IWvB?aVKwku5$e)ke3-HP8$Sv%mA(po{hhtnz<;k%3F#Qp38Yi+ z(07qdsq75Ivq+C3okMy8=}9CTsf;9%=8+tv1*9sHj})rzb%>Xct{^?7R8K>E7U?;p z=aF7g>X%jaippL^cAb7qWG3e71He`70|0BVC;N_K&VFtf`|fy`^0$SA^LM1aE#Ut? zVOsEApl<}z`iuY3{g>>Su{%Ch{3@>db+Tr^X<38cqOKc$ypHq+{RO41IIk96qqjPH WAiYh0MSh+BPVeC-=zqkPuKgE4v=M6n literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/dto/audit/AuditLogDTO$AuditLogDTOBuilderImpl.class b/target/classes/dev/lions/user/manager/dto/audit/AuditLogDTO$AuditLogDTOBuilderImpl.class new file mode 100644 index 0000000000000000000000000000000000000000..a2dd22bac717d971ee57b56d36c9476de19ed478 GIT binary patch literal 1338 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 literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/dto/base/BaseDTO.class b/target/classes/dev/lions/user/manager/dto/base/BaseDTO.class new file mode 100644 index 0000000000000000000000000000000000000000..5c3e19b4a59c3854752ac4497f329a39f62fea42 GIT binary patch literal 6571 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 Z!E6{j0zb_jBQb2!xAZ+u{6lr;!oLQzc6a~) literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/dto/role/RoleAssignmentDTO.class b/target/classes/dev/lions/user/manager/dto/role/RoleAssignmentDTO.class new file mode 100644 index 0000000000000000000000000000000000000000..3bfe9e3ef84c65bbc4ec15b8e0bc53f17462dd1a GIT binary patch literal 12917 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 Ju!m5z`rncb@df|@ literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/dto/role/RoleDTO$RoleCompositeDTO$RoleCompositeDTOBuilder.class b/target/classes/dev/lions/user/manager/dto/role/RoleDTO$RoleCompositeDTO$RoleCompositeDTOBuilder.class new file mode 100644 index 0000000000000000000000000000000000000000..91033261146630c734c8a4933631e87c4f80c247 GIT binary patch literal 3225 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 TXPn92#?SE!PH4aM#J%-DsU`M^ literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/dto/role/RoleDTO$RoleDTOBuilder.class b/target/classes/dev/lions/user/manager/dto/role/RoleDTO$RoleDTOBuilder.class new file mode 100644 index 0000000000000000000000000000000000000000..de31bf0bb9abee2c39971715803c7093da4527eb GIT binary patch literal 6570 zcmd^DS$ES$6uwGKoESkufRGaQ21o+MT_~kEq{L1k0VjbZ4HUY`_K=9kl536Aru#zo z<+(5Y4Qlkx|TFFb0xXR%euLeQfO$QVsgF6X3TZn)^i4%G);?ZT$m_C46B&4 z){e-F&0OgtZEt&NlImnU$g~{abQZLr+iMDwZr;=MdfP zvn_2wn`R26yk&At2lPw<>&r|tigS)HiM*jRlgm!G?1(ixJ)OcNc+e*mSGaB@v%1X% z?xMb8YP?bg?r_8OxX%uEk0v0pyQWsy;Ofo>gq!#u`gJo^@A1h}0%VT|l5w1KQF?tS zvswuYt@@D=n|%v})8oxPOgn}N(-Im-z~m}iZ0QxBb{NzSd?4^99FKd%8OT_O!1@T7 zF*(Dj5Wx0^&6%^|_;3YgFs>m;73vz-O`T6D)HyP`j1bRQ1(u*rI7GX12 zDdt#tNlNr*t-NL|Yh_*Z-N6`N)#1|lNE?I?=AJEBI8d(^;q9uvv`L-gOPSPC+S#A% zh}>%bksaNnT9~>oOdX(lNTH-k+o&snx2IHknx4Uy+RV7C(1nprBMQCGs?s!*ZEpo$&*#Ziz*EX#dR@SO_f{Nsk#{T^tm7Y zrb-9tkciBeRXQxA^^QtMXoo`EMucf-bAqKPbgKPSA*3LkLEFtOS!q!Lp&(EyL{`tM z^ag1OVzd$`B&EK_RVuBLu26hkGb(HzD^9qd-$|YGxqB?n5lxL^seW*?HI)o1B0Uzh zHI}i=yvA?pd=+mt*Gz6J%2~fMmlgzd{hvodw)T;wqXlP0SUe(_{K6?ww%%0fReBAK zVbQ9T^X#%NSb{1z6w37(@!=KvX*_eGSs7}iLaB7yOB=|#SHLG)Vfh_sVC7PMH_K?8`QNH%(}U5tudF>%Lu-#<+)Yf5TX5!LO=Ke*j+6ZPHScX zM0q%CS!)#EH@&aW-_U)HbqVAsQzlp@@v)0&tX~d`4C%-(*5kobK9H*}oIv$ACu;`1^HwqnUy%fw}hAIlj z9JBefW%Jlkoc~T_@?Po?EEc^udZO({+aVZeU<`CGFa|aj7y~a0jDevA#=zAAV_Udxb6}@3>FZ#Gk;rTeM zokXjk-8S|+4gZ3dPC9|7aF9TFPU5M`1vEmV=#ABloI(#ZpH4$gI{!qSp#tJMoajKC z7(4YVof-R$p8OfTAkKhX<>Fwy`_XHN3Cu~vp7s&XMnRMz6^59gbDodSwf6CR6hs-Y zVTdYS@DNk25yzt-%Ht4*xU>CTorr=c4_g>wZ~KUsq9Dqn9ERA}K4LlwqD&NFh`ZWH zoQi@d(@+>9F2hNYRqYl3uHsL7+)2E- z*Zp(&9=OtC&QDcD75ou@`-qyVq0r{W9-t6DptJa$|APu>#$_{s*Gu@N@teYLS`J^6 z&Ae literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/dto/role/RoleDTO$RoleDTOBuilderImpl.class b/target/classes/dev/lions/user/manager/dto/role/RoleDTO$RoleDTOBuilderImpl.class new file mode 100644 index 0000000000000000000000000000000000000000..860364b059fadb92feefa67441b75593ebd3eb57 GIT binary patch literal 1239 zcmbtT-A>d%6#k~$vb0t}Tou6|Kn%;8SQ8U3C~l$-Y+K zqlqRyfDdInv)c=oV6v$<=ggTo=R4o|nP0!Z{{-+H8%;P2+ld%Psnn{7%0lE(#uYy! zofsYEIu+3&iM`{4jY_{PWtxb*mwil|a2cM}i)WbGkxH5_L!-TQ!r<=eLn6eileaFykZ~Y(6%3-OD z%tTKOWg&^>3#GK-#`f11km_up&!g8uiJTjeP-<^rJIe5A`rL67HyAdjtT;dmw`^0F z7~*!#`eHky?dd6ASeG~e!%B!b%rgW>y39|-D`|%sR(tjM10Qk*|45!GZpxgVKGozp z^)AFU6O5LoOS21miUzrx@}dwl-?_;@LIan$n=Z2)J8i!=}b literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/dto/role/RoleDTO.class b/target/classes/dev/lions/user/manager/dto/role/RoleDTO.class new file mode 100644 index 0000000000000000000000000000000000000000..b0053a326ac8318df1bb9f7320324a5769c8ff81 GIT binary patch literal 15965 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 Cz9d%w literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/dto/user/UserDTO$UserDTOBuilder.class b/target/classes/dev/lions/user/manager/dto/user/UserDTO$UserDTOBuilder.class new file mode 100644 index 0000000000000000000000000000000000000000..7cbef2e025d56622b700f0958bceccb7d9d53d41 GIT binary patch literal 10068 zcmeHNX?xv96+W^ZZ{zR{2bCtkALmO?498)`do;?z#k*hy$ZDYEa_R;(-CO1e(m zQc9te0;QC)m3`lrwvaX@l(O@Izr%MP-lNe~bg#xYQv9`f9^IKanmO;8Gc#w-E9XD| zyYV&=-ADg!qb7syDayryZMlwLsQA(=luXB*Ls<-5B{&c1v8glNQ8`?(?4tDAsHO4P zY15a5Vf^sesEo!M)Xq?jS&{~A7{6>Tng!c*<_eR6XE}2N2JJjoaRRF($DBpWx2A15 z9{3>n#12#AId9%L5Iheaffs&rN~2*VPAF!6tzjmgna<&2&65`^R9zQ3D=u59m@|b zHfVKGmQ62^CFua8eb#kmcq#_9l+7hfXw{-++Zfi$UZ|kb&Xa#URMp{0(=MG3ebpJ( z&tVc6)TJg?2`sxXZutR>>6o(&$0qd~=%C2X6OJ_~rzv6n>G@DbhQA`MP zHevdroRq$=_Iz?1k2!(F5ru0u&SKBY;mXAL^id)tVtcT`XZwHh>$#IDA%+tzH*Hm$yBGN%M} z(rShu7bK{aYo`URVMFG7mvf*#M6STbyYoUt=ARR^me#S+Q-ZqGL@o$guO{+gK^s)< zVL=;J?IVIVsoF;cZC1693EHA+(}K3DT2at8Rht#Go!xON^5e}gyn+e$)hp8m)4ph$ zmj&&hod%61M{(3%fd$nQ6HW)ZGzO#sW9t6qcwaTr5wwfm&1+E>w1>@|jLg-<`V|Ut%U@7cC8t{Yrp zh~G>2cW7ebP_fuE)pPRXky7c1@AGu83ffEW;o9SZx>fDtg7&G}Cj{+RZuz939@@$M zJ|(D^x77LMda5gRg?CSNF+L-xPhovl&;hlPKPTuQt*#3&)f;973sMtcVtvup{i2{l zbeJdoB|!yM`?8=rl}TR_bQe2fRWBQka+-5agAQa5r929wM^Ls0uF7`|+5`ou-O9J# zw*|dS-|VFC()Ziwd&sTodkOjh{SXVkXxbHdX4atn(ISOc%bDrRawfpJs~I5SLIW7I*r0WMQdk_|zkrM2tCZ>yMwV}mj zJIW@edMO#0SV{&?mXd*;rDUK%DH#Y+N(O3_l7S?pWS~na8HiI#1`3suflQ@jpj9au z2v$l4s+E#~`@m!G3jKCRogYCt;&;32-hqU~@9M`PV^85AcTdTX#iwM*=VQI~n8@(s zclDUa`BS=(rN{mI>+DC~p6ZVbJ|#nfosuEdPRWpTr({UK>ty@U#)l#Nz7HNBLTR8} z)qkDd{~9XI^a1?xAcE=l;#a5+^g%j;)PTV59L8r*OU%%Q+C8lc@Whls6*VG9r2Moi0X>fA#TZz z_-GzPb%E;;w`NB)^B}79K!><3JK{_pM3sE#5VvPXlz9+UYNJEkL344Gn@>f#hm-fC zl?Ra%CnLO(Z{D4JKl0tVgYLjPB)7B>W800fOL?$4F*y>E!w*nKM z$YX-aqje_i&%Obl%!9~T`f{6Kf3yL6vTwkr@?bLySPr`<+JL>;!_3opuocVDdAct# z+fUbQc}~M?!pt*y5Sha)H`_ky$2)vd%s$&^^I$8Eq?_%*?1|iSc@Px?(;*(B&&Q$k z3n~BBM3Cq6AS!;RLo8%Rd?62_Vvjn+JF~Cji+KcOy za@F^SuO`>A#o+JU@w;y%-(ipA4@-EL{LaJY>c6<=m@HohgZ@_kH89+3bR5svoAezN z58#==^Pp-@s^UB(7x6rV=MtVr@H~pg#503O;;~fMk}6zPTv5f6DxOfqld5=16;EUA zGphP5s?VwF^Qw436))n&OE>68M0zf+IREt&=Vu8rjILvF;?FeB*cS!^{+tle{HDa` z1pMz3_z9l^x`yEApWkBmFW55eaD1KkRrv1L(IWn)W>J2NckQs_4|uN88))rCCeTdR i>5nZPbc5caxAA$-K=~K6|4M(Sf8u`t{43P>*8c&+>7-Er literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/dto/user/UserDTO$UserDTOBuilderImpl.class b/target/classes/dev/lions/user/manager/dto/user/UserDTO$UserDTOBuilderImpl.class new file mode 100644 index 0000000000000000000000000000000000000000..6a0b9615bb104a40c744e5add7f783cf66423ab0 GIT binary patch literal 1239 zcmbtT+iuf95IyVIO>InD+Hh-t7APVO5=KJep)Qf26%Z*Z61_+~ZtA5hwRe%d&hPLG z@B$J@d;lMXm`(gZsvCxEBeXu@IGO2jBirB+2$79x)_uJ{Sb z#OR6PkgU50uQw|Byp(Ao@_zO)ZNg=EQZJriZd)p8dJK)u<`ILtqZ1LJ0Y8L?Ifli7 zRAR5ph9W=U!&ERV5A-olk9aPvUKw5UUKR}7gL*t{9WiAuMEZ`Q*V+6(oc5bi8JUT` z8p%Qu%V$by!;S5)Eg;p|P@hIGg%UY8BB9jY&~}vJ!R)!?CN4AFpRwWqEnKxty~YrC zYStIq8Ewr@@yxo!0T|jL7O=<=?CUZ=7B8e7YFO>n!w-DK8T@^DqPQt@diqq8>&&|l z*Gw>8njXzA>?<1NPRffy(0muB{|F6y+F;`t=J!NlUg^T%5jCYje-Uuu*sUkMNm@jb zk@ULXF#m-v4gxyuGtkBbI>U(r$%~}9wz1^3RC!$@X@Sj}&vdfCBAqIdIAZ0T z$j3y?M*2U{dP_8}Sb%@g@F!qPyF}yqIbioH8eaD+R?h-WSUCjm;l?=0P23vGwW)g6 Y$+k@34O-{hu1}CH+`%gDj(uBy03qu&!vFvP literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/dto/user/UserDTO.class b/target/classes/dev/lions/user/manager/dto/user/UserDTO.class new file mode 100644 index 0000000000000000000000000000000000000000..705ec9d576d60cf556d34441212cfae49ff503f3 GIT binary patch literal 28831 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 Odx_X72JuJqr~Mzm6nVh_ literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/dto/user/UserSearchCriteriaDTO$UserSearchCriteriaDTOBuilder.class b/target/classes/dev/lions/user/manager/dto/user/UserSearchCriteriaDTO$UserSearchCriteriaDTOBuilder.class new file mode 100644 index 0000000000000000000000000000000000000000..16f4f98957c6769a792ca42b3e4d9f6591fd2831 GIT binary patch literal 10496 zcmeHMYkVC=6+au2+$5dSHl>eHMAU$NK%*!qNvUlEw3W2QCM_0fWs|!}wz+pVy}LJU zibX3Au~LzWAf*BosrW!aL240v;1eH+itqOW-}=oj_UF(4nX@-{Z{{YuTJnt#vorIb zGyi$doOAZ6{~UXQh%TgmW~j!Zjag@;E$8}P&{hnbLR;SU>;c5t&=+76&~C>r^bK|v z+|Vhw_C-A#TC1X~if%6J6f#t6(ai1kh~1X6y@9q3z1y9>(4wY5)ATrnyhY7jWr6On z;Ccfc7A@FV^g=i9to26R!0pXBD?QH-?U1|2RdRm5*B@$I?RZYX4xKEjG;psyJMUOj z=j3fSXHord!SQ^wagzSl2Vf|o{iR(KjMedq`DpmvT9!u#?u_Hv=tS0{*|FZP^8K7+ zdnli-8{CXJ>33PGso>bT{6-X`w=<y~cv-B4Xg-#s z%Cx?m>v&cqFIn-nGvVk2?AOCMm@JO z;HF`0(bf?=SHv*lOS9Gs9c*57w?T^p4rai*!lIKo+wJZitEI*OEz^{@cWrcnVlG6l zRNxoFRimW_nxd>0oWYq51q{7ZJiUx)iDuX9%N4VZUb2$V%nDG;&5oeedPz%yvno+7 zIWNLihBzm^#n1^#(sRrbU1NTPN7J{~>-S4l=2j`vb?TS7o*OR5sad#aGd4@7pLLq( zBzm2q4qAo{(B*p0`eMGEbHJx^O!7} zil!RLqDvIjQ9Y;DC~B0{>lHOgs!P!{Nv&6;sNSOM7EaWY>KDwEb^HyArqjt5x$)U5 zU0YMuYLB8BG?S-mv!Yov)1v;U{qh|+C5>COdwfGxZ__DhoX2~GqGpXfDm>)SDH}la#G!zU-hrMJK8##`m4p0YuD zicY5&^9Y6&ogt}$qL)Z2RP<6wjVOAVY=d2jS|znx(V3EZi=wk6b&aBz^H}gI4d61V z*sG;`e98v%c0~(m5fA1%MT==k^kDD{!QeX-oh`-hRCEq4VeDOsmeL|<7xEl1^ln9M zvM}#a^a^Ha9D5A7{Jn}^Ddq1|bS{^x==Rl*1B<+0(W_)W4k~&zi%gG1-5`rhg)S^%t43BiehPBaATiV^f1?$RZ)Xi zkV`+K=utX~S8J?PmJMo41!JUYag}3=9^)#_6;HzQi@>j;|?8%pzY_^c5C4b-YM*^^k0)`K{s$>@Or?Vq zTZ43vNo67@+;!GJr^6EK8(L=%YrQf<-@!>QuTs?641Kr4(v-er=zA5yQGam9hrUQO z(bM#-q94+aVB~2#Vne@0XT?v87_A-g+b0@nGpy&IDEcY=%%XXDdx-6yK0CbJ4F{2e zvFX8xsM!}MGw0|9q$9TXUYL#NZ8oZGShx$i{bHfdxx{6&?bNEio27iXaF}pd!XPZz z!|R-I(9Z@<^lSQUhJFK&Mfv!--iSZsw8^r`_P@mL3;n_jcNLmQj*j^U? zk=8EXA1V${KJ1E$Jy55sh+i4oMpe#iMA2#Ia^3J=baZD6pg4Gb2xfx*@` zFj(CN2K(EJNegk^;zw!uLwd`vz?TP2I07s2 zRU$yEs1rFD>U2>Rq7Gm+D9Q_A9>)7F~&bEyp5*X668a zYbAYiTT?g3&rM}>bED?wrEhLq>gMrzRDZ#DW7q zkD`iOaHRpyGPf8V5}nX&F>_@9&R?oCx^w_+mpb9Zl^lsP^T zH)-wAqFa)g4>0qsshMwym~X4P%_{nQJ2T&rn)x=Zaa(j}GV>v3zAH8Joe}dr$;^kD z`QFsb_e9M1B{Lsk=KE7K-xo1|ls;x266MrH^y+hIRPd zsPmuVr04igFY2C8&+%dF5p@MUL~L5t6Xp=-+B-$#`Hi;&jS}FD=+96ROQBk6u5{*i9wM2W+>|ROUAkjXF_M_kc!tIhh zB++4sjvzWlKPLSDB@A~3zHzHnH2r5vi$g!xQopD$DSip80h983gg?+9k!uE%g&(1R T!qWbk{z`v`y891Z^MU^YQf1Gu literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/dto/user/UserSearchCriteriaDTO.class b/target/classes/dev/lions/user/manager/dto/user/UserSearchCriteriaDTO.class new file mode 100644 index 0000000000000000000000000000000000000000..37af0c977b7838040dfc8239acb4c9ed1624f3c3 GIT binary patch literal 28552 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 A#{d8T literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/enums/audit/TypeActionAudit.class b/target/classes/dev/lions/user/manager/enums/audit/TypeActionAudit.class new file mode 100644 index 0000000000000000000000000000000000000000..fcd8957de588ad304d619b2af33cf4471f107359 GIT binary patch literal 5803 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 E0b_n3kN^Mx literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/enums/user/StatutUser.class b/target/classes/dev/lions/user/manager/enums/user/StatutUser.class new file mode 100644 index 0000000000000000000000000000000000000000..6ccab28b875330fef0db6fb97389b7a500aa4fbe GIT binary patch literal 2958 zcmb7GYjYD-7=E_7ZIXr7<<=II6@j*)G*$&KE!Ywk2&5OgO(aEu?dCLH*z7KQiPSIt z4!`*YwKIIsA_Jo%<4nK#qa5F}*|w3Q*v_Qy?sLw0-phI3H~I6gUta*YfUh&?5ir_d z?V@EmwqFc=<`rAItvAUsJ8Z>}7U)43RB1JXq=5bR^tN8Kbh}wpX_J7|bZN1CMZj2P zFI*D>GUeI$sHj!7d3E-3RX|Riy)(VIsLn2`^ioq77UrtuN`+q1>dpD`0zJ^~`T2$N z3_WHnbD3Ed6ChW1;?e@ow43B1-(bGsnQlM{(q?As%NA=05SD07ovqHCtW8&{swSX# zYp>CZlZIv5W^hqJVtAw`AX#!6Ohih=056IWm@6WV3OH2_Ow083fQ6o-b6C;a%%DeO z^G9DXoR({`AO`_&N_Y#$DbvZAcw%^WR^{E$Ze(esmLqDIVF?+|B8oV}s~`F;t1lEJF! z3+Us^YT&U278QU3%Qab0*=o*%!y~&jD&XisNab&_vfVa)lj5JYZHJ}}A4fbj%V{k; z_lsAV&A5&l6TB8*NZ5z{G>6E+<(>BCOLrvn@};cl$JujqSwbJ)$RU9S?=On&@T=O2 zw{V&S7c%laK0LC=fsliV`x)G$Vss6nHJ{o^f(4qBS>5yWHN$b&1Qfa>m|MO_MV;tw z>@BFwqsl~4&8-Ny)O{?Ta(ld6UWW$~Y|tH^>!vGNy6;cyzNYS*;{%^MEvGr5XRs?K zS77hX_rn;^oa@|d+Vq{_(dtweAwNC2Hzi&qZv(MPYOm19M8)x%MMjg@^;xlH8lK~N z&I$!qbZAKFu36M~G*xV|hN%}d8UQVwn2&Tqr%^x?E8LmVQ{yC?1bs{9rv~@{1<29} zj4TbY$kHf^ERBoEQlm$fT9!`AT%?gDMMjo12=oo|MyB^14a0*tM1BqfLY~<9-;>`U z)a4@yxnCYkKEtsmP$J|+QhrB1m57j`2pLJq1$nfCj77-1X?a|Jzk{5MkPkERNAf2f zWHLf7it?xObO$L#h}xHyugKRr(DlB|?-W2{1BzBpZeU2Or#3LA)zcd|r`0nXnAGax z21;7JkD%+?6I6btuzN5||1VPWQHGSt0ZQ@^2GEa_7{nR8iSsy4KRHg|8X3{hZ z_3q@J?_x~Fi~_!VEz#}&M|78R{qKl$p5yBx>ft|ZUO{x1YRcQCzi{T*GZ=-lPjRa- zkbH{Ug+r;Q(0A0;$ySQ8Eg;Fy#M$yE-fX;K`}r3@yvlWuA~mg`N#)~(JWua@*WnFR z>NgUF7xhW5_nE}e=U5$mxgbL1tB3YyX~p%DN8 literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/service/AuditService.class b/target/classes/dev/lions/user/manager/service/AuditService.class new file mode 100644 index 0000000000000000000000000000000000000000..ab076d78edaa8a33e2f54355b174a6b58b244eac GIT binary patch literal 3296 zcmd5;-A)rh6h2cZr4(%esfr+ie^e6p0Z*#AHQJ#}!nP@ChswYxIPAf*MU~ z^Q!u6RAhI9z*^j-iR*+%xg&gI-xd3TZKLT@_h#kO2J6~q3Oz3crpbKV^m|X&nG@9g z(0PTS#8T33Aeok)CE;<$8sV2hg+QSX@3%0#C+NO(Z`HR+X<;w%HKcl)D+Lf}j*`KVnF&th0nuwu^1$!(7dj)zX)Aoz90bg{&%6N}YchK9gV&mvS}1d(=Z!3))=f6_@a`tN86}A;Ug4 zTu+qU?GhH-%c-tmoT9}DbEgq_7CW%3_;SE3Sq!y^iGSfWfmw?Q{dSR$0v|IB*L=Eq z{q!42MRTg8%I_|>F`;Lo53A=g0uuxXjN#J^AdBy;Buqd8QaH*G>`Y=OjlU`Uk>w~qrF0a+i<51 zaJK`{EzlVNoa_KB48i)|5Nj5PShIwIY$>{|lVvQT=s7hXMC@1kuwNa}{vkXHlP2?D h9*^NkXqS>%FM|=`ibD+C)5zXy7jZ?90)iyq**~5_cTfNT literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/service/RoleService.class b/target/classes/dev/lions/user/manager/service/RoleService.class new file mode 100644 index 0000000000000000000000000000000000000000..ba549a244ffe61f128c433e7b2366cd0bc6800ef GIT binary patch literal 4135 zcmc&$-BQy)6h7O66)Mv5t015V3aG@t@utWOpbR<;btvMDcT2n0Kz^8HQ{fSO3NL&I zFTC&pd??4W*`;YoB58|o(Mh`5bI$jD=i8I~{`2z}0KA0f8AuUWsIZ!5=(go*p35A~ zq!z8>74K_$nQ7a$!AkNz16>4i`?N+igIZOsxVO*B9G9w$uNcNQqlPKAy98$DHiLa7 z?&wyvFfW%pt{d8>?(zbGo|0a*DEAyjpqLXP~GCLwq^5Gqnp^_pSzg)l3_+-`uIv_?jzE9eVU)A_86og#E>6jinWJP(dJqVV zMWNmmW=EVki7T+IZ-b=C!@$BT^NDE^==Bcq1p3|~@FU6-9UzMdP3qg2@KCdmMTHqS zXT%90z@k`$W@DU23Bm0W$WzzFVd_tv9s50wZvr@blAvDkBTbxHVsg%7vO$N{>;s>H zyYASgOee;hxT~8O$LD}r3k-yd8_76_RET&(xaX9rwS(S|tniKIlf^C~r97=v)@<|8 zc6HfVT=QbF1@E}YL6yY5oB?sCL5?i|aI!%VxzPD>-Ka(a!&!uG!=)K@}> zkR-Xc$39n50DYO;9uN(4f^VPulsxZQfhAyk%N?q7$GNt{gA5%=Ka9ouBJd7xmZP( z9EEgqf{_%6#|U8Xobn98Fwzxd^C`R$6+}4Y<*+L zlm%4BqFOcgKa$SFLLKRY4i4Kxc+`=P7D4MM{xLjJ@eN9g7N4cG5L})zbto|6DaNJX F*Yx15QfJoG;N_J=@%ao7q}!n;3G&WNC8w4Q9hIf4&0{hbnC`zSGISh{51~z z0Dcr=?0`rqqU5kz+w;!M<9Yq<`Oxcvq9E@ysXe-$$wrqT9GWK zRu!{#8?FiHoMD5~pe^OQqcc)bz-D00M@|R_-c@5lQwiAV9sX7p(Q8`{`Xd1k#u2TI3G*Jq3BWD801?QpEJW`AmIMRf*+>m zbfH$J8#_bubn6LuXiSFXhTUFj$rr1mHu4RgbK%uOmlk8~Nx+jo^NNz6KP~E(6b~`PY%$Ni z=0R-f@S3K|IGhX{)CSoj0ZYC9XSS5}zk;vW<#;->Cr-fQ#fCG7v{ty9nGSSn(#agN zr}ikBu`GaF^IHX2;g@$EmZ1f0-nCO;g%_*&6T3+P>229ODKfwi>;rF0y3~a<>0~z*{+bW| z0DqL@-DcY~wvI`CXtUk!x%Zs2_ul;c_5B9`e1JC@FbJ&FS=)5D=L$0r%r~3Vr44-I zy3K87e!+zmt}`%BAb(EV)O4uZFb_`8nJo$A1f#zFRh<+B-16RELe`}h<_Kdd%$Cn3 z^Ev%=e6UtYfjeR%aHK*JSUL(^$(yXk1wVDzA@ymKVbl%R^(2)_8iDz}b9zC2NzFEO zc)hc2*3=Rsl!yIkBTo91yHc3@p4<-{2ahhqlO12RSS(Mj!K9M6c~z|wc&{RN?XslL z-NxGBP9@w5BzMe%mLg15stJoXTq*;f5nv++T2JJva`GeQR8$6R`ooD$y!;D1Tj)tu zf?YJ7z;thKyGgl2AZz=KN~TT_I7?OqkJYfY zH`E=l2>mvZmHo}U$A!d3*&PYEJ}6jqXx8>{+$ke*s^Og^DP*fNpJTIj7q1t4746ZX zJ`W*Tt&TdArvp6_wlC2GWSY?W6Qsq|Z}t-G z_+GP_zndq;v4ZATn7U(_$x?iQp;xZNPK~Hf3PE8QciJ`+&GvBB1_5V186!VN~EO+|lmri|*RZp%yniF&01EBZ{Xd-q*?^*I!ct?>+=r(^vhEnpSQf3kg<$~)Bj J3dI=k`ZsG(n@j)z literal 0 HcmV?d00001 diff --git a/target/classes/dev/lions/user/manager/validation/ValidationConstants.class b/target/classes/dev/lions/user/manager/validation/ValidationConstants.class new file mode 100644 index 0000000000000000000000000000000000000000..9567cd26838263994bb6fb3d278f960d46cf15e2 GIT binary patch literal 2864 zcmb`JU2_vv7{{N}78+`KX(><;anV9wleC2j2w2u;(?;_~UJBBr@iaMYx3k%e`@%Q^ zGkzSobjBHHywHo>dF99O19U;q5+XCit?2g5YL zXr&>Z$1T&by?EdWH{Rqn-^2Aex6B6jVTf<`Z`a`FbKCcZX^7Fe1OA-HEpG3{b2|s3 z?lU@HE*gcbo-t~fRJN8jvg@S{Ml8kXbnjX07KlMaFnGjWf7*4IrUo|e@08a|C2Y!Q zJRQEU=)0!9cRxaB7>#Xj@#r^t^x0zcUaS_a&QCF#JpOnsV-$<}x)Gr~YHFT6q$7mn-_W^jqo zrKICFxsMD)lbe=i+MR|8MrV(eU)B?S?k@Ms%xJXZ*bnhNMiadd+uugpzf`>G!&*+L zj$srUqxEhb|G9F)Yw@})A#XXJ?>eo0)D=}btRD)N-^gW+uwWm`Xe#roTj*)Ui$$w1 z?k+4Zc8YSuGYsb@qiemQ2+eQ5w%V^-`wl`2YjZxY7mH7Fg@htcS)T}`7@CwCo$Igm z>$Jcqu|2c;Fg7QP&h5EX;l}2~z(bV-DbE`M2vs*C2wbJOVAQzd*e&9O*_P%h7TpH zJga%F_UpRIEmXdcOB=OgIy$%(fIakM8Qx zB;@@ns^aap!KGy>rwR29VLm!6-MNqs$~2rQ7>~=Tf{~~tQ${)wp#(I!CZG`BY-z&t zHD|{%_qgxikYjWvmEF|SNFtdlWb{&m)^VzIcMeDFR4JFM6*qDPIDCdP8^^soTjj{( zU=3U!J4K{VI+tCKQ0AD6<=A@xT*eYcQZJ`VsMxwuE2f?qa!zrKp3Xpe{YA<6(DYe4 zF-8}qQ^F{&6;k<9D%blG!OH%?3#D}}m&q8}Quxss{2kd#i%}@#3cdP;_Tk^~WGY|N z6Nv&oC1ESK7?rnYW|mjbzm@9CWn6AoWiP8Qw-%SGog?g!S7$4+*%!B7{X1W@^vav> z>jf5}ZAMpn2i`PqVES=Lr1DCGPd+eh(}&asXJ$7U4Xrs1F+zh>AEg?7iSDIMTV#Xg zj&MtS$3of1(@vdRo7^=ecNd5JeG}ibJL&)QR{`@hQbgnHB5BH3O#aQ^iJ1Jb(-I+4 zG;oS8(+N5W8U_te1bj;25%4=S+P9wupH=uAcwFK0;0p?01WzjaT?SuKSnmI>;(rx< zP2u;!*A@N%Jf-jr@U*hu40u*yx&NHvKM#&790M;Z{xZHLh2`_hivKO}iozd(?8k|+)&4Kd@%lIEFTmTmpE`iGmZ-SpF z{1p6!^1f%_io#VWV?Zh#R}KZ;!j<8AV(v%U`Mx8m27X82L=e^x#3XPh1qCPCr9E63 K?c;ZV%)bB{2$-G# literal 0 HcmV?d00001 diff --git a/target/lions-user-manager-server-api-1.0.0.jar b/target/lions-user-manager-server-api-1.0.0.jar new file mode 100644 index 0000000000000000000000000000000000000000..4cf8046efcdbdbd3bfe80c2ffeb34667f4ac6fcd GIT binary patch literal 80459 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 literal 0 HcmV?d00001 diff --git a/target/maven-archiver/pom.properties b/target/maven-archiver/pom.properties new file mode 100644 index 0000000..c5e85dd --- /dev/null +++ b/target/maven-archiver/pom.properties @@ -0,0 +1,3 @@ +artifactId=lions-user-manager-server-api +groupId=dev.lions.user.manager +version=1.0.0 diff --git a/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst b/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst new file mode 100644 index 0000000..dabebf0 --- /dev/null +++ b/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst @@ -0,0 +1,31 @@ +dev\lions\user\manager\dto\role\RoleDTO$RoleDTOBuilder.class +dev\lions\user\manager\dto\audit\AuditLogDTO.class +dev\lions\user\manager\dto\user\UserSearchCriteriaDTO$UserSearchCriteriaDTOBuilder.class +dev\lions\user\manager\dto\audit\AuditLogDTO$AuditLogDTOBuilder.class +dev\lions\user\manager\dto\role\RoleAssignmentDTO.class +dev\lions\user\manager\dto\base\BaseDTO$BaseDTOBuilder.class +dev\lions\user\manager\enums\role\TypeRole.class +dev\lions\user\manager\dto\base\BaseDTO.class +dev\lions\user\manager\dto\user\UserSearchResultDTO.class +dev\lions\user\manager\enums\user\StatutUser.class +dev\lions\user\manager\dto\role\RoleAssignmentDTO$RoleAssignmentDTOBuilder.class +dev\lions\user\manager\dto\role\RoleDTO$RoleDTOBuilderImpl.class +dev\lions\user\manager\service\SyncService.class +dev\lions\user\manager\service\UserService.class +dev\lions\user\manager\service\AuditService.class +dev\lions\user\manager\dto\role\RoleDTO$RoleCompositeDTO.class +dev\lions\user\manager\dto\user\UserDTO$FederatedIdentityDTO.class +dev\lions\user\manager\dto\user\UserDTO$FederatedIdentityDTO$FederatedIdentityDTOBuilderImpl.class +dev\lions\user\manager\dto\user\UserSearchResultDTO$UserSearchResultDTOBuilder.class +dev\lions\user\manager\dto\role\RoleDTO.class +dev\lions\user\manager\dto\user\UserDTO$FederatedIdentityDTO$FederatedIdentityDTOBuilder.class +dev\lions\user\manager\dto\role\RoleDTO$RoleCompositeDTO$RoleCompositeDTOBuilder.class +dev\lions\user\manager\dto\user\UserDTO$UserDTOBuilder.class +dev\lions\user\manager\dto\user\UserDTO$UserDTOBuilderImpl.class +dev\lions\user\manager\dto\user\UserSearchCriteriaDTO.class +dev\lions\user\manager\enums\audit\TypeActionAudit.class +dev\lions\user\manager\dto\role\RoleDTO$RoleCompositeDTO$RoleCompositeDTOBuilderImpl.class +dev\lions\user\manager\dto\user\UserDTO.class +dev\lions\user\manager\validation\ValidationConstants.class +dev\lions\user\manager\service\RoleService.class +dev\lions\user\manager\dto\audit\AuditLogDTO$AuditLogDTOBuilderImpl.class diff --git a/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst b/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst new file mode 100644 index 0000000..4078820 --- /dev/null +++ b/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst @@ -0,0 +1,15 @@ +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\service\RoleService.java +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\enums\role\TypeRole.java +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\enums\user\StatutUser.java +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\dto\user\UserSearchCriteriaDTO.java +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\dto\audit\AuditLogDTO.java +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\service\AuditService.java +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\dto\base\BaseDTO.java +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\service\SyncService.java +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\validation\ValidationConstants.java +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\dto\role\RoleAssignmentDTO.java +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\dto\user\UserSearchResultDTO.java +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\enums\audit\TypeActionAudit.java +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\dto\user\UserDTO.java +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\dto\role\RoleDTO.java +C:\Users\dadyo\PersonalProjects\lions-workspace\lions-user-manager\lions-user-manager-server-api\src\main\java\dev\lions\user\manager\service\UserService.java