ldap-cesi/Controllers/RoleController.cs

@@ -0,0 +1,84 @@
+using Microsoft.AspNetCore.Mvc;
+using ldap_cesi.DTOs.Inputs.Role;
+using ldap_cesi.Services.Interfaces;
+using System.Threading.Tasks;
+
+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
+        [HttpGet]
+        public async Task<IActionResult> GetAllRoles()
+        {
+            var result = await _roleService.GetAll();
+            if (result.Success)
+            {
+                return Ok(result.Data);
+            }
+            return StatusCode(result.StatusCode, result.Message);
+        }
+
+        // GET: api/Role/{id}
+        [HttpGet("{id}")]
+        public async Task<IActionResult> GetRoleById(int id)
+        {
+            var result = await _roleService.GetById(id);
+            if (result.Success)
+            {
+                return Ok(result.Data);
+            }
+            return StatusCode(result.StatusCode, result.Message);
+        }
+
+        // POST: api/Role
+        [HttpPost]
+        public async Task<IActionResult> CreateRole([FromBody] RoleCreateDto roleDto)
+        {
+            var result = await _roleService.Create(roleDto);
+            if (result.Success)
+            {
+                return CreatedAtAction(nameof(GetRoleById), new { id = result.Data }, result.Data);
+            }
+            return StatusCode(result.StatusCode, result.Message);
+        }
+
+        // PUT: api/Role/{id}
+        [HttpPut("{id}")]
+        public async Task<IActionResult> UpdateRole(int id, [FromBody] RoleUpdateDto roleDto)
+        {
+            if (id != roleDto.Id)
+            {
+                return BadRequest("Role ID mismatch");
+            }
+
+            var result = await _roleService.Update(roleDto);
+            if (result.Success)
+            {
+                return NoContent();
+            }
+            return StatusCode(result.StatusCode, result.Message);
+        }
+
+        // DELETE: api/Role/{id}
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeleteRole(int id)
+        {
+            var result = await _roleService.Delete(id);
+            if (result.Success)
+            {
+                return NoContent();
+            }
+            return StatusCode(result.StatusCode, 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/Inputs/Role/RoleCreateDto.cs

@@ -0,0 +1,6 @@
+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/Services/Interfaces/IServiceBase.cs

@@ -0,0 +1,16 @@
+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<T>> Create(TCreateDto dto);
+    Task<IResponseDataModel<T>> Update(TUpdateDto dto);
+    Task<IResponseDataModel<string>> Delete(int id);
+}

ldap-cesi/Services/ServiceBase.cs

@@ -0,0 +1,178 @@
+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.Threading.Tasks;
+
+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;
+
+    public ServiceBase(IRepositoryBase<T> repository, IMapper mapper, ILogger<ServiceBase<T, TDto, TCreateDto, TUpdateDto>> logger)
+    {
+        _repository = repository;
+        _mapper = mapper;
+        _logger = logger;
+    }
+
+    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<T>> Create(TCreateDto dto)
+    {
+        try
+        {
+            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 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
+            };
+        }
+    }
+}