private static async Task <PagedList <TResultItem> > GetPagedAsync <TQueryItem, TResultItem>( [NotNull] IQueryable <TQueryItem> query, [NotNull] Expression <Func <TQueryItem, TResultItem> > converter, [NotNull] IPagedRequest request) { var totalCount = query.ToFutureValue(q => q.Count()); int?pageSize = request.PageSize != null && request.PageSize > 0 ? request.PageSize.Value : (int?)null; int pageNumber = 0; if (pageSize != null) { query = query.Take(pageSize.Value); if (request.PageIndex != null && request.PageIndex > 0) { var skip = pageSize.Value * request.PageIndex.Value; query = query.Skip(skip); } } var items = await query.Select(converter).ToListAsync().ConfigureAwait(false); return(new PagedList <TResultItem> { Items = items, TotalCount = totalCount.Value, PageIndex = pageNumber, PageSize = pageSize ?? totalCount.Value }); }
public async Task <TPagedResult> GetPage <TPagedResult>(IPagedRequest pagedRequest, Expression <Func <TModel, bool> > filterExpression = null) where TPagedResult : IPagedResult <TModel> { return(await GetPage <TPagedResult, object>(pagedRequest, options => { options.FilterExpression = filterExpression; })); }
public static IQueryable <T> ApplySorting <T>(this IQueryable <T> query, IPagedRequest request) { Guard.ArgumentNotNull(query, nameof(query)); Guard.ArgumentNotNull(request, nameof(request)); return(query.ApplySorting(request.SortExpression)); }
public static Task <IPagedResult <T> > ToPagedListAsync <T>(this IQueryable <T> query, IPagedRequest request, CancellationToken cancellationToken = default) { var filtering = request is IFilteredPagedRequest q ? q.Filtering : null; return(query.ToPagedListAsync(request.Page, request.PageSize, request.SortExpression, filtering, cancellationToken)); }
public PagedResultSet(ApiClient client, string endpoint, HttpMethod verb, IPagedRequest request) { _client = client; _endpoint = endpoint; _verb = verb; _request = request; CurrentIndex = -1; }
public static T CreatePagedResponse <T, U>(this IPagedRequest request, IPagedQueryResponse <U> response) where T : IPagedResponse <U>, new() { return(new T { Page = request.Page, TotalCount = response.TotalItems, TotalPages = response.TotalItems / request.ItemsPerPage, PageResults = response.PageResults.ToList() }); }
public async Task <TPagedResult> GetPage <TPagedResult, TKey>(IPagedRequest pagedRequest, Expression <Func <TModel, bool> > filterExpression = null, OrderBy orderBy = OrderBy.None, Expression <Func <TModel, TKey> > orderByExpression = null) where TPagedResult : IPagedResult <TModel> { return(await GetPage <TPagedResult, TKey>(pagedRequest, options => { options.OrderBy = orderBy; options.FilterExpression = filterExpression; options.OrderByExpression = orderByExpression; })); }
public IPagedResults <T> FindPage <TSortKey>(IPagedRequest <T, TSortKey> pagedRequest, params Expression <Func <T, object> >[] includes) { try { return(FindPageAsync(pagedRequest, includes).Result); } catch (AggregateException ae) { throw ae.Flatten(); } }
public PagedResponse(IPagedRequest pagination, IEnumerable <T> data, int?recordCount = null) { Data = data; CurrentPage = pagination.Page; PageSize = pagination.PageSize; if (data != null) { RecordCount = recordCount ?? data.Count(); } }
public async Task <IPagedResults <T> > FindPageAsync <TSortKey>(IPagedRequest <T, TSortKey> pagedRequest, params Expression <Func <T, object> >[] includes) { if (pagedRequest.KeySelector == null) { throw new ArgumentException("Order By must be set for a paged result set. Call the OrderBy method on the PagedRequest to set."); } //Build the simple query IQueryable <T> query = _context.Set <T>().Where(pagedRequest.QueryExpression); if (pagedRequest.Comparer != null) { switch (pagedRequest.SortDirection) { case SortDirection.Ascending: query = query.OrderBy(pagedRequest.KeySelector, pagedRequest.Comparer); break; default: query = query.OrderByDescending(pagedRequest.KeySelector, pagedRequest.Comparer); break; } } else { switch (pagedRequest.SortDirection) { case SortDirection.Ascending: query = query.OrderBy(pagedRequest.KeySelector); break; default: query = query.OrderByDescending(pagedRequest.KeySelector); break; } } //Get a count of matching records int totalCount = query.Count(); query = query.Skip((pagedRequest.PageNumber - 1) * pagedRequest.PageSize).Take(pagedRequest.PageSize); if (includes != null && includes.Length > 0) { query = includes.Aggregate(query, (current, include) => current.Include(include)); } var results = await query.ToListAsync(); return(new PagedResults <T>(results, pagedRequest.PageSize, pagedRequest.PageNumber, totalCount)); }
public async Task <IPagedResult <TModel> > FindPagedListAsync(IPagedRequest request, CancellationToken cancellationToken = default) { var pagedList = await FindEntityPagedListAsync(request, cancellationToken); var result = new PagedResult <TModel> { ItemList = pagedList.ItemList.MapReadOnlyList(MapToModel), TotalCount = pagedList.TotalCount }; await AfterFindAsync(result.ItemList, cancellationToken); return(result); }
public static IQueryable <T> ApplyPaging <T>(this IQueryable <T> query, IPagedRequest request) { Guard.ArgumentNotNull(query, nameof(query)); Guard.ArgumentNotNull(request, nameof(request)); if (request.Page < 1) { request.Page = 1; } if (request.PageSize < 1) { request.PageSize = 10; } return(query.ApplyPaging(request.Page, request.PageSize)); }
public static Task <PagedList <TResultItem> > ToPagedListAsync <TQueryItem, TResultItem>( [NotNull] this IQueryable <TQueryItem> query, [NotNull] Expression <Func <TQueryItem, TResultItem> > converter, [CanBeNull] IPagedRequest request) { if (query == null) { throw new ArgumentNullException(nameof(query)); } if (converter == null) { throw new ArgumentNullException(nameof(converter)); } if (request == null || request.PageIndex == null && request.PageSize == null) { return(GetAllAsync(query, converter)); } return(GetPagedAsync(query, converter, request)); }
public async Task <TPagedResult> GetPage <TPagedResult, TKey>(IPagedRequest pagedRequest, Action <PagerOptions <TModel, TKey> > pagerOptions) where TPagedResult : IPagedResult <TModel> { var options = GetPagerOptions(pagerOptions); var query = _modelRepository.Query(options.FilterExpression); var totalItems = await query.CountAsync(); if (options.OrderByExpression == null) { throw new ArgumentNullException(nameof(options.OrderByExpression)); } if (options.IncludeExpressions != null) { query.IncludeMany(options.IncludeExpressions); } return(CreatePagedResult <TPagedResult>(pagedRequest.PageIndex, pagedRequest.ItemsPerPage, totalItems, await(await GetPagedResult(options.OrderBy == OrderBy.Ascending ? query.OrderBy(options.OrderByExpression) : query.OrderByDescending(options.OrderByExpression), pagedRequest.PageIndex, pagedRequest.ItemsPerPage)) .ToArrayAsync())); }
public static IPagedList <T> ToPagedList <T>(this IEnumerable <T> subSet, IPagedRequest request, int totalItemCount) { return(new PagedList <T>(subSet, request.PageNumber, request.PageSize, totalItemCount)); }
protected abstract Task <IPagedResult <TEntity> > FindEntityPagedListAsync(IPagedRequest request, CancellationToken cancellationToken = default);
public static Task <IPagedResult <T> > ToPagedListAsync <T>(this IQueryable <T> query, IPagedRequest request, CancellationToken cancellationToken = default) { return(query.ToPagedListAsync(request.Page, request.PageSize, request.ParsedSorting, null, cancellationToken)); }
/// <summary> /// 从集合中查询指定数据筛选的分页信息 /// </summary> /// <typeparam name="TEntity">动态实体类型</typeparam> /// <typeparam name="TResult">要返回动态实体类型</typeparam> /// <param name="source">数据源</param> /// <param name="predicate">查询条件表达式</param> /// <param name="pageParameters">分页参数</param> /// <param name="selector">数据筛选表达式</param> /// <returns></returns> public static async Task <PageResult <TResult> > ToPageAsync <TEntity, TResult>(this IQueryable <TEntity> source, Expression <Func <TEntity, bool> > predicate, IPagedRequest request, Expression <Func <TEntity, TResult> > selector) { request.NotNull(nameof(request)); selector.NotNull(nameof(selector)); var result = await source.WhereAsync(request.PageIndex, request.PageSize, predicate, request.OrderConditions); var list = await result.data.Select(selector).ToArrayAsync(); var total = result.totalNumber; return(new PageResult <TResult>(list, total)); }
///// <summary> ///// 从集合中查询指定输出DTO的分页信息 ///// </summary> ///// <typeparam name="TEntity">动态实体类型</typeparam> ///// <typeparam name="TOutputDto">输出DTO数据类型</typeparam> ///// <param name="source">数据源</param> ///// <param name="pageParameters">分页参数</param> ///// <returns></returns> public static async Task <IPagedResult <TOutputDto> > ToPageAsync <TEntity, TOutputDto>(this IQueryable <TEntity> source, IPagedRequest request) where TOutputDto : IOutputDto { request.NotNull(nameof(request)); var isFiltered = request is IFilteredPagedRequest; Expression <Func <TEntity, bool> > expression = null; if (isFiltered) { var filter = (request as IFilteredPagedRequest).Filter; expression = filter == null ? null : FilterBuilder.GetExpression <TEntity>(filter); } var result = await source.WhereAsync(request.PageIndex, request.PageSize, expression, request.OrderConditions); var list = await result.data.ToOutput <TOutputDto>().ToArrayAsync(); var total = result.totalNumber; return(new PageResult <TOutputDto>(list, total)); }
/// <summary> /// 从集合中查询指定数据筛选的分页信息 /// </summary> /// <typeparam name="TEntity">动态实体类型</typeparam> /// <typeparam name="TResult">要返回动态实体类型</typeparam> /// <param name="source">数据源</param> /// <param name="predicate">查询条件表达式</param> /// <param name="pageParameters">分页参数</param> /// <param name="selector">数据筛选表达式</param> /// <returns></returns> public static async Task <PageResult <TEntity> > ToPageAsync <TEntity>(this IQueryable <TEntity> source, IPagedRequest request) { request.NotNull(nameof(request)); var result = await source.WhereAsync(request.PageIndex, request.PageSize, null, request.OrderConditions); var list = await result.data.ToArrayAsync(); var total = result.totalNumber; return(new PageResult <TEntity>(list, total)); }
public static ITypeSearch <TEntry> PagedBy <TEntry>(this ITypeSearch <TEntry> typeSearch, IPagedRequest request) where TEntry : IContent { var pageIndex = request.PageNumber < 1 ? 0 : request.PageNumber - 1; var pageSize = request.PageSize > 1000 ? 1000 : request.PageSize; var take = pageSize; var skip = pageSize * pageIndex; typeSearch = SearchExtensions.Take(SearchExtensions.Skip(typeSearch, skip), take); return(typeSearch); }
public static Task <PagedList <TResultItem> > ToPagedListAsync <TResultItem>( [NotNull] this IQueryable <TResultItem> query, [CanBeNull] IPagedRequest request) { return(ToPagedListAsync(query, item => item, request)); }
public static async Task <PageResult <TResult> > ToPageAsync <TEntity, TResult>(this IMongoCollection <TEntity> collection, Expression <Func <TEntity, bool> > predicate, IPagedRequest request, Expression <Func <TEntity, TResult> > selector) { var count = predicate.IsNotNull() ? await collection.CountDocumentsAsync(predicate) : await collection.CountDocumentsAsync(FilterDefinition <TEntity> .Empty); var findFluent = collection.Find(predicate).Skip(request.PageRow * (request.PageIndex - 1)).Limit(request.PageRow); findFluent = findFluent.OrderBy(request.OrderConditions); var lists = await findFluent.Project(selector).ToListAsync(); return(new PageResult <TResult>() { Data = lists, Message = "加载成功", Success = true, Total = count.AsTo <int>() }); }
public static async Task <PagedResponse <TProxy> > CreateAsync <TEntity, TProxy>(IQueryable <TEntity> query, IPagedRequest pagination, Func <TEntity, TProxy> map) { var recordCount = await query.CountAsync(); query = query .Skip((pagination.Page - 1) * pagination.PageSize) .Take(pagination.PageSize); var list = query.ToListAsync().Result.Select(s => map(s)); return(new PagedResponse <TProxy>(pagination, list, recordCount)); }
public static async Task <PagedResponse <TProxy> > ToPagedResponseAsync <TEntity, TProxy>(this IQueryable <TEntity> query, IPagedRequest pagination, Func <TEntity, TProxy> map, CancellationToken cancellationToken = default) { var recordCount = await query.CountAsync(cancellationToken); var result = await query.Skip((pagination.Page - 1) *pagination.PageSize).Take(pagination.PageSize).ToListAsync(cancellationToken); var items = result.Select(s => map(s)); return(new PagedResponse <TProxy>(items, pagination.Page, pagination.PageSize, recordCount)); }
private static PagedResponse <TProxy> ToPagedResponseAsync <TEntity, TProxy>(IQueryable <TEntity> query, IPagedRequest pagination, Func <TEntity, TProxy> map) { return(query.ToPagedResponseAsync <TEntity, TProxy>(pagination, map).GetAwaiter().GetResult()); }
public Task <TPagedResult> GetPage <TPagedResult>(IPagedRequest pagedRequest, Action <PagerOptions <TModel, object> > pagerOptions) where TPagedResult : IPagedResult <TModel> { return(GetPage <TPagedResult, object>(pagedRequest, pagerOptions)); }