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));
}
