public static Uri BuildUri(Uri baseUri, Version requestedApiVersion, string path, IQueryString queryString)
{
if (baseUri == null)
{
throw new ArgumentNullException("baseUri");
}
UriBuilder builder = new UriBuilder(baseUri);
if (requestedApiVersion != null)
{
builder.Path += string.Format(CultureInfo.InvariantCulture, "v{0}/", requestedApiVersion);
}
if (!string.IsNullOrEmpty(path))
{
builder.Path += path;
}
if (queryString != null)
{
builder.Query = queryString.GetQueryString();
}
return builder.Uri;
}
internal async Task<DockerApiResponse> MakeRequestAsync(IEnumerable<ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IRequestContent data, TimeSpan? timeout, CancellationToken cancellationToken)
{
HttpResponseMessage response = await this.MakeRequestInnerAsync(null, HttpCompletionOption.ResponseContentRead, method, path, queryString, null, data, cancellationToken);
string body = await response.Content.ReadAsStringAsync();
HandleIfErrorResponse(response.StatusCode, body, errorHandlers);
return new DockerApiResponse(response.StatusCode, body);
}
private Task <HttpResponseMessage> PrivateMakeRequestAsync(
TimeSpan timeout,
HttpCompletionOption completionOption,
HttpMethod method,
string path,
IQueryString queryString,
IDictionary <string, string> headers,
IRequestContent data,
CancellationToken cancellationToken)
{
var request = PrepareRequest(method, path, queryString, headers, data);
if (timeout != s_InfiniteTimeout)
{
var timeoutTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
timeoutTokenSource.CancelAfter(timeout);
cancellationToken = timeoutTokenSource.Token;
}
return(_client.SendAsync(request, completionOption, cancellationToken));
}
async Task <AssociationIdList> IHubSpotCrmAssociationClient.GetAllAsync(long objectId, AssociationType associationType, int limit, long?offset)
{
if (limit > 100)
{
throw new ArgumentOutOfRangeException(nameof(limit), "Up to 100 items can be requested at the same time");
}
var builder = new HttpQueryStringBuilder();
builder.Add("limit", limit);
if (offset.HasValue)
{
builder.Add("offset", offset.Value);
}
string path = $"/crm-associations/v1/associations/{objectId}/HUBSPOT_DEFINED/{associationType.Id}";
IQueryString query = builder.BuildQuery();
var list = await _client.SendAsync <AssociationIdList>(HttpMethod.Get, path, query);
return(list);
}
private async Task <HttpResponseMessage> InternalMakeRequestAsync(
TimeSpan timeout,
HttpCompletionOption completionOption,
HttpMethod method,
string path,
IQueryString queryString,
IDictionary <string, string> headers,
Func <HttpContent> content,
CancellationToken cancellationToken)
{
await EnsureConnection();
var request = PrepareRequest(method, path, queryString, headers, content);
if (timeout != InfiniteTimeout)
{
var timeoutTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
timeoutTokenSource.CancelAfter(timeout);
cancellationToken = timeoutTokenSource.Token;
}
await _authenticationProvider.AuthenticateAsync(request);
var response = await _client.SendAsync(request, completionOption, cancellationToken);
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
//Prepare another request (we can't reuse the same request)
var request2 = PrepareRequest(method, path, queryString, headers, content);
//Authenticate given the challenge
await _authenticationProvider.AuthenticateAsync(request2, response);
//Send it again
response = await _client.SendAsync(request2, completionOption, cancellationToken);
}
return(response);
}
internal async Task <WriteClosableStream> MakeRequestForHijackedStreamAsync(
IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers,
HttpMethod method,
string path,
IQueryString queryString,
IRequestContent body,
IDictionary <string, string> headers,
TimeSpan timeout,
CancellationToken cancellationToken)
{
var response = await PrivateMakeRequestAsync(timeout, HttpCompletionOption.ResponseHeadersRead, method, path, queryString, headers, body, cancellationToken).ConfigureAwait(false);
await HandleIfErrorResponseAsync(response.StatusCode, response, errorHandlers);
var content = response.Content as HttpConnectionResponseContent;
if (content == null)
{
throw new NotSupportedException("message handler does not support hijacked streams");
}
return(content.HijackStream());
}
internal async Task <RegistryApiResponse <string> > MakeRequestAsync(
CancellationToken cancellationToken,
HttpMethod method,
string path,
IQueryString queryString = null,
IDictionary <string, string> headers = null,
Func <HttpContent> content = null)
{
//Console.WriteLine(
// "Requesting Path: {0} Method: {1} QueryString: {2}",
// path,
// method,
// queryString?.GetQueryString());
using (var response = await this.InternalMakeRequestAsync(
this.DefaultTimeout,
HttpCompletionOption.ResponseContentRead,
method,
path,
queryString,
headers,
content,
cancellationToken))
{
var responseBody = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var apiResponse = new RegistryApiResponse <string>(
response.StatusCode,
responseBody,
response.Headers);
this.HandleIfErrorResponse(apiResponse);
return(apiResponse);
}
}
internal HttpRequestMessage PrepareRequest(
HttpMethod method,
string path,
IQueryString queryString,
IDictionary <string, string> headers,
Func <HttpContent> content)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
}
var request = new HttpRequestMessage(
method,
this._effectiveEndpointBaseUri.BuildUri(path, queryString));
request.Headers.Add("User-Agent", UserAgent);
request.Headers.AddRange(headers);
//Create the content
request.Content = content?.Invoke();
return(request);
}
internal HttpRequestMessage PrepareRequest(HttpMethod method, string path, IQueryString queryString, IDictionary <string, string> headers, Func <HttpContent> content)
{
if (string.IsNullOrEmpty("path"))
{
throw new ArgumentNullException(nameof(path));
}
var request = new HttpRequestMessage(method, HttpUtility.BuildUri(_configuration.EndpointBaseUri, path, queryString));
request.Headers.Add("User-Agent", UserAgent);
if (headers != null)
{
foreach (var header in headers)
{
request.Headers.Add(header.Key, header.Value);
}
}
//Create the content
request.Content = content?.Invoke();
return(request);
}
public IResponseResult <T> Delete <T>(TUrlParams urlParams = null, RequestBody body = null, IQueryString queryString = null, IHeaderCollection headers = null)
{
return(this.ExecuteRequest <T>(HttpMethod.Delete, urlParams, body, queryString, headers));
}
public async Task <IResponseResult> DeleteAsync(TUrlParams urlParams = null, RequestBody body = null, IQueryString queryString = null, IHeaderCollection headers = null)
{
return(await this.ExecuteRequestAsync(HttpMethod.Delete, urlParams, body, queryString, headers));
}
internal async Task <DockerApiResponse> MakeRequestAsync(IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IDictionary <string, string> headers, IRequestContent data)
{
var response = await MakeRequestInnerAsync(null, HttpCompletionOption.ResponseContentRead, method, path, queryString, headers, data, default(CancellationToken)).ConfigureAwait(false);
var body = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
HandleIfErrorResponse(response.StatusCode, body, errorHandlers);
return(new DockerApiResponse(response.StatusCode, body));
}
private async Task<HttpResponseMessage> MakeRequestInnerAsync(TimeSpan? requestTimeout, HttpCompletionOption completionOption, HttpMethod method, string path, IQueryString queryString, IDictionary<string, string> headers, IRequestContent data, CancellationToken cancellationToken)
{
HttpClient client = this.GetHttpClient();
if (requestTimeout.HasValue)
{
client.Timeout = requestTimeout.Value;
}
HttpRequestMessage request = PrepareRequest(method, path, queryString, headers, data);
return await client.SendAsync(request, completionOption, cancellationToken);
}
public bool IsShowExcel(IQueryString queryString)
{
TkDebug.AssertArgumentNull(queryString, "queryString", this);
return(queryString[fQueryStringName] == fExcelValue);
}
public static Dictionary <string, string> ToDictionary(this IQueryString queryString)
{
TkDebug.AssertArgumentNull(queryString, nameof(queryString), null);
return(queryString.ToDictionary(p => p.Key, p => p.Value));
}
public static Uri BuildUri(Uri baseUri, Version requestedApiVersion, string path, IQueryString queryString)
{
if (baseUri == null)
{
throw new ArgumentNullException(nameof(baseUri));
}
UriBuilder builder = new UriBuilder(baseUri);
if (requestedApiVersion != null)
{
builder.Path += string.Format(CultureInfo.InvariantCulture, "v{0}/", requestedApiVersion);
}
if (!string.IsNullOrEmpty(path))
{
builder.Path += path;
}
if (queryString != null)
{
builder.Query = queryString.GetQueryString();
}
return(builder.Uri);
}
internal async Task <Stream> MakeRequestForStreamAsync(IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IDictionary <string, string> headers, IRequestContent data, CancellationToken cancellationToken)
{
HttpResponseMessage response = await MakeRequestInnerAsync(InfiniteTimeout, HttpCompletionOption.ResponseHeadersRead, method, path, queryString, headers, data, cancellationToken).ConfigureAwait(false);
HandleIfErrorResponse(response.StatusCode, null, errorHandlers);
return(await response.Content.ReadAsStreamAsync().ConfigureAwait(false));
}
internal HttpRequestMessage PrepareRequest(HttpMethod method, string path, IQueryString queryString, IDictionary<string, string> headers, IRequestContent data)
{
if (string.IsNullOrEmpty("path"))
{
throw new ArgumentNullException("path");
}
HttpRequestMessage request = new HttpRequestMessage(method, HttpUtility.BuildUri(this.Configuration.EndpointBaseUri, this.RequestedApiVersion, path, queryString));
request.Headers.Add("User-Agent", UserAgent);
if (headers != null)
{
foreach (var header in headers)
{
request.Headers.Add(header.Key, header.Value);
}
}
if (data != null)
{
HttpContent requestContent = data.GetContent(); // make the call only once.
request.Content = requestContent;
}
return request;
}
public async Task PostAsync_forwards_to_IHttpRestClient(IHttpRestClient client, string path, IQueryString queryString)
{
await client.PostAsync(path, queryString);
Mock.Get(client).Verify(p => p.SendAsync(HttpMethod.Post, path, queryString));
}
public async Task GetAsync_forwards_to_IHttpRestClient(IHttpRestClient client, string path, Request request, IQueryString queryString, Response _)
{
_ = await client.GetAsync <Request, Response>(path, request, queryString);
Mock.Get(client).Verify(p => p.SendAsync <Request, Response>(HttpMethod.Get, path, request, queryString));
}
public async Task DeleteAsync_forwards_to_IHttpRestClient(IHttpRestClient client, string path, Request request, IQueryString queryString)
{
await client.DeleteAsync(path, request, queryString);
Mock.Get(client).Verify(p => p.SendAsync(HttpMethod.Delete, path, request, queryString));
}
private Task<HttpResponseMessage> MakeRequestInnerAsync(TimeSpan? requestTimeout, HttpCompletionOption completionOption, HttpMethod method, string path, IQueryString queryString, IDictionary<string, string> headers, IRequestContent data, CancellationToken cancellationToken)
{
HttpRequestMessage request = PrepareRequest(method, path, queryString, headers, data);
if (requestTimeout.HasValue)
{
if (requestTimeout.Value != InfiniteTimeout)
{
cancellationToken = CreateTimeoutToken(cancellationToken, requestTimeout.Value);
}
}
else
{
cancellationToken = CreateTimeoutToken(cancellationToken, _defaultTimeout);
}
return _client.SendAsync(request, completionOption, cancellationToken);
}
public static Uri BuildUri(Uri baseUri, Version requestedApiVersion, string path, IQueryString queryString)
{
if (baseUri == null)
{
throw new ArgumentNullException(nameof(baseUri));
}
var builder = new UriBuilder(baseUri);
if (requestedApiVersion != null)
{
builder.Path += $"v{requestedApiVersion}/";
}
if (!string.IsNullOrEmpty(path))
{
builder.Path += path;
}
if (queryString != null)
{
builder.Query = queryString.GetQueryString();
}
return(builder.Uri);
}
private Task <HttpResponseMessage> MakeRequestInnerAsync(TimeSpan?requestTimeout, HttpCompletionOption completionOption, HttpMethod method, string path, IQueryString queryString, IDictionary <string, string> headers, IRequestContent data, CancellationToken cancellationToken)
{
HttpRequestMessage request = PrepareRequest(method, path, queryString, headers, data);
if (requestTimeout.HasValue)
{
if (requestTimeout.Value != InfiniteTimeout)
{
cancellationToken = CreateTimeoutToken(cancellationToken, requestTimeout.Value);
}
}
else
{
cancellationToken = CreateTimeoutToken(cancellationToken, _defaultTimeout);
}
return(_client.SendAsync(request, completionOption, cancellationToken));
}
private static string GetQueryString(IQueryString queryString)
{
return(queryString.Query ?? string.Empty);
}
internal Task <DockerApiStreamedResponse> MakeRequestForStreamedResponseAsync(IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IRequestContent data, CancellationToken cancellationToken)
{
return(MakeRequestForStreamedResponseAsync(errorHandlers, method, path, queryString, null, data, cancellationToken));
}
private async Task <HttpResponseMessage> MakeRequestInnerAsync(TimeSpan?requestTimeout, HttpCompletionOption completionOption, HttpMethod method, string path, IQueryString queryString, IDictionary <string, string> headers, IRequestContent data, CancellationToken cancellationToken)
{
HttpClient client = this.GetHttpClient();
if (requestTimeout.HasValue)
{
client.Timeout = requestTimeout.Value;
}
HttpRequestMessage request = PrepareRequest(method, path, queryString, headers, data);
return(await client.SendAsync(request, completionOption, cancellationToken));
}
public IResponseResult Get(IUrlParams urlParams = null, RequestBody body = null, IQueryString queryString = null, IHeaderCollection headers = null)
{
return(this.ExecuteRequest(HttpMethod.Get, urlParams, body, queryString, headers));
}
internal Task<DockerApiResponse> MakeRequestAsync(IEnumerable<ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IRequestContent data)
{
return MakeRequestAsync(errorHandlers, method, path, queryString, data, null, CancellationToken.None);
}
public bool IsShowMetaData(IQueryString queryString)
{
TkDebug.AssertArgumentNull(queryString, "queryString", this);
return(queryString[fQueryStringName] == fMetaDataValue);
}
internal async Task <DockerApiStreamedResponse> MakeRequestForStreamedResponseAsync(IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IDictionary <string, string> headers, IRequestContent data, CancellationToken cancellationToken)
{
HttpResponseMessage response = await MakeRequestInnerAsync(TimeSpan.FromMilliseconds(Timeout.Infinite), HttpCompletionOption.ResponseHeadersRead, method, path, queryString, headers, data, cancellationToken);
HandleIfErrorResponse(response.StatusCode, null, errorHandlers);
Stream body = await response.Content.ReadAsStreamAsync();
return(new DockerApiStreamedResponse(response.StatusCode, body, response.Headers));
}
internal Task<Stream> MakeRequestForStreamAsync(IEnumerable<ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IRequestContent data, CancellationToken cancellationToken)
{
return MakeRequestForStreamAsync(errorHandlers, method, path, queryString, null, data, cancellationToken);
}
internal Task <DockerApiResponse> MakeRequestAsync(IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString)
{
return(MakeRequestAsync(errorHandlers, method, path, queryString, null, null, CancellationToken.None));
}
public string GenerateCurlCode(HttpMethod method, TUrlParams urlParams = default(TUrlParams), RequestBody body = null, IQueryString queryString = null, IHeaderCollection headers = null)
{
string curl = $"curl --location --request {method.ToString().ToUpper()} '{this.GenerateUrl(urlParams, queryString)}' \\" + Environment.NewLine;
if (headers != null)
{
foreach (var header in headers)
{
curl += $"--header '{header.Key}: {header.Value}' \\" + Environment.NewLine;
}
}
if (body != null)
{
curl += $"--data-raw '{body.Context}'";
}
return(curl);
}
internal async Task <DockerApiResponse> MakeRequestAsync(IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IRequestContent data, TimeSpan?timeout, CancellationToken cancellationToken)
{
HttpResponseMessage response = await MakeRequestInnerAsync(null, HttpCompletionOption.ResponseContentRead, method, path, queryString, null, data, cancellationToken).ConfigureAwait(false);
string body = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
HandleIfErrorResponse(response.StatusCode, body, errorHandlers);
return(new DockerApiResponse(response.StatusCode, body));
}
public static IQueryString Add(IQueryString collection)
{
return(new HttpQueryString(collection.ToDictionary()));
}
protected async Task <IResponseResult <T> > ExecuteRequestAsync <T>(HttpMethod method, TUrlParams urlParams, RequestBody body = null, IQueryString queryString = null, IHeaderCollection headers = null)
{
string url = this.GenerateUrl(urlParams, queryString);
return(await RestHandler.Current.ExecuteRequestAsync <T>(method, url, body, headers));
}
internal async Task<Stream> MakeRequestForStreamAsync(IEnumerable<ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IDictionary<string, string> headers, IRequestContent data, CancellationToken cancellationToken)
{
HttpResponseMessage response = await MakeRequestInnerAsync(TimeSpan.FromMilliseconds(Timeout.Infinite), HttpCompletionOption.ResponseHeadersRead, method, path, queryString, headers, data, cancellationToken);
HandleIfErrorResponse(response.StatusCode, null, errorHandlers);
return await response.Content.ReadAsStreamAsync();
}
