.idea/.idea.ldap-cesi/.idea/vcs.xml

@@ -1,4 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="VcsDirectoryMappings" defaultProject="true" />
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
 </project>

ldap-cesi/Configurations/Conf.cs

@@ -43,7 +43,7 @@ public static class Conf
     {
         builder.Services.AddScoped<IServiceService, ServiceService >();
         // builder.Services.AddScoped<IRoleService, RoleService>();
-        // builder.Services.AddScoped<ISiteService, SiteService>();
+        builder.Services.AddScoped<ISiteService, SiteService>();
         builder.Services.AddScoped<ISalarieService, SalarieService>();
         builder.Services.AddScoped<IUtilisateurService, UtilisateurService>();
         builder.Services.AddScoped<IJwtService, JwtService>();
@@ -53,7 +53,7 @@ public static class Conf
     {
         string connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
         builder.Services.AddDbContext<PgContext>(options => options.UseNpgsql(connectionString));
-    }
+    }   
     public static void CorseConfiguration(this WebApplicationBuilder builder)
     {
         builder.Services.AddCors(options =>

ldap-cesi/Controllers/SalarieController.cs

@@ -1,4 +1,7 @@
+using ldap_cesi.DTOs.Inputs.Salarie;
+using ldap_cesi.DTOs.Inputs.Service;
 using ldap_cesi.Services.Interfaces;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
 namespace ldap_cesi.Controllers;
@@ -13,27 +16,115 @@ public class SalarieController : ControllerBase
         _salarieService = salarieService;
     }
     
-    // GET: api/salaries
-    /// <summary>
-    /// Endpoint qui retournes tous les salaries
+     /// <summary>
+    /// Endpoint qui retourne tous les salariés.
     /// </summary>
-    /// <returns>List<Salarie></returns>
+    /// <returns>Une liste de salariés.</returns>
     [HttpGet]
-    public async Task<ActionResult> GetUtilisateurs()
+    public async Task<IActionResult> GetAllSalaries()
     {
         var result = await _salarieService.GetAll();
-        return result.Success ? Ok(result) : BadRequest(result);
-    }            
-    
-    // GET: api/salaries
+        return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+    }
+
     /// <summary>
-    /// Endpoint retourne le salarie correspondant à l'id en param
+    /// Endpoint qui retourne le salarié correspondant à l'ID en paramètre.
     /// </summary>
-    /// <returns>Salarie</returns>
+    /// <param name="id">L'ID du salarié.</param>
+    /// <returns>Le salarié correspondant à l'ID.</returns>
     [HttpGet("{id}")]
-    public async Task<ActionResult> GetUtilisateurById(int id)
+    public async Task<IActionResult> GetSalarieById(int id)
     {
         var result = await _salarieService.GetById(id);
-        return result.Success ? Ok(result) : BadRequest(result);
-    }    
-}
+        return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+    }
+    
+    /// <summary>
+    /// Endpoint qui retourne le salarié correspondant à l'ID en paramètre. Avec le nom de service et de site auxquels il apaprtient.
+    /// </summary>
+    /// <param name="id">L'ID du salarié.</param>
+    /// <returns>Le salarié correspondant à l'ID.</returns>
+    [HttpGet("/complet/{id}")]
+    public async Task<IActionResult> GetSalarieCompletById(int id)
+    {
+        var result = await _salarieService.GetCompletById(id);
+        return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+    }
+
+    /// <summary>
+    /// Endpoint qui crée un salarié.
+    /// </summary>
+    /// <param name="salarieInput">Les informations du salarié à créer.</param>
+    /// <returns>Le salarié créé.</returns>
+    [HttpPost]
+    [Authorize(Roles = "admin")]
+    public async Task<IActionResult> CreateSalarie([FromBody] SalarieCreateDto salarieInput)
+    {
+        var result = await _salarieService.Create(salarieInput);
+        return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+    }
+
+    /// <summary>
+    /// Endpoint qui met à jour un salarié.
+    /// </summary>
+    /// <param name="salarieInput">Les informations du salarié à mettre à jour.</param>
+    /// <returns>Le salarié mis à jour.</returns>
+    [HttpPut]
+    [Authorize(Roles = "admin")]
+    public async Task<IActionResult> UpdateSalarie([FromBody] SalarieUpdateDto salarieInput)
+    {
+        var result = await _salarieService.Update(salarieInput);
+        return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+    }
+
+    /// <summary>
+    /// Endpoint qui supprime un salarié.
+    /// </summary>
+    /// <param name="id">L'ID du salarié à supprimer.</param>
+    /// <returns>Un message de confirmation de suppression.</returns>
+    [HttpDelete("{id}")]
+    [Authorize(Roles = "admin")]
+    public async Task<IActionResult> DeleteSalarie(int id)
+    {
+        var result = await _salarieService.Delete(id);
+        return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+    }
+    
+    /// <summary>
+    /// Récupère les salariés appartenant à un site spécifique
+    /// </summary>
+    /// <param name="siteId">Identifiant du site</param>
+    /// <returns>Liste des salariés du site</returns>
+    [HttpGet("site/{siteId}")]
+    public async Task<IActionResult> GetSalariesBySite(int siteId)
+    {
+        var result = await _salarieService.GetSalariesBySite(siteId);
+        return result.Success ? Ok(result.Data) : NotFound(result.Message);
+    }
+    
+    /// <summary>
+    /// Récupère les salariés appartenant à un service spécifique
+    /// </summary>
+    /// <param name="serviceId">Identifiant du service</param>
+    /// <returns>Liste des salariés du service</returns>
+    [HttpGet("service/{serviceId}")]
+    public async Task<IActionResult> GetSalariesByService(int serviceId)
+    {
+        var result = await _salarieService.GetSalariesByService(serviceId);
+        return result.Success ? Ok(result.Data) : NotFound(result.Message);
+    }
+
+    /// <summary>
+    /// Endpoint qui met à jour partiellement un salarié.
+    /// </summary>
+    /// <param name="id">L'ID du salarié.</param>
+    /// <param name="salariePatch">Les informations du salarié à mettre à jour partiellement.</param>
+    /// <returns>Le salarié mis à jour partiellement.</returns>
+    // [HttpPatch("{id}")]
+    // [Authorize(Roles = "admin")]
+    // public async Task<IActionResult> PatchSalarie(int id, [FromBody] SalariePatchDto salariePatch)
+    // {
+    //     var result = await _salarieService.Patch(id, salariePatch);
+    //     return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+    // }
+}

ldap-cesi/Controllers/ServicesController.cs

@@ -16,40 +16,67 @@ public class ServicesController : ControllerBase
         _serviceService = serviceService;
     }
     
-    // GET: api/services
     /// <summary>
-    /// Endpoint qui retournes tous les services
+    /// Endpoint qui retourne tous les services.
     /// </summary>
-    /// <returns>Retourne tous les services</returns>
+    /// <returns>Retourne tous les services.</returns>
     [HttpGet]
-    // [Authorize(Roles = "admin")]
-    public async Task<ActionResult> GetServices()
+    [Authorize(Roles = "admin")]
+    public async Task<IActionResult> GetServices()
     {
         var result = await _serviceService.GetAll();
-        return result.Success ? Ok(result) : BadRequest(result);
-    }            
-    
-    // GET: api/services
+        return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+    }
+
     /// <summary>
-    /// Endpoint retourne le service correspondant à l'id en param
+    /// Endpoint qui retourne le service correspondant à l'id en paramètre.
     /// </summary>
-    /// <returns>Service</returns>
+    /// <param name="id">L'ID du service.</param>
+    /// <returns>Le service correspondant à l'ID.</returns>
     [HttpGet("{id}")]
-    public async Task<ActionResult> GetServices(int id)
+    [Authorize(Roles = "admin")]
+    public async Task<IActionResult> GetServiceById(int id)
     {
         var result = await _serviceService.GetById(id);
-        return result.Success ? Ok(result) : BadRequest(result);
-    }        
-    
-    // {POST}: api/services
+        return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+    }
+
     /// <summary>
-    /// Endpoint qui créé un service
+    /// Endpoint qui crée un service.
     /// </summary>
-    /// <returns>Retourne tous les services</returns>
+    /// <param name="serviceInputDto">Les informations du service à créer.</param>
+    /// <returns>Le service créé.</returns>
     [HttpPost]
-    public async Task<ActionResult> CreateService([FromBody] ServiceCreateDto serviceInputDto)
+    [Authorize(Roles = "admin")]
+    public async Task<IActionResult> CreateService([FromBody] ServiceCreateDto serviceInputDto)
     {
         var result = await _serviceService.CreateService(serviceInputDto);
-        return result.Success ? Ok(result) : BadRequest(result);
-    }    
+        return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+    }
+
+    /// <summary>
+    /// Endpoint qui met à jour un service.
+    /// </summary>
+    /// <param name="serviceUpdateDto">Les informations du service à mettre à jour.</param>
+    /// <returns>Le service mis à jour.</returns>
+    [HttpPut]
+    [Authorize(Roles = "admin")]
+    public async Task<IActionResult> UpdateService([FromBody] ServiceUpdateDto serviceUpdateDto)
+    {
+        var result = await _serviceService.UpdateService(serviceUpdateDto);
+        return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+    }
+
+    /// <summary>
+    /// Endpoint qui supprime un service.
+    /// </summary>
+    /// <param name="id">L'ID du service à supprimer.</param>
+    /// <returns>Un message de confirmation de suppression.</returns>
+    [HttpDelete("{id}")]
+    [Authorize(Roles = "admin")]
+    public async Task<IActionResult> DeleteService(int id)
+    {
+        var result = await _serviceService.DeleteService(id);
+        return result.Success ? Ok(result.Message) : BadRequest(result.Message);
+    }
 }

ldap-cesi/Controllers/SiteController.cs

@@ -0,0 +1,84 @@
+using ldap_cesi.DTOs.Inputs.Site;
+using ldap_cesi.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ldap_cesi.Controllers;
+
+[ApiController]
+[Route("/api/site")]
+public class SiteController : ControllerBase
+{
+    private readonly ISiteService _siteService;
+
+    public SiteController(ISiteService siteService)
+    {
+        _siteService = siteService;
+    }
+    
+    // GET: api/site
+    /// <summary>
+    /// Récupère la liste de tous les sites.
+    /// </summary>
+    /// <returns>Retourne une liste de tous les sites.</returns>
+    [HttpGet]
+    public async Task<ActionResult> GetSites()
+    {
+        var result = await _siteService.GetAll();
+        return result.Success ? Ok(result) : BadRequest(result);
+    }            
+    
+    // GET: api/site/{id}
+    /// <summary>
+    /// Récupère un site spécifique par son identifiant.
+    /// </summary>
+    /// <param name="id">L'identifiant du site à récupérer.</param>
+    /// <returns>Retourne le site correspondant à l'identifiant.</returns>
+    /// <response code="200">Le site a été récupéré avec succès.</response>
+    /// <response code="400">Une erreur s'est produite lors de la récupération du site.</response>
+    /// <response code="404">Le site n'a pas été trouvé.</response>
+    [HttpGet("{id}")]
+    public async Task<ActionResult> GetSite(int id)
+    {
+        var result = await _siteService.GetById(id);
+        return result.Success ? Ok(result) : BadRequest(result);
+    }        
+    
+    // POST: api/site
+    /// <summary>
+    /// Crée un nouveau site.
+    /// </summary>
+    /// <param name="siteCreateDto">Les données du site à créer.</param>
+    /// <returns>Retourne l'identifiant du site créé.</returns>
+    [HttpPost]
+    public async Task<ActionResult> CreateSite([FromBody] SiteCreateDto siteCreateDto)
+    {
+        var result = await _siteService.CreateSite(siteCreateDto);
+        return result.Success ? Ok(result) : BadRequest(result);
+    }
+    
+    // PUT: api/site
+    /// <summary>
+    /// Met à jour un site existant.
+    /// </summary>
+    /// <param name="siteUpdateDto">Les données du site à mettre à jour.</param>
+    /// <returns>Retourne l'objet ou une erreur.</returns>
+    [HttpPut]
+    public async Task<IActionResult> UpdateSite([FromBody] SiteUpdateDto siteUpdateDto)
+    {
+        var result = await _siteService.UpdateSite(siteUpdateDto);
+        return result.Success ? Ok(result) : BadRequest(result);
+    }
+    
+    // DELETE: api/site/{id}
+    /// <summary>
+    /// Supprime un site par son identifiant.
+    /// </summary>
+    /// <param name="id">L'identifiant du site à supprimer.</param>
+    /// <returns>Retourne l'id, ou l'erreur</returns>
+    [HttpDelete("{id}")]
+    public async Task<IActionResult> DeleteSite(int id)
+    {
+        var result = await _siteService.DeleteSite(id);
+        return result.Success ? Ok(result) : BadRequest(result);
+    }
+}

ldap-cesi/Controllers/UtilisateurController.cs

@@ -1,5 +1,6 @@
 using ldap_cesi.DTOs.Inputs;
 using ldap_cesi.Services.Interfaces;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
 namespace ldap_cesi.Controllers;
@@ -13,35 +14,42 @@ public class UtilisateurController : ControllerBase
     {
         _utilisateurService = utilisateurService;
     }
-    
+
+
+    /// <summary>
+    /// Endpoint pour la connexion des utilisateurs.
+    /// </summary>
+    /// <param name="utilisateurInput">Les informations de connexion de l'utilisateur.</param>
+    /// <returns>Un token JWT si la connexion est réussie.</returns>
     [HttpPost("login")]
     public async Task<IActionResult> Login([FromBody] UtilisateurLoginDto utilisateurInput)
     {
         var response = await _utilisateurService.Login(utilisateurInput);
         return StatusCode(response.StatusCode, response);
     }
-    
-    // GET: api/utilisateurs
+
     /// <summary>
-    /// Endpoint qui retournes tous les utilisateurs
+    /// Endpoint pour récupérer tous les utilisateurs.
     /// </summary>
-    /// <returns>List<Utilisateur></returns>
+    /// <returns>Une liste d'utilisateurs.</returns>
     [HttpGet]
-    public async Task<ActionResult> GetUtilisateurs()
+    [Authorize(Roles = "admin")]
+    public async Task<IActionResult> GetUtilisateurs()
     {
         var result = await _utilisateurService.GetAll();
-        return result.Success ? Ok(result) : BadRequest(result);
-    }            
-    
-    // GET: api/utilisateur
+        return result.Success ? Ok(result.Data) : BadRequest(result.Message);
+    }
+
     /// <summary>
-    /// Endpoint retourne l'utilisateur correspondant à l'id en param
+    /// Endpoint pour récupérer un utilisateur par son ID.
     /// </summary>
-    /// <returns>Utilisateur</returns>
+    /// <param name="id">L'ID de l'utilisateur.</param>
+    /// <returns>L'utilisateur correspondant à l'ID.</returns>
     [HttpGet("{id}")]
-    public async Task<ActionResult> GetUtilisateurById(int id)
+    [Authorize(Roles = "admin")]
+    public async Task<IActionResult> GetUtilisateurById(int id)
     {
         var result = await _utilisateurService.GetById(id);
-        return result.Success ? Ok(result) : BadRequest(result);
+        return result.Success ? Ok(result.Data) : BadRequest(result.Message);
     }
 }

ldap-cesi/DTOs/Generic/ServiceDto.cs

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

ldap-cesi/DTOs/Generic/SiteDto.cs

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

ldap-cesi/DTOs/Inputs/Salarie/SalarieCreateDto.cs

@@ -4,8 +4,8 @@ public class SalarieCreateDto
 {
     public string Nom { get; set; }
     public string Prenom { get; set; }
-    public string Telephone_fix { get; set; }
-    public string Telephone_portable { get; set; }
+    public string TelephoneFix { get; set; }
+    public string TelephonePortable { get; set; }
     public string Email { get; set; }
     public int IdSite { get; set; }
     public int IdService { get; set; }

ldap-cesi/DTOs/Outputs/Salarie/SalarieListDto.cs

@@ -0,0 +1,12 @@
+namespace ldap_cesi.DTOs.Outputs.Salarie;
+
+public class SalarieListDto
+{
+
+    public int Id { get; set; }
+    public string Nom { get; set; }
+    public string Prenom { get; set; }
+    public string NomComplet => $"{Prenom} {Nom}";
+    public ServiceDto Service { get; set; }
+    public SiteDto Site { get; set; }
+}

ldap-cesi/DTOs/Outputs/Salarie/SalarieOutputDetail.cs

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

ldap-cesi/Mapper/AutoMapperProfile.cs

@@ -1,5 +1,9 @@
 using AutoMapper;
+using ldap_cesi.DTOs;
+using ldap_cesi.DTOs.Inputs.Salarie;
 using ldap_cesi.DTOs.Inputs.Service;
+using ldap_cesi.DTOs.Inputs.Site;
+using ldap_cesi.DTOs.Outputs.Salarie;
 using ldap_cesi.DTOs.Outputs.Utilisateur;
 using ldap_cesi.Entities;
 
@@ -9,8 +13,30 @@ public class AutoMapperProfile : Profile
 {
     public AutoMapperProfile()
     {
+        // INPUTS MAPPER 
+        CreateMap<ServiceCreateDto, Service>();
+        CreateMap<ServiceUpdateDto, Service>();
+        CreateMap<SiteCreateDto, Site>();
+        CreateMap<SiteUpdateDto, Site>();
+        CreateMap<SalarieCreateDto, Salarie>()
+            .ForMember(dest => dest.TelephoneFixe, opt => opt.MapFrom(src => src.TelephoneFix))
+            .ForMember(dest => dest.TelephonePortable, opt => opt.MapFrom(src => src.TelephonePortable));
+        CreateMap<SalarieUpdateDto, Salarie>()
+            .ForMember(dest => dest.TelephoneFixe, opt => opt.MapFrom(src => src.TelephoneFixe))
+            .ForMember(dest => dest.TelephonePortable, opt => opt.MapFrom(src => src.TelephonePortable));
+        
+        
+        //OUTPUTS MAPPER
         CreateMap<Utilisateur, UtilisateurOutputDto>()
             .ForMember(dest => dest.RoleNom, opt => opt.MapFrom(src => src.IdRoleNavigation.Nom));
-        CreateMap<ServiceCreateDto, Service>();
+        CreateMap<Salarie, SalarieOutputDetail>()
+            .ForMember(dest => dest.Service, opt => opt.MapFrom(src => src.IdServiceNavigation))
+            .ForMember(dest => dest.Site, opt => opt.MapFrom(src => src.IdSiteNavigation));
+        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/Models/IEntity.cs

@@ -0,0 +1,6 @@
+namespace ldap_cesi.Models;
+
+public interface IEntity
+{
+    int Id { get; set; }
+}

ldap-cesi/Repositories/Interfaces/IRepositoryBase.cs

@@ -8,8 +8,8 @@ public interface IRepositoryBase<TEntity> where TEntity : class
     Task<bool> AnyAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
     Task<TEntity>  GetByIdAsync<TId>(TId id, CancellationToken cancellationToken = default) where TId : notnull;
     Task<List<TEntity>> GetAllAsync(CancellationToken cancellationToken = default);
-    Task UpdateAsync(TEntity entity, CancellationToken cancellationToken = default);
-    Task DeleteAsync(TEntity entity, CancellationToken cancellationToken = default);
+    Task<bool> UpdateAsync(TEntity entity, CancellationToken cancellationToken = default);
+    Task<bool> DeleteAsync(TEntity entity, CancellationToken cancellationToken = default);
     Task<TEntity?> FirstOrDefaultAsync(Expression<Func<TEntity, bool>> predicate,
         CancellationToken cancellationToken = default);
 }

ldap-cesi/Repositories/Interfaces/IRepositorySalarie.cs

@@ -4,5 +4,8 @@ namespace ldap_cesi.Repository.Services;
 
 public interface IRepositorySalarie : IRepositoryBase<Salarie>
 {
-    
+    Task<Salarie> GetSalarieWithRelationsAsync(int id);
+    Task<List<Salarie>> SearchByNameAsync(string inputRecherche);
+    Task<List<Salarie>> GetSalariesBySiteAsync(int siteId);
+    Task<List<Salarie>> GetSalariesByServiceAsync(int serviceId);
 }

ldap-cesi/Repositories/RepositoryBase.cs

@@ -1,5 +1,6 @@
 using System.Linq.Expressions;
 using ldap_cesi.Context;
+using ldap_cesi.Models;
 using ldap_cesi.Repository.Services;
 using Microsoft.EntityFrameworkCore;
 
@@ -49,12 +50,13 @@ public class RepositoryBase<TEntity> : IRepositoryBase<TEntity> where TEntity :
             return await _context.Set<TEntity>().FirstOrDefaultAsync(predicate, cancellationToken);
         }
         
-        public virtual async Task UpdateAsync(TEntity entity, CancellationToken cancellationToken = default)
+        public virtual async Task<bool> UpdateAsync(TEntity entity, CancellationToken cancellationToken = default)
         {
             try
             {
                 _context.Set<TEntity>().Update(entity);
                 await SaveChangesAsync(cancellationToken);
+                return true;
             }
             catch (Exception ex)
             {
@@ -74,12 +76,13 @@ public class RepositoryBase<TEntity> : IRepositoryBase<TEntity> where TEntity :
             }
         }
         
-        public virtual async Task DeleteAsync(TEntity entity, CancellationToken cancellationToken = default)
+        public virtual async Task<bool> DeleteAsync(TEntity entity, CancellationToken cancellationToken = default)
         {
             try
             {
                 _context.Set<TEntity>().Remove(entity);
                 await SaveChangesAsync(cancellationToken);
+                return true;
             }
             catch (Exception ex)
             {

ldap-cesi/Repositories/SalarieRepository.cs

@@ -1,6 +1,7 @@
 using ldap_cesi.Context;
 using ldap_cesi.Entities;
 using ldap_cesi.Repository.Services;
+using Microsoft.EntityFrameworkCore;
 
 namespace ldap_cesi.Repository;
 
@@ -10,4 +11,39 @@ public class SalarieRepository : RepositoryBase<Salarie>, IRepositorySalarie
     {
         
     }
+    
+    public async Task<Salarie> GetSalarieWithRelationsAsync(int id)
+    {
+        return await _context.Salaries
+            .Include(s => s.IdServiceNavigation)
+            .Include(s => s.IdSiteNavigation)
+            .FirstOrDefaultAsync(s => s.Id == id);
+    }
+
+    public async Task<List<Salarie>> SearchByNameAsync(string inputRecherche)
+    {
+        return await _context.Salaries
+            .Where(s => s.Nom.Contains(inputRecherche) || s.Prenom.Contains(inputRecherche))
+            .Include(s => s.IdServiceNavigation)
+            .Include(s => s.IdSiteNavigation)
+            .ToListAsync();
+    }
+
+    public async Task<List<Salarie>> GetSalariesBySiteAsync(int siteId)
+    {
+        return await _context.Salaries
+            .Where(s => s.IdSite == siteId)
+            .Include(s => s.IdServiceNavigation)
+            .Include(s => s.IdSiteNavigation)
+            .ToListAsync();
+    }
+    
+    public async Task<List<Salarie>> GetSalariesByServiceAsync(int serviceId)
+    {
+        return await _context.Salaries
+            .Where(s => s.IdService == serviceId)
+            .Include(s => s.IdServiceNavigation)
+            .Include(s => s.IdSiteNavigation)
+            .ToListAsync();
+    }
 }

ldap-cesi/Services/Interfaces/ISalarieService.cs

@@ -1,3 +1,6 @@
+using ldap_cesi.DTOs.Inputs.Salarie;
+using ldap_cesi.DTOs.Inputs.Service;
+using ldap_cesi.DTOs.Outputs.Salarie;
 using ldap_cesi.Entities;
 using ldap_cesi.Models;
 
@@ -7,4 +10,10 @@ public interface ISalarieService
 {
     Task<IResponseDataModel<List<Salarie>>> GetAll();
     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<Salarie>> Update(SalarieUpdateDto salarieInput);
+    Task<IResponseDataModel<string>> Delete(int id);
+    Task<IResponseDataModel<SalarieOutputDetail>> GetCompletById(int id);
 }

ldap-cesi/Services/Interfaces/IServiceService.cs

@@ -9,4 +9,6 @@ public interface IServiceService
     Task<IResponseDataModel<List<Service>>> GetAll();
     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/Interfaces/ISiteService.cs

@@ -1,6 +1,15 @@
+using ldap_cesi.DTOs.Inputs.Service;
+using ldap_cesi.DTOs.Inputs.Site;
+using ldap_cesi.Entities;
+using ldap_cesi.Models;
+
 namespace ldap_cesi.Services.Interfaces;
 
 public interface ISiteService
 {
-    
+    Task<IResponseDataModel<List<Site>>> GetAll();
+    Task<IResponseDataModel<Site>> GetById(int id);
+    Task<IResponseDataModel<string>> CreateSite(SiteCreateDto siteCreateDto);
+    Task<IResponseDataModel<Site>> UpdateSite(SiteUpdateDto siteUpdate);
+    Task<IResponseDataModel<string>> DeleteSite(int id);
 }

ldap-cesi/Services/SalarieService.cs

@@ -1,17 +1,28 @@
+using AutoMapper;
+using ldap_cesi.DTOs.Inputs.Salarie;
+using ldap_cesi.DTOs.Inputs.Service;
+using ldap_cesi.DTOs.Outputs.Salarie;
 using ldap_cesi.Entities;
 using ldap_cesi.Models;
 using ldap_cesi.Repository.Services;
 using ldap_cesi.Services.Interfaces;
+using ldap_cesi.Validator.Salarie;
 
 namespace ldap_cesi.Services;
 
 public class SalarieService : ISalarieService
 {
     private IRepositorySalarie _repositorySalarie;
+    private readonly IRepositorySite _repositorySite;
+    private readonly IRepositoryService _repositoryService;
+    private readonly IMapper _mapper;
 
-    public SalarieService(IRepositorySalarie repositorySalarie)
+    public SalarieService(IRepositorySalarie repositorySalarie, IMapper mapper, IRepositorySite repositorySite, IRepositoryService repositoryService)
     {
         _repositorySalarie = repositorySalarie;
+        _repositorySite = repositorySite;
+        _repositoryService = repositoryService;
+        _mapper = mapper;
     }
     
     public async Task<IResponseDataModel<List<Salarie>>> GetAll()
@@ -27,12 +38,202 @@ public class SalarieService : ISalarieService
     
     public async Task<IResponseDataModel<Salarie>> GetById(int id)
     {
-        var service = await _repositorySalarie.GetByIdAsync(id);
+        var salarie = await _repositorySalarie.GetSalarieWithRelationsAsync(id);
         return new ResponseDataModel<Salarie>
         {
             Success = true,
-            Data = service,
+            Data = salarie,
+            StatusCode = 200,
+        };
+    }    
+    
+    public async Task<IResponseDataModel<SalarieOutputDetail>> GetCompletById(int id)
+    {
+        var salarie = await _repositorySalarie.GetSalarieWithRelationsAsync(id);
+        var salarieOutput = _mapper.Map<SalarieOutputDetail>(salarie);
+        return new ResponseDataModel<SalarieOutputDetail>
+        {
+            Success = true,
+            Data = salarieOutput,
             StatusCode = 200,
         };
     }
+
+    public async Task<IResponseDataModel<List<SalarieListDto>>> GetSalariesBySite(int siteId)
+    {
+        var site = await _repositorySite.GetByIdAsync(siteId);
+        if (site == null)
+        {
+            return new ResponseDataModel<List<SalarieListDto>>
+            {
+                Success = false,
+                Message = "Site non trouvé",
+                StatusCode = 404
+            };
+        }
+
+        var salaries = await _repositorySalarie.GetSalariesBySiteAsync(siteId);
+        if (!salaries.Any())
+        {
+            return new ResponseDataModel<List<SalarieListDto>>
+            {
+                Success = true,
+                Message = "Aucun salarié trouvé pour ce site",
+                Data = new List<SalarieListDto>(),
+                StatusCode = 200
+            };
+        }
+
+        var salariesDto = _mapper.Map<List<SalarieListDto>>(salaries);
+        
+        return new ResponseDataModel<List<SalarieListDto>>
+        {
+            Success = true,
+            Data = salariesDto,
+            StatusCode = 200
+        };
+    }
+
+    public async Task<IResponseDataModel<List<SalarieListDto>>> GetSalariesByService(int serviceId)
+    {
+        var service = await _repositoryService.GetByIdAsync(serviceId);
+        if (service == null)
+        {
+            return new ResponseDataModel<List<SalarieListDto>>
+            {
+                Success = false,
+                Message = "Service non trouvé",
+                StatusCode = 404
+            };
+        }
+
+        var salaries = await _repositorySalarie.GetSalariesByServiceAsync(serviceId);
+        var salariesDto = _mapper.Map<List<SalarieListDto>>(salaries);
+            
+        return new ResponseDataModel<List<SalarieListDto>>
+        {
+            Success = true,
+            Data = salariesDto,
+            StatusCode = 200
+        };
+    }
+    
+    public async Task<IResponseDataModel<List<SalarieListDto>>> RechercherParNom(string nom)
+    {
+        var salaries = await _repositorySalarie.SearchByNameAsync(nom);
+        var salariesDto = _mapper.Map<List<SalarieListDto>>(salaries);
+            
+        return new ResponseDataModel<List<SalarieListDto>>
+        {
+            Success = true,
+            Data = salariesDto,
+            StatusCode = 200
+        };
+    }
+
+    public async Task<IResponseDataModel<string>> Create(SalarieCreateDto salarieInput)
+    {
+        var validation = new SalarieCreateValidator();
+        var result = validation.Validate(salarieInput);
+        if (!result.IsValid)
+        {
+            return new ResponseDataModel<string>
+            {
+                StatusCode = 400,
+                Success = false,
+                Message = "Données salariées invalides: " + string.Join(", ", result.Errors)
+            };
+        }
+        var service = _mapper.Map<Salarie>(salarieInput);
+        var response = await _repositorySalarie.AddAsync(service);
+        return new ResponseDataModel<string>
+        {
+            StatusCode = 201,
+            Success = true,
+            Data = response.Id.ToString(),
+        };
+    }
+
+    public async Task<IResponseDataModel<Salarie>> Update(SalarieUpdateDto salarieInput)
+    {
+        var validation = new SalarieUpdateValidator();
+        var result = validation.Validate(salarieInput);
+        if (!result.IsValid)
+        {
+            return new ResponseDataModel<Salarie>
+            {
+                StatusCode = 400,
+                Success = false,
+                Message = "Données salariées invalides: " + string.Join(", ", result.Errors)
+            };
+        }
+
+        var salarieFind = await _repositorySalarie.GetByIdAsync(salarieInput.Id);
+        if (salarieFind == null)
+        {
+            return new ResponseDataModel<Salarie>
+            {
+                Success = false,
+                Message = "Salarié introuvable.",
+                StatusCode = 404
+            };
+        }
+
+        var salarie = _mapper.Map(salarieInput, salarieFind);
+        var response = await _repositorySalarie.UpdateAsync(salarie);
+        if (!response)
+        {
+            return new ResponseDataModel<Salarie>
+            {
+                StatusCode = 500,
+                Success = false,
+                Message = "Erreur lors de la mise à jour du salarié : " + string.Join(", ", result.Errors)
+            };
+        }
+        return new ResponseDataModel<Salarie>
+        {
+            StatusCode = 200,
+            Success = true,
+            Data = salarie,
+        };
+    }
+
+    public async Task<IResponseDataModel<string>> Delete(int id)
+    {
+        if (id == null)
+        {
+            return new ResponseDataModel<string>
+            {
+                StatusCode = 400,
+                Success = false,
+                Message = "Id manquant"
+            };
+        }
+        var salarie = await _repositorySalarie.GetByIdAsync(id);
+        if (salarie == null)
+        {
+            return new ResponseDataModel<string>
+            {
+                Success = false,
+                Message = "Salarié introuvable.",
+                StatusCode = 404
+            };
+        }
+        var response = await _repositorySalarie.DeleteAsync(salarie);
+        if (!response)
+        {
+            return new ResponseDataModel<string>
+            {
+                StatusCode = 500,
+                Success = false,
+                Message = "Erreur durant la suppression du service"
+            };
+        }
+        return new ResponseDataModel<string>
+        {
+            StatusCode = 200,
+            Success = true,
+            Data = salarie.Id.ToString(),
+        };
+    }
 }

ldap-cesi/Services/ServiceService.cs

@@ -4,6 +4,7 @@ using ldap_cesi.Entities;
 using ldap_cesi.Models;
 using ldap_cesi.Repository.Services;
 using ldap_cesi.Services.Interfaces;
+using ldap_cesi.Validator.Service;
 
 namespace ldap_cesi.Services;
 
@@ -43,12 +44,107 @@ public class ServiceService : IServiceService
 
     public async Task<IResponseDataModel<string>> CreateService(ServiceCreateDto serviceCreateDto)
     {
+        var validation = new ServiceCreateValidator();
+        var result = validation.Validate(serviceCreateDto);
+        if (!result.IsValid)
+        {
+            return new ResponseDataModel<string>
+            {
+                StatusCode = 400,
+                Success = false,
+                Message = "Données du service invalides: " + string.Join(", ", result.Errors)
+            };
+        }
         var service = _mapper.Map<Service>(serviceCreateDto);
         var response = await _repositoryService.AddAsync(service);
         return new ResponseDataModel<string>
         {
+            StatusCode = 201,
             Success = true,
             Data = response.Id.ToString(),
         };
     }
+    
+    public async Task<IResponseDataModel<Service>> UpdateService(ServiceUpdateDto serviceUpdateDto)
+    {
+        var validation = new ServiceUpdateValidator();
+        var result = validation.Validate(serviceUpdateDto);
+        if (!result.IsValid)
+        {
+            return new ResponseDataModel<Service>
+            {
+                StatusCode = 400,
+                Success = false,
+                Message = "Données du service invalides: " + string.Join(", ", result.Errors)
+            };
+        }
+        var serviceFind = await _repositoryService.GetByIdAsync(serviceUpdateDto.Id);
+        if (serviceFind is null)
+        {
+            return new ResponseDataModel<Service>
+            {
+                Success = false,
+                Message = "Service introuvable.",
+                StatusCode = 404
+            };
+        }
+        
+        var service =    _mapper.Map(serviceUpdateDto, serviceFind);
+        var response = await _repositoryService.UpdateAsync(service);
+        if (!response)
+        {
+            return new ResponseDataModel<Service>
+            {
+                StatusCode = 500,
+                Success = false,
+                Message = "Erreur lors de la mise à jour du service : " + string.Join(", ", result.Errors)
+            };
+        }
+        return new ResponseDataModel<Service>
+        {
+            StatusCode = 200,
+            Success = true,
+            Data = service,
+        };
+    }    
+    
+    public async Task<IResponseDataModel<string>> DeleteService(int idService)
+    {
+        if (idService == null)
+        {
+            return new ResponseDataModel<string>
+            {
+                StatusCode = 400,
+                Success = false,
+                Message = "Id manquant"
+            };
+        }
+
+        var service = await _repositoryService.GetByIdAsync(idService);
+        if (service == null)
+        {
+            return new ResponseDataModel<string>
+            {
+                Success = false,
+                Message = "Service introuvable.",
+                StatusCode = 404
+            };
+        }
+        var response = await _repositoryService.DeleteAsync(service);
+        if (!response)
+        {
+            return new ResponseDataModel<string>
+            {
+                StatusCode = 500,
+                Success = false,
+                Message = "Erreur durant la suppression du service"
+            };
+        }
+        return new ResponseDataModel<string>
+            {
+                StatusCode = 200,
+                Success = true,
+                Data = service.Id.ToString(),
+            };
+    }
 }

ldap-cesi/Services/SiteService.cs

@@ -0,0 +1,151 @@
+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;
+
+namespace ldap_cesi.Services;
+
+public class SiteService : ISiteService
+{
+
+    private readonly IRepositorySite _repositorySite;
+    private readonly IMapper _mapper;
+
+    public SiteService(IRepositorySite repositorySite, IMapper mapper)
+    { 
+        _repositorySite = repositorySite;
+        _mapper = mapper;
+    }
+    
+    public async Task<IResponseDataModel<List<Site>>> GetAll()
+    {
+        var sites = await _repositorySite.GetAllAsync();
+        return new ResponseDataModel<List<Site>>
+        {
+            Success = true,
+            Data = sites,
+            StatusCode = 200,
+        };
+    }
+
+    public async Task<IResponseDataModel<Site>> GetById(int id)
+    {
+        var site = await _repositorySite.GetByIdAsync(id);
+        return new ResponseDataModel<Site>
+        {
+            Success = true,
+            Data = site,
+            StatusCode = 200,
+        };
+    }
+
+    public async Task<IResponseDataModel<string>> CreateSite(SiteCreateDto siteCreateDto)
+    {
+        var validation = new SiteCreateValidator();
+        var result = validation.Validate(siteCreateDto);
+        if (!result.IsValid)
+        {
+            return new ResponseDataModel<string>
+            {
+                StatusCode = 400,
+                Success = false,
+                Message = "Données du site invalides: " + string.Join(", ", result.Errors)
+            };
+        }
+        var site = _mapper.Map<Site>(siteCreateDto);
+        var response = await _repositorySite.AddAsync(site);
+        return new ResponseDataModel<string>
+        {
+            StatusCode = 201,
+            Success = true,
+            Data = response.Id.ToString(),
+        };
+    }
+
+    public async Task<IResponseDataModel<Site>> UpdateSite(SiteUpdateDto siteUpdate)
+    {
+        var validation = new SiteUpdateValidator();
+        var result = validation.Validate(siteUpdate);
+        if (!result.IsValid)
+        {
+            return new ResponseDataModel<Site>
+            {
+                StatusCode = 400,
+                Success = false,
+                Message = "Données du site invalides: " + string.Join(", ", result.Errors)
+            };
+        }
+        
+        var siteFind = await _repositorySite.GetByIdAsync(siteUpdate.Id);
+        if (siteFind is null)
+        {
+            return new ResponseDataModel<Site>
+            {
+                Success = false,
+                Message = "Site introuvable.",
+                StatusCode = 404
+            };
+        }
+        
+        var site = _mapper.Map(siteUpdate, siteFind);
+        var response = await _repositorySite.UpdateAsync(site);
+        if (!response)
+        {
+            return new ResponseDataModel<Site>
+            {
+                StatusCode = 500,
+                Success = false,
+                Message = "Erreur lors de la mise à jour du site : " + string.Join(", ", result.Errors)
+            };
+        }
+        return new ResponseDataModel<Site>
+        {
+            StatusCode = 200,
+            Success = true,
+            Data = site,
+        };
+    }
+
+    public async Task<IResponseDataModel<string>> DeleteSite(int id)
+    {
+        if (id == null)
+        {
+            return new ResponseDataModel<string>
+            {
+                StatusCode = 400,
+                Success = false,
+                Message = "Id manquant"
+            };
+        }
+
+        var site = await _repositorySite.GetByIdAsync(id);
+        if (site == null)
+        {
+            return new ResponseDataModel<string>
+            {
+                Success = false,
+                Message = "Site introuvable.",
+                StatusCode = 404
+            };
+        }
+        var response = await _repositorySite.DeleteAsync(site);
+        if (!response)
+        {
+            return new ResponseDataModel<string>
+            {
+                StatusCode = 500,
+                Success = false,
+                Message = "Erreur durant la suppression du site"
+            };
+        }
+        return new ResponseDataModel<string>
+        {
+            StatusCode = 200,
+            Success = true,
+            Data = site.Id.ToString(),
+        };
+    }
+}

ldap-cesi/Validator/Salarie/SalarieCreateValidator.cs

@@ -0,0 +1,37 @@
+using FluentValidation;
+using ldap_cesi.DTOs.Inputs.Salarie;
+
+namespace ldap_cesi.Validator.Salarie;
+
+public class SalarieCreateValidator : AbstractValidator<SalarieCreateDto>
+{
+    public SalarieCreateValidator()
+    {
+        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.Prenom)
+            .NotEmpty().WithMessage("Le prénom est requis.")
+            .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.")
+            .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.")
+            .MaximumLength(15).WithMessage("Le téléphone portable ne doit pas dépasser 15 caractères.");
+
+        RuleFor(x => x.Email)
+            .NotEmpty().WithMessage("L'email est requis.")
+            .EmailAddress().WithMessage("L'email n'est pas valide.")
+            .MaximumLength(50).WithMessage("L'email ne doit pas dépasser 50 caractères.");
+
+        RuleFor(x => x.IdSite)
+            .NotEmpty().WithMessage("L'ID du site est requis.");
+
+        RuleFor(x => x.IdService)
+            .NotEmpty().WithMessage("L'ID du service est requis.");
+    }
+}

ldap-cesi/Validator/Salarie/SalarieUpdateValidator.cs

@@ -0,0 +1,39 @@
+using FluentValidation;
+using ldap_cesi.DTOs.Inputs.Service;
+
+namespace ldap_cesi.Validator.Salarie;
+
+public class SalarieUpdateValidator : AbstractValidator<SalarieUpdateDto>
+{
+    public SalarieUpdateValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty().WithMessage("L'identifiant du salarié est requis.");
+        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.Prenom)
+            .NotEmpty().WithMessage("Le prénom est requis.")
+            .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.")
+            .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.")
+            .MaximumLength(15).WithMessage("Le téléphone portable ne doit pas dépasser 15 caractères.");
+
+        RuleFor(x => x.Email)
+            .NotEmpty().WithMessage("L'email est requis.")
+            .EmailAddress().WithMessage("L'email n'est pas valide.")
+            .MaximumLength(50).WithMessage("L'email ne doit pas dépasser 50 caractères.");
+
+        RuleFor(x => x.IdSite)
+            .NotEmpty().WithMessage("L'ID du site est requis.");
+
+        RuleFor(x => x.IdService)
+            .NotEmpty().WithMessage("L'ID du service est requis.");
+    }
+}

ldap-cesi/Validator/Service/ServiceCreateValidator.cs

@@ -0,0 +1,14 @@
+using FluentValidation;
+using ldap_cesi.DTOs.Inputs.Service;
+
+namespace ldap_cesi.Validator.Service;
+
+public class ServiceCreateValidator : AbstractValidator<ServiceCreateDto>
+{
+    public ServiceCreateValidator()
+    {
+        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/Service/ServiceUpdateValidator.cs

@@ -0,0 +1,18 @@
+using FluentValidation;
+using ldap_cesi.DTOs.Inputs.Service;
+
+namespace ldap_cesi.Validator.Service;
+
+public class ServiceUpdateValidator : AbstractValidator<ServiceUpdateDto>
+{
+    public ServiceUpdateValidator()
+    {
+        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 service est requis.");
+            
+    }
+
+}

ldap-cesi/Validator/Site/SiteCreateValidator.cs

@@ -0,0 +1,14 @@
+using FluentValidation;
+using ldap_cesi.DTOs.Inputs.Site;
+
+namespace ldap_cesi.Validator.Site;
+
+public class SiteCreateValidator : AbstractValidator<SiteCreateDto>
+{
+    public SiteCreateValidator()
+    {
+        RuleFor(x => x.Ville)
+            .NotEmpty().WithMessage("Le nom est requis.")
+            .MaximumLength(150).WithMessage("Le nom de la ville ne doit pas dépasser 150 caractères.");
+    }
+}

ldap-cesi/Validator/Site/SiteUpdateValidator.cs

@@ -0,0 +1,16 @@
+using FluentValidation;
+using ldap_cesi.DTOs.Inputs.Site;
+
+namespace ldap_cesi.Validator.Site;
+
+public class SiteUpdateValidator : AbstractValidator<SiteUpdateDto>
+{
+    public SiteUpdateValidator()
+    {
+        RuleFor(x => x.Ville)
+            .NotEmpty().WithMessage("Le nom est requis.")
+            .MaximumLength(150).WithMessage("Le nom de la ville ne doit pas dépasser 150 caractères.");
+        RuleFor(x => x.Id)
+            .NotEmpty().WithMessage("L'identifiant du site est requis.");
+    }
+}

ldap-cesi/ldap-cesi.csproj

@@ -31,7 +31,6 @@
     </ItemGroup>
 
     <ItemGroup>
-      <Folder Include="Entities\" />
       <Folder Include="Migrations\" />
     </ItemGroup>