HRCenter/Diligent.WebAPI.Business/Services/AdService.cs

using Diligent.WebAPI.Business.Extensions;

namespace Diligent.WebAPI.Business.Services
{
    public class AdService : IAdService
    {
        private readonly DatabaseContext _context;
        private readonly IMapper _mapper;
        private readonly ITechnologyService _technologyService;

        public AdService(DatabaseContext context, IMapper mapper, ITechnologyService technologyService)
        {
            _context = context;
            _mapper = mapper;
            _technologyService = technologyService;
        }

        public async Task<List<AdResponseDto>> GetAllAsync()
        {
            var today = DateTime.Now;
            return _mapper.Map<List<AdResponseDto>>(await _context.Ads.Include(x => x.Technologies).Where(x => x.ExpiredAt > today).ToListAsync());
        }

        public async Task<AdResponseDto> GetByIdAsync(int id)
        {
            var ad = await _context.Ads.FindAsync(id);

            if(ad is null)
                throw new EntityNotFoundException("Ad not found");

            return _mapper.Map<AdResponseDto>(ad);

        }

        public async Task<AdDetailsResponseDto> GetAdDetailsByIdAsync(int id)
        {
            var ad = await _context.Ads.Include(x => x.Applicants).Where(x => x.Id == id).FirstOrDefaultAsync();

            if (ad is null)
                throw new EntityNotFoundException("Ad not found");

            return _mapper.Map<AdDetailsResponseDto>(ad);
        }

        public async Task<List<AdResponseDto>> GetArchiveAds()
        {
            var today = DateTime.Now;
            var archiveAds = await _context.Ads.Where(x => x.ExpiredAt < today).ToListAsync();

            return _mapper.Map<List<AdResponseDto>>(archiveAds);
        }

        public async Task<List<AdResponseDto>> GetFilteredAdsAsync(AdFilterDto filters)
        {
            var filteredAds = await _context.Ads.Include(x => x.Technologies)
                .FilterByExperience(filters.MinExperience, filters.MaxExperience)
                .FilterByWorkType(filters.WorkHour)
                .FilterByEmploymentType(filters.EmploymentType)
                .ToListAsync();

            filteredAds = filteredAds.FilterByTechnologies(filters.Technologies);

            return _mapper.Map<List<AdResponseDto>>(filteredAds);
        }

        public async Task CreateAsync(AdCreateDto adCreateDto)
        {
            var ad = _mapper.Map<Ad>(adCreateDto);

            for (int i = 0; i < adCreateDto.TechnologiesIds.Count; i++)
            {
                var technology = await _technologyService.GetEntityByIdAsync(adCreateDto.TechnologiesIds[i]);
                ad.Technologies.Add(technology);
            }

            await _context.Ads.AddAsync(ad);

            await _context.SaveChangesAsync();
        }

        public async Task UpdateAsync(int id, AdUpdateDto adUpdateDto)
        {
            var ad = await _context.Ads.FindAsync(id);

            if (ad is null)
                throw new EntityNotFoundException("Ad not found");

            _mapper.Map(adUpdateDto, ad);

            _context.Entry(ad).State = EntityState.Modified;
            await _context.SaveChangesAsync();
        }

        public async Task DeleteAsync(int id)
        {
            var ad = await _context.Ads.FindAsync(id);

            if (ad is null)
                throw new EntityNotFoundException("Ad not found");

            _context.Ads.Remove(ad);
            await _context.SaveChangesAsync();
        }
    }
}