ldap-cesi/ldap-cesi/Services/ServiceBase.cs

using AutoMapper;
using ldap_cesi.Models;
using ldap_cesi.Repository.Services;
using ldap_cesi.Services.Interfaces;
using System.Linq.Expressions;
using FluentValidation;
using Microsoft.EntityFrameworkCore;

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;
    }

    private Expression<Func<T, bool>> BuildSearchPredicate(string inputSearch)
    {
        return entity =>
            EF.Functions.ILike(EF.Property<string>(entity, "Nom"), $"%{inputSearch}%") ||
            EF.Functions.ILike(EF.Property<string>(entity, "Prenom"), $"%{inputSearch}%");
    }
    public virtual async Task<IResponseDataModel<List<T>>> GetAll(int pageNumber, int pageSize)
    {
        try
        {
            var response = await _repository.GetAllAsync( pageNumber,  pageSize);
            return new ResponseDataModel<List<T>>
            {
                Success = true,
                Data = response.Data,
                TotalPages = response.TotalPages,
                TotalCount = response.TotalItems,
                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(int pageNumber, int pageSize,params Expression<Func<T, object>>[] relationsAInclure)
    {
        try
        {
            var response = await _repository.GetAllWithRelationsAsync(pageNumber, pageSize,relationsAInclure);
            var dtos = _mapper.Map<List<TDto>>(response.Data);
            return new ResponseDataModel<List<TDto>>
            {
                Success = true,
                Data = dtos,
                TotalPages = response.TotalPages,
                TotalCount = response.TotalItems,
                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
            };
        }
    }
    
    public virtual async Task<IResponseDataModel<PaginatedList<TDto>>> SearchWithRelations(string searchTerm, int pageNumber, int pageSize, params Expression<Func<T, object>>[] includeProperties)
    {
        if (string.IsNullOrWhiteSpace(searchTerm) || searchTerm.Length < 2)
        {
            return new ResponseDataModel<PaginatedList<TDto>>
            {
                Success = false,
                Message = "Le terme de recherche doit contenir au moins deux caractères.",
                StatusCode = 400
            };
        }

        try
        {
            var predicate = BuildSearchPredicate(searchTerm);
            var entities = await _repository.SearchAsync(predicate, pageNumber, pageSize, includeProperties);
            var dtos = _mapper.Map<List<TDto>>(entities);
            var totalCount = await _repository.CountAsync(predicate);
            
            var response = new PaginatedList<TDto>(dtos, totalCount, pageNumber, pageSize);

            return new ResponseDataModel<PaginatedList<TDto>>
            {
                Success = true,
                Data = response,
                TotalPages = response.TotalPages,
                TotalCount = response.TotalCount,
                StatusCode = 200,
                Message = "Recherche effectuée avec succès."
            };
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Une erreur s'est produite lors de la recherche des entités.");
            return new ResponseDataModel<PaginatedList<TDto>>
            {
                Success = false,
                Message = "Une erreur s'est produite lors de la recherche des entités.",
                StatusCode = 500
            };
        }
    }

}