internal CouchbaseHttpClient(HttpClientHandler handler)
: base(handler)
{
DefaultRequestHeaders.Add(UserAgentHeaderName, ClientIdentifier.GetClientDescription());
}
public BingHttpClient(string key)
{
DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", key);
}
/// <summary>
/// Initializes a new instance of the ExchangeRatesClient class with the provided handler, and specifies whether that handler should be disposed when this instance is disposed.
/// </summary>
/// <param name="handler">The HttpMessageHandler responsible for processing the HTTP response messages.</param>
/// <param name="disposeHandler">true if the inner handler should be disposed of by ExchangeRatesClient.Dispose; false if you intend to reuse the inner handler.</param>
/// <exception cref="ArgumentNullException"></exception>
public ExchangeRatesClient(HttpMessageHandler handler, bool disposeHandler) : base(handler, disposeHandler)
{
BaseAddress = new Uri("https://tassidicambio.bancaditalia.it/terzevalute-wf-web/rest/v1.0/");
DefaultRequestHeaders.Add("Accept", MediaTypeNames.Application.Json);
}
/// <summary>
/// Create a RestClient for the specified base URL
/// </summary>
public RestClient(string baseURL)
{
BaseAddress = new Uri(baseURL);
DefaultRequestHeaders.Add("Accept", "application/json");
}
public SpeedTestHttpClient()
{
DefaultRequestHeaders.Add("Accept", "text/html, application/xhtml+xml, */*");
DefaultRequestHeaders.Add("User-Agent", "Mozilla/5.0 (Windows NT 6.3; WOW64; Trident/7.0; rv:11.0) like Gecko");
}
/// <summary>
///
/// </summary>
/// <param name="url"></param>
internal WebApiClient(string url)
{
BaseAddress = new Uri(url);
DefaultRequestHeaders.Clear();
DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
}
/*
* Convenience function fetching the Approov token
*
*/
protected override void FetchApproovToken(string url, HttpRequestMessage message = null)
{
// Check if Bind Header is set to a non empty String
lock (bindingHeaderLock)
{
if (BindingHeader != null)
{
var headersToCheck = message == null ? DefaultRequestHeaders : message.Headers;
if (headersToCheck.Contains(BindingHeader))
{
// Returns all header values for a specified header stored in the HttpHeaders collection.
var headerValues = headersToCheck.GetValues(BindingHeader);
var enumerator = headerValues.GetEnumerator();
int i = 0;
string headerValue = null;
while (enumerator.MoveNext())
{
i++;
headerValue = enumerator.Current;
}
// Check that we have only one value
if (i != 1)
{
throw new ApproovSDKException(TAG + "Only one value can be used as binding header, detected " + i);
}
SetDataHashInToken(headerValue);
}
else
{
throw new ApproovSDKException(TAG + "Missing token binding header: " + BindingHeader);
}
}
}// lock
// Invoke fetch token sync
var approovResult = FetchApproovTokenAndWait(url);
// Log result
Console.WriteLine(TAG + "Approov token for host " + url + " : " + approovResult.LoggableToken());
// Update dynamic config
if (approovResult.IsConfigChanged())
{
StoreApproovDynamicConfig(FetchConfig());
}
// Check the status of the Approov token fetch
if (approovResult.Status() == ApproovTokenFetchStatus.Success)
{
// we successfully obtained a token so add it to the header for the HttpClient or HttpRequestMessage
if (message == null)
{
DefaultRequestHeaders.Add(ApproovTokenHeader, ApproovTokenPrefix + approovResult.Token());
}
else
{
if (message.Headers.Contains(ApproovTokenHeader))
{
message.Headers.Remove(ApproovTokenHeader);
}
message.Headers.Add(ApproovTokenHeader, ApproovTokenPrefix + approovResult.Token());
}
}
else if ((approovResult.Status() == ApproovTokenFetchStatus.NoNetwork) ||
(approovResult.Status() == ApproovTokenFetchStatus.PoorNetwork) ||
(approovResult.Status() == ApproovTokenFetchStatus.MITMDetected))
{
// Must not proceed with network request and inform user a retry is needed
throw new ApproovSDKException(TAG + "Retry attempt needed. " + approovResult.LoggableToken(), true);
}
else if ((approovResult.Status() == ApproovTokenFetchStatus.UnknownURL) ||
(approovResult.Status() == ApproovTokenFetchStatus.UnprotectedURL) ||
(approovResult.Status() == ApproovTokenFetchStatus.NoApproovService))
{
Console.WriteLine(TAG + "Will continue without Approov-Token");
}
else
{
throw new ApproovSDKException("Unknown approov token fetch result " + approovResult.Status());
}
}
public CustomHttpClient(DownloadConfig config) : base()
{
Config = config;
DefaultRequestHeaders.Add("Accept", "application/json");
DefaultRequestHeaders.Add("Authorization", GetBasicAuth());
}
public void AddRequestHeader(string name, string value)
{
RemoveRequestHeader(name);
DefaultRequestHeaders.Add(name, value);
}
public HttpClient()
: base(new HttpClientHandler(), disposeHandler: true)
{
DefaultRequestHeaders.Add("Accept", "*/*");
DefaultRequestHeaders.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:63.0) Gecko/20100101 Firefox/63.0");
}
public HttpClientBase()
{
DefaultRequestHeaders.Add("Acept", "application/json");
DefaultRequestHeaders.Add("ContentType", "application/json");
Timeout = TimeSpan.FromMinutes(30);
}
void CleanHeaders()
{
ReferrerUri = "https://duckduckgo.com";
AutherizationHeader = string.Empty;
DefaultRequestHeaders.Remove("Authorization");
}
private HttpClientSingleton()
{
DefaultRequestHeaders.Add("cache-control", "no-cache");
}
private void Setup()
{
BaseAddress = new Uri("https://api.github.com/users/");
DefaultRequestHeaders.Add("User-Agent", "jameshealey94"); // https://developer.github.com/v3/#user-agent-required
DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json"); // https://developer.github.com/v3/media
}
public ArksLayerHttpClient()
{
DefaultRequestHeaders.Add("User-Agent", "PSRT.Astra");
DefaultRequestHeaders.Add("Cache-Control", "no-cache, no-store, must-revalidate");
}
public void RemoveRequestHeader(string name)
{
DefaultRequestHeaders.Remove(name);
}
/// <summary>
/// Asynchronously send a request
/// </summary>
/// <param name="request">The request do send</param>
/// <param name="cancellationToken">The cancellation token used to signal an abortion</param>
/// <returns>The task to query the response</returns>
public async Task <IHttpResponseMessage> SendAsync(IHttpRequestMessage request, CancellationToken cancellationToken)
{
var uri = new Uri(BaseAddress, request.RequestUri);
var wr = _httpClientFactory.CreateWebRequest(uri);
if (wr.HasCookieContainerSupport() && CookieContainer != null)
{
wr.CookieContainer = CookieContainer;
}
if (Credentials != null)
{
wr.Credentials = Credentials;
}
wr.Method = request.Method.ToString();
#if !NO_PROXY
wr.Proxy = Proxy ?? System.Net.WebRequest.DefaultWebProxy;
#endif
// Combine all headers into one header collection
var headers = new GenericHttpHeaders();
if (request.Content?.Headers != null)
{
foreach (var header in request.Content.Headers.Where(x => !headers.Contains(x.Key)))
{
headers.TryAddWithoutValidation(header.Key, header.Value);
}
}
if (request.Headers != null)
{
foreach (var header in request.Headers.Where(x => !headers.Contains(x.Key)))
{
headers.TryAddWithoutValidation(header.Key, header.Value);
}
}
if (DefaultRequestHeaders != null)
{
foreach (var header in DefaultRequestHeaders.Where(x => !headers.Contains(x.Key)))
{
headers.TryAddWithoutValidation(header.Key, header.Value);
}
}
bool hasContentLength = false;
foreach (var header in headers)
{
var value = string.Join(",", header.Value);
SetWebRequestHeaderValue(wr, header.Key, value);
if (!hasContentLength && string.Equals(header.Key, "content-length", StringComparison.OrdinalIgnoreCase))
{
hasContentLength = true;
}
}
if (request.Content != null)
{
// Add content length if not provided by the user.
if (!hasContentLength)
{
long contentLength;
if (request.Content.TryComputeLength(out contentLength))
{
SetWebRequestHeaderValue(wr, "Content-Length", contentLength.ToString());
}
}
try
{
#if NETSTANDARD1_0 || PROFILE259
var getRequestStreamAsync = Task.Factory.FromAsync(wr.BeginGetRequestStream, wr.EndGetRequestStream, null);
var requestStream = await getRequestStreamAsync.HandleCancellation(cancellationToken);
#else
var requestStream = await wr.GetRequestStreamAsync().HandleCancellation(cancellationToken);
#endif
using (requestStream)
{
var temp = new MemoryStream();
await request.Content.CopyToAsync(temp);
var buffer = temp.ToArray();
await requestStream.WriteAsync(buffer, 0, buffer.Length, cancellationToken);
await requestStream.FlushAsync(cancellationToken);
}
}
catch (OperationCanceledException)
{
wr.Abort();
throw;
}
}
try
{
#if NETSTANDARD1_0 || PROFILE259
var getResponseAsync = Task.Factory.FromAsync(wr.BeginGetResponse, wr.EndGetResponse, null);
var response = await getResponseAsync.HandleCancellation(cancellationToken);
#else
var response = await wr.GetResponseAsync().HandleCancellation(cancellationToken);
#endif
var httpWebResponse = response as HttpWebResponse;
if (httpWebResponse == null)
{
#if !NET40
response.Dispose();
#endif
throw new ProtocolViolationException("No HTTP request")
{
Data =
{
{ "URI", wr.RequestUri },
},
};
}
return(new DefaultHttpResponseMessage(request, httpWebResponse, CookieContainer));
}
catch (WebException ex)
{
var httpWebResponse = (HttpWebResponse)ex.Response;
return(new DefaultHttpResponseMessage(request, httpWebResponse, null, ex));
}
catch (OperationCanceledException)
{
wr.Abort();
throw;
}
}
public object ExecuteJson(string requestUri, HttpMethod method,
IDictionary <string, string> headers, object payload,
bool GetBinaryResponse = false)
{
HttpResponseMessage response;
switch (method.Method)
{
case "POST":
DefaultRequestHeaders.Add("X-RequestDigest", RequestFormDigest());
if (headers != null)
{
foreach (var header in headers)
{
DefaultRequestHeaders.Add(header.Key, header.Value);
}
}
if ((payload != null) && (payload.GetType().Name == "FileStream"))
{
StreamContent requestContent = new StreamContent((Stream)payload);
requestContent.Headers.ContentType = MediaTypeHeaderValue.Parse(
"application/json;odata=verbose");
response = PostAsync(requestUri, requestContent).Result;
}
else
{
StringContent requestContent = null; // = new StringContent(string.Empty);
if (payload.GetType().FullName == "System.String")
{
requestContent = new StringContent((string)payload);
}
else
{
requestContent = new StringContent(
JsonConvert.SerializeObject(payload));
}
requestContent.Headers.ContentType = MediaTypeHeaderValue.Parse(
"application/json;odata=verbose");
response = PostAsync(requestUri, requestContent).Result;
}
break;
case "GET":
response = GetAsync(requestUri).Result;
break;
default:
throw new NotSupportedException(string.Format(
"Method {0} is not supported", method.Method));
}
//response.EnsureSuccessStatusCode();
if (GetBinaryResponse == true)
{
var responseContentStream = response.Content.ReadAsStreamAsync().Result;
return(responseContentStream);
}
else
{
var responseContent = response.Content.ReadAsStringAsync().Result;
return(String.IsNullOrEmpty(responseContent) ? new JObject() :
JObject.Parse(responseContent));
}
}
/// <summary>
/// Initialize an instance.
/// </summary>
public HttpClient()
: base(new HttpClientHandler(), disposeHandler: true)
{
DefaultRequestHeaders.Add("Accept", "*/*");
DefaultRequestHeaders.Add("User-Agent", "Mozilla/5.0 (Android 4.1.2; Mobile; rv:60.0) Gecko/60.0 Firefox/60.0");
}
public CoreSpeedWebClient()
{
this.Timeout = 60;
DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", "Mozilla/5.0 (Windows NT 6.2; WOW64; rv:19.0) Gecko/20100101 Firefox/19.0");
CacheControlHeaderValue cc = new CacheControlHeaderValue();
}
