public PagedResultDto(IPagedResultRequest request, long totalItems, IReadOnlyList <T> items)
{
CurrentPage = request.PageIndex;
TotalItems = totalItems;
ItemsPerPage = request.PageSize;
Items = items;
}
public static IQueryable <T> PageBy <T>([NotNull] this IQueryable <T> query, [NotNull] IPagedResultRequest pagedResultRequest)
{
Check.NotNull(query, nameof(query));
Check.NotNull(pagedResultRequest, nameof(pagedResultRequest));
return(query.PageBy(pagedResultRequest.SkipCount, pagedResultRequest.MaxResultCount));
}
/// <summary>
/// 应用requestInput指定的分页参数
/// </summary>
public static IQueryable <T> ApplyPaging <T>(this IQueryable <T> query, IPagedResultRequest requestInput = null) where T : class
{
if (requestInput != null)
{
return(query.PageBy(requestInput));
}
return(query);
}
public IPagedResult <TOutput> GetPage(IPagedResultRequest input)
{
var result = _entityRepository.PageBy(input);
var mapResult = ObjectMapper.Map <List <TEntity>, List <TOutput> >(result.ToList());
return(new PagedResultDto <TOutput>(result.Count(), mapResult));
}
protected List <TEntity> GetList(Expression <Func <TEntity, bool> > predicate,
IPagedResultRequest pagedResultRequest, out int total)
{
var queryable = GetQueryable(predicate);
total = queryable.Count();
return(queryable.OrderBy(t => t.Id).PageBy(pagedResultRequest).ToList());
}
public static IQueryable <TEntity> PageBy <TEntity>(this IOrderedQueryable <TEntity> entities,
IPagedResultRequest pagedResultRequest)
{
if (entities == null)
{
throw new ArgumentNullException(nameof(entities));
}
return(PageBy(entities, pagedResultRequest.PageSize, pagedResultRequest.PageIndex));
}
/// <summary>
/// 将SQL包装为分页SQL
/// </summary>
/// <param name="rawSql">原始SQL(必须包含RowID的序号列)</param>
/// <param name="paggerInput">分页输入</param>
/// <returns>分页SQL</returns>
protected virtual string getPaggerWapperSql(string rawSql, IPagedResultRequest paggerInput)
{
if (string.IsNullOrWhiteSpace(rawSql))
{
throw new ArgumentNullException(nameof(rawSql));
}
string sql =
$@"SELECT * FROM ({rawSql}) AS _T WHERE _T.RowID BETWEEN {paggerInput.SkipCount + 1} AND {(paggerInput.SkipCount + paggerInput.MaxResultCount)} ";
return(sql);
}
/// <summary>
/// 获取分页结果
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <param name="request"></param>
/// <returns></returns>
public static async Task <PagedResult <TModel> > ToPageResultAsync <TEntity, TModel>(
[NotNull] this IQueryable <TEntity> query,
[NotNull] IPagedResultRequest request)
where TModel : class
{
Check.NotNull(request, nameof(request));
var total = await query.LongCountAsync();
var items = await query.PageBy(request).ToListAsync();
var result = new PagedResult <TModel>(request, total, items.Select(MapToListOutput).ToList());
return(result);
public static async Task <IPagedResult <T> > ToPageResultAsync <T>(this IQueryable <T> query,
IPagedResultRequest pagedResultRequest, bool findTotalCount = true)
{
var pageResult = new PagedResultDto <T>();
if (findTotalCount)
{
pageResult.TotalCount = await query.CountAsync();
}
pageResult.Items = await query.Skip(pagedResultRequest.SkipCount).Take(pagedResultRequest.MaxResultCount)
.ToListAsync();
return(pageResult);
}
public static IPagedResult <T> ToPageResult <T>(this IQueryable <T> query, IPagedResultRequest pagedResultRequest,
bool findTotalCount = true)
{
var pageResult = new PagedResultDto <T>();
if (findTotalCount)
{
var totalCount = query.Count();
pageResult.TotalCount = totalCount;
}
pageResult.Items = query.Skip(pagedResultRequest.SkipCount).Take(pagedResultRequest.MaxResultCount)
.ToList();
return(pageResult);
}
/// <summary>
/// Should apply paging if needed.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="input">The input.</param>
protected virtual IQueryable <TEntity> ApplyPaging <TEntity>(IQueryable <TEntity> query, IPagedResultRequest input)
{
//Try to use paging if available
IPagedResultRequest pagedInput = input;
if (pagedInput != null)
{
return(query.PageBy(pagedInput));
}
//Try to limit query result if available
ILimitedResultRequest limitedInput = input;
if (limitedInput != null)
{
return(query.Take(limitedInput.MaxResultCount));
}
//No paging
return(query);
}
public static IQueryable <T> Paging <T>(this IQueryable <T> query, IPagedResultRequest request)
{
query = query.Skip((request.PageNumber - 1) * request.PageSize).Take(request.PageSize);
return(query);
}
/// <summary>
/// Used for paging. Can be used as an alternative to Skip(...).Take(...) chaining.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="request">分页请求</param>
/// <returns></returns>
public static IQueryable <T> PageBy <T>([NotNull] this IQueryable <T> query, IPagedResultRequest request)
{
Check.NotNull(query, nameof(request));
return(PageBy(query, request.Page, request.Limit));
}
protected virtual async Task <PagedResultDto <T> > GetPagedResult <T>(IQueryable <T> query, IPagedResultRequest input) where T : class
{
IQueryable <T> items = ApplyPaging <T>(query, input);
int count = await query.CountAsync();
return(new PagedResultDto <T>(count, await items.ToListAsync()));
}
/// <summary>
/// 获取分页结果
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="query"></param>
/// <param name="request">分页请求</param>
/// <returns></returns>
public static async Task <PagedResult <TEntity> > ToPageResultAsync <TEntity>([NotNull] this IQueryable <TEntity> query, [NotNull] IPagedResultRequest request)
{
Check.NotNull(request, nameof(request));
var total = query.LongCount();
var items = query.PageBy(request);
return(new PagedResult <TEntity>(request, total, await items.ToListAsync()));
}
/// <summary>
/// Used for paging with an <see cref="IPagedResultRequest"/> object.
/// </summary>
/// <param name="query">Queryable to apply paging</param>
/// <param name="pagedResultRequest">An object implements <see cref="IPagedResultRequest"/> interface</param>
public static IQueryable <T> PageBy <T>(this IQueryable <T> query, IPagedResultRequest pagedResultRequest)
{
return(query.PageBy(pagedResultRequest.PageIndex, pagedResultRequest.PageSize));
}
public static IPagedResult <T> PageBy <T>(this IEnumerable <T> query, IPagedResultRequest pagedResultRequest)
{
return(query.PageBy((pagedResultRequest.PageCount * (pagedResultRequest.PageIndex - 1)), pagedResultRequest.PageCount));
}
public IQueryable <TSource> ApplySorting <TSource, TSourcePrimaryKey>(IQueryable <TSource> query, IPagedResultRequest input) where TSource : class, IEntity <TSourcePrimaryKey>
{
//Try to sort query if available
var sortInput = input as ISortedResultRequest;
if (sortInput != null)
{
if (!sortInput.Sorting.IsNullOrWhiteSpace())
{
return(query.OrderBy(sortInput.Sorting));
}
}
//IQueryable.Task requires sorting, so we should sort if Take will be used.
if (input is ILimitedResultRequest)
{
return(query.OrderByDescending(e => e.Id));
}
//No sorting
return(query);
}
/// <summary>
/// Used for paging with an <see cref="IPagedResultRequest"/> object.
/// </summary>
/// <param name="query">Queryable to apply paging</param>
/// <param name="pagedResultRequest">An object implements <see cref="IPagedResultRequest"/> interface</param>
public static IQueryable <T> PageBy <T>(this IQueryable <T> query, IPagedResultRequest pagedResultRequest)
{
return(query.PageBy((pagedResultRequest.CurrentPage - 1) * pagedResultRequest.MaxResultCount, pagedResultRequest.MaxResultCount));
}
public IQueryable <TSource> ApplyPaging <TSource>(IQueryable <TSource> query, IPagedResultRequest input)
{
//Try to use paging if available
var pagedInput = input as IPagedResultRequest;
if (pagedInput != null)
{
return(query.PageBy(pagedInput));
}
//Try to limit query result if available
var limitedInput = input as ILimitedResultRequest;
if (limitedInput != null)
{
return(query.Take(limitedInput.MaxResultCount));
}
//No paging
return(query);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="query"></param>
/// <param name="page"></param>
/// <param name="selector"></param>
/// <returns></returns>
public async static Task <PagedResultDto <TResult> > ToPagedResultAsync <TSource, TResult>(this IQueryable <TSource> query, IPagedResultRequest page, Expression <Func <TSource, TResult> > selector) where TResult : class
{
var count = await query.CountAsync();
var list = await query.Select(selector).Skip(page.SkipCount).Take(page.MaxResultCount).AsNoTracking().ToListAsync();
return(new PagedResultDto <TResult>(count, list));
}
public PagedResult(IPagedResultRequest request,
long totalCount,
IReadOnlyList <T> items) : this(request.Page, request.Limit, totalCount, items)
{
}
/// <summary>
/// Used for paging with an <see cref="T:Abp.Application.Services.Dto.IPagedResultRequest" /> object.
/// </summary>
/// <param name="query">Queryable to apply paging</param>
/// <param name="pagedResultRequest">An object implements <see cref="T:Abp.Application.Services.Dto.IPagedResultRequest" /> interface</param>
public static IQueryable <T> PageBy <T>(this IQueryable <T> query, IPagedResultRequest pagedResultRequest)
{
return(PageBy(query, pagedResultRequest.SkipCount, pagedResultRequest.MaxResultCount));
}
protected async Task <PagedResultDto <TDestination> > GetAllPagedByQueryFilter <TDestination, TSource, TSourcePrimaryKey>(IQueryable <TSource> query, IPagedResultRequest input) where TSource : class, IEntity <TSourcePrimaryKey>
{
var totalCount = await query.CountAsync();
query = ApplySorting <TSource, TSourcePrimaryKey>(query, input);
query = ApplyPaging(query, input);
var entities = await query.ToListAsync();
return(new PagedResultDto <TDestination>(
totalCount,
entities.Select(v => v.MapTo <TDestination>()).ToList()
));
}
