Project/Project.Application/Services/RoleService.cs

using AutoMapper;
using Project.Application.DTOs.Incoming;
using Project.Application.DTOs.Outgoing;
using Project.Application.Interfaces;
using Project.Domain.Entities;
using Project.Infrastructure.Interfaces;

namespace Project.Application.Services
{
    public class RoleService : IRoleService
    {
        // FIELDS FOR CTOR
        private readonly IRoleRepository _roleRepository;
        private readonly IMapper _mapper;

        // CTOR
        public RoleService(IRoleRepository roleRepository, IMapper mapper)
        {
            _roleRepository = roleRepository;
            _mapper = mapper;
        }

        // CREATE
        public async Task<Role?> AddRoleAsync(CreatingRoleDto creatingRoleDto)
        {
            var role = _mapper.Map<Role>(creatingRoleDto);
            var created = await _roleRepository.AddAsync(role);
            return created;
        }

        // READ ALL
        public async Task<IEnumerable<ReadingRoleDto>> GetAllAsync()
        {
            var roles = await _roleRepository.GetAllAsync();
            var readDto = _mapper.Map<IEnumerable<ReadingRoleDto>>(roles);
            return readDto;
        }

        // READ BY ID
        public async Task<ReadingRoleDto> GetByIdAsync(int id)
        {
            var role = await _roleRepository.GetByIdAsync(id);
            var readDto = _mapper.Map<ReadingRoleDto>(role);
            return readDto;
        }

        // READ BY NAME
        public async Task<ReadingRoleDto> GetByNameAsync(string name)
        {
            var role = await _roleRepository.GetByNameAsync(name);
            var readDto = _mapper.Map<ReadingRoleDto>(role);
            return readDto;
        }

        // UPDATE
        public async Task<bool> UpdateRoleAsync(UpdatingRoleDto updatingRoleDto)
        {
            var role = _mapper.Map<Role>(updatingRoleDto);
            bool isUpdated = await _roleRepository.UpdateAsync(role);
            return isUpdated;
        }

        // DELETE
        public async Task<bool> DeleteRoleAsync(int id)
        {
            Role? role = await _roleRepository.GetByIdAsync(id);

            if (role is null)
                return false;

            bool isDeleted = await _roleRepository.DeleteAsync(role);
            return isDeleted;
        }
    }
}