public PagedList(IMongoQueryable <T> superset, int pageNumber, int pageSize)
{
if (pageNumber < 1)
{
throw new ArgumentOutOfRangeException("pageNumber", pageNumber, "PageNumber cannot be below 1.");
}
if (pageSize < 1)
{
throw new ArgumentOutOfRangeException("pageSize", pageSize, "PageSize cannot be less than 1.");
}
TotalItemCount = superset == null ? 0 : superset.Count();
PageSize = pageSize;
PageNumber = pageNumber;
PageCount = TotalItemCount > 0 ? (int)Math.Ceiling(TotalItemCount / (double)PageSize) : 0;
HasPreviousPage = PageNumber > 1;
HasNextPage = PageNumber < PageCount;
IsFirstPage = PageNumber == 1;
IsLastPage = PageNumber >= PageCount;
FirstItemOnPage = (PageNumber - 1) * PageSize + 1;
var numberOfLastItemOnPage = FirstItemOnPage + PageSize - 1;
LastItemOnPage = numberOfLastItemOnPage > TotalItemCount
? TotalItemCount
: numberOfLastItemOnPage;
if (superset != null && TotalItemCount > 0)
{
Subset.AddRange(pageNumber == 1
? superset.Skip(0).Take(pageSize).ToList()
: superset.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList()
);
}
}
private void Init(IMongoQueryable <T> source, int pageIndex, int pageSize, int?totalCount = null)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (pageSize <= 0)
{
throw new ArgumentException("pageSize must be greater than zero");
}
TotalCount = totalCount ?? source.Count();
TotalPages = TotalCount / pageSize;
if (TotalCount % pageSize > 0)
{
TotalPages++;
}
PageSize = pageSize;
PageIndex = pageIndex;
source = totalCount == null?source.Skip(pageIndex *pageSize).Take(pageSize) : source;
AddRange(source);
}
/// <summary>
/// Mount the query based on the params sent to the methods of query.
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="where"></param>
/// <param name="orderby"></param>
/// <param name="skip"></param>
/// <param name="take"></param>
/// <returns></returns>
protected virtual IMongoQueryable <TEntity> GetQueryable <TEntity>(
Expression <Func <TEntity, bool> > where = null,
Func <IMongoQueryable <TEntity>, IOrderedMongoQueryable <TEntity> > orderby = null,
int?skip = null,
int?take = null)
where TEntity : class, IEntity, new()
{
//Query
IMongoQueryable <TEntity> query = contexto.Set <TEntity>().AsQueryable();
if (where != null)
{
query = query.Where(where);
}
if (orderby != null)
{
query = orderby(query);
}
if (skip.HasValue)
{
query = query.Skip(skip.Value);
}
if (take.HasValue)
{
query = query.Take(take.Value);
}
return(query);
}
public static async Task <IQueryResult <TDocument> > Paginate <TDocument>(this IMongoQueryable <TDocument> queryable, PaginationOptions <TDocument> options)
{
if (options == default)
{
options = new PaginationOptions <TDocument>()
{
Page = DefaultPage,
PageSize = DefaultPageSize
};
}
if (options.Sorting != default && options.Sorting.Any())
{
(var selector, var ascending) = options.Sorting.First();
var orderQueryable = ascending ? queryable.OrderBy(selector) : queryable.OrderByDescending(selector);
foreach (var(selectorThen, ascendingThen) in options.Sorting.Skip(1))
{
orderQueryable = ascendingThen ? orderQueryable.ThenBy(selectorThen) : orderQueryable.ThenByDescending(selectorThen);
}
queryable = orderQueryable;
}
int page = options.Page ?? DefaultPage;
int pageSize = options.PageSize ?? DefaultPageSize;
int toSkip = (page - 1) * pageSize;
List <TDocument> listResult = await queryable.Skip(toSkip).Take(pageSize + 1).ToListAsync();
var hasNext = listResult.Count >= (pageSize + 1);
if (hasNext)
{
listResult.RemoveAt(listResult.Count - 1);
}
return(new QueryResult <TDocument>(hasNext, listResult));
}
private async Task InitializeAsync(IMongoQueryable <T> source, int pageIndex, int pageSize, int?totalCount = null)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (pageSize <= 0)
{
throw new ArgumentException("pageSize deve ser maior do que zero!");
}
TotalCount = totalCount ?? await source.CountAsync();
source = totalCount == null?source.Skip(pageIndex *pageSize).Take(pageSize) : source;
AddRange(source);
if (pageSize > 0)
{
TotalPages = TotalCount / pageSize;
if (TotalCount % pageSize > 0)
{
TotalPages++;
}
}
PageSize = pageSize;
PageIndex = pageIndex;
}
public async Task <IEnumerable <WorkflowInstance> > GetWorkflowInstances(WorkflowStatus?status, string type, DateTime?createdFrom, DateTime?createdTo, int skip, int take)
{
IMongoQueryable <WorkflowInstance> result = WorkflowInstances.AsQueryable();
if (status.HasValue)
{
result = result.Where(x => x.Status == status.Value);
}
if (!String.IsNullOrEmpty(type))
{
result = result.Where(x => x.WorkflowDefinitionId == type);
}
if (createdFrom.HasValue)
{
result = result.Where(x => x.CreateTime >= createdFrom.Value);
}
if (createdTo.HasValue)
{
result = result.Where(x => x.CreateTime <= createdTo.Value);
}
return(await result.Skip(skip).Take(take).ToListAsync());
}
/// <summary>
/// Return an object that contains paged result for a query
/// </summary>
/// <param name="page">Page</param>
/// <param name="limit">Limit per page</param>
/// <param name="query">Query to apply</param>
/// <returns></returns>
public async Task <PagedList <TDocument> > Get(int page, int limit, IMongoQueryable <TDocument> query)
{
// Define a query
query ??= AsQueryable();
// Apply main filters
query = query.Where(p => !p.Deleted);
//
// Get count
var total = await query.CountAsync();
// Create result
var result = new PagedList <TDocument>
{
TotalCount = total,
PageIndex = page,
PageSize = limit
};
// Return result
if (total == 0)
{
return(result);
}
query = limit == 0 ? query : query.Skip((page - 1) * limit).Take(limit);
result.AddRange(await query.ToListAsync());
return(result);
}
protected virtual IMongoQueryable <TEntidade> ObterQueryable <TEntidade>(
Expression <Func <TEntidade, bool> > filtro = null,
Func <IMongoQueryable <TEntidade>, IOrderedMongoQueryable <TEntidade> > ordenarPor = null,
int?skip = null,
int?take = null)
where TEntidade : class, IEntidade, new()
{
IMongoQueryable <TEntidade> query = contexto.Set <TEntidade>().AsQueryable();
if (filtro != null)
{
query = query.Where(filtro);
}
if (ordenarPor != null)
{
query = ordenarPor(query);
}
if (skip.HasValue)
{
query = query.Skip(skip.Value);
}
if (take.HasValue)
{
query = query.Take(take.Value);
}
return(query);
}
public static async Task <PagedResult <T> > PaginateAsync <T>(this IMongoQueryable <T> values, int page = 1,
int results = 10)
{
var totalResults = await values.CountAsync();
if (totalResults == 0)
{
return(PagedResult <T> .Empty);
}
if (page <= 0)
{
page = 1;
}
if (results <= 0)
{
results = 10;
}
var totalPages = (int)Math.Ceiling((double)totalResults / results);
var skip = (page - 1) * results;
var items = await values.Skip(skip).Take(results).ToListAsync();
return(PagedResult <T> .Create(items, page, results, totalPages, totalResults));
}
public static async Task <MongoPagedList <T> > CreateAsync(IMongoQueryable <T> source, int pageNumber, int pageSize)
{
int count = await source.CountAsync();
var items = await source.Skip((pageNumber - 1) *pageSize).Take(pageSize).ToListAsync();
return(new MongoPagedList <T>(items, count, pageNumber, pageSize));
}
public static async Task <PaginatedList <T> > CreateAsync(IMongoQueryable <T> source, int pageIndex, int pageSize)
{
var count = await source.CountAsync();
var items = await source.Skip((pageIndex - 1) *pageSize).Take(pageSize).ToListAsync();
return(new PaginatedList <T>(items, count, pageIndex, pageSize));
}
private static IMongoQueryable <T> Limit <T>(this IMongoQueryable <T> collection,
int currentPage, int pageSize)
{
var skip = pageSize * (currentPage - 1);
var data = collection.Skip(skip)
.Take(pageSize);
return(data);
}
public static async Task <PagedQueryResult <TSource> > GetPagedAsync <TSource>(this IMongoQueryable <TSource> source, GetPagedResourceQuery resource)
{
var countOfDocuments = source.CountAsync();
var points = source.Skip((resource.Page - 1) * resource.PageSize).Take(resource.PageSize).ToListAsync();
await Task.WhenAll(countOfDocuments, points);
return(PagedQueryResult <TSource> .Create(points.Result, countOfDocuments.Result, (countOfDocuments.Result / resource.PageSize)));
}
public async Task <IReadOnlyList <LogModule.Domain.Entities.Log> > GetPagedReponseAsync(int pageNumber, int pageSize, LogLevels logLevel = LogLevels.ALL, string sorOrder = "desc")
{
IMongoQueryable <LogModule.Domain.Entities.Log> query = _logs.AsQueryable();
switch (logLevel)
{
case LogLevels.ALL:
break;
case LogLevels.Information:
query = query.Where(x => x.Level == "Information");
break;
case LogLevels.Error:
query = query.Where(x => x.Level == "Error");
break;
case LogLevels.Warning:
query = query.Where(x => x.Level == "Warning");
break;
case LogLevels.Debug:
query = query.Where(x => x.Level == "Debug");
break;
case LogLevels.Fatal:
query = query.Where(x => x.Level == "Fatal");
break;
case LogLevels.Critical:
query = query.Where(x => x.Level == "Critical");
break;
case LogLevels.Trace:
query = query.Where(x => x.Level == "Trace");
break;
case LogLevels.Verbose:
query = query.Where(x => x.Level == "Verbose");
break;
default:
break;
}
switch (sorOrder)
{
default:
query = query.OrderByDescending(x => x.Id); //.ThenByDescending(t => t.Timestamp);
break;
}
return(await query
.Skip((pageNumber - 1) *pageSize)
.Take(pageSize)
.ToListAsync());
}
public async Task <IEnumerable <PostViewModel> > GetAllPosts(PageViewModel page)
{
var posts = await _posts
.Skip(page.Number *page.Size)
.Take(page.Size)
.ToListAsync();
await UpdateViews(posts);
return(_mapper.Map <IEnumerable <PostViewModel> >(posts));
}
public static IMongoQueryable <TDocument> Pagination <TDocument>(this IMongoQueryable <TDocument> query, IPagination pagination)
{
if (pagination is null)
{
throw new ArgumentNullException(nameof(pagination));
}
return(query
.Skip(pagination.Skip)
.Take(pagination.Take));
}
/// <summary>
/// 分页
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="this"></param>
/// <param name="page"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public static IMongoQueryable <T> PageBy <T>(this IMongoQueryable <T> @this, int page, int pageSize)
{
if (@this == null)
{
return(null);
}
if (page < 1)
{
page = 1;
}
return(@this.Skip((page - 1) * pageSize).Take(pageSize));
}
public static async Task <PaginatedResponse <T> > AsPaginatedResponse <T>(this IMongoQueryable <T> workflows, int limit, int offset)
{
var data = new List <T>();
if (limit > 0)
{
data = await workflows.Skip(offset).Take(limit).ToListAsync();
}
var count = await workflows.CountAsync();
return(PaginatedResponse <T> .Create(data, limit, offset, count));
}
public static async Task <PaginatedResponse <T> > AsPaginatedResponse <T>(this IMongoQueryable <T> workflows, int limit, int offset) where T : class, IMongoModel
{
var dataTask = limit > 0 ? workflows.Skip(offset).Take(limit).ToListAsync() : Task.FromResult(new List <T>());
var countTask = workflows.CountAsync();
await Task.WhenAll(dataTask, countTask);
var data = await dataTask;
var count = await countTask;
return(PaginatedResponse <T> .Create(data, limit, offset, count));
}
public static IMongoQueryable <TSource> MongoQueryOptionsAsQueryable <TSource>(
this IMongoQueryable <TSource> source,
IQueryOptions queryOptions)
{
// Is there any sort column supplied?
IMongoQueryable <TSource> data = source;
if (!string.IsNullOrEmpty(queryOptions.Sort))
{
data = data.OrderByName(queryOptions.Sort, queryOptions.SortOrder == SortOrder.Descending);
}
if (queryOptions.PageSize > 0 || queryOptions.RecordCount > 0)
{
// Apply paging to (sorted) data
data = queryOptions.RecordCount > 0
? data.Skip(queryOptions.StartRecord).Take(queryOptions.RecordCount)
: data.Skip((queryOptions.Page - 1) * queryOptions.PageSize).Take(queryOptions.PageSize);
}
return(data);
}
private IMongoQueryable <Project> ApplyPagination(
IMongoQueryable <Project> query, DbGetProjectFilterRequest request)
{
if (request.Offset > 0)
{
query = query.Skip(request.Offset);
}
if (request.Limit > 0)
{
query = query.Take(request.Limit);
}
return(query);
}
private IMongoQueryable <DbGeoTask> ApplyPagination(
IMongoQueryable <DbGeoTask> query, DbGetGeoTaskListRequest request)
{
if (request.Offset > 0)
{
query = query.Skip(request.Offset);
}
if (request.Limit > 0)
{
query = query.Take(request.Limit);
}
return(query);
}
public static IMongoQueryable <T> Paginate <T>(this IMongoQueryable <T> query, int skip = 0, int take = 0)
{
if (skip > 0)
{
query = query.Skip(skip);
}
if (take > 0)
{
query = query.Take(take);
}
return(query);
}
public virtual async Task <List <T> > GetPagedListAsync(int pageIndex, int pageSize, Expression <Func <T, bool> > exp = null)
{
int skipCount = (pageIndex - 1) * pageSize;
int takeCount = pageSize;
if (exp == null)
{
return(await _query.Skip(skipCount).Take(takeCount).ToListAsync());
}
else
{
return(await _query.Where(exp).Skip(skipCount).Take(takeCount).ToListAsync());
}
}
public static IMongoQueryable <T> ApplyPaging <T>(this IMongoQueryable <T> query, int page, int pageSize)
{
if (page <= 0)
{
page = 1;
}
if (pageSize <= 0)
{
pageSize = 5;
}
return(query.Skip((page - 1) * pageSize).Take(pageSize));
}
public static IMongoQueryable <T> Limit <T>(this IMongoQueryable <T> collection,
int page = DEFAULT_PAGE, int resultsPerPage = DEFAULT_RESULTS_PER_PAGE)
{
if (page <= 0)
{
page = DEFAULT_PAGE;
}
if (resultsPerPage <= 0)
{
resultsPerPage = DEFAULT_RESULTS_PER_PAGE;
}
var skip = (page - 1) * resultsPerPage;
return(collection.Skip(skip).Take(resultsPerPage));
}
public static IMongoQueryable <T> Limit <T>(this IMongoQueryable <T> collection,
int page = 1, int resultsPerPage = 10)
{
if (page <= 0)
{
page = 1;
}
if (resultsPerPage <= 0)
{
resultsPerPage = 10;
}
var skip = (page - 1) * resultsPerPage;
var data = collection.Skip(skip)
.Take(resultsPerPage);
return(data);
}
public PagedList(IMongoQueryable <T> source, int pageIndex, int pageSize, bool product)
{
var products = source.Skip(pageIndex * pageSize).Take(pageSize + 1).ToList();
int count = products.Count();
int total = count + (pageIndex * pageSize);
this.TotalCount = total;
this.TotalPages = total / pageSize;
if (total % pageSize > 0)
{
TotalPages++;
}
this.PageSize = pageSize;
this.PageIndex = pageIndex;
this.AddRange(products.Take(pageSize));
}
public IEnumerable <TEntity> GetPaged(Expression <Func <TEntity, bool> > filter, int pageIndex, int pageCount, params ISorting[] sortColumns)
{
IMongoQueryable <TEntity> query = GetSet();
if (filter != null)
{
query = query.Where(filter);
}
if (sortColumns != null && sortColumns.Length > 0)
{
query = (IOrderedMongoQueryable <TEntity>)query.OrderBy(sortColumns);
}
if (pageCount > 0)
{
int skip = (pageIndex - 1) * pageCount;
return(query.Skip(skip).Take(pageCount));
}
return(query);
}
public async Task <IEnumerable <Notification> > GetNotificationAsync(Username username, bool?isSeen, int skip, int take, CancellationToken cancellationToken)
{
IMongoQueryable <Notification>?queryable = DbSet.AsQueryable();
queryable = queryable.Where(x => x.Username.Value == username.Value);
if (isSeen.HasValue)
{
queryable = queryable.Where(x => x.IsSeen == isSeen.Value);
}
queryable = queryable.OrderByDescending(x => x.CreatedOn);
List <Notification> notificationList = await queryable.Skip(skip).Take(take).ToListAsync(cancellationToken);
if (!notificationList.Any())
{
throw new NotFoundException <Notification>();
}
return(notificationList);
}
