public static string GetAuthenticationMethodValue([NotNull] this IHttpResponseMessage response, AuthHeader header, [NotNull] string methodName) { return(GetAuthenticationHeaderInfo(response, header) .Where(x => string.Equals(x.Name, methodName, StringComparison.OrdinalIgnoreCase)) .Select(x => x.RawValue) .SingleOrDefault()); }
public HttpClientResponse(Request request, IHttpResponseMessage response, HttpContent content, Exception error = null) : base(request) { Response = response; Content = content; Error = error; }
internal void Connect() { IHttpResponseMessage response = null; try { var getTask = _webClient.GetAsync(_uri, _username, _password); getTask.Wait(); response = getTask.Result; } catch (Exception) { throw new NeoServerUnavalaibleExpcetion(_uri, response.StatusCode.ToString()); } if (!response.IsSuccessStatusCode) { throw new NeoServerUnavalaibleExpcetion(_uri, response.StatusCode.ToString()); } var readTask = response.Content.ReadAsStringAsync(); Task.WaitAll(readTask); var json = readTask.Result; var serviceResponse = _webSerializer.Deserialize <ServiceRootResponse>(json); AssertVersion(serviceResponse); }
/// <summary> /// Utility function that really initializes this response object from /// a HttpResponseMessage /// </summary> /// <param name="response"> /// Response that will be used to initialize this response. /// </param> /// <returns> /// Task, because this function runs asynchronously /// </returns> /// <remarks> /// This override also deserializes the response /// </remarks> protected override async Task LoadResponse(IHttpResponseMessage response) { await base.LoadResponse(response); var handler = Client.GetHandler(ContentType); Data = (handler != null) ? handler.Deserialize <T>(this) : default(T); }
/// <summary> /// Determines if the authentication module can handle the challenge sent with the response. /// </summary> /// <param name="client">The REST client the response is assigned to</param> /// <param name="request">The REST request the response is assigned to</param> /// <param name="credentials">The credentials to be used for the authentication</param> /// <param name="response">The response that returned the authentication challenge</param> /// <returns>true when the authenticator can handle the sent challenge</returns> public override bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { if (HasAuthorizationToken) return false; if (response.StatusCode == HttpStatusCode.NotFound) return true; return base.CanHandleChallenge(client, request, credentials, response); }
public static IEnumerable <AuthHeaderInfo> GetAuthenticationHeaderInfo([NotNull] this IHttpResponseMessage response, AuthHeader header) { var headerName = header.ToAuthenticationHeaderName(); IEnumerable <string> headerValues; if (!response.Headers.TryGetValues(headerName, out headerValues)) { headerValues = _emptyHeaderValues; } return(headerValues .SelectMany(ParseAuthenticationHeader) .ToList()); }
/// <summary> /// Utility function that really initializes this response object from /// a HttpResponseMessage /// </summary> /// <param name="response">Response that will be used to initialize this response.</param> /// <returns>Task, because this function runs asynchronously</returns> protected virtual async Task LoadResponse(IHttpResponseMessage response) { Headers = response.Headers; IsSuccess = response.IsSuccessStatusCode; StatusCode = response.StatusCode; StatusDescription = response.ReasonPhrase; var requestUri = Client.BuildUri(Request, false); ResponseUri = new Uri(requestUri, response.Headers.GetValue("Location", requestUri.ToString())); var content = response.Content; if (content == null) { RawBytes = new byte[0]; } else { var contentType = content.Headers.GetValue("Content-Type"); if (string.IsNullOrEmpty(contentType)) { ContentType = string.Empty; } else { var semicolonPos = contentType.IndexOf(';'); if (semicolonPos != -1) { contentType = contentType.Substring(0, semicolonPos); } ContentType = contentType.Trim(); } var data = await content.ReadAsByteArrayAsync(); IEnumerable <string> contentEncodings; if (content.Headers.TryGetValues("Content-Encoding", out contentEncodings)) { var encoding = Client.GetEncoding(contentEncodings); if (encoding != null) { data = encoding.Decode(data); } } RawBytes = data; } }
/// <summary> /// Utility function that really initializes this response object from /// a HttpResponseMessage /// </summary> /// <param name="response"> /// Response that will be used to initialize this response. /// </param> /// <param name="ct">The cancellation token</param> /// <returns> /// Task, because this function runs asynchronously /// </returns> /// <remarks> /// This override also deserializes the response /// </remarks> protected override async Task LoadResponse(IHttpResponseMessage response, CancellationToken ct) { await base.LoadResponse(response, ct).ConfigureAwait(false); if (RawBytes != null) { var handler = Client.GetHandler(ContentType); Data = (handler != null) ? handler.Deserialize <T>(this) : default(T); } else { Data = default(T); } }
internal void Connect() { IHttpResponseMessage response = null; try { response = _webClient.GetAsync(_uri).Result; } catch (Exception) { throw new NeoServerUnavalaibleExpcetion(_uri); } var json = response.Content.ReadAsStringAsync().Result; var serviceResponse = _webSerializer.Deserialize <ServiceRootResponse>(json); AssertVersion(serviceResponse); }
/// <summary> /// Determines if the authentication module can handle the challenge sent with the response. /// </summary> /// <param name="client">The REST client the response is assigned to</param> /// <param name="request">The REST request the response is assigned to</param> /// <param name="credentials">The credentials to be used for the authentication</param> /// <param name="response">The response that returned the authentication challenge</param> /// <returns>true when the authenticator can handle the sent challenge</returns> public virtual bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { // No credentials defined? if (credentials == null) { return(false); } // No challenge header found? var authModeInfo = response.GetAuthenticationMethodValue(_authHeader, AuthenticationMethod); if (authModeInfo == null) { return(false); } // Search for credential for request URI var responseUri = client.GetRequestUri(request, response); var credential = credentials.GetCredential(responseUri, AuthenticationMethod); if (credential == null) { return(false); } // Did we already try to use the found credentials? if (ReferenceEquals(credential, _authCredential)) { // Yes, so we don't retry the authentication. return(false); } return(true); }
/// <inheritdoc/> public override bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { // Get authentication header using the method specified by <code>_tokenType</code> or <code>OAuth</code> var authHeaderInfo = response .GetAuthenticationHeaderInfo(AuthHeader.Www) .FirstOrDefault( x => string.Equals(x.Name, _tokenType, StringComparison.OrdinalIgnoreCase) || string.Equals(x.Name, "OAuth", StringComparison.OrdinalIgnoreCase)); if (authHeaderInfo == null) return false; // Check for WWW-Authenticate when status code is 401 (Unauthorized) if (response.StatusCode == HttpStatusCode.Unauthorized) return authHeaderInfo.Values["error"].Any(x => string.Equals(x, "invalid_token")); // Not a 400 (Bad Request)? Cannot handle challenge. if (response.StatusCode != HttpStatusCode.BadRequest) return false; // Check for Facebooks broken WWW-Authenticate var isFacebook = authHeaderInfo.Values[string.Empty].Any(x => x.Contains("Facebook")); if (!isFacebook) return false; if (!authHeaderInfo.Values[string.Empty].Any(x => x.Equals("invalid_token", StringComparison.OrdinalIgnoreCase))) return false; if (!base.CanHandleChallenge(client, request, credentials, response)) return false; return true; }
private IReleaseStorage WebReleaseStorage(IHttpResponseMessage httpResponse) { _httpClient.GetAsync(_config.FeedUri).Returns(httpResponse); return(WebReleaseStorage()); }
public static Uri GetRequestUri([CanBeNull] this IHttpClient client, [NotNull] IHttpRequestMessage request, [NotNull] IHttpResponseMessage response) { var requestUri = client.GetRequestUri(request); IEnumerable <string> locationValues; if (!response.Headers.TryGetValues("Location", out locationValues)) { return(requestUri); } var location = locationValues.FirstOrDefault(); if (string.IsNullOrWhiteSpace(location)) { return(requestUri); } return(new Uri(requestUri, location)); }
/// <summary> /// Will be called when the authentication failed /// </summary> /// <param name="client">Client executing this request</param> /// <param name="request">Request to authenticate</param> /// <param name="credentials">The credentials used for the authentication</param> /// <param name="response">Response of the failed request</param> /// <returns>Task where the handler for a failed authentication gets executed</returns> public Task HandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { return Task.Factory.StartNew(() => { if (!CanHandleChallenge(client, request, credentials, response)) throw new InvalidOperationException(); var responseUri = client.GetRequestUri(request, response); _authCredential = credentials.GetCredential(responseUri, AuthenticationMethod); var authModeInfo = response.GetAuthenticationMethodValue(_authHeader, AuthenticationMethod); ParseResponseHeader(authModeInfo); }); }
/// <summary> /// Will be called when the authentication failed /// </summary> /// <param name="client">Client executing this request</param> /// <param name="request">Request to authenticate</param> /// <param name="credentials">The credentials used for the authentication</param> /// <param name="response">Response of the failed request</param> /// <returns>Task where the handler for a failed authentication gets executed</returns> public Task HandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { throw new NotSupportedException(); }
/// <summary> /// Determines if the authentication module can handle the challenge sent with the response. /// </summary> /// <param name="client">The REST client the response is assigned to</param> /// <param name="request">The REST request the response is assigned to</param> /// <param name="credentials">The credentials to be used for the authentication</param> /// <param name="response">The response that returned the authentication challenge</param> /// <returns>true when the authenticator can handle the sent challenge</returns> public virtual bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { // No refresh token? Cannot handle challenge if (string.IsNullOrEmpty(Client.RefreshToken)) { return(false); } var currentChallenge = DateTimeOffset.UtcNow; if (_lastChallenge.HasValue) { var safetyMargin = TimeSpan.FromSeconds(60); if (currentChallenge < _lastChallenge.Value + safetyMargin) { return(false); } } _lastChallenge = currentChallenge; return(true); }
/// <summary> /// Will be called when the authentication failed /// </summary> /// <param name="client">Client executing this request</param> /// <param name="request">Request to authenticate</param> /// <param name="credentials">The credentials used for the authentication</param> /// <param name="response">Response of the failed request</param> /// <returns>Task where the handler for a failed authentication gets executed</returns> public Task HandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { var authenticator = response .GetAuthenticationHeaderInfo(Header) .Where(x => _authenticators.ContainsKey(x.Name)) .Select(x => _authenticators[x.Name]) .Where(x => x.Authenticator.CanHandleChallenge(client, request, credentials, response)) .OrderByDescending(x => x.Security) .Select(x => x.Authenticator) .First(); return(authenticator.HandleChallenge(client, request, credentials, response)); }
/// <summary> /// Determines if the authentication module can handle the challenge sent with the response. /// </summary> /// <param name="client">The HTTP client the response is assigned to</param> /// <param name="request">The HTTP request the response is assigned to</param> /// <param name="credentials">The credentials to be used for the authentication</param> /// <param name="response">The response that returned the authentication challenge</param> /// <returns>true when the authenticator can handle the sent challenge</returns> public virtual bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { return(false); }
/// <summary> /// Will be called when the authentication failed /// </summary> /// <param name="client">Client executing this request</param> /// <param name="request">Request to authenticate</param> /// <param name="credentials">The credentials used for the authentication</param> /// <param name="response">Response of the failed request</param> /// <returns>Task where the handler for a failed authentication gets executed</returns> public async Task HandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { var authenticator = response .GetAuthenticationHeaderInfo(Header) .Where(x => _authenticators.ContainsKey(x.Name)) .Select(x => _authenticators[x.Name]) .Where(x => x.Authenticator.CanHandleChallenge(client, request, credentials, response)) .OrderByDescending(x => x.Security) .Select(x => x.Authenticator) .First(); await authenticator.HandleChallenge(client, request, credentials, response); }
/// <summary> /// Determines if the authentication module can handle the challenge sent with the response. /// </summary> /// <param name="client">The REST client the response is assigned to</param> /// <param name="request">The REST request the response is assigned to</param> /// <param name="credentials">The credentials to be used for the authentication</param> /// <param name="response">The response that returned the authentication challenge</param> /// <returns>true when the authenticator can handle the sent challenge</returns> public bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { return response .GetAuthenticationHeaderInfo(Header) .Where(x => _authenticators.ContainsKey(x.Name)) .Select(x => _authenticators[x.Name]) .Where(x => x.Authenticator.CanHandleChallenge(client, request, credentials, response)) .OrderByDescending(x => x.Security) .Select(x => x.Authenticator) .Any(); }
public bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) => false;
private IDownloadableFile DownloadableFile(string uri, IHttpResponseMessage httpResponse) { _httpClient.GetAsync(uri).Returns(httpResponse); return(DownloadableFile()); }
/// <summary> /// Will be called when the authentication failed /// </summary> /// <param name="client">Client executing this request</param> /// <param name="request">Request to authenticate</param> /// <param name="credentials">The credentials used for the authentication</param> /// <param name="response">Response of the failed request</param> /// <returns>Task where the handler for a failed authentication gets executed</returns> public virtual Task HandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { throw new NotSupportedException(); }
/// <summary> /// Will be called when the authentication failed /// </summary> /// <param name="client">Client executing this request</param> /// <param name="request">Request to authenticate</param> /// <param name="credentials">The credentials used for the authentication</param> /// <param name="response">Response of the failed request</param> /// <returns>Task where the handler for a failed authentication gets executed</returns> public virtual async Task HandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { if (!CanHandleChallenge(client, request, credentials, response)) { throw new InvalidOperationException(); } await Client.GetCurrentToken(forceUpdate : true); }
/// <summary> /// Determines if the authentication module can handle the challenge sent with the response. /// </summary> /// <param name="client">The REST client the response is assigned to</param> /// <param name="request">The REST request the response is assigned to</param> /// <param name="credentials">The credentials to be used for the authentication</param> /// <param name="response">The response that returned the authentication challenge</param> /// <returns>true when the authenticator can handle the sent challenge</returns> public virtual bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { // No credentials defined? if (credentials == null) return false; // No challenge header found? var authModeInfo = response.GetAuthenticationMethodValue(_authHeader, AuthenticationMethod); if (authModeInfo == null) return false; // Search for credential for request URI var responseUri = client.GetRequestUri(request, response); var credential = credentials.GetCredential(responseUri, AuthenticationMethod); if (credential == null) return false; // Did we already try to use the found credentials? if (ReferenceEquals(credential, _authCredential)) { // Yes, so we don't retry the authentication. return false; } return true; }
/// <summary> /// Determines if the authentication module can handle the challenge sent with the response. /// </summary> /// <param name="client">The REST client the response is assigned to</param> /// <param name="request">The REST request the response is assigned to</param> /// <param name="credentials">The credentials to be used for the authentication</param> /// <param name="response">The response that returned the authentication challenge</param> /// <returns>true when the authenticator can handle the sent challenge</returns> public override bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { if (HasAuthorizationToken) { return(false); } if (response.StatusCode == HttpStatusCode.NotFound) { return(true); } return(base.CanHandleChallenge(client, request, credentials, response)); }
public System.Threading.Tasks.Task HandleChallenge(IHttpClient client, IHttpRequestMessage request, System.Net.ICredentials credentials, IHttpResponseMessage response) { throw new NotImplementedException(); }
public Task HandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { throw new NotImplementedException(); }
internal static LuisResponse AsLuisResponse(this IHttpResponseMessage responseMessage) { return(JsonConvert.DeserializeObject <LuisResponse>(responseMessage.Content)); }
/// <inheritdoc/> public override bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { // Get authentication header using the method specified by <code>_tokenType</code> or <code>OAuth</code> var authHeaderInfo = response .GetAuthenticationHeaderInfo(AuthHeader.Www) .FirstOrDefault( x => string.Equals(x.Name, _tokenType, StringComparison.OrdinalIgnoreCase) || string.Equals(x.Name, "OAuth", StringComparison.OrdinalIgnoreCase)); if (authHeaderInfo == null) { return(false); } // Check for WWW-Authenticate when status code is 401 (Unauthorized) if (response.StatusCode == HttpStatusCode.Unauthorized) { return(authHeaderInfo.Values["error"].Any(x => string.Equals(x, "invalid_token"))); } // Not a 400 (Bad Request)? Cannot handle challenge. if (response.StatusCode != HttpStatusCode.BadRequest) { return(false); } // Check for Facebooks broken WWW-Authenticate var isFacebook = authHeaderInfo.Values[string.Empty].Any(x => x.Contains("Facebook")); if (!isFacebook) { return(false); } if (!authHeaderInfo.Values[string.Empty].Any(x => x.Equals("invalid_token", StringComparison.OrdinalIgnoreCase))) { return(false); } if (!base.CanHandleChallenge(client, request, credentials, response)) { return(false); } return(true); }
/// <summary> /// Create a <see cref="IRestResponse"/> from a <see cref="IRestClient"/>, <see cref="IRestRequest"/> and a <see cref="IHttpResponseMessage"/>. /// </summary> /// <typeparam name="T">The type to instantiate the response for.</typeparam> /// <param name="client">The <see cref="IRestClient"/> used to create a <see cref="IRestResponse"/></param> /// <param name="request">The <see cref="IRestRequest"/> used to create a <see cref="IRestResponse"/></param> /// <param name="responseMessage">The <see cref="IHttpResponseMessage"/> used to create a <see cref="IRestResponse"/></param> /// <param name="ct">The cancellation token</param> /// <returns>The new <see cref="IRestResponse"/></returns> public static async Task <IRestResponse <T> > CreateResponse <T>(IRestClient client, IRestRequest request, IHttpResponseMessage responseMessage, CancellationToken ct) { var response = new RestResponse <T>(client, request); await response.LoadResponse(responseMessage, ct); return(response); }
/// <summary> /// Will be called when the authentication failed /// </summary> /// <param name="client">Client executing this request</param> /// <param name="request">Request to authenticate</param> /// <param name="credentials">The credentials used for the authentication</param> /// <param name="response">Response of the failed request</param> /// <returns>Task where the handler for a failed authentication gets executed</returns> public Task HandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { return Task.Factory.StartNew(() => { if (!CanHandleChallenge(client, request, credentials, response)) { throw new InvalidOperationException(); } var responseUri = client.GetRequestUri(request, response); _authCredential = credentials.GetCredential(responseUri, AuthenticationMethod); _authToken = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{_authCredential.UserName}:{_authCredential.Password}")); }); }
/// <summary> /// Will be called when the authentication failed /// </summary> /// <param name="client">Client executing this request</param> /// <param name="request">Request to authenticate</param> /// <param name="credentials">The credentials used for the authentication</param> /// <param name="response">Response of the failed request</param> /// <returns>Task where the handler for a failed authentication gets executed</returns> public Task HandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { if (!CanHandleChallenge(client, request, credentials, response)) { throw new InvalidOperationException(); } var responseUri = client.GetRequestUri(request, response); _authCredential = credentials.GetCredential(responseUri, AuthenticationMethod); _authToken = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{_authCredential.UserName}:{_authCredential.Password}")); #if ASYNC_PCL return(Task.FromResult(0)); #else return(new Task(() => { })); #endif }
/// <summary> /// Will be called when the authentication failed /// </summary> /// <param name="client">Client executing this request</param> /// <param name="request">Request to authenticate</param> /// <param name="credentials">The credentials used for the authentication</param> /// <param name="response">Response of the failed request</param> /// <returns>Task where the handler for a failed authentication gets executed</returns> public virtual async Task HandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { if (!CanHandleChallenge(client, request, credentials, response)) throw new InvalidOperationException(); await Client.GetCurrentToken(forceUpdate: true); }
/// <summary> /// Utility function that really initializes this response object from /// a HttpResponseMessage /// </summary> /// <param name="response">Response that will be used to initialize this response.</param> /// <param name="ct">The cancellation token</param> /// <returns>Task, because this function runs asynchronously</returns> protected virtual async Task LoadResponse(IHttpResponseMessage response, CancellationToken ct) { Headers = response.Headers; IsSuccess = response.IsSuccessStatusCode; StatusCode = response.StatusCode; StatusDescription = response.ReasonPhrase; var requestUri = Client.BuildUri(Request, false); ResponseUri = new Uri(requestUri, response.Headers.GetValue("Location", requestUri.ToString())); Cookies = response.Cookies?.GetCookies(ResponseUri); var content = response.Content; if (content == null) { RawBytes = new byte[0]; } else { var contentType = content.Headers.GetValue("Content-Type"); if (string.IsNullOrEmpty(contentType)) { ContentType = string.Empty; } else { var semicolonPos = contentType.IndexOf(';'); if (semicolonPos != -1) { contentType = contentType.Substring(0, semicolonPos); } ContentType = contentType.Trim(); } var responseWriter = Request.ResponseWriterAsync; if (responseWriter != null) { if (response.Content != null) { var responseStream = await response.Content.ReadAsStreamAsync(); if (responseStream != null) { var encoding = response.Content.GetEncoding(Client); if (encoding != null) { responseStream = encoding.DecodeStream(responseStream); } await responseWriter(responseStream, ct); } } } else { var data = await content.ReadAsByteArrayAsync(); var encoding = content.GetEncoding(Client); if (encoding != null) { data = encoding.Decode(data); } RawBytes = data; } } }
public static async Task <HttpClientResponse> Create(HttpClientRequest request, IHttpResponseMessage response) { var content = await response.Content.GetContent().ConfigureAwait(false); return(new HttpClientResponse(request, response, content)); }
public bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, System.Net.ICredentials credentials, IHttpResponseMessage response) { return false; }
public bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, System.Net.ICredentials credentials, IHttpResponseMessage response) { return(false); }
/// <summary> /// Will be called when the authentication failed /// </summary> /// <param name="client">Client executing this request</param> /// <param name="request">Request to authenticate</param> /// <param name="credentials">The credentials used for the authentication</param> /// <param name="response">Response of the failed request</param> /// <returns>Task where the handler for a failed authentication gets executed</returns> public Task HandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { if (!CanHandleChallenge(client, request, credentials, response)) { throw new InvalidOperationException(); } var responseUri = client.GetRequestUri(request, response); _authCredential = credentials.GetCredential(responseUri, AuthenticationMethod); var authModeInfo = response.GetAuthenticationMethodValue(_authHeader, AuthenticationMethod); ParseResponseHeader(authModeInfo); #if USE_TASKEX return(TaskEx.FromResult(0)); #else return(Task.FromResult(0)); #endif }
/// <summary> /// Determines if the authentication module can handle the challenge sent with the response. /// </summary> /// <param name="client">The REST client the response is assigned to</param> /// <param name="request">The REST request the response is assigned to</param> /// <param name="credentials">The credentials to be used for the authentication</param> /// <param name="response">The response that returned the authentication challenge</param> /// <returns>true when the authenticator can handle the sent challenge</returns> public virtual bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { return !string.IsNullOrEmpty(Client.RefreshToken); }
/// <summary> /// Determines if the authentication module can handle the challenge sent with the response. /// </summary> /// <param name="client">The HTTP client the response is assigned to</param> /// <param name="request">The HTTP request the response is assigned to</param> /// <param name="credentials">The credentials to be used for the authentication</param> /// <param name="response">The response that returned the authentication challenge</param> /// <returns>true when the authenticator can handle the sent challenge</returns> public virtual bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { return false; }
/// <summary> /// Determines if the authentication module can handle the challenge sent with the response. /// </summary> /// <param name="client">The REST client the response is assigned to</param> /// <param name="request">The REST request the response is assigned to</param> /// <param name="credentials">The credentials to be used for the authentication</param> /// <param name="response">The response that returned the authentication challenge</param> /// <returns>true when the authenticator can handle the sent challenge</returns> public virtual bool CanHandleChallenge(IHttpClient client, IHttpRequestMessage request, ICredentials credentials, IHttpResponseMessage response) { // No refresh token? Cannot handle challenge if (string.IsNullOrEmpty(Client.RefreshToken)) return false; var currentChallenge = DateTimeOffset.UtcNow; if (_lastChallenge.HasValue) { var safetyMargin = TimeSpan.FromSeconds(60); if (currentChallenge < _lastChallenge.Value + safetyMargin) return false; } _lastChallenge = currentChallenge; return true; }
public System.Threading.Tasks.Task HandleChallenge(IHttpClient client, IHttpRequestMessage request, System.Net.ICredentials credentials, IHttpResponseMessage response) { throw new NotImplementedException(); }
/// <summary> /// Create a <see cref="IRestResponse"/> from a <see cref="IRestClient"/>, <see cref="IRestRequest"/> and a <see cref="IHttpResponseMessage"/>. /// </summary> /// <param name="client">The <see cref="IRestClient"/> used to create a <see cref="IRestResponse"/></param> /// <param name="request">The <see cref="IRestRequest"/> used to create a <see cref="IRestResponse"/></param> /// <param name="responseMessage">The <see cref="IHttpResponseMessage"/> used to create a <see cref="IRestResponse"/></param> /// <returns>The new <see cref="IRestResponse"/></returns> public static async Task <IRestResponse> CreateResponse(IRestClient client, IRestRequest request, IHttpResponseMessage responseMessage) { var response = new RestResponse(client, request); await response.LoadResponse(responseMessage); return(response); }