public async Task <ActionResult <List <Room> > > Filter(FilterItemDTO filterItem)
        {
            var itemQueryable = _context.Rooms.AsQueryable();

            if (!string.IsNullOrWhiteSpace(filterItem.Name))
            {
                itemQueryable = itemQueryable.Where(x => x.ClassName.Contains(filterItem.Name));
            }

            if (filterItem.IsCompleted)
            {
                itemQueryable = itemQueryable.Where(x => x.CompleteСlass);
            }

            if (filterItem.UpcomingReleases)
            {
                var today = DateTime.Today;
                itemQueryable = itemQueryable.Where(x => x.StartOfTheSchoolYear > today);
            }

            if (filterItem.GroupId != 0)
            {
                itemQueryable = itemQueryable.Where(x => x.ClassRoomGroupList.Select(i => i.GroupId)
                                                    .Contains(filterItem.GroupId));
            }

            await HttpContext.InsertPaginationParametersInResponse(itemQueryable, filterItem.ItemsPerPage);

            var items = await itemQueryable.Paginate(filterItem.Pagination).ToListAsync();

            return(items);
        }
 public string Save(FilterItemDTO dto)
 {
     if (Login())
     {
         return(Put("Filter", dto));
     }
     return(null);
 }
Exemple #3
0
        public async Task <PaginatedResponseDTO <List <Room> > > GetItemsFiltered(FilterItemDTO filterItem)
        {
            var responseHTTP = await _httpService.Post <FilterItemDTO, List <Room> >($"{url}/filter", filterItem);

            var totalAmountPages = int.Parse(responseHTTP.HttpResponseMessage.Headers.GetValues("totalAmountPages").FirstOrDefault());

            var paginatedResponse = new PaginatedResponseDTO <List <Room> >()
            {
                Response         = responseHTTP.Response,
                TotalAmountPages = totalAmountPages
            };

            return(paginatedResponse);
        }
        public async Task <ActionResult <List <Person> > > Filter(FilterItemDTO filterItemDTO)
        {
            var modelQueryable = _context.People.AsQueryable();

            if (!string.IsNullOrWhiteSpace(filterItemDTO.Title))
            {
                modelQueryable = modelQueryable.Where(o => o.Name.Contains(filterItemDTO.Title));
            }
            if (filterItemDTO.InWork)
            {
                modelQueryable = modelQueryable.Where(o => o.InWork);
            }

            await HttpContext.InsertPaginationParametersInResponse(modelQueryable, filterItemDTO.RecordsPerPage);

            var model = await modelQueryable.Paginate(filterItemDTO.Pagination).ToListAsync();

            return(model);
        }
        public FilterItemDTO Save(FilterItemDTO filterItem)
        {
            try
            {
                if (filterItem.Id == 0)
                {
                    _dbContext.FilterItems.Add(AutoMapper.Mapper.Map <FilterItemEntity>(filterItem));
                }
                else
                {
                    _dbContext.FilterItems.Update(AutoMapper.Mapper.Map <FilterItemEntity>(filterItem));
                }

                _dbContext.SaveChanges();

                return(GetItem(filterItem.Id));
            }
            catch (Exception e)
            {
                throw e;
            }
        }
 public async Task SaveAsync(FilterItemDTO dto)
 {
     await Task.Run(() => Save(dto));
 }