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

using Diligent.WebAPI.Business.Extensions;
using Microsoft.AspNetCore.Http;

namespace Diligent.WebAPI.Business.Services
{
    public class ApplicantService : IApplicantService
    {
        private readonly DatabaseContext _context;
        private readonly IMapper _mapper;
        private readonly IHttpContextAccessor _httpContextAccessor;

        public ApplicantService(DatabaseContext context, IMapper mapper, IHttpContextAccessor httpContextAccessor)
        {
            _context = context;
            _mapper = mapper;
            _httpContextAccessor = httpContextAccessor;
        }

        public async Task<List<ApplicantViewDto>> GetFilteredApplicants(ApplicantFilterDto applicantFilterDto)
        {

            int applicantsToSkip = (applicantFilterDto.CurrentPage - 1) * applicantFilterDto.PageSize;

            var context = _httpContextAccessor.HttpContext;

            var allApplicants = _context.Applicants
                .Include(c => c.Ads)
                .Include(x => x.TechnologyApplicants)
                .ThenInclude(x => x.Technology);

            context.Response.AddHeader("Pagination", allApplicants.ToList().Count);

            var filteredApplicants = await allApplicants
               .FilterByExperience(applicantFilterDto.MinExperience, applicantFilterDto.MaxExperience)
               .FilterByEmploymentType(applicantFilterDto.EmploymentType)
               .FilterByDateOfApplication(applicantFilterDto.MinDateOfApplication, applicantFilterDto.MaxDateOfApplication)
               .Skip(applicantsToSkip)
               .Take(applicantFilterDto.PageSize)
               .ToListAsync();

            filteredApplicants = filteredApplicants.FilterByTechnologies(applicantFilterDto.Technologies);

            return _mapper.Map<List<ApplicantViewDto>>(filteredApplicants);
        }

        public async Task<ApplicantViewDto> GetById(int id)
        {
            var applicant = await _context.Applicants
                .Include(x => x.Ads)
                .ThenInclude(x => x.Technologies)
                .Include(x => x.TechnologyApplicants)
                .ThenInclude(x => x.Technology)
                .Include(x => x.Comments)
                .ThenInclude(t => t.User)
                .FirstOrDefaultAsync(x => x.ApplicantId == id);

            if (applicant is null)
                throw new EntityNotFoundException("Applicant not found");

            return _mapper.Map<ApplicantViewDto>(applicant);
        }
        public async Task CreateApplicant(ApplicantCreateDto applicantCreateDto)
        {
            var applicant = _mapper.Map<Applicant>(applicantCreateDto);
            await _context.Applicants.AddAsync(applicant);

            await _context.SaveChangesAsync();
        }

        public async Task DeleteApplicant(int id)
        {
            var applicant = await _context.Applicants.FindAsync(id);

            if (applicant is null)
                throw new EntityNotFoundException("Applicant not found");

            _context.Applicants.Remove(applicant);
            await _context.SaveChangesAsync();
        }

        public async Task UpdateApplicant(int id, ApplicantUpdateDto applicantUpdateDto)
        {
            var applicant = await _context.Applicants.FindAsync(id);
            if (applicant is null)
                throw new EntityNotFoundException("Applicant not found");

            _mapper.Map(applicantUpdateDto, applicant);

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

        public async Task<List<AdApplicantsViewDto>> GetAllAdsApplicants()
        {
            var adsApplicants = await _context.Ads
                .Include(a => a.Applicants)
                .ThenInclude(a => a.TechnologyApplicants).ThenInclude(a => a.Technology).ToListAsync();

            return _mapper.Map<List<AdApplicantsViewDto>>(adsApplicants);
        }

        public async Task<ApplicantViewDto> GetApplicantWithSelectionProcessesById(int id)
        {
            var applicant = await _context.Applicants
                .Include(a => a.SelectionProcesses).ThenInclude(sp => sp.SelectionLevel)
                .Include(a => a.SelectionProcesses).ThenInclude(sp => sp.Scheduler)
                .FirstOrDefaultAsync(a => a.ApplicantId == id);

            if (applicant is null)
                throw new EntityNotFoundException("Applicant not found");

            return _mapper.Map<ApplicantViewDto>(applicant);
        }
    }
}