public PaginatedResult(IPaginatedRequest <T> request, IEnumerable <T> results)
        {
            Guard.ThrowIfNull(request, nameof(request));

            Request = request;

            results = results ?? ImmutableArray <T> .Empty;

            _results = new BetterLazy <IReadOnlyCollection <T> >(() => results.ToImmutableArray());
        }
        /// <summary>
        /// Returns page of items from the query.
        /// </summary>
        /// <typeparam name="TEntity">Type of items.</typeparam>
        /// <param name="query">Query to query.</param>
        /// <param name="continuationToken">Continuation token string.</param>
        /// <param name="cancellation">Cancellation.</param>
        /// <returns>A <see cref="Task{TResult}" /> representing the result of the asynchronous operation.</returns>
        public static async Task <PaginatedResponse <TEntity> > ToPageAsync <TEntity>(
            this IODataQueryable <TEntity> query,
            IPaginatedRequest request,
            CancellationToken cancellation = default)
        {
            var newQuery = query.Skip(request.Skip);

            newQuery.Take = request.Take;
            var items = await query.Context.Provider.RetrieveItemsAsync(newQuery, cancellation);

            return(new PaginatedResponse <TEntity>
            {
                Items = items.Items.ToList(),
                HasMore = items.HasMore,
                Take = request.Take,
                Skip = request.Skip,
                Total = items.Total,
            });
        }
 public bool Equals(IPaginatedRequest <T> other)
 {
     return(other is PaginatedRequest <T> otherPaginatedRequest &&
            Equals(otherPaginatedRequest));
 }
Example #4
0
 public SqlPaginationBuilder(IPaginatedRequest request)
 {
     _request    = request;
     _parameters = new Dictionary <string, object>();
 }
        /// <summary>
        /// Create pagination by <see cref="IPaginatedRequest"/>. Extension for EF core package.
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="query"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public static async Task <IPaginatedResult <TEntity> > PaginateAsyncLinq2DB <TEntity>(this IQueryable <TEntity> query, IPaginatedRequest request)
            where TEntity : class
        {
            var total = await query.LongCountAsyncLinqToDB();

            int skip = (request.Page - 1) * request.PerPage;

            var data = await query.Skip(skip)
                       .Take(request.PerPage)
                       .ToListAsyncEF();

            return(new PaginatedResult <TEntity>(request.Page, request.PerPage, total, data));
        }
Example #6
0
 /// <summary>
 /// Gets a PaginationOptions from an IPaginatedRequest.
 /// </summary>
 /// <param name="request">The request</param>
 public static PaginationOptions GetPaginationOptions(this IPaginatedRequest request) =>
Example #7
0
        /// <summary>
        /// Create pagination by <see cref="IPaginatedRequest"/>. Extension for EF core package.
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="query"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public static IPaginatedResult <TEntity> PaginateEF <TEntity>(this IQueryable <TEntity> query, IPaginatedRequest request)
            where TEntity : class
        {
            var total = query.LongCount();
            int skip  = (request.Page - 1) * request.PerPage;

            var data = query.Skip(skip)
                       .Take(request.PerPage)
                       .AsNoTracking()
                       .ToList();

            return(new PaginatedResult <TEntity>(request.Page, request.PerPage, total, data));
        }