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); }