public void Run(IPageRequest nextCommand)
{
while (nextCommand != null)
{
nextCommand = _mediator.Send(nextCommand);
}
}
/// <summary>
/// Request to change a page
/// </summary>
/// <param name="request">The request.</param>
/// <exception cref="System.ArgumentNullException">request</exception>
public void Change(IPageRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
OnNext(request);
}
public async Task <PageResponse> Page(string tableName, IPageRequest req)
{
if (!req.ContainsQueryField("columnNum"))
{
return(PageResponse <ContentData> .Error("无效数据"));
}
return(await _dapper.Page(tableName, req));
}
/// <summary>
/// Returns a single page of results from an IQueryable.
/// </summary>
/// <typeparam name="T">The collection type.</typeparam>
/// <param name="source">The collection to be paged.</param>
/// <param name="request">An IPageRequest specifying a PageSize and a PageNumber to by which to reduce the collection.</param>
/// <returns>the IQueryable with Skip() and Take() applied.</returns>
public static IQueryable <T> Page <T>(this IQueryable <T> source, IPageRequest request)
{
if (request is object)
{
return(source.Page(request.PageNumber, request.PageSize));
}
return(source);
}
/// <summary>
/// Returns a single page of results from an IOrderedQueryable.
/// </summary>
/// <typeparam name="T">The collection type.</typeparam>
/// <param name="source">The collection to be paged.</param>
/// <param name="request">An IPageRequest specifying a PageSize and a PageNumber to reduce the collection by.</param>
/// <returns>the IOrderedQueryable with Skip() and Take() applied.</returns>
public static IQueryable <T> Page <T>(this IOrderedQueryable <T> source, IPageRequest request)
{
if (request != null)
{
return(source.Page(request.PageNumber, request.PageSize));
}
return(source);
}
/// <inheritdoc/>
public Task <IPageResult <TModel> > AllAsync(IPageRequest pageRequest, CancellationToken ct)
{
var result = new PageResult <TModel>
{
Items = Enumerable.Empty <TModel>(),
};
return(Task.FromResult <IPageResult <TModel> >(result));
}
/// <summary>
/// Computes the Linq 'Take' amount
/// </summary>
/// <param name="pageRequest">extended</param>
/// <returns>skip amount</returns>
public static int TakeAmount(this IPageRequest pageRequest)
{
Arguments.NotNull(pageRequest, nameof(pageRequest));
#pragma warning disable CA1062 // Validate arguments of public methods
return((int)pageRequest.PageSize);
#pragma warning restore CA1062 // Validate arguments of public methods
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public PageController(IPageRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
OnNext(request);
}
public async Task <PageResponse> Page(string tableName, IPageRequest req)
{
var whereSql = _pageSqlHelper.OutDefaultParams(req.Queries, out var whereParams);
var dataSql = _pageSqlHelper.GetPageDataSql(req, whereSql, tableName);
var countSql = _pageSqlHelper.GetPageCountSql(whereSql, tableName);
return(new PageResponse(
await Connection().QueryAsync <dynamic>(dataSql, whereParams),
await Connection().QueryFirstOrDefaultAsync <long>(countSql, whereParams)));
}
public static IQueryable <TEntity> PageQuery <TEntity>(IPageRequest request, IQueryable <TEntity> query)
where TEntity : class
{
if (request.StartIndex.HasValue && request.StartIndex.Value > 0)
{
query = query.Skip(request.StartIndex.Value);
}
query = query.Take(Math.Min(request.Count ?? 100, 100));
return(query);
}
public static IReadOnlyDictionary <string, object> ToReadOnlyDictionary(this IPageRequest request)
{
return(request
.GetType()
.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
.Where(x => x.GetValue(request) != null)
.ToDictionary(x => {
var attr = x.GetCustomAttribute <QueryStringKeyAttribute>();
return attr?.Key ?? x.Name.ToLowerInvariant();
}, x => x.GetValue(request)));
}
public IPageRequest <T> AddSortAndOrderItems(IPageRequest <T> request)
{
if (SortBy.Item != null)
{
request.OrderColumnName = SortBy.Item.Value;
}
if (AscDesc.Item != null)
{
request.SortOrder = AscDesc.Item.Value;
}
return(request);
}
private IChangeSet <T> Page(IPageRequest request)
{
if (request == null || request.Page < 0 || request.Size < 1)
{
return(null);
}
if (request.Size == _parameters.Size && request.Page == _parameters.Page)
{
return(null);
}
_parameters = request;
return(Page());
}
private IChangeSet <T> Page(List <T> all, ChangeAwareList <T> paged, IPageRequest request)
{
if (request == null || request.Page < 0 || request.Size < 1)
{
return(null);
}
if (request.Size == _parameters.Size && request.Page == _parameters.Page)
{
return(null);
}
_parameters = request;
return(Page(all, paged));
}
public IPagedChangeSet <TObject, TKey>?Paginate(IPageRequest?parameters)
{
if (parameters is null || parameters.Page < 0 || parameters.Size < 1)
{
return(null);
}
if (parameters.Size == _request.Size && parameters.Page == _request.Page)
{
return(null);
}
_request = parameters;
return(Paginate());
}
private int CalculatePages(List <T> all, IPageRequest request)
{
if (request.Size >= all.Count)
{
return(1);
}
int pages = all.Count / request.Size;
int overlap = all.Count % request.Size;
if (overlap == 0)
{
return(pages);
}
return(pages + 1);
}
public static Pageable <Story> Page(this IEnumerable <Story> source, IPageRequest request)
{
Pageable <Story> pageable = new Pageable <Story>
{
totalCount = source.Count(),
pageSize = request.pageSize,
page = request.page
};
if (!string.IsNullOrWhiteSpace(request.search))
{
pageable.content = source.Where(x => x?.title?.IndexOf(request.search.Trim(), StringComparison.OrdinalIgnoreCase) > -1);
}
else
{
pageable.content = source;
}
pageable.filtered = (pageable.content?.Count()).GetValueOrDefault();
pageable.content = pageable.content?.Skip(request.page * request.pageSize).Take(request.pageSize);
pageable.Calculate();
return(pageable);
}
public override string GetPageDataSql(IPageRequest req, string whereSql, string tableName)
{
return
($"SELECT * FROM (SELECT *,ROW_NUMBER() OVER({req.Sort.ToSql()}) AS RowNum FROM [{tableName}] WHERE 1=1 {whereSql}) AS temp WHERE RowNum BETWEEN {req.Begin} AND {req.End} ");
}
public Paginator()
{
_request = PageRequest.Default;
_isLoaded = false;
}
public static IQueryable <T> Page <T>(this IQueryable <T> source, IPageRequest request)
{
return(source
.Skip(request.GetSkip())
.Take(request.PageSize));
}
private void OnNext(IPageRequest request)
{
_subject.OnNext(request);
}
private static int GetSkip(this IPageRequest request)
{
var pageNumber = request.PageNumber < 1 ? 1 : request.PageNumber;
return((pageNumber - 1) * request.PageSize);
}
/// <summary>
/// Generalized Queryable search that supports filtering and paging
/// </summary>
/// <param name="filter">filter expression</param>
/// <param name="pageRequest">page request</param>
/// <param name="ct">cancellation token</param>
/// <returns>search results</returns>
protected async Task <IPageResult <TModel> > OnGeneralizedSearch(Expression <Func <TModel, bool> > filter, IPageRequest pageRequest, CancellationToken ct)
{
var result = new PageResult <TModel>
{
PageNumber = 1,
};
var query = this.OnQueryable(ct);
// add filter expression to query
if (filter != null)
{
var expression = this.DataMapper.MapExpression <Expression <Func <TEntity, bool> > >(filter);
query = query.Where(expression);
}
// add paging expression to query
if (pageRequest != null)
{
result.PageNumber = pageRequest.PageNumber;
query = query.Skip(pageRequest.SkipAmount())
.Take(pageRequest.TakeAmount());
if (pageRequest.IncludeTotalCount)
{
await this.CountEntityAsync(result, query, ct)
.ConfigureAwait(false);
}
}
var entitySet = query.ToList();
result.Items = this.OnConvert(entitySet);
return(result);
}
/// <summary> /// 获取分页查询数据SQL /// </summary> /// <param name="req"></param> /// <param name="whereSql"></param> /// <param name="tableName"></param> /// <returns></returns> public abstract string GetPageDataSql(IPageRequest req, string whereSql, string tableName);
/// <inheritdoc/>
public Task <IPageResult <TModel> > AllAsync(IPageRequest pageRequest, CancellationToken ct)
{
return(this.OnGeneralizedSearch(null, pageRequest, ct));
}
/// <inheritdoc/>
public Task <IPageResult <TModel> > WhereAsync(Expression <Func <TModel, bool> > filter, IPageRequest pageRequest, CancellationToken ct)
{
return(this.OnGeneralizedSearch(filter, pageRequest, ct));
}
public static IQueryable <TEntity> ApplyPaging <TEntity>(this IQueryable <TEntity> query, IPageRequest pageRequest, out int total)
where TEntity : class, IEntity
{
if (pageRequest == null)
{
throw new ArgumentNullException(nameof(pageRequest));
}
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
IQueryable <TEntity> result;
if (!string.IsNullOrEmpty(pageRequest.OrderColumnName))
{
result = query.OrderBy(pageRequest.OrderColumnName + " " + pageRequest.SortOrder);
}
else
{
result = query.OrderBy("Id");
}
total = result.Count();
return(result.Skip(pageRequest.PageSize * (pageRequest.CurrentPage - 1))
.Take(pageRequest.PageSize));
}
private PageChangeSet <T> Page(List <T> all, ChangeAwareList <T> paged, IPageRequest request, IChangeSet <T> changeset = null)
{
if (changeset != null)
{
all.Clone(changeset);
}
var previous = paged;
int pages = CalculatePages(all, request);
int page = request.Page > pages ? pages : request.Page;
int skip = request.Size * (page - 1);
var current = all.Skip(skip)
.Take(request.Size)
.ToList();
var adds = current.Except(previous);
var removes = previous.Except(current);
paged.RemoveMany(removes);
adds.ForEach(t =>
{
var index = current.IndexOf(t);
paged.Insert(index, t);
});
var startIndex = skip;
var moves = changeset.EmptyIfNull()
.Where(change => change.Reason == ListChangeReason.Moved &&
change.MovedWithinRange(startIndex, startIndex + request.Size));
foreach (var change in moves)
{
//check whether an item has moved within the same page
var currentIndex = change.Item.CurrentIndex - startIndex;
var previousIndex = change.Item.PreviousIndex - startIndex;
paged.Move(previousIndex, currentIndex);
}
//find replaces [Is this ever the case that it can be reached]
for (int i = 0; i < current.Count; i++)
{
var currentItem = current[i];
var previousItem = previous[i];
if (ReferenceEquals(currentItem, previousItem))
{
continue;
}
var index = paged.IndexOf(currentItem);
paged.Move(i, index);
}
var changed = paged.CaptureChanges();
return(new PageChangeSet <T>(changed, new PageResponse(paged.Count, page, all.Count, pages)));
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public PageController(IPageRequest request)
{
if (request == null) throw new ArgumentNullException(nameof(request));
OnNext(request);
}
/// <summary>
/// Request to change a page
/// </summary>
/// <param name="request">The request.</param>
/// <exception cref="System.ArgumentNullException">request</exception>
public void Change(IPageRequest request)
{
if (request == null) throw new ArgumentNullException(nameof(request));
OnNext(request);
}
public PageOption(string key, string description, IPageRequest action)
{
Key = key;
Description = description;
Action = action;
}
private void OnNext(IPageRequest request)
{
_subject.OnNext(request);
}
private PageChangeSet <T> CheckParametersAndPage(List <T> all, ChangeAwareList <T> paged, IPageRequest request)
{
if (request == null || request.Page < 0 || request.Size < 1)
{
return(null);
}
return(Page(all, paged, request));
}
