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(); }