public async Task <List <CategoryRestaurant> > GetAllWithFilter(CategoryRestaurantFilter CategoryRestaurantFilter)
        {
            Expression <Func <CategoryRestaurant, bool> > filter = null;
            Func <IQueryable <CategoryRestaurant>, IOrderedQueryable <CategoryRestaurant> > ordeBy = null;
            int?skip = null;
            int?take = 25;

            if (!string.IsNullOrWhiteSpace(CategoryRestaurantFilter.Name))
            {
                if (filter == null)
                {
                    filter = PredicateBuilder.New <CategoryRestaurant>(true);
                }

                filter = filter.And(x => x.Name == CategoryRestaurantFilter.Name);
            }

            if (!string.IsNullOrWhiteSpace(CategoryRestaurantFilter.Description))
            {
                if (filter == null)
                {
                    filter = PredicateBuilder.New <CategoryRestaurant>(true);
                }

                filter = filter.And(x => x.Description == CategoryRestaurantFilter.Description);
            }

            if (!string.IsNullOrWhiteSpace(CategoryRestaurantFilter.Order))
            {
                switch (CategoryRestaurantFilter.Order)
                {
                case "Id":
                    ordeBy = x => x.OrderBy(n => n.Id);
                    break;

                case "Name":
                    ordeBy = x => x.OrderBy(n => n.Name);
                    break;

                case "Description":
                    ordeBy = x => x.OrderBy(n => n.Description);
                    break;

                case "CreatedAt":
                    ordeBy = x => x.OrderBy(n => n.CreatedAt);
                    break;
                }
            }

            if (CategoryRestaurantFilter.Id != Guid.Empty)
            {
                if (filter == null)
                {
                    filter = PredicateBuilder.New <CategoryRestaurant>(true);
                }

                filter = filter.And(x => x.Id == CategoryRestaurantFilter.Id);
            }

            if (CategoryRestaurantFilter.CreatedAt.Year > 1)
            {
                if (filter == null)
                {
                    filter = PredicateBuilder.New <CategoryRestaurant>(true);
                }

                filter = filter.And(x => x.Id == CategoryRestaurantFilter.Id);
            }

            if (CategoryRestaurantFilter.PageIndex != null)
            {
                if (CategoryRestaurantFilter.PageIndex > 1)
                {
                    skip = CategoryRestaurantFilter.PageIndex * 25;
                }
            }

            if (CategoryRestaurantFilter.PageSize != null)
            {
                if (CategoryRestaurantFilter.PageSize > 0)
                {
                    take = CategoryRestaurantFilter.PageSize;
                }
            }

            return(await _unitOfWork
                   .RepositoryFactory
                   .CategoryRestaurantRepository
                   .Search(filter, ordeBy, skip, take));
        }
 public async Task <IEnumerable <CategoryRestaurantViewModel> > GetAllWithFilter([FromQuery] CategoryRestaurantFilter filter)
 {
     return(_mapper.Map <IEnumerable <CategoryRestaurantViewModel> >(await _categoryRestaurantService.GetAllWithFilter(filter)));
 }