internal static bool ShouldContinue(Uri uri, IApiOptions options)
{
if (uri == null)
{
return(false);
}
if (uri.Query.Contains("page=") && options.PageCount.HasValue)
{
var allValues = ToQueryStringDictionary(uri);
string pageValue;
if (allValues.TryGetValue("page", out pageValue))
{
var startPage = options.StartPage ?? 1;
var pageCount = options.PageCount.Value;
var endPage = startPage + pageCount;
if (pageValue.Equals(endPage.ToString(CultureInfo.InvariantCulture), StringComparison.OrdinalIgnoreCase))
{
return(false);
}
}
}
return(true);
}
public IEnumerable <TResult> Query <TResult>(string uri, IApiOptions options, HttpMethod method, Func <string, IEnumerable <TResult> > serializer)
{
if (method == HttpMethod.Post)
{
return(Post <IEnumerable <TResult> >(uri, options, serializer));
}
return(Get <IEnumerable <TResult> >(uri, options, serializer));
}
public IEnumerable <TResult> Query <TResult>(string uri, IApiOptions options, HttpMethod method)
{
if (method == HttpMethod.Post)
{
return(Post <IEnumerable <TResult> >(uri, options));
}
return(Get <IEnumerable <TResult> >(uri, options));
}
public CommandSendActivity(IApiOptions apiOptions)
{
if (apiOptions is null)
{
throw new ArgumentNullException(nameof(apiOptions));
}
ReferenceLink.BaseUrl = apiOptions.Url;
}
public async Task <IReadOnlyPagedCollection <T> > GetPage <T>(
Uri uri,
IDictionary <string, string> parameters,
string accepts,
IApiOptions options)
{
uri.ArgumentNotNull(nameof(uri));
var response = await Connection.Get <IList <T> >(uri, parameters, accepts).ConfigureAwait(false);
return(new ReadOnlyPagedCollection <T>(
response,
x =>
{
var shouldContinue = Pagination.ShouldContinue(x, options);
return shouldContinue
? Connection.Get <IList <T> >(x, parameters, accepts)
: null;
}));
}
public static IServiceProvider BuildServiceProvider(IApiOptions options)
{
IServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddLogging("CalculateFunding.Migrations.ProviderVersionDefectCorrection");
serviceCollection.AddPolicySettings(Configuration);
serviceCollection.AddSingleton <ICalculationsEtlResiliencePolicies>(ctx =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers
.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new ResiliencePolicies
{
CalculationsApiClient = GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
SpecificationApiClient = GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
DataSetsApiClient = GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy)
});
});
AddHttpClientForClientKey(HttpClientKeys.Specifications,
options.SpecificationsApiUri,
options.SpecificationsApiKey,
serviceCollection);
AddHttpClientForClientKey(HttpClientKeys.Calculations,
options.CalculationsApiUri,
options.CalculationsApiKey,
serviceCollection);
AddHttpClientForClientKey(HttpClientKeys.Datasets,
options.DataSetsApiUri,
options.DataSetsApiKey,
serviceCollection);
serviceCollection.AddSingleton <ICalculationsApiClient, CalculationsApiClient>();
serviceCollection.AddTransient <ISpecificationsApiClient, SpecificationsApiClient>();
serviceCollection.AddTransient <IDatasetsApiClient, DatasetsApiClient>();
return(serviceCollection.BuildServiceProvider());
}
public TResult Post <TResult>(string uri, IApiOptions options, Func <string, TResult> serializer)
{
return(_httpClient.Post <TResult>(ParseAssertUri(uri), serializer, options.Parameters));
}
public TResult Post <TResult>(string uri, IApiOptions options)
{
return(_httpClient.Post <TResult>(ParseAssertUri(uri), options.Parameters));
}
private static IServiceProvider ConfigureApis(IApiOptions options)
{
return(BootStrapper.BuildServiceProvider(options));
}
public Task <IReadOnlyList <T> > GetAll <T>(Uri uri, IDictionary <string, string> parameters, IApiOptions options)
where T : class
{
return(GetAll <T>(uri, parameters, null, options));
}
public Task <IReadOnlyList <T> > GetAll <T>(Uri uri, IApiOptions options)
where T : class
{
return(GetAll <T>(uri, null, null, options));
}
public Task <IReadOnlyList <T> > GetAll <T>(Uri uri, IDictionary <string, string> parameters, string accepts, IApiOptions options)
where T : class
{
uri.ArgumentNotNull(nameof(uri));
options.ArgumentNotNull(nameof(options));
parameters = Pagination.Setup(parameters, options);
return(pagination.GetAllPages(async() => await GetPage <T>(uri, parameters, accepts, options).ConfigureAwait(false), uri));
}
public Task <IReadOnlyList <GpgKey> > GetAllForCurrent(IApiOptions options)
{
options.ArgumentNotNull(nameof(options));
return(ApiConnection.GetAll <GpgKey>(ApiUrls.GpgKeys(), options));
}
public StudentApiHandler(IApiOptions <IStudentApi> options) : base(options)
{
}
public CommandSendActivity(IApiOptions apiOptions)
{
this.apiOptions = apiOptions ?? throw new ArgumentNullException(nameof(apiOptions));
}
internal static IDictionary <string, string> Setup(IDictionary <string, string> parameters, IApiOptions options)
{
parameters = parameters ?? new Dictionary <string, string>();
if (options.PageSize.HasValue)
{
parameters.Add("per_page", options.PageSize.Value.ToString(CultureInfo.InvariantCulture));
}
if (options.StartPage.HasValue)
{
parameters.Add("page", options.StartPage.Value.ToString(CultureInfo.InvariantCulture));
}
return(parameters);
}
