public Task <IPagedResults <IAssetRegisterVersion> > Search(IPagedQuery searchRequest, CancellationToken cancellationToken)
{
using (var context = new AssetRegisterContext(_databaseUrl))
{
IQueryable <AssetRegisterVersionEntity> queryable = context.AssetRegisterVersions;
queryable = queryable.OrderByDescending(o => o.Id)
.Skip((searchRequest.Page.Value - 1) * searchRequest.PageSize.Value)
.Take(searchRequest.PageSize.Value);
IEnumerable <AssetRegisterVersionEntity> results = queryable.ToList();
int totalCount = context.AssetRegisterVersions.Select(s => s.Id).Count();
IPagedResults <IAssetRegisterVersion> pagedResults = new PagedResults <IAssetRegisterVersion>
{
Results = results.Select(s => new AssetRegisterVersion
{
Id = s.Id,
ModifiedDateTime = s.ModifiedDateTime
} as IAssetRegisterVersion).ToList(),
TotalCount = totalCount,
NumberOfPages = (int)Math.Ceiling(totalCount / (decimal)searchRequest.PageSize.Value)
};
return(Task.FromResult(pagedResults));
}
}
public static PageData GetPageData(IPagedQuery query)
{
int offset;
if (!query.Page.HasValue ||
!query.PerPage.HasValue)
{
offset = 0;
}
else
{
offset = (query.Page.Value - 1) * query.PerPage.Value;
}
int next;
if (!query.PerPage.HasValue)
{
next = int.MaxValue;
}
else
{
next = query.PerPage.Value;
}
return(new PageData(offset, next));
}
public PagedResult <TEntity> Find <TEntity>(IPagedQuery <TEntity> query, int pageNumber, int itemsPerPage) where TEntity : class
{
var skip = pageNumber * itemsPerPage;
return(query.Execute(session,
databaseProvider(),
skip, itemsPerPage));
}
public async Task <PagedResponse <CaffItemDto> > GetPagedCaffItemsAsync(IPagedQuery pagedQuery)
{
var response = await _context
.CaffItems
.ToPagedAsync <CaffItem, CaffItemDto>(pagedQuery, _mapper);
await _fileService.SetPreviewFileUris(response.Results.Select(r => r.PreviewFile));
return(response);
}
private static void AddPaginationToQueryBuilder(IDapperQuery dapperQuery, IPagedQuery pagedQuery)
{
var sqlBuilder = dapperQuery.SqlBuilder;
var config = pagedQuery.PagingConfiguration !;
var offset = config.ItemsPerPage * (config.Page - 1);
sqlBuilder.Offset("@Paging_Offset", new { Paging_Offset = offset });
sqlBuilder.FetchNext("@Paging_FetchNext", new { Paging_FetchNext = config.ItemsPerPage });
}
protected IHttpActionResult Page <T>(IPagedQuery query, bool withoutProjection = false)
{
var viewModel = MapViewModel <IEnumerable <T>, T>(query, withoutProjection);
return(Ok(new
{
Result = viewModel,
query?.Total
}));
}
public override Task <IPagedEnumerable <TResult> > Execute(IPagedQuery <TResult> query, CancellationToken cancellationToken,
IContainer container)
{
Task <IPagedEnumerable <TResult> > Handler() => container.ResolveHandler <IPagedQueryHandler <TQuery, TResult> >().Execute((TQuery)query, cancellationToken);
return(container
.ResolveAll <IPipelineBehavior <TQuery, IPagedEnumerable <TResult> > >()
.Reverse()
.Aggregate((HandlerDelegate <IPagedEnumerable <TResult> >)Handler, (next, pipeline) => () => pipeline.Execute((TQuery)query, cancellationToken, next))());
}
/// <summary>
/// Requests the next page to the API, and returns it wrapped in an <see cref="IBridgeResponseCollection{T}"/> object.
/// </summary>
/// <returns>A wrapper around the response to the request for a next page. In abscence of a next page, this method returns the current page from the internal cache.</returns>
public IBridgeResponseCollection <T> More()
{
if (HasMore)
{
if (EndpointBuilder.Query is IPagedQuery)
{
IPagedQuery paged = (IPagedQuery)EndpointBuilder.Query;
paged.Page = (paged.Page ?? 1) + 1;
return(_requestHandler.ProcessRequest <T>(EndpointBuilder));
}
}
return(this);
}
public Task <IPagedEnumerable <TResult> > ExecuteAsync <TResult>(IPagedQuery <TResult> query, CancellationToken cancellationToken = default) where TResult : class
{
if (query is null)
{
throw new ArgumentNullException(nameof(query));
}
var queryType = query.GetType();
var handler = (PagedQueryHandlerWrapper <TResult>)_pagedQueryHandlers.GetOrAdd(queryType,
t => Activator.CreateInstance(typeof(PagedQueryHandlerWrapperImpl <,>).MakeGenericType(queryType, typeof(TResult))));
return(handler.Execute(query, cancellationToken, this.container));
}
public static IFindFluent <T, T> Limit <T>(this IFindFluent <T, T> collection, IPagedQuery query) => collection.Limit(query.Page, query.Results);
public static async Task <PagedResult <T> > PaginateAsync <T>(this IMongoQueryable <T> collection, IPagedQuery query) => await collection.PaginateAsync(query.OrderBy, query.SortOrder, query.Page, query.Results);
public async Task <IPagedResult <License> > BrowseAsync(Guid customerId, IPagedQuery query) => await _repository.BrowseAsync(license => license.CustomerId == customerId, query);
public static PagedResult <T> Paginate <T>(this IEnumerable <T> values, IPagedQuery query) => values.Paginate(query.Page, query.Results);
protected CrudPageingController(IPagedQuery <TPoco> pageing, ICrudService <TPoco> crudservice)
: base(crudservice)
{
_pageing = pageing;
}
public static async Task <PagedResult <T> > PaginateAsync <T>(this IMongoQueryable <T> collection, IPagedQuery query)
{
return(await collection.PaginateAsync(query.Page, query.Results));
}
public virtual async Task<PagedCollection<MovementDto>> FormatResult(IPagedQuery query, IOrderedQueryable<Movement> movements)
{
return await movements.Map().ToPagedCollectionAsync(query);
}
private static TCollection MapViewModel <TCollection, T>(IPagedQuery query, bool withoutProjection)
{
if (query == null)
{
return(default);
public T Execute <T>(IPagedQuery <T> query, int numberOfItems, int page)
{
return(query.Execute(dataStore, numberOfItems, page));
}
public static Task <PagedResultFromStart <T> > PaginateFromStartAsync <T, TKey>(this IFindFluent <T, T> collection, IPagedQuery query, long?totalResultsInCollection)
where T : IIdentifiable <TKey>
=> PaginateFromStartAsync <T, TKey>(collection, query.Page, query.Results, totalResultsInCollection);
public static IMongoQueryable <T> Limit <T>(this IMongoQueryable <T> collection, IPagedQuery query) => collection.Limit(query.Page, query.Results);
public static async Task <PagedResult <T> > Paginate <T>(this IMongoQueryable <T> collection, IPagedQuery query, CancellationToken cancellationToken = default) => await collection.Paginate(query.OrderBy, query.SortOrder, query.Page, query.Results, cancellationToken);
public static async Task <PagedResponse <TDestination> > ToPagedAsync <TSource, TDestination>(this IQueryable <TSource> query, IPagedQuery pagedQuery, IMapper mapper) where TSource : class
{
var result = new PagedResponse <TDestination>
{
CurrentPage = pagedQuery.Page,
PageSize = pagedQuery.PageSize,
TotalResultCount = await query.CountAsync()
};
var skip = (pagedQuery.Page - 1) * pagedQuery.PageSize;
result.Results = await query
.Skip(skip)
.Take(pagedQuery.PageSize)
.ProjectTo <TDestination>(mapper.ConfigurationProvider)
.ToListAsync();
return(result);
}
public static async Task <IPagedResult <T> > PaginateAsync <T>(this IQueryable <T> collection, IPagedQuery query) => await collection.PaginateAsync(query.Page, query.Results);
public static Task <PagedResult <T> > PaginateAsync <T, TKey>(this IMongoQueryable <T> collection, IPagedQuery query)
where T : IIdentifiable <TKey>
=> PaginateAsync <T, TKey>(collection, query.Results);
public TEntity FindFirstOrDefault <TEntity>(IPagedQuery <TEntity> query) where TEntity : class
{
return(One(Find(query, 0, 1), false));
}
public PagedResult <TEntity> Find <TEntity>(IPagedQuery <TEntity> query, int pageNumber, int itemsPerPage) where TEntity : class
{
return(query.Execute(beerDbContext, (pageNumber - 1) * itemsPerPage, itemsPerPage));
}
public TEntity FindFirstOrDefault <TEntity>(IPagedQuery <TEntity> query) where TEntity : class
{
return(query.Execute(beerDbContext, 0, 1).FirstOrDefault());
}
public abstract Task <IPagedEnumerable <TResult> > Execute(IPagedQuery <TResult> query, CancellationToken cancellationToken,
IContainer container);
public static async Task <bool> QueryAllPages <T>(this IQueryDispatcher queryDispatcher, IPagedQuery <T> query, Func <T, bool> callback)
{
IPagedResult <T> page;
do
{
page = await queryDispatcher.QueryAsync(query);
foreach (var item in page.Items)
{
if (callback(item))
{
return(true);
}
}
page.Bind(p => p.CurrentPage, page.CurrentPage + 1); // todo yuck
} while (page.CurrentPage < page.TotalPages);
return(false);
}
public PagedResult <T> Find <T>(IPagedQuery <T> query)
{
return(query.Execute(Session));
}
public static async Task <ListDto <T2> > ProjectAndPageAsync <T1, T2>(this IQueryable <T1> queryable, IPagedQuery query)
where T1 : class
where T2 : class
{
var count = await queryable.CountAsync();
var items = await queryable.Skip(query.PageIndex *query.PageSize)
.Take(query.PageSize)
.ProjectTo <T2>()
.ToListAsync();
return(new ListDto <T2>()
{
Count = count,
PageSize = query.PageSize,
PageIndex = query.PageIndex,
Items = items
});
}
