public async Task <IActionResult> IndexEdit()
        {
            var query = queryProvider.Parse <ProductViewModel>();

            int pg       = (int)query.Page;
            var grouping = query.GetGrouping <ProductViewModelGrouping>();

            ProductlistViewModel model = new ProductlistViewModel
            {
                Query    = query,
                Products =
                    grouping == null ?
                    await Repository.GetPage(
                        query.GetFilterExpression(),
                        query.GetSorting() ??
                        (q => q.OrderBy(m => m.Name)),
                        pg, 3)
                        :
                    await Repository.GetPageExtended(
                        query.GetFilterExpression(),
                        query.GetSorting <ProductViewModelGrouping>() ??
                        (q => q.OrderBy(m => m.Name)),
                        pg, 3,
                        query.GetGrouping <ProductViewModelGrouping>())
            };


            ViewBag.AllTypes = (await TypesRepository.GetPage <DisplayValue>(null, m => m.OrderBy(n => n.Display), 1, 1000)).Data;

            return(View(model));
        }
        public async Task <DataPage <D> > ExecuteQuery <D, Dext>(IWebQueryProvider query) where Dext : D
        {
            if (SourceRepository is IWebQueryable)
            {
                return(await(SourceRepository as IWebQueryable).ExecuteQuery <D, Dext>(query));
            }
            else
            {
                QueryDescription <D> qd = null;
                if (query != null)
                {
                    qd = query.Parse <D>();
                }

                if (qd == null)
                {
                    return(await
                           SourceRepository.GetPage <D>(null, null, 1, int.MaxValue, null));
                }
                else
                {
                    var grouping = qd.GetGrouping <Dext>();
                    if (grouping == null)
                    {
                        return(await
                               SourceRepository.GetPage <D>(qd.GetFilterExpression(), qd.GetSorting(), (int)qd.Page, (int)qd.Take));
                    }
                    else
                    {
                        return(await
                               SourceRepository.GetPageExtended <D, Dext>(qd.GetFilterExpression(), qd.GetSorting <Dext>(), (int)qd.Page, (int)qd.Take, grouping));
                    }
                }
            }
        }
        public async Task <IActionResult> Index(int?page)
        {
            var query = queryProvider?.Parse <ProductViewModel>();
            int pg    = page.HasValue ? page.Value : 1;

            if (pg < 1)
            {
                pg = 1;
            }

            var res = await Repository.GetPage <ProductViewModel>(
                query?.GetFilterExpression(),
                q => q.OrderBy(m => m.Name),
                pg, 3);

            var model = new ProductlistViewModel
            {
                Products = res
            };

            return(View(model));
        }