public ListOfSpecialistsViewModel()
 {
     IsEmpty         = true;
     Filter          = new SpecialistFilter();
     LanguagesFilter = new List <Filter>();
     CitiesFilter    = new List <Filter>();
     ServicesFilter  = new List <Filter>();
     Specialists     = new List <Specialist>();
     Categories      = new List <Category>();
 }
Esempio n. 2
0
        public async Task <List <Specialist> > GetByFilterAsync(SpecialistFilter filter)
        {
            IQueryable <Specialist> query = context.Specialists;


            if (filter.CityIds.Any())
            {
                query = query
                        .Where(x => filter.CityIds
                               .Contains(x.CityId));
            }

            if (filter.LanguageIds.Any())
            {
                query = query.Include(x => x.LanguageSpecialists)
                        .Where(x => x.LanguageSpecialists
                               .Any(y => filter.LanguageIds
                                    .Contains(y.LanguageId)));
            }

            if (filter.Rating > 1)
            {
                query = query.Include(z => z.Orders)
                        .ThenInclude(z => z.Review)
                        .Where(x => x.Orders
                               .Any(y => y.Review.Mark >= filter.Rating));
            }


            if (filter.Experience > -1)
            {
                switch (filter.Experience)
                {
                case 1:
                    query = query.Include(x => x.Experiences).Where(x =>
                                                                    x.Experiences.Select(y => (y.EndDate - y.EndDate).Value.Days)
                                                                    .Any(q => q >= 0 && q <= filter.Experience * 364)); break;

                case 2:
                    query = query.Include(x => x.Experiences).Where(x =>
                                                                    x.Experiences.Select(y => (y.EndDate - y.EndDate).Value.Days)
                                                                    .Any(q => q >= 1 * 364 && q <= filter.Experience * 364)); break;

                case 5:
                    query = query.Include(x => x.Experiences).Where(x =>
                                                                    x.Experiences.Select(y => (y.EndDate - y.EndDate).Value.Days)
                                                                    .Any(q => q >= 2 * 364 && q <= filter.Experience * 364)); break;

                case 6:
                    query = query.Include(x => x.Experiences).Where(x =>
                                                                    x.Experiences.Select(y => (y.EndDate - y.EndDate).Value.Days)
                                                                    .Any(q => q >= 5 * 364 && q <= 20 * 364)); break;
                }
            }

            if (filter.ServiceIds.Any())
            {
                query = query.Include(x => x.SpecialistServices)
                        .ThenInclude(x => x.Service)
                        .Where(x => x.SpecialistServices
                               .Any(d => filter.ServiceIds.Contains(d.ServiceId)));
            }

            if (filter.SubCategoryIds.Any())
            {
                query = query
                        .Include(x => x.SpecialistSubCategories)
                        .Where(x => x.SpecialistSubCategories
                               .Any(s => filter.SubCategoryIds.Contains(s.SubCategoryId)));
            }

            if (filter.Page == 1)
            {
                return(await query.Take(20).ToListAsync());
            }
            var result = await query.ToListAsync();

            return(result.Skip((filter.Page - 1) * 20).Take(20).ToList());
        }