PaginatedClient.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Models.Response;
 
namespace Tgstation.Server.Client
{
    abstract class PaginatedClient
    {
        protected IApiClient ApiClient { get; }
 
        public PaginatedClient(IApiClient apiClient)
        {
            ApiClient = apiClient ?? throw new ArgumentNullException(nameof(apiClient));
        }
 
        protected async ValueTask<List<TModel>> ReadPaged<TModel>(
            PaginationSettings? paginationSettings,
            string route,
            long? instanceId,
            CancellationToken cancellationToken)
        {
            if (route == null)
                throw new ArgumentNullException(nameof(route));
 
            var routeFormatter = $"{route}?page={{0}}";
            var currentPage = 1;
            if (paginationSettings != null)
            {
                if (paginationSettings.RetrieveCount == 0)
                    return new List<TModel>(); // that was easy
                else if (paginationSettings.RetrieveCount < 0)
                    throw new ArgumentOutOfRangeException(nameof(paginationSettings), "RetrieveCount cannot be less than 0!");
 
                int? pageSize = null;
                if (paginationSettings.PageSize.HasValue)
                {
                    // pagesize validates itself on first request
                    pageSize = paginationSettings.PageSize.Value;
                    routeFormatter += $"&pageSize={pageSize}";
                }
 
                if (paginationSettings.Offset.HasValue)
                {
                    if (paginationSettings.Offset.Value < 0)
                        throw new ArgumentOutOfRangeException(nameof(paginationSettings), "Offset cannot be less than 0!");
 
                    pageSize ??= paginationSettings.Offset.Value;
                    currentPage = (paginationSettings.Offset.Value / pageSize.Value) + 1;
                }
            }
 
            ValueTask<PaginatedResponse<TModel>> GetPage() => instanceId.HasValue
                ? ApiClient.Read<PaginatedResponse<TModel>>(
                    String.Format(CultureInfo.InvariantCulture, routeFormatter, currentPage),
                    instanceId.Value,
                    cancellationToken)
                : ApiClient.Read<PaginatedResponse<TModel>>(
                    String.Format(CultureInfo.InvariantCulture, routeFormatter, currentPage),
                    cancellationToken);
 
            var firstPage = await GetPage().ConfigureAwait(false);
 
            var totalAvailable = firstPage.TotalPages * firstPage.PageSize;
            var maximumItems = paginationSettings?.RetrieveCount.HasValue == true
                ? Math.Min(paginationSettings.RetrieveCount!.Value, totalAvailable)
                : totalAvailable;
 
            var results = new List<TModel>(maximumItems);
            var currentResults = firstPage;
            do
            {
                // check if first page
                if (currentPage > 1)
                    currentResults = await GetPage().ConfigureAwait(false);
 
                if (currentResults.Content == null)
                    throw new ApiConflictException("Paginated results missing content!");
 
                IEnumerable<TModel> rangeToAdd = currentResults.Content;
                if (paginationSettings?.Offset.HasValue == true)
                {
                    rangeToAdd = rangeToAdd
                        .Skip(paginationSettings.Offset!.Value % currentResults.PageSize);
                }
 
                var itemsAvailableInPage = rangeToAdd.Count();
                var itemsStillRequired = maximumItems - results.Count;
                if (itemsAvailableInPage > itemsStillRequired)
                    rangeToAdd = rangeToAdd
                        .Take(itemsStillRequired);
 
                results.AddRange(rangeToAdd);
                ++currentPage;
            }
            while (results.Count < maximumItems && currentPage <= currentResults.TotalPages);
 
            return results;
        }
    }
}