DocumentOrganizer/Diligent.WebAPI.Business/Extensions/ApplicantExtensions.cs

using System.Diagnostics.CodeAnalysis;
using static Diligent.WebAPI.Data.Entities.Applicant;

namespace Diligent.WebAPI.Business.Extensions
{
    [ExcludeFromCodeCoverage]
    public static class ApplicantExtensions
    {
        public static List<Applicant> FilterApplicants(this List<Applicant> query,ApplicantFilterDto applicantFilterDto)
        {
           return query.FilterByExperience(applicantFilterDto.MinExperience, applicantFilterDto.MaxExperience)
                            .FilterByEmploymentType(applicantFilterDto.EmploymentType)
                            .FilterByDateOfApplication(applicantFilterDto.MinDateOfApplication, applicantFilterDto.MaxDateOfApplication)
                            .FilterByTechnologies(applicantFilterDto.Technologies).ToList();
        }
        public static List<Ad> FilterAdApplicants(this List<Ad> query, ApplicantFilterDto applicantFilterDto)
        {

            List<Ad> filteredAds = new();
            List<List<Applicant>> applicants = new();

            for (int i = 0; i < query.Count; i++)
            {
                var app = query[i].Applicants.FilterApplicants(applicantFilterDto);
                applicants.Add(app);
                
                var k = query[i];
                k.Applicants = applicants[i];
                filteredAds.Add(k);
            }

            return filteredAds;
        }

        private static List<Applicant> FilterByExperience(this List<Applicant> query, int minExperience, int maxExperience)
        {
            if ((minExperience == 0 && maxExperience == 0) || minExperience > maxExperience) return query;
            return query.Where(x => x.Experience >= minExperience && x.Experience <= maxExperience).ToList();
        }

        private static List<Applicant> FilterByEmploymentType(this List<Applicant> query, string? employmentType)
        {
            if (employmentType == null) return query;
            return query.Where(x => x.TypeOfEmployment == Enum.Parse<TypesOfEmployment>(employmentType)).ToList();
        }

        private static List<Applicant> FilterByDateOfApplication(this List<Applicant> query, DateTime? minDateOfApplication, DateTime? maxDateOfApplication)
        {
            if (minDateOfApplication == null) return query;
            if (minDateOfApplication > maxDateOfApplication) return query;
            if (maxDateOfApplication == null) return query.Where(x => x.DateOfApplication >= minDateOfApplication && x.DateOfApplication <= DateTime.Now).ToList();
            return query.Where(x => x.DateOfApplication >= minDateOfApplication && x.DateOfApplication < maxDateOfApplication).ToList();
        }

        private static List<Applicant> FilterByTechnologies(this List<Applicant> query, string[]? technologies)
        {
            if (technologies is null)
            {
                return query;
            }

            List<Applicant> filteredApplicants = new();

            for (int i = 0; i < query.Count; i++)
            {
                for (int j = 0; j < query[i].TechnologyApplicants.Count; j++)
                {
                    bool s = false;
                    for (int n = 0; n < technologies.Length; n++)
                    {
                        if (query[i].TechnologyApplicants[j].Technology.Name.ToLower() == technologies[n].ToLower())
                        {
                            s = true;
                            break;
                        }
                    }
                    if (s)
                    {
                        filteredApplicants.Add(query[i]);
                        break;
                    }
                }
            }

            return filteredApplicants;
        }
    }
}