public async Task <PaginationData <Post> > GetPostsByBlogIdAndPaginationAsync( string blogId, Pagination pagination, bool ascending = false) { var filter = Builders <Post> .Filter.Eq(a => a.BlogId, blogId); var aggregateFluent = Collection.Aggregate(); var totalFacet = AggregateFacet.Create("total", PipelineDefinition <Post, AggregateCountResult> .Create(new[] { PipelineStageDefinitionBuilder.Count <Post>() })); AggregateFacet <Post, Post> dataFacet; if (ascending) { dataFacet = AggregateFacet.Create("data", PipelineDefinition <Post, Post> .Create(new[] { PipelineStageDefinitionBuilder.Sort(Builders <Post> .Sort.Ascending(x => x.CreatedDate)), PipelineStageDefinitionBuilder.Skip <Post>(pagination.NumberPerPage * (pagination.CurrentPage - 1)), PipelineStageDefinitionBuilder.Limit <Post>(pagination.NumberPerPage), })); } else { dataFacet = AggregateFacet.Create("data", PipelineDefinition <Post, Post> .Create(new[] { PipelineStageDefinitionBuilder.Sort(Builders <Post> .Sort.Descending(x => x.CreatedDate)), PipelineStageDefinitionBuilder.Skip <Post>(pagination.NumberPerPage * (pagination.CurrentPage - 1)), PipelineStageDefinitionBuilder.Limit <Post>(pagination.NumberPerPage), })); } var aggregation = await aggregateFluent .Match(filter) .Facet(totalFacet, dataFacet) .ToListAsync(); var total = aggregation .First() .Facets.First(a => a.Name == "total") .Output <AggregateCountResult>() .First() .Count; var data = aggregation .First() .Facets.First(a => a.Name == "data") .Output <Post>(); return(new PaginationData <Post>(data, total, pagination.CurrentPage, pagination.NumberPerPage, pagination.MaximumPage)); }
/// <summary> /// Returns entity count. /// </summary> /// <returns></returns> public async Task <int> GetCountAsync(Expression <Func <TEntity, bool> > filterExpression = null) { var filter = filterExpression ?? Builders <TEntity> .Filter.Empty; var countFacet = AggregateFacet.Create("totalDataCount", PipelineDefinition <TEntity, AggregateCountResult> .Create(new[] { PipelineStageDefinitionBuilder.Count <TEntity>() })); var aggregateFacetResult = await _collection.Aggregate().Match(filter).Facet(countFacet).ToListAsync().ConfigureAwait(false); var count = aggregateFacetResult.First().Facets.First(x => x.Name == "totalDataCount").Output <AggregateCountResult>()?.FirstOrDefault()?.Count ?? 0; return((int)count); }
public async Task <Envelope <T> > GetEnvelopeAsync <T>(IMongoCollection <T> collection, FilterDefinition <T> filter, PageParameters pageParams) { var countFacet = AggregateFacet.Create("count", PipelineDefinition <T, AggregateCountResult> .Create(new[] { PipelineStageDefinitionBuilder.Count <T> () })); var dataFacet = AggregateFacet.Create("data", PipelineDefinition <T, T> .Create(new[] { (pageParams.IsAscend) ? PipelineStageDefinitionBuilder.Sort(Builders <T> .Sort.Ascending(pageParams.SortBy)): PipelineStageDefinitionBuilder.Sort(Builders <T> .Sort.Descending(pageParams.SortBy)), PipelineStageDefinitionBuilder.Skip <T> ((pageParams.PageNumber - 1) * pageParams.PageSize), PipelineStageDefinitionBuilder.Limit <T> (pageParams.PageSize) })); var aggregation = await collection.Aggregate() .Match(filter) .Facet(countFacet, dataFacet) .ToListAsync(); var count = (aggregation.FirstOrDefault() .Facets.FirstOrDefault(x => x.Name == "count") .Output <AggregateCountResult>() .FirstOrDefault() ?? new AggregateCountResult(0)).Count; var data = aggregation.FirstOrDefault() .Facets.FirstOrDefault(x => x.Name == "data") .Output <T>() .ToList(); var totalPages = (int)Match.Ceiling(count / (double)pageParams.PageSize); var hasPreviousPage = pageParams.PageNumber > 1; var hasNextPage = pageParams.PageNumber < totalPages; var envelope = new Envelope <T>() { Items = data, TotalSize = count TotalPages = totalPages HasPreviousPage = HasPreviousPage HasNextPage = hasNextPage }; return(envelope); } }
public async Task <Page <TemplateKind> > GetTemplateKindsPage(int page, int pageSize, CancellationToken cancellationToken = default) { var countFacetName = "count"; var entitiesFacetName = "entities"; var countFacet = AggregateFacet.Create(countFacetName, PipelineDefinition <TemplateKind, AggregateCountResult> .Create(new[] { PipelineStageDefinitionBuilder.Count <TemplateKind>(), })); var sortDefinition = Builders <TemplateKind> .Sort.Ascending(x => x.TemplateKindKey); var entitiesFacet = AggregateFacet.Create(entitiesFacetName, PipelineDefinition <TemplateKind, TemplateKind> .Create(new[] { PipelineStageDefinitionBuilder.Sort(sortDefinition), PipelineStageDefinitionBuilder.Skip <TemplateKind>((page - 1) * pageSize), PipelineStageDefinitionBuilder.Limit <TemplateKind>(pageSize), })); var aggregation = await _collection.Aggregate() .Facet(countFacet, entitiesFacet) .ToListAsync(cancellationToken); var data = aggregation.First() .Facets.First(x => x.Name == entitiesFacetName) .Output <TemplateKind>(); var countOutput = aggregation.First() .Facets.First(x => x.Name == countFacetName) .Output <AggregateCountResult>(); long count = 0; if (countOutput.Any()) { count = countOutput.First() .Count; } return(new Page <TemplateKind>(count, data)); }
public static async Task <PagedCollection <T> > ApplyOData <T>(this IMongoCollection <T> collection, IODataQuery query) { var page = 1; var skip = query.Skip.Normalize(0); var limit = query.Limit.Normalize(10, 1000); var countFacet = AggregateFacet.Create("count", PipelineDefinition <T, AggregateCountResult> .Create(new[] { PipelineStageDefinitionBuilder.Count <T>() })); var sort = CreateODataSort <T>(query, false); var filter = CreateODataFilter <T>(query, false); var dataFacet = AggregateFacet.Create("data", PipelineDefinition <T, T> .Create(new [] { PipelineStageDefinitionBuilder.Sort(sort), PipelineStageDefinitionBuilder.Skip <T>(skip), PipelineStageDefinitionBuilder.Limit <T>(limit), })); var aggregation = await collection.Aggregate() .Match(filter) .Facet(countFacet, dataFacet) .ToListAsync(); var count = aggregation.First() .Facets.First(x => x.Name == "count") .Output <AggregateCountResult>() .First() .Count; int totalPages = (int)(count / limit); var data = aggregation.First() .Facets.First(x => x.Name == "data") .Output <T>(); return(PagedCollection <T> .Create(data, page, limit, totalPages, count)); }
public static async Task <IReadOnlyList <TDocument> > AggregateByPage <TDocument>( this IMongoCollection <TDocument> collection, FilterDefinition <TDocument> filterDefinition, SortDefinition <TDocument> sortDefinition, int page, int pageSize) { var countFacet = AggregateFacet.Create("count", PipelineDefinition <TDocument, AggregateCountResult> .Create(new[] { PipelineStageDefinitionBuilder.Count <TDocument>() })); var dataFacet = AggregateFacet.Create("data", PipelineDefinition <TDocument, TDocument> .Create(new[] { PipelineStageDefinitionBuilder.Sort(sortDefinition), PipelineStageDefinitionBuilder.Skip <TDocument>((page - 1) * pageSize), PipelineStageDefinitionBuilder.Limit <TDocument>(pageSize), })); var aggregation = await collection.Aggregate() .Match(filterDefinition) .Facet(countFacet, dataFacet) .ToListAsync(); var count = aggregation.First() .Facets.First(x => x.Name == "count") .Output <AggregateCountResult>() .First() .Count; var totalPages = (int)Math.Ceiling((double)count / pageSize); var data = aggregation.First() .Facets.First(x => x.Name == "data") .Output <TDocument>(); return(data); }
public async Task <ServiceResult <SongPagination> > RetreiveSongOfArtist(string artistName, int pageSize, int page) { var filter = Builders <Song> .Filter.Eq(s => s.ArtistName, artistName); var countFacet = AggregateFacet.Create("count", PipelineDefinition <Song, AggregateCountResult> .Create(new[] { PipelineStageDefinitionBuilder.Count <Song>() })); var paginationFacet = AggregateFacet.Create("pagination", PipelineDefinition <Song, Song> .Create(new[] { PipelineStageDefinitionBuilder.Sort(Builders <Song> .Sort.Ascending(x => x.Title)), PipelineStageDefinitionBuilder.Skip <Song>(pageSize * (page - 1)), PipelineStageDefinitionBuilder.Limit <Song>(pageSize) })); var aggregation = await this.songCollection.Aggregate() .Match(filter) .Facet(countFacet, paginationFacet) .ToListAsync(); long count = aggregation.First() .Facets.First(x => x.Name == "count") .Output <AggregateCountResult>() .First() .Count; var totalPages = Math.Ceiling((decimal)(count / pageSize)); IEnumerable <Song> items = aggregation.First() .Facets.First(f => f.Name == "pagination") .Output <Song>() .ToList(); return(ServiceResult.Succes(new SongPagination { ToTalPages = totalPages, Songs = items })); }
/// <summary> /// /// You can bring up the page number you want with the number of data count you want. /// /// <para> You can sort when listing data. </para> /// <para> You can send the filter value to the Nested list. See <paramref name="filterDefinition"/>. </para> /// <para> You can get the specific properties. See <paramref name="projectExpression"/>. </para> /// /// </summary> /// <param name="pageIndex"></param> /// <param name="requestedItemCount"></param> /// <param name="orderByProps"></param> /// <param name="filterDefinition"></param> /// <param name="projectExpression"></param> /// <returns></returns> public async Task <(List <TEntity> entities, int pageCount, int totalDataCount)> GetAsPaginatedAsync(int pageIndex, int requestedItemCount, List <OrderByProp> orderByProps, FilterDefinition <TEntity> filterDefinition = null, Expression <Func <TEntity, TEntity> > projectExpression = null) { ValidatePaginationParameters(pageIndex, requestedItemCount); var stages = GetSortDefinitions <TEntity>(orderByProps).ToList(); var filter = filterDefinition ?? Builders <TEntity> .Filter.Empty; var projectionDefinition = Builders <TEntity> .Projection.Expression(projectExpression ?? (entity => entity)); var countFacat = AggregateFacet.Create("count", PipelineDefinition <TEntity, AggregateCountResult> .Create(new[] { PipelineStageDefinitionBuilder.Count <TEntity>() })); AggregateFacet <TEntity, TEntity> dataFacet = null; stages.Add(PipelineStageDefinitionBuilder.Skip <TEntity>((pageIndex - 1) * requestedItemCount)); stages.Add(PipelineStageDefinitionBuilder.Limit <TEntity>(requestedItemCount)); stages.Add(PipelineStageDefinitionBuilder.Project(projectionDefinition)); dataFacet = AggregateFacet.Create("data", PipelineDefinition <TEntity, TEntity> .Create(stages)); var aggregateFacetResults = await _collection.Aggregate().Match(filter).Facet(countFacat, dataFacet).ToListAsync().ConfigureAwait(false); var count = aggregateFacetResults.First().Facets.First(x => x.Name == "count").Output <AggregateCountResult>()?.FirstOrDefault()?.Count ?? 0; var totalPages = (int)Math.Ceiling((double)count / requestedItemCount); var data = aggregateFacetResults.First().Facets.First(x => x.Name == "data").Output <TEntity>().ToList(); return(data, totalPages, (int)count); }