public async Task DoPaginationAsync(IPaginationRequest request)
{
await ResetReactionsAsync(request).ConfigureAwait(false);
this._requests.Add(request);
try
{
var tcs = await request.GetTaskCompletionSourceAsync().ConfigureAwait(false);
await tcs.Task.ConfigureAwait(false);
await request.DoCleanupAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
this._client.Logger.LogError(InteractivityEvents.InteractivityPaginationError, ex, "Exception occurred while paginating");
}
finally
{
this._requests.TryRemove(request);
}
}
public async Task DoPaginationAsync(IPaginationRequest request)
{
await ResetReactionsAsync(request);
this._requests.Add(request);
try
{
var tcs = await request.GetTaskCompletionSourceAsync();
await tcs.Task;
await request.DoCleanupAsync();
}
catch (Exception ex)
{
this._client.DebugLogger.LogMessage(LogLevel.Error, "Interactivity",
$"Something went wrong with exception {ex.GetType().Name}.", DateTime.Now);
}
finally
{
this._requests.TryRemove(request);
}
}
async Task PaginateAsync(IPaginationRequest p, DiscordEmoji emoji)
{
var emojis = await p.GetEmojisAsync();
var msg = await p.GetMessageAsync();
if (emoji == emojis.SkipLeft)
{
await p.SkipLeftAsync();
}
else if (emoji == emojis.Left)
{
await p.PreviousPageAsync();
}
else if (emoji == emojis.Right)
{
await p.NextPageAsync();
}
else if (emoji == emojis.SkipRight)
{
await p.SkipRightAsync();
}
else if (emoji == emojis.Stop)
{
var tcs = await p.GetTaskCompletionSourceAsync();
tcs.TrySetResult(true);
return;
}
var page = await p.GetPageAsync();
var builder = new DiscordMessageBuilder()
.WithContent(page.Content)
.WithEmbed(page.Embed);
await builder.ModifyAsync(msg);
}
public async Task <IPagedList <CommentDto> > Handle(GetPagedListOfPostCommentsQuery request,
CancellationToken cancellationToken)
{
int rootCommentsCount = await GetRootCommentsCountOfPostAsync(request.PostId, cancellationToken)
.ConfigureAwait(false);
if (rootCommentsCount == 0)
{
await _context.Post.ThrowIfDoesNotExistAsync(request.PostId)
.ConfigureAwait(false);
return(PagedList <CommentDto> .CreateEmptyPagedList(request));
}
IEnumerable <CommentDto> commentHierarchy = await GetCommentHierarchyOfPostAsync(request.PostId,
request.PageNumber, request.PageSize, cancellationToken)
.ConfigureAwait(false);
IPaginationRequest paginationRequest = request;
return(PagedList <CommentDto> .CreateFromExistingPage(commentHierarchy, rootCommentsCount,
paginationRequest));
}
private PaginationResult assemble(ClarifyGenericMapEntry rootGenericMap, IPaginationRequest paginationRequest)
{
var result = new PaginationResult();
var rootClarifyGeneric = rootGenericMap.ClarifyGeneric;
//setup SDK generic for PaginationRequest if necessary
if (paginationRequest != null)
{
result.CurrentPage = paginationRequest.CurrentPage;
result.PageSize = paginationRequest.PageSize;
rootClarifyGeneric.MaximumRows = 1; //hack! what if query has only one result?
rootClarifyGeneric.MaximumRowsExceeded += (sender, args) =>
{
args.RowsToReturn = paginationRequest.CurrentPage * paginationRequest.PageSize;
result.TotalRecordCount = args.TotalPossibleRows;
};
}
rootClarifyGeneric.DataSet.Query(rootClarifyGeneric);
traverseGenericsPopulatingSubRootMaps(rootGenericMap);
var records = rootGenericMap.ClarifyGeneric.DataRows();
//take the results and constrain them to the requested page
if (paginationRequest != null)
{
var startRow = (paginationRequest.CurrentPage - 1) * paginationRequest.PageSize;
records = records.Skip(startRow).Take(paginationRequest.PageSize);
}
result.Models = createDtosForMap(rootGenericMap, records);
return(result);
}
/// <summary>
/// A static factory method, that paginates the given <paramref name="query"/>
/// according to <paramref name="paginationRequest"/> and creates an instance of type <see cref="PagedList{T}"/>.
/// </summary>
/// <param name="query"></param>
/// <param name="paginationRequest"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public static async Task <PagedList <T> > CreateFromQueryAsync(IQueryable <T> query,
IPaginationRequest paginationRequest,
CancellationToken cancellationToken = default)
{
List <T> currentPageItems = await query
.Paginate(paginationRequest)
.ToListAsync(cancellationToken)
.ConfigureAwait(false);
int totalItemsCount = await query.CountAsync(cancellationToken)
.ConfigureAwait(false);
int totalPagesCount = GetTotalPagesCount(totalItemsCount, paginationRequest.PageSize);
return(new()
{
TotalItemsCount = totalItemsCount,
TotalPagesCount = totalPagesCount,
HasPreviousPage = paginationRequest.PageNumber > 1,
HasNextPage = paginationRequest.PageNumber < totalPagesCount,
CurrentPageNumber = paginationRequest.PageNumber,
CurrentPageItems = currentPageItems
});
}
public static bool UsePagination(this IPaginationRequest pagination) => pagination is null ? false : !(pagination.PageNumber is null) || !(pagination.PageSize is null);
public PaginationResult <MODEL> Get(Filter filter, IPaginationRequest paginationRequest)
{
var rootGenericMap = _mapEntryBuilder.BuildFromModelMap(_modelMap);
return(assembleWithFilter(filter, rootGenericMap, paginationRequest));
}
public PaginationResult <MODEL> Get(Func <FilterExpression, Filter> func, IPaginationRequest paginationRequest)
{
var filter = func(new FilterExpression());
return(Get(filter, paginationRequest));
}
private PaginationResult <MODEL> assembleWithSortOverrides(ClarifyGenericMapEntry rootGenericMap, IPaginationRequest paginationRequest)
{
if (FieldSortMapOverrides.Any()) //override map sort with our own
{
rootGenericMap.ClarifyGeneric.ClearSorts();
foreach (var f in FieldSortMapOverrides)
{
rootGenericMap.ClarifyGeneric.AppendSort(f.FieldName, f.IsAscending);
}
}
return(assemble(rootGenericMap, paginationRequest));
}
private PaginationResult <MODEL> assembleWithFilter(Filter filter, ClarifyGenericMapEntry rootGenericMap, IPaginationRequest paginationRequest)
{
rootGenericMap.ClarifyGeneric.Filter.AddFilter(filter);
return(assembleWithSortOverrides(rootGenericMap, paginationRequest));
}
public static IEnumerable <TSource> Limit <TSource>(this IEnumerable <TSource> query, IPaginationRequest request, StartFrom startFrom = StartFrom.FirstPage) => Limit(query, request.PageSize, request.CurrentPage, startFrom);
public static Paginated <TResult> Paginate <TSource, TResult>(this IEnumerable <TSource> query, IPaginationRequest request, Func <TSource, TResult> target, StartFrom startFrom = StartFrom.FirstPage) => Paginate(query, request.PageSize, request.CurrentPage, target, startFrom);
/// <summary> /// Waits for a custom pagination request to finish. /// This does NOT handle removing emojis after finishing for you. /// </summary> /// <param name="request"></param> /// <returns></returns> public async Task WaitForCustomPaginationAsync(IPaginationRequest request) => await Paginator.DoPaginationAsync(request).ConfigureAwait(false);
/// <summary>
/// A static factory method, that creates an instance of type <see cref="PagedList{T}"/>,
/// containing no items inside.
/// </summary>
public static PagedList <T> CreateEmptyPagedList(IPaginationRequest paginationRequest)
{
return(CreateFromExistingPage(Enumerable.Empty <T>(), 0, paginationRequest));
}
/// <summary>
/// Creates an object of type <see cref="IPagedList{T}"/> based on <paramref name="query"/>
/// according to <paramref name="paginationRequest"/>.
/// </summary>
/// <param name="query"></param>
/// <param name="paginationRequest"></param>
/// <param name="cancellationToken"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static async Task <IPagedList <T> > ProjectToPagedListAsync <T>(this IQueryable <T> query,
IPaginationRequest paginationRequest, CancellationToken cancellationToken = default)
=> await PagedList <T> .CreateFromQueryAsync(query, paginationRequest, cancellationToken);
public static PagedQueryable <T> WithPagination <T>(this SortedQueryable <T> source, IPaginationRequest paginationRequest) => paginationRequest.Paginate(source);
protected ListRequestBase(IPaginationRequest list) : this()
{
PageSize = list.PageSize;
PageNumber = list.PageNumber;
}
public PaginationResult Get(string name, Func <FilterExpression, Filter> filterFunction, IPaginationRequest paginationRequest)
{
var filter = filterFunction(new FilterExpression());
return(Get(name, filter, paginationRequest));
}
public static Task <Paginated <TResult> > PaginateAsync <TSource, TResult>(this IQueryable <TSource> query, IPaginationRequest request, Func <TSource, TResult> target, StartFrom startFrom = StartFrom.FirstPage) => PaginateAsync(query, request.PageSize, request.CurrentPage, target, startFrom);
/// <summary> /// Waits for custom button-based pagination request to finish. /// <br/> /// This does <i><b>not</b></i> invoke <see cref="IPaginationRequest.DoCleanupAsync"/>. /// </summary> /// <param name="request">The request to wait for.</param> public async Task WaitForCustomComponentPaginationAsync(IPaginationRequest request) => await this._compPaginator.DoPaginationAsync(request).ConfigureAwait(false);
/// <summary>
/// Waits for a custom pagination request to finish.
/// This does NOT handle removing emojis after finishing for you.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task WaitForCustomPaginationAsync(IPaginationRequest request)
{
await Paginator.DoPaginationAsync(request);
}
public static IQueryable <TResult> Limit <TSource, TResult>(this IQueryable <TSource> query, IPaginationRequest request, Expression <Func <TSource, TResult> > target, StartFrom startFrom = StartFrom.FirstPage) => Limit(query, request.PageSize, request.CurrentPage, target, startFrom);
