Merge pull request 'feat/service-base' (#15) from feat/service-base into dev

Reviewed-on: http://192.168.1.94:3000/Yoann/ldap-cesi/pulls/15

ldap-cesi/Configurations/Conf.cs

@@ -1,6 +1,8 @@
 using System.Reflection;
 using System.Security.Cryptography;
 using System.Text;
+using FluentValidation;
+using FluentValidation.AspNetCore;
 using ldap_cesi.Context;
 using ldap_cesi.Repository;
 using ldap_cesi.Repository.Services;
@@ -42,12 +44,14 @@ public static class Conf
     public static void AddServices(this WebApplicationBuilder builder)
     {
         builder.Services.AddScoped<IServiceService, ServiceService >();
-        // builder.Services.AddScoped<IRoleService, RoleService>();
+        builder.Services.AddScoped<IRoleService, RoleService>();
         builder.Services.AddScoped<ISiteService, SiteService>();
         builder.Services.AddScoped<ISalarieService, SalarieService>();
         builder.Services.AddScoped<IUtilisateurService, UtilisateurService>();
         builder.Services.AddScoped<IJwtService, JwtService>();
         builder.Services.AddSingleton<IRsaKeyService, RsaKeyService>();
+        builder.Services.AddValidatorsFromAssemblyContaining<Program>();
+        builder.Services.AddFluentValidationAutoValidation();
     }    
     public static void AddEFCoreConfiguration(this WebApplicationBuilder builder)
     {

ldap-cesi/Controllers/RoleController.cs

@@ -0,0 +1,88 @@
+using Microsoft.AspNetCore.Mvc;
+using ldap_cesi.DTOs.Inputs.Role;
+using ldap_cesi.Services.Interfaces;
+using Microsoft.AspNetCore.Authorization;
+
+namespace ldap_cesi.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class RoleController : ControllerBase
+    {
+        private readonly IRoleService _roleService;
+
+        public RoleController(IRoleService roleService)
+        {
+            _roleService = roleService;
+        }
+
+        // GET: api/Role
+        /// <summary>
+        /// Endpoint qui retourne tous les rôles
+        /// </summary>
+        /// <returns>Un tableau de rôle</returns>
+        [HttpGet]
+        [Authorize(Roles = "admin")]
+        public async Task<IActionResult> GetAllRoles()
+        {
+            var result = await _roleService.GetAll();
+            return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+        }
+
+        // GET: api/Role/{id}
+        /// <summary>
+        /// Endpoint qui retourne le role
+        /// </summary>
+        /// <param name="id">L'id du rôle.</param>
+        /// <returns>Le role update</returns>
+        [HttpGet("{id}")]
+        [Authorize(Roles = "admin")]
+        public async Task<IActionResult> GetRoleById(int id)
+        {
+            var result = await _roleService.GetById(id);
+            return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+        }
+
+        // POST: api/Role
+        /// <summary>
+        /// Endpoint créer le Role
+        /// </summary>
+        /// <param name="CreateRoleInput">Le nom du rôle.</param>
+        /// <returns>Response.</returns>
+        [HttpPost]
+        [Authorize(Roles = "admin")]
+        public async Task<IActionResult> CreateRole([FromBody] RoleCreateDto roleDto)
+        {
+            var result = await _roleService.Create(roleDto);
+            return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+        }
+
+        // PUT: api/Role
+        /// <summary>
+        /// Endpoint qui met à jour un role.
+        /// </summary>
+        /// <param name="roleUpdateDto">Les informations du role à mettre à jour. Id, nom</param>
+        /// <returns>Le role mis à jour.</returns>
+        [HttpPut]
+        [Authorize(Roles = "admin")]
+        public async Task<IActionResult> UpdateRole([FromBody] RoleUpdateDto roleDto)
+        {
+            var result = await _roleService.Update(roleDto);
+            return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+        }
+
+        // DELETE: api/Role/{id}
+        /// <summary>
+        /// Endpoint qui supprime un rôle.
+        /// </summary>
+        /// <param name="id">L'ID du rôle à supprimer.</param>
+        /// <returns>Un message de confirmation de suppression.</returns>
+        [HttpDelete("{id}")]
+        [Authorize(Roles = "admin")]
+        public async Task<IActionResult> DeleteRole(int id)
+        {
+            var result = await _roleService.Delete(id);
+            return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+        }
+    }
+}

ldap-cesi/Controllers/SalarieController.cs

@@ -16,7 +16,7 @@ public class SalarieController : ControllerBase
         _salarieService = salarieService;
     }
     
-     /// <summary>
+    /// <summary>
     /// Endpoint qui retourne tous les salariés.
     /// </summary>
     /// <returns>Une liste de salariés.</returns>
@@ -25,6 +25,17 @@ public class SalarieController : ControllerBase
     {
         var result = await _salarieService.GetAll();
         return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+    }     
+     
+    /// <summary>
+    /// Endpoint qui retourne tous les salariés.
+    /// </summary>
+    /// <returns>Une liste de salariés.</returns>
+    [HttpGet("/complete")]
+    public async Task<IActionResult> GetAllSalariesComplet()
+    {
+        var result = await _salarieService.GetAllWithoutIService();
+        return result.Success ? Ok(result.Data) : BadRequest(result.Message);
     }
 
     /// <summary>
@@ -33,7 +44,7 @@ public class SalarieController : ControllerBase
     /// <param name="id">L'ID du salarié.</param>
     /// <returns>Le salarié correspondant à l'ID.</returns>
     [HttpGet("{id}")]
-    public async Task<IActionResult> GetSalarieById(int id)
+    public async Task<IActionResult> GetById(int id)
     {
         var result = await _salarieService.GetById(id);
         return result.Success ? Ok(result.Data) : BadRequest(result.Message);
@@ -49,6 +60,17 @@ public class SalarieController : ControllerBase
     {
         var result = await _salarieService.GetCompletById(id);
         return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+    }    
+    
+    /// <summary>
+    /// Endpoint qui retourne tout les salariés et les relations qu'il détient
+    /// </summary>
+    /// <returns>Tous les salariés avec leurs relations</returns>
+    [HttpGet("all")]
+    public async Task<IActionResult> GetAllSariesWithRelations()
+    {
+        var result = await _salarieService.GetAllWithRelationsAsync(s => s.IdServiceNavigation, s => s.IdSiteNavigation);
+        return result.Success ? Ok(result.Data) : BadRequest(result.Message);
     }
 
     /// <summary>

ldap-cesi/Controllers/ServicesController.cs

@@ -21,7 +21,6 @@ public class ServicesController : ControllerBase
     /// </summary>
     /// <returns>Retourne tous les services.</returns>
     [HttpGet]
-    [Authorize(Roles = "admin")]
     public async Task<IActionResult> GetServices()
     {
         var result = await _serviceService.GetAll();
@@ -34,7 +33,6 @@ public class ServicesController : ControllerBase
     /// <param name="id">L'ID du service.</param>
     /// <returns>Le service correspondant à l'ID.</returns>
     [HttpGet("{id}")]
-    [Authorize(Roles = "admin")]
     public async Task<IActionResult> GetServiceById(int id)
     {
         var result = await _serviceService.GetById(id);
@@ -50,7 +48,7 @@ public class ServicesController : ControllerBase
     [Authorize(Roles = "admin")]
     public async Task<IActionResult> CreateService([FromBody] ServiceCreateDto serviceInputDto)
     {
-        var result = await _serviceService.CreateService(serviceInputDto);
+        var result = await _serviceService.Create(serviceInputDto);
         return result.Success ? Ok(result.Data) : BadRequest(result.Message);
     }
 
@@ -63,7 +61,7 @@ public class ServicesController : ControllerBase
     [Authorize(Roles = "admin")]
     public async Task<IActionResult> UpdateService([FromBody] ServiceUpdateDto serviceUpdateDto)
     {
-        var result = await _serviceService.UpdateService(serviceUpdateDto);
+        var result = await _serviceService.Update(serviceUpdateDto);
         return result.Success ? Ok(result.Data) : BadRequest(result.Message);
     }
 
@@ -76,7 +74,7 @@ public class ServicesController : ControllerBase
     [Authorize(Roles = "admin")]
     public async Task<IActionResult> DeleteService(int id)
     {
-        var result = await _serviceService.DeleteService(id);
+        var result = await _serviceService.Delete(id);
         return result.Success ? Ok(result.Message) : BadRequest(result.Message);
     }
 }

ldap-cesi/DTOs/Generic/RoleDto.cs

@@ -0,0 +1,8 @@
+namespace ldap_cesi.DTOs;
+
+public class RoleDto
+{
+    public int Id { get; set; }
+
+    public string Nom { get; set; }
+}

ldap-cesi/DTOs/Generic/SalarieDto.cs

@@ -0,0 +1,19 @@
+namespace ldap_cesi.DTOs;
+
+public class SalarieDto
+{
+    public int Id { get; set; }
+
+    public string Nom { get; set; } = null!;
+
+    public string Prenom { get; set; } = null!;
+
+    public string TelephoneFixe { get; set; } = null!;
+
+    public string TelephonePortable { get; set; } = null!;
+
+    public string Email { get; set; } = null!;
+    
+    public ServiceDto Service { get; set; }
+    public SiteDto Site { get; set; }
+}

ldap-cesi/DTOs/Inputs/Role/RoleCreateDto.cs

@@ -0,0 +1,7 @@
+
+namespace ldap_cesi.DTOs.Inputs.Role;
+
+public class RoleCreateDto
+{
+    public string Nom { get; set; }
+}

ldap-cesi/DTOs/Inputs/Role/RoleUpdateDto.cs

@@ -0,0 +1,7 @@
+namespace ldap_cesi.DTOs.Inputs.Role;
+
+public class RoleUpdateDto
+{
+    public int Id { get; set; }
+    public string Nom { get; set; }
+}

ldap-cesi/Mapper/AutoMapperProfile.cs

@@ -1,5 +1,6 @@
 using AutoMapper;
 using ldap_cesi.DTOs;
+using ldap_cesi.DTOs.Inputs.Role;
 using ldap_cesi.DTOs.Inputs.Salarie;
 using ldap_cesi.DTOs.Inputs.Service;
 using ldap_cesi.DTOs.Inputs.Site;
@@ -17,6 +18,7 @@ public class AutoMapperProfile : Profile
         CreateMap<ServiceCreateDto, Service>();
         CreateMap<ServiceUpdateDto, Service>();
         CreateMap<SiteCreateDto, Site>();
+        CreateMap<RoleCreateDto, Role>();
         CreateMap<SiteUpdateDto, Site>();
         CreateMap<SalarieCreateDto, Salarie>()
             .ForMember(dest => dest.TelephoneFixe, opt => opt.MapFrom(src => src.TelephoneFix))
@@ -29,14 +31,14 @@ public class AutoMapperProfile : Profile
         //OUTPUTS MAPPER
         CreateMap<Utilisateur, UtilisateurOutputDto>()
             .ForMember(dest => dest.RoleNom, opt => opt.MapFrom(src => src.IdRoleNavigation.Nom));
-        CreateMap<Salarie, SalarieOutputDetail>()
+        CreateMap<Salarie, SalarieDto>()
             .ForMember(dest => dest.Service, opt => opt.MapFrom(src => src.IdServiceNavigation))
             .ForMember(dest => dest.Site, opt => opt.MapFrom(src => src.IdSiteNavigation));
+        CreateMap<Service, ServiceDto>();
+        CreateMap<Site, SiteDto>();
+        CreateMap<Salarie, SalarieListDto>();
         CreateMap<Salarie, SalarieListDto>()
             .ForMember(dest => dest.Service, opt => opt.MapFrom(src => src.IdServiceNavigation.Nom))
             .ForMember(dest => dest.Site, opt => opt.MapFrom(src => src.IdSiteNavigation.Ville));
-        CreateMap<Salarie, SalarieListDto>();
-        CreateMap<Service, ServiceDto>();
-        CreateMap<Site, SiteDto>();
     }
 }

ldap-cesi/Repositories/Interfaces/IRepositoryBase.cs

@@ -10,6 +10,8 @@ public interface IRepositoryBase<TEntity> where TEntity : class
     Task<List<TEntity>> GetAllAsync(CancellationToken cancellationToken = default);
     Task<bool> UpdateAsync(TEntity entity, CancellationToken cancellationToken = default);
     Task<bool> DeleteAsync(TEntity entity, CancellationToken cancellationToken = default);
+    Task<TEntity> GetWithRelationsAsync(int id, params Expression<Func<TEntity, object>>[] relationsAInclude);
+    Task<List<TEntity>> GetAllWithRelationsAsync(params Expression<Func<TEntity, object>>[] relationsAInclude);
     Task<TEntity?> FirstOrDefaultAsync(Expression<Func<TEntity, bool>> predicate,
         CancellationToken cancellationToken = default);
 }

ldap-cesi/Repositories/RepositoryBase.cs

@@ -9,10 +9,11 @@ namespace ldap_cesi.Repository;
 public class RepositoryBase<TEntity> : IRepositoryBase<TEntity> where TEntity : class
 {
     protected readonly PgContext _context;
-
+    protected readonly DbSet<TEntity> _dbSet;
     public RepositoryBase(PgContext context)
     {
         _context = context ?? throw new ArgumentNullException(nameof(context));
+        _dbSet = context.Set<TEntity>();
     }
       public virtual async Task<TEntity> AddAsync(TEntity entity, CancellationToken cancellationToken = default)
         {
@@ -113,5 +114,28 @@ public class RepositoryBase<TEntity> : IRepositoryBase<TEntity> where TEntity :
                 throw new Exception("Erreur qui concerne le listing des entités", ex);
             }
         }
+        public virtual async Task<List<TEntity>> GetAllWithRelationsAsync(params Expression<Func<TEntity, object>>[] relationInclues)
+        {
+            IQueryable<TEntity> query = _dbSet;
+
+            foreach (var relationInclue in relationInclues)
+            {
+                query = query.Include(relationInclue);
+            }
+
+            return await query.ToListAsync();
+        }
+
+        public virtual async Task<TEntity> GetWithRelationsAsync(int id, params Expression<Func<TEntity, object>>[] relationInclues)
+        {
+            IQueryable<TEntity> query = _dbSet;
+
+            foreach (var relationInclue in relationInclues)
+            {
+                query = query.Include(relationInclue);
+            }
+
+            return await query.FirstOrDefaultAsync(e => EF.Property<int>(e, "Id") == id);
+        }
     
 }

ldap-cesi/Services/Interfaces/IRoleService.cs

@@ -1,6 +1,10 @@
-namespace ldap_cesi.Services.Interfaces;
+using ldap_cesi.Entities;
+using ldap_cesi.DTOs;
+using ldap_cesi.DTOs.Inputs.Role;
 
-public interface IRoleService
+namespace ldap_cesi.Services.Interfaces
 {
-    
+    public interface IRoleService : IServiceBase<Role, RoleDto, RoleCreateDto, RoleUpdateDto>
+    {
+    }
 }

ldap-cesi/Services/Interfaces/ISalarieService.cs

@@ -1,3 +1,4 @@
+using ldap_cesi.DTOs;
 using ldap_cesi.DTOs.Inputs.Salarie;
 using ldap_cesi.DTOs.Inputs.Service;
 using ldap_cesi.DTOs.Outputs.Salarie;
@@ -6,14 +7,10 @@ using ldap_cesi.Models;
 
 namespace ldap_cesi.Services.Interfaces;
 
-public interface ISalarieService
+public interface ISalarieService : IServiceBase<Salarie, SalarieDto, SalarieCreateDto, SalarieUpdateDto>
 {
-    Task<IResponseDataModel<List<Salarie>>> GetAll();
+    Task<IResponseDataModel<List<Salarie>>> GetAllWithoutIService();
-    Task<IResponseDataModel<Salarie>> GetById(int id);
     Task<IResponseDataModel<List<SalarieListDto>>> GetSalariesBySite(int siteId);
     Task<IResponseDataModel<List<SalarieListDto>>> GetSalariesByService(int serviceId);
-    Task<IResponseDataModel<string>> Create(SalarieCreateDto salarieInput);
+    Task<IResponseDataModel<SalarieDto>> GetCompletById(int id);
-    Task<IResponseDataModel<Salarie>> Update(SalarieUpdateDto salarieInput);
-    Task<IResponseDataModel<string>> Delete(int id);
-    Task<IResponseDataModel<SalarieOutputDetail>> GetCompletById(int id);
 }

ldap-cesi/Services/Interfaces/IServiceBase.cs

@@ -0,0 +1,19 @@
+using System.Linq.Expressions;
+using ldap_cesi.Models;
+
+namespace ldap_cesi.Services.Interfaces;
+
+public interface IServiceBase<T, TDto, TCreateDto, TUpdateDto>
+    where T : class
+    where TDto : class
+    where TCreateDto : class
+    where TUpdateDto : class
+{
+    Task<IResponseDataModel<List<T>>> GetAll();
+    Task<IResponseDataModel<T>> GetById(int id);
+    Task<IResponseDataModel<TDto>> GetByIdWithRelations(int id, params Expression<Func<T, object>>[] relationsAInclures); // préciser avec une ou des fonctions lambda les relations à inclure dans la réponse
+    Task<IResponseDataModel<List<TDto>>> GetAllWithRelationsAsync(params Expression<Func<T, object>>[] relationsAInclure);
+    Task<IResponseDataModel<T>> Create(TCreateDto dto);
+    Task<IResponseDataModel<T>> Update(TUpdateDto dto);
+    Task<IResponseDataModel<string>> Delete(int id);
+}

ldap-cesi/Services/Interfaces/IServiceService.cs

@@ -1,14 +1,11 @@
 using ldap_cesi.DTOs.Inputs.Service;
+using ldap_cesi.DTOs;
 using ldap_cesi.Entities;
 using ldap_cesi.Models;
 
-namespace ldap_cesi.Services.Interfaces;
+namespace ldap_cesi.Services.Interfaces
-
-public interface IServiceService
 {
-    Task<IResponseDataModel<List<Service>>> GetAll();
+    public interface IServiceService : IServiceBase<Service, ServiceDto, ServiceCreateDto, ServiceUpdateDto>
-    Task<IResponseDataModel<Service>> GetById(int id);
+    {
-    Task<IResponseDataModel<string>> CreateService(ServiceCreateDto serviceCreateDto);
+    }
-    Task<IResponseDataModel<Service>> UpdateService(ServiceUpdateDto serviceUpdateDto);
+}
-    Task<IResponseDataModel<string>> DeleteService(int id);
-}

ldap-cesi/Services/JwtService.cs

@@ -60,7 +60,7 @@ public class JwtService : IJwtService
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "An error occurred while generating the JWT token.");
+            _logger.LogError(ex, "Une erreur s'est produitel lors de la génération du token.");
             throw;
         }
     }
@@ -74,7 +74,7 @@ public class JwtService : IJwtService
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "An error occurred while retrieving the public key.");
+            _logger.LogError(ex, "Une erreur s'est produite pendant la récupération de la clé.");
             throw;
         }
     }
@@ -100,14 +100,14 @@ public class JwtService : IJwtService
             var nameIdClaim = principal.FindFirst(ClaimTypes.NameIdentifier);
             if (nameIdClaim == null || !int.TryParse(nameIdClaim.Value, out var tokenUserId) || tokenUserId != userId)
             {
-                _logger.LogWarning("Token validation failed: Invalid user ID.");
+                _logger.LogWarning("Erreur de validation : Id utilisateur invalide.");
                 return false;
             }
 
             var utilisateur = await _context.Utilisateurs.FindAsync(userId);
             if (utilisateur == null)
             {
-                _logger.LogWarning("Token validation failed: User not found.");
+                _logger.LogWarning("Erreur de validation : Utilisateur non trouvé.");
                 return false;
             }
 
@@ -119,7 +119,7 @@ public class JwtService : IJwtService
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "An error occurred while validating the JWT token.");
+            _logger.LogError(ex, "Une erreur s'est produite lors pendant la validation du token JWT.");
             return false;
         }
     }

ldap-cesi/Services/RoleService.cs

@@ -1,15 +1,17 @@
 using ldap_cesi.Repository.Services;
 using ldap_cesi.Services.Interfaces;
+using ldap_cesi.Entities;
+using ldap_cesi.DTOs;
+using ldap_cesi.DTOs.Inputs.Role;
+using AutoMapper;
+using ldap_cesi.Validator.Role;
 
 namespace ldap_cesi.Services;
 
-public class RoleService : IRoleService
+public class RoleService : ServiceBase<Role, RoleDto, RoleCreateDto, RoleUpdateDto>,IRoleService
 {
-    private IRepositoryRole _repositoryRole;
+    public RoleService(IRepositoryRole repositoryRole, IMapper mapper, ILogger<RoleService> logger, RoleCreateValidator roleCreateValidator, RoleUpdateValidator roleUpdateValidator)
-
+        : base(repositoryRole, mapper, logger, roleCreateValidator, roleUpdateValidator)
-    public RoleService(IRepositoryRole repositoryRole)
     {
-        _repositoryRole = repositoryRole;
     }
-    
 }

ldap-cesi/Services/SalarieService.cs

@@ -1,4 +1,5 @@
 using AutoMapper;
+using ldap_cesi.DTOs;
 using ldap_cesi.DTOs.Inputs.Salarie;
 using ldap_cesi.DTOs.Inputs.Service;
 using ldap_cesi.DTOs.Outputs.Salarie;
@@ -10,14 +11,16 @@ using ldap_cesi.Validator.Salarie;
 
 namespace ldap_cesi.Services;
 
-public class SalarieService : ISalarieService
+public class SalarieService : ServiceBase<Salarie, SalarieDto, SalarieCreateDto, SalarieUpdateDto>, ISalarieService
 {
     private IRepositorySalarie _repositorySalarie;
     private readonly IRepositorySite _repositorySite;
     private readonly IRepositoryService _repositoryService;
     private readonly IMapper _mapper;
 
-    public SalarieService(IRepositorySalarie repositorySalarie, IMapper mapper, IRepositorySite repositorySite, IRepositoryService repositoryService)
+    public SalarieService(IRepositorySalarie repositorySalarie, IMapper mapper, IRepositorySite repositorySite, IRepositoryService repositoryService, 
+                        ILogger<SalarieService> logger, SalarieCreateValidator salarieCreateValidator, SalarieUpdateValidator salarieUpdateValidator) 
+        : base(repositorySalarie, mapper, logger, salarieCreateValidator, salarieUpdateValidator)
     {
         _repositorySalarie = repositorySalarie;
         _repositorySite = repositorySite;
@@ -25,7 +28,7 @@ public class SalarieService : ISalarieService
         _mapper = mapper;
     }
     
-    public async Task<IResponseDataModel<List<Salarie>>> GetAll()
+    public async Task<IResponseDataModel<List<Salarie>>> GetAllWithoutIService()
     {
         var salaries = await _repositorySalarie.GetAllAsync();
         return new ResponseDataModel<List<Salarie>>
@@ -36,22 +39,22 @@ public class SalarieService : ISalarieService
         };
     }    
     
-    public async Task<IResponseDataModel<Salarie>> GetById(int id)
+    // public async Task<IResponseDataModel<Salarie>> GetById(int id)
-    {
+    // {
-        var salarie = await _repositorySalarie.GetSalarieWithRelationsAsync(id);
+    //     var salarie = await _repositorySalarie.GetSalarieWithRelationsAsync(id);
-        return new ResponseDataModel<Salarie>
+    //     return new ResponseDataModel<Salarie>
-        {
+    //     {
-            Success = true,
+    //         Success = true,
-            Data = salarie,
+    //         Data = salarie,
-            StatusCode = 200,
+    //         StatusCode = 200,
-        };
+    //     };
-    }    
+    // }    
     
-    public async Task<IResponseDataModel<SalarieOutputDetail>> GetCompletById(int id)
+    public async Task<IResponseDataModel<SalarieDto>> GetCompletById(int id)
     {
         var salarie = await _repositorySalarie.GetSalarieWithRelationsAsync(id);
-        var salarieOutput = _mapper.Map<SalarieOutputDetail>(salarie);
+        var salarieOutput = _mapper.Map<SalarieDto>(salarie);
-        return new ResponseDataModel<SalarieOutputDetail>
+        return new ResponseDataModel<SalarieDto>
         {
             Success = true,
             Data = salarieOutput,
@@ -131,109 +134,109 @@ public class SalarieService : ISalarieService
         };
     }
 
-    public async Task<IResponseDataModel<string>> Create(SalarieCreateDto salarieInput)
+    // public async Task<IResponseDataModel<string>> Create(SalarieCreateDto salarieInput)
-    {
+    // {
-        var validation = new SalarieCreateValidator();
+    //     var validation = new SalarieCreateValidator();
-        var result = validation.Validate(salarieInput);
+    //     var result = validation.Validate(salarieInput);
-        if (!result.IsValid)
+    //     if (!result.IsValid)
-        {
+    //     {
-            return new ResponseDataModel<string>
+    //         return new ResponseDataModel<string>
-            {
+    //         {
-                StatusCode = 400,
+    //             StatusCode = 400,
-                Success = false,
+    //             Success = false,
-                Message = "Données salariées invalides: " + string.Join(", ", result.Errors)
+    //             Message = "Données salariées invalides: " + string.Join(", ", result.Errors)
-            };
+    //         };
-        }
+    //     }
-        var service = _mapper.Map<Salarie>(salarieInput);
+    //     var service = _mapper.Map<Salarie>(salarieInput);
-        var response = await _repositorySalarie.AddAsync(service);
+    //     var response = await _repositorySalarie.AddAsync(service);
-        return new ResponseDataModel<string>
+    //     return new ResponseDataModel<string>
-        {
+    //     {
-            StatusCode = 201,
+    //         StatusCode = 201,
-            Success = true,
+    //         Success = true,
-            Data = response.Id.ToString(),
+    //         Data = response.Id.ToString(),
-        };
+    //     };
-    }
+    // }
 
-    public async Task<IResponseDataModel<Salarie>> Update(SalarieUpdateDto salarieInput)
+    // public async Task<IResponseDataModel<Salarie>> Update(SalarieUpdateDto salarieInput)
-    {
+    // {
-        var validation = new SalarieUpdateValidator();
+    //     var validation = new SalarieUpdateValidator();
-        var result = validation.Validate(salarieInput);
+    //     var result = validation.Validate(salarieInput);
-        if (!result.IsValid)
+    //     if (!result.IsValid)
-        {
+    //     {
-            return new ResponseDataModel<Salarie>
+    //         return new ResponseDataModel<Salarie>
-            {
+    //         {
-                StatusCode = 400,
+    //             StatusCode = 400,
-                Success = false,
+    //             Success = false,
-                Message = "Données salariées invalides: " + string.Join(", ", result.Errors)
+    //             Message = "Données salariées invalides: " + string.Join(", ", result.Errors)
-            };
+    //         };
-        }
+    //     }
 
-        var salarieFind = await _repositorySalarie.GetByIdAsync(salarieInput.Id);
+    //     var salarieFind = await _repositorySalarie.GetByIdAsync(salarieInput.Id);
-        if (salarieFind == null)
+    //     if (salarieFind == null)
-        {
+    //     {
-            return new ResponseDataModel<Salarie>
+    //         return new ResponseDataModel<Salarie>
-            {
+    //         {
-                Success = false,
+    //             Success = false,
-                Message = "Salarié introuvable.",
+    //             Message = "Salarié introuvable.",
-                StatusCode = 404
+    //             StatusCode = 404
-            };
+    //         };
-        }
+    //     }
 
-        var salarie = _mapper.Map(salarieInput, salarieFind);
+    //     var salarie = _mapper.Map(salarieInput, salarieFind);
-        var response = await _repositorySalarie.UpdateAsync(salarie);
+    //     var response = await _repositorySalarie.UpdateAsync(salarie);
-        if (!response)
+    //     if (!response)
-        {
+    //     {
-            return new ResponseDataModel<Salarie>
+    //         return new ResponseDataModel<Salarie>
-            {
+    //         {
-                StatusCode = 500,
+    //             StatusCode = 500,
-                Success = false,
+    //             Success = false,
-                Message = "Erreur lors de la mise à jour du salarié : " + string.Join(", ", result.Errors)
+    //             Message = "Erreur lors de la mise à jour du salarié : " + string.Join(", ", result.Errors)
-            };
+    //         };
-        }
+    //     }
-        return new ResponseDataModel<Salarie>
+    //     return new ResponseDataModel<Salarie>
-        {
+    //     {
-            StatusCode = 200,
+    //         StatusCode = 200,
-            Success = true,
+    //         Success = true,
-            Data = salarie,
+    //         Data = salarie,
-        };
+    //     };
-    }
+    // }
 
-    public async Task<IResponseDataModel<string>> Delete(int id)
+    // public async Task<IResponseDataModel<string>> Delete(int id)
-    {
+    // {
-        if (id == null)
+    //     if (id == null)
-        {
+    //     {
-            return new ResponseDataModel<string>
+    //         return new ResponseDataModel<string>
-            {
+    //         {
-                StatusCode = 400,
+    //             StatusCode = 400,
-                Success = false,
+    //             Success = false,
-                Message = "Id manquant"
+    //             Message = "Id manquant"
-            };
+    //         };
-        }
+    //     }
-        var salarie = await _repositorySalarie.GetByIdAsync(id);
+    //     var salarie = await _repositorySalarie.GetByIdAsync(id);
-        if (salarie == null)
+    //     if (salarie == null)
-        {
+    //     {
-            return new ResponseDataModel<string>
+    //         return new ResponseDataModel<string>
-            {
+    //         {
-                Success = false,
+    //             Success = false,
-                Message = "Salarié introuvable.",
+    //             Message = "Salarié introuvable.",
-                StatusCode = 404
+    //             StatusCode = 404
-            };
+    //         };
-        }
+    //     }
-        var response = await _repositorySalarie.DeleteAsync(salarie);
+    //     var response = await _repositorySalarie.DeleteAsync(salarie);
-        if (!response)
+    //     if (!response)
-        {
+    //     {
-            return new ResponseDataModel<string>
+    //         return new ResponseDataModel<string>
-            {
+    //         {
-                StatusCode = 500,
+    //             StatusCode = 500,
-                Success = false,
+    //             Success = false,
-                Message = "Erreur durant la suppression du service"
+    //             Message = "Erreur durant la suppression du service"
-            };
+    //         };
-        }
+    //     }
-        return new ResponseDataModel<string>
+    //     return new ResponseDataModel<string>
-        {
+    //     {
-            StatusCode = 200,
+    //         StatusCode = 200,
-            Success = true,
+    //         Success = true,
-            Data = salarie.Id.ToString(),
+    //         Data = salarie.Id.ToString(),
-        };
+    //     };
-    }
+    // }
 }

ldap-cesi/Services/ServiceBase.cs

@@ -0,0 +1,266 @@
+using AutoMapper;
+using ldap_cesi.DTOs.Inputs.Site;
+using ldap_cesi.Entities;
+using ldap_cesi.Models;
+using ldap_cesi.Repository.Services;
+using ldap_cesi.Services.Interfaces;
+using ldap_cesi.Validator.Site;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+using FluentValidation;
+
+namespace ldap_cesi.Services;
+
+public class ServiceBase<T, TDto, TCreateDto, TUpdateDto> : IServiceBase<T, TDto, TCreateDto, TUpdateDto>
+    where T : class
+    where TDto : class
+    where TCreateDto : class
+    where TUpdateDto : class
+{
+    protected readonly IRepositoryBase<T> _repository;
+    protected readonly IMapper _mapper;
+    protected readonly ILogger<ServiceBase<T, TDto, TCreateDto, TUpdateDto>> _logger;
+    protected readonly IValidator<TCreateDto> _createDtoValidator;
+    protected readonly IValidator<TUpdateDto> _updateDtoValidator;
+
+    public ServiceBase(IRepositoryBase<T> repository, IMapper mapper, ILogger<ServiceBase<T, TDto, TCreateDto, TUpdateDto>> logger, IValidator<TCreateDto> createDtoValidator, IValidator<TUpdateDto> updateDtoValidator)
+    {
+        _repository = repository;
+        _mapper = mapper;
+        _logger = logger;
+        _createDtoValidator = createDtoValidator;
+        _updateDtoValidator = updateDtoValidator;
+    }
+
+    public virtual async Task<IResponseDataModel<List<T>>> GetAll()
+    {
+        try
+        {
+            var entities = await _repository.GetAllAsync();
+            return new ResponseDataModel<List<T>>
+            {
+                Success = true,
+                Data = entities,
+                StatusCode = 200,
+                Message = "Liste des entités récupérée avec succès."
+            };
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Une erreur s'est produite lors de la récupération des entités.");
+            return new ResponseDataModel<List<T>>
+            {
+                Success = false,
+                Message = "Une erreur s'est produite lors de la récupération des entités.",
+                StatusCode = 500
+            };
+        }
+    }
+
+    public virtual async Task<IResponseDataModel<T>> GetById(int id)
+    {
+        try
+        {
+            var entity = await _repository.GetByIdAsync(id);
+            if (entity == null)
+            {
+                return new ResponseDataModel<T>
+                {
+                    Success = false,
+                    Message = $"Aucune entité trouvée avec l'identifiant {id}.",
+                    StatusCode = 404
+                };
+            }
+
+            return new ResponseDataModel<T>
+            {
+                Success = true,
+                Data = entity,
+                StatusCode = 200,
+                Message = "Entité récupérée avec succès."
+            };
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, $"Une erreur s'est produite lors de la récupération de l'entité avec l'identifiant {id}.");
+            return new ResponseDataModel<T>
+            {
+                Success = false,
+                Message = "Une erreur s'est produite lors de la récupération de l'entité.",
+                StatusCode = 500
+            };
+        }
+    }
+    
+    public virtual async Task<IResponseDataModel<List<TDto>>> GetAllWithRelationsAsync(params Expression<Func<T, object>>[] relationsAInclure)
+    {
+        try
+        {
+            var entities = await _repository.GetAllWithRelationsAsync(relationsAInclure);
+            var dtos = _mapper.Map<List<TDto>>(entities);
+            return new ResponseDataModel<List<TDto>>
+            {
+                Success = true,
+                Data = dtos,
+                StatusCode = 200,
+                Message = "Liste des entités récupérée avec succès."
+            };
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Une erreur s'est produite lors de la récupération des entités.");
+            return new ResponseDataModel<List<TDto>>
+            {
+                Success = false,
+                Message = "Une erreur s'est produite lors de la récupération des entités.",
+                StatusCode = 500
+            };
+        }
+    }
+    
+    public virtual async Task<IResponseDataModel<TDto>> GetByIdWithRelations(int id, params Expression<Func<T, object>>[] relationsAInclure)
+    {
+        try
+        {
+            var entity = await _repository.GetWithRelationsAsync(id, relationsAInclure);
+            if (entity == null)
+            {
+                return new ResponseDataModel<TDto>
+                {
+                    Success = false,
+                    Message = $"Aucune entité trouvée avec l'identifiant {id}.",
+                    StatusCode = 404
+                };
+            }
+
+            var dto = _mapper.Map<TDto>(entity);
+            return new ResponseDataModel<TDto>
+            {
+                Success = true,
+                Data = dto,
+                StatusCode = 200,
+                Message = "Entité avec relations récupérée avec succès."
+            };
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, $"Une erreur s'est produite lors de la récupération de l'entité avec l'identifiant {id}.");
+            return new ResponseDataModel<TDto>
+            {
+                Success = false,
+                Message = "Une erreur s'est produite lors de la récupération de l'entité avec relations.",
+                StatusCode = 500
+            };
+        }
+    }
+
+    public virtual async Task<IResponseDataModel<T>> Create(TCreateDto dto)
+    {
+        try
+        {
+            var validationResult = _createDtoValidator.Validate(dto);
+            if (!validationResult.IsValid)
+            {
+                return new ResponseDataModel<T>
+                {
+                    Success = false,
+                    Message = string.Join("; ", validationResult.Errors.Select(e => e.ErrorMessage)),
+                    StatusCode = 400
+                };
+            }
+            var entity = _mapper.Map<T>(dto);
+            var createdEntity = await _repository.AddAsync(entity);
+            return new ResponseDataModel<T>
+            {
+                Success = createdEntity != null,
+                Data = createdEntity,
+                StatusCode = createdEntity != null ? 201 : 500,
+                Message = createdEntity != null ? "Entité créée avec succès." : "Échec de la création de l'entité."
+            };
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Une erreur s'est produite lors de la création de l'entité.");
+            return new ResponseDataModel<T>
+            {
+                Success = false,
+                Message = "Une erreur s'est produite lors de la création de l'entité.",
+                StatusCode = 500
+            };
+        }
+    }
+
+    public virtual async Task<IResponseDataModel<T>> Update(TUpdateDto dto)
+    {
+        try
+        {
+            var validationResult = _updateDtoValidator.Validate(dto);
+            if (!validationResult.IsValid)
+            {
+                return new ResponseDataModel<T>
+                {
+                    Success = false,
+                    Message = string.Join("; ", validationResult.Errors.Select(e => e.ErrorMessage)),
+                    StatusCode = 400
+                };
+            }
+            var entity = _mapper.Map<T>(dto);
+            bool isUpdated = await _repository.UpdateAsync(entity);
+            return new ResponseDataModel<T>
+            {
+                Success = isUpdated,
+                Data = isUpdated ? entity : default,
+                StatusCode = isUpdated ? 200 : 500,
+                Message = isUpdated ? "Entité mise à jour avec succès." : "Échec de la mise à jour de l'entité."
+            };
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Une erreur s'est produite lors de la mise à jour de l'entité.");
+            return new ResponseDataModel<T>
+            {
+                Success = false,
+                Message = "Une erreur s'est produite lors de la mise à jour de l'entité.",
+                StatusCode = 500
+            };
+        }
+    }
+
+    public virtual async Task<IResponseDataModel<string>> Delete(int id)
+    {
+        try
+        {
+            var entity = await _repository.GetByIdAsync(id);
+            if (entity == null)
+            {
+                return new ResponseDataModel<string>
+                {
+                    Success = false,
+                    Message = $"Aucune entité trouvée avec l'identifiant {id}.",
+                    StatusCode = 404
+                };
+            }
+
+            var isDeleted = await _repository.DeleteAsync(entity);
+            return new ResponseDataModel<string>
+            {
+                Success = isDeleted,
+                Data = isDeleted ? id.ToString() : null,
+                StatusCode = isDeleted ? 200 : 500,
+                Message = isDeleted ? "Entité supprimée avec succès." : "Échec de la suppression de l'entité."
+            };
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, $"Une erreur s'est produite lors de la suppression de l'entité avec l'identifiant {id}.");
+            return new ResponseDataModel<string>
+            {
+                Success = false,
+                Message = "Une erreur s'est produite lors de la suppression de l'entité.",
+                StatusCode = 500
+            };
+        }
+    }
+}

ldap-cesi/Services/ServiceService.cs

@@ -5,146 +5,145 @@ using ldap_cesi.Models;
 using ldap_cesi.Repository.Services;
 using ldap_cesi.Services.Interfaces;
 using ldap_cesi.Validator.Service;
+using ldap_cesi.DTOs;
+using ldap_cesi.DTOs.Inputs.Service;
 
 namespace ldap_cesi.Services;
 
-public class ServiceService : IServiceService
+public class ServiceService : ServiceBase<Service, ServiceDto, ServiceCreateDto, ServiceUpdateDto>, IServiceService
 {
-    private readonly IRepositoryService _repositoryService;
-    private readonly IMapper _mapper;
 
-    public ServiceService(IRepositoryService repositoryService, IMapper mapper)
+    public ServiceService(IRepositoryService repositoryService, IMapper mapper, ILogger<ServiceService> logger, ServiceCreateValidator serviceCreateValidator, ServiceUpdateValidator serviceUpdateValidator) 
+        : base(repositoryService, mapper, logger, serviceCreateValidator, serviceUpdateValidator)
     {
-        _repositoryService = repositoryService;
-        _mapper = mapper;
     }
 
 
-    public async Task<IResponseDataModel<List<Service>>> GetAll()
+    // public async Task<IResponseDataModel<List<Service>>> GetAll()
-    {
+    // {
-        var services = await _repositoryService.GetAllAsync();
+    //     var services = await _repositoryService.GetAllAsync();
-        return new ResponseDataModel<List<Service>>
+    //     return new ResponseDataModel<List<Service>>
-        {
+    //     {
-            Success = true,
+    //         Success = true,
-            Data = services,
+    //         Data = services,
-            StatusCode = 200,
+    //         StatusCode = 200,
-        };
+    //     };
-    }    
+    // }    
     
-    public async Task<IResponseDataModel<Service>> GetById(int id)
+    // public async Task<IResponseDataModel<Service>> GetById(int id)
-    {
+    // {
-        var service = await _repositoryService.GetByIdAsync(id);
+    //     var service = await _repositoryService.GetByIdAsync(id);
-        return new ResponseDataModel<Service>
+    //     return new ResponseDataModel<Service>
-        {
+    //     {
-            Success = true,
+    //         Success = true,
-            Data = service,
+    //         Data = service,
-            StatusCode = 200,
+    //         StatusCode = 200,
-        };
+    //     };
-    }
+    // }
 
-    public async Task<IResponseDataModel<string>> CreateService(ServiceCreateDto serviceCreateDto)
+    // public async Task<IResponseDataModel<string>> CreateService(ServiceCreateDto serviceCreateDto)
-    {
+    // {
-        var validation = new ServiceCreateValidator();
+    //     var validation = new ServiceCreateValidator();
-        var result = validation.Validate(serviceCreateDto);
+    //     var result = validation.Validate(serviceCreateDto);
-        if (!result.IsValid)
+    //     if (!result.IsValid)
-        {
+    //     {
-            return new ResponseDataModel<string>
+    //         return new ResponseDataModel<string>
-            {
+    //         {
-                StatusCode = 400,
+    //             StatusCode = 400,
-                Success = false,
+    //             Success = false,
-                Message = "Données du service invalides: " + string.Join(", ", result.Errors)
+    //             Message = "Données du service invalides: " + string.Join(", ", result.Errors)
-            };
+    //         };
-        }
+    //     }
-        var service = _mapper.Map<Service>(serviceCreateDto);
+    //     var service = _mapper.Map<Service>(serviceCreateDto);
-        var response = await _repositoryService.AddAsync(service);
+    //     var response = await _repositoryService.AddAsync(service);
-        return new ResponseDataModel<string>
+    //     return new ResponseDataModel<string>
-        {
+    //     {
-            StatusCode = 201,
+    //         StatusCode = 201,
-            Success = true,
+    //         Success = true,
-            Data = response.Id.ToString(),
+    //         Data = response.Id.ToString(),
-        };
+    //     };
-    }
+    // }
     
-    public async Task<IResponseDataModel<Service>> UpdateService(ServiceUpdateDto serviceUpdateDto)
+    // public async Task<IResponseDataModel<Service>> UpdateService(ServiceUpdateDto serviceUpdateDto)
-    {
+    // {
-        var validation = new ServiceUpdateValidator();
+    //     var validation = new ServiceUpdateValidator();
-        var result = validation.Validate(serviceUpdateDto);
+    //     var result = validation.Validate(serviceUpdateDto);
-        if (!result.IsValid)
+    //     if (!result.IsValid)
-        {
+    //     {
-            return new ResponseDataModel<Service>
+    //         return new ResponseDataModel<Service>
-            {
+    //         {
-                StatusCode = 400,
+    //             StatusCode = 400,
-                Success = false,
+    //             Success = false,
-                Message = "Données du service invalides: " + string.Join(", ", result.Errors)
+    //             Message = "Données du service invalides: " + string.Join(", ", result.Errors)
-            };
+    //         };
-        }
+    //     }
-        var serviceFind = await _repositoryService.GetByIdAsync(serviceUpdateDto.Id);
+    //     var serviceFind = await _repositoryService.GetByIdAsync(serviceUpdateDto.Id);
-        if (serviceFind is null)
+    //     if (serviceFind is null)
-        {
+    //     {
-            return new ResponseDataModel<Service>
+    //         return new ResponseDataModel<Service>
-            {
+    //         {
-                Success = false,
+    //             Success = false,
-                Message = "Service introuvable.",
+    //             Message = "Service introuvable.",
-                StatusCode = 404
+    //             StatusCode = 404
-            };
+    //         };
-        }
+    //     }
         
-        var service =    _mapper.Map(serviceUpdateDto, serviceFind);
+    //     var service =    _mapper.Map(serviceUpdateDto, serviceFind);
-        var response = await _repositoryService.UpdateAsync(service);
+    //     var response = await _repositoryService.UpdateAsync(service);
-        if (!response)
+    //     if (!response)
-        {
+    //     {
-            return new ResponseDataModel<Service>
+    //         return new ResponseDataModel<Service>
-            {
+    //         {
-                StatusCode = 500,
+    //             StatusCode = 500,
-                Success = false,
+    //             Success = false,
-                Message = "Erreur lors de la mise à jour du service : " + string.Join(", ", result.Errors)
+    //             Message = "Erreur lors de la mise à jour du service : " + string.Join(", ", result.Errors)
-            };
+    //         };
-        }
+    //     }
-        return new ResponseDataModel<Service>
+    //     return new ResponseDataModel<Service>
-        {
+    //     {
-            StatusCode = 200,
+    //         StatusCode = 200,
-            Success = true,
+    //         Success = true,
-            Data = service,
+    //         Data = service,
-        };
+    //     };
-    }    
+    // }    
     
-    public async Task<IResponseDataModel<string>> DeleteService(int idService)
+    // public async Task<IResponseDataModel<string>> DeleteService(int idService)
-    {
+    // {
-        if (idService == null)
+    //     if (idService == null)
-        {
+    //     {
-            return new ResponseDataModel<string>
+    //         return new ResponseDataModel<string>
-            {
+    //         {
-                StatusCode = 400,
+    //             StatusCode = 400,
-                Success = false,
+    //             Success = false,
-                Message = "Id manquant"
+    //             Message = "Id manquant"
-            };
+    //         };
-        }
+    //     }
 
-        var service = await _repositoryService.GetByIdAsync(idService);
+    //     var service = await _repositoryService.GetByIdAsync(idService);
-        if (service == null)
+    //     if (service == null)
-        {
+    //     {
-            return new ResponseDataModel<string>
+    //         return new ResponseDataModel<string>
-            {
+    //         {
-                Success = false,
+    //             Success = false,
-                Message = "Service introuvable.",
+    //             Message = "Service introuvable.",
-                StatusCode = 404
+    //             StatusCode = 404
-            };
+    //         };
-        }
+    //     }
-        var response = await _repositoryService.DeleteAsync(service);
+    //     var response = await _repositoryService.DeleteAsync(service);
-        if (!response)
+    //     if (!response)
-        {
+    //     {
-            return new ResponseDataModel<string>
+    //         return new ResponseDataModel<string>
-            {
+    //         {
-                StatusCode = 500,
+    //             StatusCode = 500,
-                Success = false,
+    //             Success = false,
-                Message = "Erreur durant la suppression du service"
+    //             Message = "Erreur durant la suppression du service"
-            };
+    //         };
-        }
+    //     }
-        return new ResponseDataModel<string>
+    //     return new ResponseDataModel<string>
-            {
+    //         {
-                StatusCode = 200,
+    //             StatusCode = 200,
-                Success = true,
+    //             Success = true,
-                Data = service.Id.ToString(),
+    //             Data = service.Id.ToString(),
-            };
+    //         };
-    }
+    // }
 }

ldap-cesi/Services/UtilisateurService.cs

@@ -47,7 +47,7 @@ public class UtilisateurService : IUtilisateurService
     
     public async Task<IResponseDataModel<UtilisateurOutputDto>> Login(UtilisateurLoginDto utilisateurInput)
     {
-        var validation = new UtilisateurCreateValidator();
+        var validation = new UtilisateurLoginValidator();
         var result = validation.Validate(utilisateurInput);
         if (!result.IsValid)
         {

ldap-cesi/Validator/Role/RoleCreateValidator.cs

@@ -0,0 +1,14 @@
+using FluentValidation;
+using ldap_cesi.DTOs.Inputs.Role;
+
+namespace ldap_cesi.Validator.Role;
+
+public class RoleCreateValidator : AbstractValidator<RoleCreateDto>
+{
+    public RoleCreateValidator()
+    {
+        RuleFor(x => x.Nom)
+            .NotEmpty().WithMessage("Le nom est requis.")
+            .MaximumLength(50).WithMessage("Le nom ne doit pas dépasser 50 caractères.");
+    }
+}

ldap-cesi/Validator/Role/RoleUpdateValidator.cs

@@ -0,0 +1,16 @@
+using FluentValidation;
+using ldap_cesi.DTOs.Inputs.Role;
+
+namespace ldap_cesi.Validator.Role;
+
+public class RoleUpdateValidator : AbstractValidator<RoleUpdateDto>
+{
+    public RoleUpdateValidator()
+    {
+        RuleFor(x => x.Nom)
+            .NotEmpty().WithMessage("Le nom est requis.")
+            .MaximumLength(50).WithMessage("Le nom ne doit pas dépasser 50 caractères.");
+        RuleFor(x => x.Id)
+            .NotEmpty().WithMessage("L'identifiant du Rôle est requis.");
+    }
+}

ldap-cesi/Validator/Salarie/SalarieCreateValidator.cs

@@ -16,11 +16,15 @@ public class SalarieCreateValidator : AbstractValidator<SalarieCreateDto>
             .MaximumLength(50).WithMessage("Le prénom ne doit pas dépasser 50 caractères.");
 
         RuleFor(x => x.TelephoneFix)
-            .NotEmpty().WithMessage("Le téléphone fixe est requis.")
+            .NotEmpty().WithMessage("Le téléphone fixe est requis.")       
+            .Matches(@"^(\+33|0)[1-9](\d{2}){4}$")
+            .WithMessage("Le numéro de téléphone fixe n'est pas valide. Format attendu : +33XXXXXXXXX ou 0XXXXXXXXX.")
             .MaximumLength(15).WithMessage("Le téléphone fixe ne doit pas dépasser 15 caractères.");
 
         RuleFor(x => x.TelephonePortable)
             .NotEmpty().WithMessage("Le téléphone portable est requis.")
+            .Matches(@"^(\+33|0)[6-7](\d{2}){4}$")
+            .WithMessage("Le numéro de téléphone portable n'est pas valide. Format attendu : +33XXXXXXXXX ou 0XXXXXXXXX.")
             .MaximumLength(15).WithMessage("Le téléphone portable ne doit pas dépasser 15 caractères.");
 
         RuleFor(x => x.Email)

ldap-cesi/Validator/Salarie/SalarieUpdateValidator.cs

@@ -18,11 +18,15 @@ public class SalarieUpdateValidator : AbstractValidator<SalarieUpdateDto>
             .MaximumLength(50).WithMessage("Le prénom ne doit pas dépasser 50 caractères.");
 
         RuleFor(x => x.TelephoneFixe)
-            .NotEmpty().WithMessage("Le téléphone fixe est requis.")
+            .NotEmpty().WithMessage("Le téléphone fixe est requis.")       
+            .Matches(@"^(\+33|0)[1-9](\d{2}){4}$")
+            .WithMessage("Le numéro de téléphone fixe n'est pas valide. Format attendu : +33XXXXXXXXX ou 0XXXXXXXXX.")
             .MaximumLength(15).WithMessage("Le téléphone fixe ne doit pas dépasser 15 caractères.");
 
         RuleFor(x => x.TelephonePortable)
             .NotEmpty().WithMessage("Le téléphone portable est requis.")
+            .Matches(@"^(\+33|0)[6-7](\d{2}){4}$")
+            .WithMessage("Le numéro de téléphone portable n'est pas valide. Format attendu : +33XXXXXXXXX ou 0XXXXXXXXX.")
             .MaximumLength(15).WithMessage("Le téléphone portable ne doit pas dépasser 15 caractères.");
 
         RuleFor(x => x.Email)

ldap-cesi/Validator/Utilisateur/UtilisateurLoginValidator.cs

@@ -3,16 +3,18 @@ using ldap_cesi.DTOs.Inputs;
 
 namespace ldap_cesi.Validator.Utilisateur;
 
-public class UtilisateurCreateValidator : AbstractValidator<UtilisateurLoginDto>
+public class UtilisateurLoginValidator : AbstractValidator<UtilisateurLoginDto>
 {
-    public UtilisateurCreateValidator()
+    public UtilisateurLoginValidator()
     {
         RuleFor(x => x.Email)
             .NotEmpty().WithMessage("L'email est requis.")
-            .EmailAddress().WithMessage("L'email n'est pas valide.");
+            .EmailAddress().WithMessage("L'email n'est pas valide.")
+            .MaximumLength(50).WithMessage("L'email ne doit pas dépasser 50 caractères.");
 
         RuleFor(x => x.MotDePasse)
             .NotEmpty().WithMessage("Le mot de passe est requis.")
-            .MinimumLength(6).WithMessage("Le mot de passe doit contenir au moins 6 caractères.");
+            .MinimumLength(6).WithMessage("Le mot de passe doit contenir au moins 6 caractères.")
+            .MaximumLength(20).WithMessage("Le mot de passe ne doit pas dépasser 20 caractères.");
     }
 }

ldap-cesi/ldap-cesi.csproj

@@ -5,6 +5,7 @@
         <Nullable>enable</Nullable>
         <ImplicitUsings>enable</ImplicitUsings>
         <RootNamespace>ldap_cesi</RootNamespace>
+        <NoWarn>CS0472,CS1591,CS1587</NoWarn>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>
     </PropertyGroup>