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));
}
public ETTask <List <ComponentWithId> > GetJson(string collectionName, string json, long skip, long limit)
{
ETTaskCompletionSource <List <ComponentWithId> > tcs = new ETTaskCompletionSource <List <ComponentWithId> >();
PipelineStageDefinition <ComponentWithId, ComponentWithId> _match = PipelineStageDefinitionBuilder.Match <ComponentWithId>(json);
PipelineStageDefinition <ComponentWithId, ComponentWithId> _skip = PipelineStageDefinitionBuilder.Skip <ComponentWithId>((int)skip);
PipelineStageDefinition <ComponentWithId, ComponentWithId> _limit = PipelineStageDefinitionBuilder.Limit <ComponentWithId>((int)limit);
PipelineDefinition <ComponentWithId, ComponentWithId> pipeline = new PipelineStagePipelineDefinition <ComponentWithId, ComponentWithId>(
new PipelineStageDefinition <ComponentWithId, ComponentWithId>[] { _match, _skip, _limit });
DBQueryPipelineTask dbQueryPipelineTask = ComponentFactory.Create <DBQueryPipelineTask, string, PipelineDefinition <ComponentWithId, ComponentWithId>, ETTaskCompletionSource <List <ComponentWithId> > >
(collectionName, pipeline, tcs);
this.tasks[(int)((ulong)dbQueryPipelineTask.Id % taskCount)].Add(dbQueryPipelineTask);
return(tcs.Task);
}
private static IEnumerable <PipelineStageDefinition <TDocument, TDocument> > GetPipelineDefinitions <TDocument>(
FilterDefinition <TDocument> filterQuery,
SortDefinition <TDocument> sortQuery,
int pageIndex,
int pageSize)
{
yield return(PipelineStageDefinitionBuilder.Match(filterQuery));
if (sortQuery != null)
{
yield return(PipelineStageDefinitionBuilder.Sort(sortQuery));
}
yield return(PipelineStageDefinitionBuilder.Skip <TDocument>((pageIndex - 1) * pageSize));
yield return(PipelineStageDefinitionBuilder.Limit <TDocument>(pageSize));
}
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);
}
