public List <OfferDetails> GetPaginatedOfferDetails(int categoryId, int userId, int maxPerPage, int page)
{
IRequestConfiguration conf = new RequestConfiguration();
conf.Headers = new System.Collections.Specialized.NameValueCollection();
conf.Headers.Add(new System.Collections.Specialized.NameValueCollection()
{
{ "authorization", "opnsdgsd353sapgqejpg" },
{ "http_authorization", "opnsdgsd353sapgqejpg" }
});
string indexName = $"{userId}_cat{categoryId}";
if (userId == 1)
{
indexName = "offer_details";
}
SearchRequest request = new SearchRequest <OfferDetails>(indexName)
{
Size = maxPerPage,
From = page * maxPerPage
};
request.RequestConfiguration = conf;
var k = client.Search <OfferDetails>(request);
for (int x = 0; x < k.Documents.Count; x++)
{
k.Documents.ElementAt(x).Id = k.Hits.ElementAt(x).Source.Id;
}
return(k.Documents.ToList());
}
public List <OfferDetails> GetByAnyFieldKeywords(string keywords, int categoryId, int userId)
{
string[] args = keywords.Split(',');
QueryContainer qc = new QueryContainer();
BoolQuery bq = new BoolQuery();
foreach (var VARIABLE in args)
{
qc &= new MultiMatchQuery()
{
Fields = "*",
Query = VARIABLE,
Operator = Operator.Or
};
}
bq = new BoolQuery()
{
Must = new[] { qc }
};
string indexName = $"{userId}_cat{categoryId}";
if (userId == 1)
{
indexName = "offer_details";
}
SearchRequest request = new SearchRequest <OfferDetails>(indexName)
{
Size = 100,
Query = bq
};
IRequestConfiguration conf = new RequestConfiguration();
conf.Headers = new System.Collections.Specialized.NameValueCollection();
conf.Headers.Add(new System.Collections.Specialized.NameValueCollection()
{
{
"authorization", "opnsdgsd353sapgqejpg"
},
{
"http_authorization", "opnsdgsd353sapgqejpg"
}
});
request.RequestConfiguration = conf;
var k = client.Search <OfferDetails>(request);
for (int x = 0;
x < k.Documents.Count;
x++)
{
k.Documents.ElementAt(x).Id = k.Hits.ElementAt(x).Source.Id;
}
var json = client.RequestResponseSerializer.SerializeToString(request);
return(k.Documents.ToList());
}
public RequestConfiguration GetConfiguration(Type requestType, Type responseType, Action <IRequestConfigurationBuilder> configuration)
{
// leverage direct reply to: https://www.rabbitmq.com/direct-reply-to.html
var replyQueueConfig = new QueueConfiguration
{
QueueName = _directReplyTo,
AutoDelete = true,
Durable = false,
Exclusive = true
};
var exchangeConfig = new ExchangeConfiguration(_clientConfig.Exchange)
{
ExchangeName = _conventions.ExchangeNamingConvention(requestType)
};
var defaultConfig = new RequestConfiguration
{
ReplyQueue = replyQueueConfig,
Exchange = exchangeConfig,
RoutingKey = _conventions.QueueNamingConvention(requestType),
ReplyQueueRoutingKey = replyQueueConfig.QueueName
};
var builder = new RequestConfigurationBuilder(defaultConfig);
configuration?.Invoke(builder);
return(builder.Configuration);
}
public static void SetRequestConfiguration(RequestConfiguration requestConfiguration)
{
if (requestConfiguration.MaxAdContentRating != null)
{
Externs.GADUSetRequestConfigurationMaxAdContentRating(requestConfigurationPtr, requestConfiguration.MaxAdContentRating.Value);
}
if (requestConfiguration.TestDeviceIds.Count > 0)
{
string[] testDeviceIdsArray = new string[requestConfiguration.TestDeviceIds.Count];
requestConfiguration.TestDeviceIds.CopyTo(testDeviceIdsArray);
Externs.GADUSetRequestConfigurationTestDeviceIdentifiers(requestConfigurationPtr, testDeviceIdsArray, requestConfiguration.TestDeviceIds.Count);
}
if (requestConfiguration.TagForChildDirectedTreatment.HasValue)
{
TagForChildDirectedTreatment?tagForChildDirectedTreatment = requestConfiguration.TagForChildDirectedTreatment;
Externs.GADUSetRequestConfigurationTagForChildDirectedTreatment(requestConfigurationPtr, (int)tagForChildDirectedTreatment.GetValueOrDefault());
}
if (requestConfiguration.TagForUnderAgeOfConsent.HasValue)
{
TagForUnderAgeOfConsent?TagForUnderAgeOfConsent = requestConfiguration.TagForUnderAgeOfConsent;
Externs.GADUSetRequestConfigurationTagForUnderAgeOfConsent(requestConfigurationPtr, (int)TagForUnderAgeOfConsent.GetValueOrDefault());
}
Externs.GADUSetRequestConfiguration(requestConfigurationPtr);
}
///############################################################
/// <summary>
/// Retrieves an HTTP Transaction, containing only the configured HTTP Request.
/// </summary>
/// <param name="sURL">String representing the required URL.</param>
/// <param name="oConfiguration">RequestConfiguration object representing the required HTTP Request configuration settings.</param>
/// <returns>HTTPTransaction object representing the defined HTTP Request.</returns>
///############################################################
/// <LastUpdated>September 11, 2007</LastUpdated>
public static HTTPTransaction Get(string sURL, RequestConfiguration oConfiguration)
{
HTTPTransaction oReturn = new HTTPTransaction();
//#### Setup the oReturn value with the passed sURL, it's related .Request and the .Timeout
oReturn.URL = sURL;
oReturn.Request = (HttpWebRequest)WebRequest.Create(sURL);
oReturn.Request.Timeout = oConfiguration.Timeout;
//#### If the passed oConfiguration has a .Proxy set, set it within the oReturn value
if (oConfiguration.Proxy != null)
{
oReturn.Request.Proxy = oConfiguration.Proxy;
}
//#### If we are supposed to .UseBasicAuthorization in the .Request
if (oConfiguration.UseBasicAuthorization)
{
//#### Determine the sBasicAuthHeader, .Encoding the ":" delimited sUsername/sPassword as a byte array as we go
//! Is there a specific advantage to utilize .ASCII in place of .Default?
// Encoding.Default.GetBytes(String.Format("{0}:{1}", sUsername, sPassword));
// Encoding.ASCII.GetBytes(String.Format("{0}:{1}", sUsername, sPassword));
string sBasicAuthHeader = "Basic " +
Convert.ToBase64String(Encoding.ASCII.GetBytes(oConfiguration.Username + ":" + oConfiguration.Password)
);
//#### .Add the sBasicAuthHeader into the oReturn value's .Request
oReturn.Request.Headers.Add("Authorization", sBasicAuthHeader);
}
//#### Return the above determined oReturn value to the caller
return(oReturn);
}
public void GetTextAnalyticsConfiguration_WhenValidParameters_ReturnValidConfiguration()
{
// Arrange
var json = new JsonManager();
var validQueries = new List <string> {
"languages", "keyPhrases", "sentiment"
};
var text = "I'm sorry that you had to write all these tests, I really do. But it's for humanity's sake.";
var language = "English";
foreach (var query in validQueries)
{
var body = query == "languages"
? json.GetTextAnalyticsJson(text)
: json.GetTextAnalyticsJson(text, language);
var expected = new RequestConfiguration(
Uri: $"https://westus.api.cognitive.microsoft.com/text/analytics/v2.0/{query}",
Data: ByteArrayBuilder.FromJsonObject(body),
ContentType: "application/json",
CredentialKey: Credentials.TextAnalyticsKey);
// Act
var actual = req.GetTextAnalyticsConfiguration(query, text, language);
// Assert
Assert.IsInstanceOfType(actual, typeof(RequestConfiguration));
Assert.AreEqual(expected.ContentType, actual.ContentType);
Assert.AreEqual(expected.CredentialKey, actual.CredentialKey);
Assert.IsTrue(expected.Data.SequenceEqual(actual.Data));
Assert.AreEqual(expected.Uri, actual.Uri);
}
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
StaffMemberConfiguration.Configure(modelBuilder);
RetailerConfiguration.Configure(modelBuilder);
RequestConfiguration.Configure(modelBuilder);
ExternalSystemConfiguration.Configure(modelBuilder);
}
public IList <Uri> Sniff()
{
var pingTimeout = this.Settings.PingTimeout.GetValueOrDefault(50);
var requestOverrides = new RequestConfiguration()
.ConnectTimeout(pingTimeout)
.RequestTimeout(pingTimeout)
.DisableSniffing();
var requestParameters = new FluentRequestParameters()
.RequestConfiguration(r => requestOverrides);
var path = "_nodes/_all/clear?timeout=" + pingTimeout;
using (var tracer = new ElasticsearchResponseTracer <Stream>(this.Settings.TraceEnabled))
{
var requestState = new TransportRequestState <Stream>(tracer, "GET", path, requestParameters: requestParameters);
var response = this.DoRequest(requestState);
if (response.Response == null)
{
return(null);
}
using (response.Response)
{
return(Sniffer.FromStream(response, response.Response, this.Serializer));
}
}
}
public void GetEmotionConfiguration_WhenInvalidRemoteImagePath_ReturnValidConfig()
{
// We don't handle validity of remote image url because the API does it for us.
// Thus the method should return a valid configuration.
// Arrange
string imagePath = "https://invalid-remote-url-image.com";
var json = new JsonManager();
var body = json.GetEmotionJson(imagePath);
var expected = new RequestConfiguration(
Uri: "https://westus.api.cognitive.microsoft.com/emotion/v1.0/recognize",
Data: ByteArrayBuilder.FromJsonObject(body),
ContentType: "application/json",
CredentialKey: Credentials.EmotionKey);
// Act
var actual = req.GetEmotionConfiguration(imagePath);
// Assert
Assert.IsInstanceOfType(actual, typeof(RequestConfiguration));
Assert.AreEqual(expected.ContentType, actual.ContentType);
Assert.AreEqual(expected.CredentialKey, actual.CredentialKey);
Assert.IsTrue(expected.Data.SequenceEqual(actual.Data));
Assert.AreEqual(expected.Uri, actual.Uri);
}
public virtual Task <TResponse> Request <TRequest, TResponse>(TRequest request, Action <IRequestConfiguration> configure)
where TRequest : class
where TResponse : class
{
Preconditions.CheckNotNull(request, "request");
var correlationId = Guid.NewGuid();
var requestType = typeof(TRequest);
var configuration = new RequestConfiguration();
configure(configuration);
var tcs = new TaskCompletionSource <TResponse>();
var timeout = timeoutStrategy.GetTimeoutSeconds(requestType);
Timer timer = null;
if (timeout > 0)
{
timer = new Timer(state =>
{
tcs.TrySetException(new TimeoutException(string.Format("Request timed out. CorrelationId: {0}", correlationId.ToString())));
responseActions.TryRemove(correlationId.ToString(), out ResponseAction responseAction);
}, null, TimeSpan.FromSeconds(timeout), disablePeriodicSignaling);
}
RegisterErrorHandling(correlationId, timer, tcs);
var queueName = SubscribeToResponse <TRequest, TResponse>();
var routingKey = configuration.QueueName ?? conventions.RpcRoutingKeyNamingConvention(requestType);
RequestPublish(request, routingKey, queueName, correlationId);
return(tcs.Task);
}
public void SetRequestConfiguration(RequestConfiguration requestConfiguration)
{
AndroidJavaClass mobileAdsClass = new AndroidJavaClass(Utils.MobileAdsClassName);
AndroidJavaObject requestConfigurationAndroidObject = RequestConfigurationClient.BuildRequestConfiguration(requestConfiguration);
mobileAdsClass.CallStatic("setRequestConfiguration", requestConfigurationAndroidObject);
}
///############################################################
/// <summary>
/// Retrieves an HTTP Transaction, including the file (message body) retrieved as part of the HTTP Request/Response.
/// </summary>
/// <param name="sURL">String representing the required URL.</param>
/// <param name="oConfiguration">RequestConfiguration object representing the required HTTP Request configuration settings.</param>
/// <returns>HTTPTransaction object representing the defined HTTP Request.</returns>
///############################################################
/// <LastUpdated>September 1, 2007</LastUpdated>
public static HTTPTransaction GetFile(string sURL, RequestConfiguration oConfiguration)
{
//#### .Connect to the sURL then collect the .Response's Stream
HTTPTransaction oReturn = Connect(sURL, oConfiguration, "GET");
oReturn.ResponseFile = oReturn.Response.GetResponseStream();
//#### Return the above determined oReturn value to the caller
return(oReturn);
/*
* StreamReader oStreamReader;
* string sFileContents;
*
* //#### Open the .GetResponseStream, reading it's sFileContents
* oStreamReader = new StreamReader(m_oWebResponse.GetResponseStream());
* sFileContents = oStreamReader.ReadToEnd();
*
* //#### Ensure we .Close the oConnection to clean up it's .WebRequest and .WebResponse
* Close();
*
* //#### Convert the sFileContents back into a Stream to return to the caller
* //! this conversion is WRONG!
* return new MemoryStream( Encoding.ASCII.GetBytes(sFileContents) );
*/
}
private void MakeRequest(RequestConfiguration config)
{
// Added try here because some versions of FF (v56) throw an exception for an unresolved site,
// but in other versions it seems to fail gracefully. We want to always fail gracefully
try
{
switch (config.Method.ToUpper())
{
case "GET":
Driver.Navigate().GoToUrl(config.Uri);
break;
case "POST":
case "PUT":
case "DELETE":
Driver.Navigate().GoToUrl("about:blank");
var script = "var xhr = new XMLHttpRequest();";
script += $"xhr.open('{config.Method.ToUpper()}', '{config.Uri}', true);";
script += "xhr.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');";
script += "xhr.onload = function() {";
script += "document.write(this.responseText);";
script += "};";
script += $"xhr.send('{config.FormValues.ToFormValueString()}');";
var javaScriptExecutor = (IJavaScriptExecutor)Driver;
javaScriptExecutor.ExecuteScript(script);
break;
}
}
catch (Exception e)
{
_log.Trace(e.Message);
}
}
private void MakeRequest(RequestConfiguration config)
{
switch (config.Method.ToUpper())
{
case "GET":
Driver.Navigate().GoToUrl(config.Uri);
break;
case "POST":
case "PUT":
case "DELETE":
Driver.Navigate().GoToUrl("about:blank");
var script = "var xhr = new XMLHttpRequest();";
script += $"xhr.open('{config.Method.ToUpper()}', '{config.Uri}', true);";
script += "xhr.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');";
script += "xhr.onload = function() {";
script += "document.write(this.responseText);";
script += "};";
script += $"xhr.send('{config.FormValues.ToFormValueString()}');";
var javaScriptExecutor = (IJavaScriptExecutor)Driver;
javaScriptExecutor.ExecuteScript(script);
break;
}
}
/// <summary>
/// 发送请求，获取请求结果
/// </summary>
/// <param name="requestConfiguration"></param>
/// <param name="originalRequest"></param>
/// <returns></returns>
public async Task <RepsonseResult <HttpResponseMessage> > GetRepsonse(RequestConfiguration requestConfiguration, HttpRequest originalRequest)
{
var httpRequestMessage = await GetHttpRequestMessage(requestConfiguration, originalRequest);
var httpResponseMessage = await GetResponse(httpRequestMessage);
return(httpResponseMessage);
}
public async Task <RepsonseResult <HttpResponseMessage> > GetRepsonse <T>(string serverName, T contentValue)
{
RequestConfiguration requestConfiguration = GetRequestInfo(serverName);
var result = await GetRepsonse <T>(requestConfiguration, contentValue);
return(result);
}
public RequestConfiguration GetRequestConfiguration()
{
AndroidJavaClass mobileAdsClass = new AndroidJavaClass(Utils.MobileAdsClassName);
AndroidJavaObject androidRequestConfiguration = mobileAdsClass.CallStatic <AndroidJavaObject>("getRequestConfiguration");
RequestConfiguration requestConfiguration = RequestConfigurationClient.GetRequestConfiguration(androidRequestConfiguration);
return(requestConfiguration);
}
/// <summary>
/// 发送请求，获取请求结果
/// </summary>
/// <param name="requestConfiguration"></param>
/// <param name="originalRequest"></param>
/// <returns></returns>
public async Task <RepsonseResult <HttpResponseMessage> > GetRepsonse <T>(RequestConfiguration requestConfiguration, T contentValue)
{
var httpRequestMessage = await GetHttpRequestMessage <T>(requestConfiguration, contentValue);
var httpResponseMessage = await GetResponse(httpRequestMessage);
return(httpResponseMessage);
}
protected void RequestConfiguration(string name, Action action)
{
this.currentRequestConfiguration = new RequestConfiguration()
{
Name = name
};
this.requestConfigurations.Add(this.currentRequestConfiguration);
action();
}
/// <summary>
/// Creates a request based on request configuration class.
/// Its also possible to configure httpclient as you wish and pass.
/// Futhermore you can create your on implementation for retries.
/// </summary>
/// <typeparam name="TEntity">Parameters type</typeparam>
/// <param name="configuration"> Configuration of request</param>
/// <param name="httpClientConfigurations">Pass your own httpclient configuration</param>
/// <param name="retryHandler">Case you want to create a custom retry implementation</param>
/// <returns></returns>
public static IHttpMethod <TEntity> Build <TEntity>(RequestConfiguration configuration, Action <HttpClient> httpClientConfigurations = null, IHttpRequestRetryHandler retryHandler = null, ILogger logger = null)
{
var requestBuilder = new RequestBuilder(configuration);
var services = requestBuilder.ConfigureServices(httpClientConfigurations, retryHandler);
var serviceProvider = services.BuildServiceProvider();
var httpClientFactory = requestBuilder.GetService <IHttpClientFactory>(serviceProvider);
return(requestBuilder.Build <TEntity>(httpClientFactory, logger));
}
/// <summary>
/// 发送请求，获取请求结果
/// </summary>
/// <param name="requestConfiguration"></param>
/// <param name="originalRequest"></param>
/// <returns></returns>
public async Task <RepsonseResult <HttpResponseMessage> > GetResponse(string serverName, HttpRequest originalRequest)
{
RequestConfiguration requestConfiguration = GetRequestInfo(serverName);
var httpRequestMessage = await GetHttpRequestMessage(requestConfiguration, originalRequest);
var httpResponseMessage = await GetResponse(httpRequestMessage);
return(httpResponseMessage);
}
public void SendTestResults(OctaneTestResult octaneTestResult)
{
bool skipErrors = false;
var baseUri = $"{INTERNAL_API}{_connectionDetails.SharedSpace}{ANALYTICS_TEST_RESULTS}?skip-errors={skipErrors.ToString().ToLower()}";
String xml = OctaneTestResutsUtils.SerializeToXml(octaneTestResult);
ResponseWrapper res = _restConnector.ExecutePost(baseUri, null, xml,
RequestConfiguration.Create().SetGZipCompression(true).AddHeader("ContentType", "application/xml"));
ValidateExpectedStatusCode(res, HttpStatusCode.Accepted);
}
///############################################################
/// <summary>
/// Retrieves an HTTP Transaction, containing only the HTTP Header information retrieved as part of the HTTP Request/Response.
/// </summary>
/// <param name="sURL">String representing the required URL.</param>
/// <param name="oConfiguration">RequestConfiguration object representing the required HTTP Request configuration settings.</param>
/// <returns>HTTPTransaction object representing the defined HTTP Request.</returns>
///############################################################
/// <LastUpdated>September 1, 2007</LastUpdated>
public static HTTPTransaction GetHeaders(string sURL, RequestConfiguration oConfiguration)
{
//#### .Connect to the sURL, signaling the request to only retreve the HEADers
HTTPTransaction oReturn = Connect(sURL, oConfiguration, "HEAD");
//#### Ensure we .Close the request to clean up the open connections/handles/etc.
oReturn.Close();
//#### Return the above determined oReturn value to the caller
return(oReturn);
}
private IList <Uri> Sniff(ITransportRequestState ownerState = null)
{
var pingTimeout = this.Settings.PingTimeout.GetValueOrDefault(50);
var requestOverrides = new RequestConfiguration
{
ConnectTimeout = pingTimeout,
RequestTimeout = pingTimeout,
DisableSniff = true //sniff call should never recurse
};
var requestParameters = new RequestParameters {
RequestConfiguration = requestOverrides
};
try
{
var path = "_nodes/_all/clear?timeout=" + pingTimeout;
ElasticsearchResponse <Stream> response;
using (var requestState = new TransportRequestState <Stream>(this.Settings, requestParameters, "GET", path))
{
response = this.DoRequest(requestState);
//inform the owing request state of the requests the sniffs did.
if (requestState.RequestMetrics != null && ownerState != null)
{
foreach (var r in requestState.RequestMetrics.Where(p => p.RequestType == RequestType.ElasticsearchCall))
{
r.RequestType = RequestType.Sniff;
}
if (ownerState.RequestMetrics == null)
{
ownerState.RequestMetrics = new List <RequestMetrics>();
}
ownerState.RequestMetrics.AddRange(requestState.RequestMetrics);
}
if (response.Response == null)
{
return(null);
}
using (response.Response)
{
return(Sniffer.FromStream(response, response.Response, this.Serializer));
}
}
}
catch (MaxRetryException e)
{
throw new MaxRetryException(new SniffException(e));
}
}
public void GetRequestWithNullCredentialsTest()
{
// arrange
var requestConfig = new RequestConfiguration();
var request = new Request("http://test.com", requestConfig);
// act
var httpRequest = request.GetRequest();
// assert
Assert.IsNull(httpRequest.Credentials);
}
public bool IsTestResultRelevant(string jobName)
{
var baseUri = $"{INTERNAL_API}{_connectionDetails.SharedSpace}{ANALYTICS_CI_SERVERS}{_connectionDetails.InstanceId}/jobs/{jobName}/tests-result-preflight";
bool result = false;
ResponseWrapper res = _restConnector.ExecuteGet(baseUri, null, RequestConfiguration.Create().SetTimeout(DEFAULT_TIMEOUT));
if (res.StatusCode == HttpStatusCode.OK)
{
result = Boolean.Parse(res.Data);
}
return(result);
}
Task <bool> ITransportDelegator.PingAsync(ITransportRequestState requestState)
{
var pingTimeout = this.Settings.PingTimeout.GetValueOrDefault(DefaultPingTimeout);
pingTimeout = requestState.RequestConfiguration != null
? requestState.RequestConfiguration.ConnectTimeout.GetValueOrDefault(pingTimeout)
: pingTimeout;
var requestOverrides = new RequestConfiguration
{
ConnectTimeout = pingTimeout,
RequestTimeout = pingTimeout
};
var rq = requestState.InitiateRequest(RequestType.Ping);
try
{
return(this.Connection.Head(requestState.CreatePathOnCurrentNode(""), requestOverrides)
.ContinueWith(t =>
{
if (t.IsFaulted)
{
rq.Finish(false, null);
rq.Dispose();
throw new PingException(requestState.CurrentNode, t.Exception);
}
rq.Finish(t.Result.Success, t.Result.HttpStatusCode);
rq.Dispose();
var response = t.Result;
if (!response.HttpStatusCode.HasValue || response.HttpStatusCode.Value == -1)
{
throw new PingException(requestState.CurrentNode, t.Exception);
}
if (response.HttpStatusCode == (int)HttpStatusCode.Unauthorized)
{
throw new ElasticsearchAuthenticationException(response);
}
using (response.Response)
return response.Success;
}));
}
catch (ElasticsearchAuthenticationException)
{
throw;
}
catch (Exception e)
{
var tcs = new TaskCompletionSource <bool>();
var pingException = new PingException(requestState.CurrentNode, e);
tcs.SetException(pingException);
return(tcs.Task);
}
}
/// <summary>
/// 获取请求信息
/// </summary>
/// <param name="requestConfiguration"></param>
/// <param name="originalRequest"></param>
/// <returns></returns>
public async Task <HttpRequestMessage> GetHttpRequestMessage(RequestConfiguration requestConfiguration, HttpRequest originalRequest)
{
requestConfiguration.Query = originalRequest.QueryString.ToString();
HttpRequestMessage httpRequestMessage = new HttpRequestMessage()
{
Content = await MapContent(originalRequest),
Method = MapMethod(requestConfiguration),
RequestUri = MapUri(requestConfiguration)
};
return(httpRequestMessage);
}
/// <summary>
/// 获取请求信息
/// </summary>
/// <param name="requestConfiguration"></param>
/// <param name="originalRequest"></param>
/// <returns></returns>
public async Task <HttpRequestMessage> GetHttpRequestMessage <T>(RequestConfiguration requestConfiguration, T contentValue)
{
HttpRequestMessage httpRequestMessage = new HttpRequestMessage()
{
Content = await MapContent <T>(contentValue),
Method = MapMethod(requestConfiguration),
RequestUri = MapUri(requestConfiguration)
};
MapHeaders(null, httpRequestMessage);
return(httpRequestMessage);
}
private Uri MapUri(RequestConfiguration requestConfiguration)
{
var uri = new UriBuilder
{
Port = requestConfiguration.Port,
Host = requestConfiguration.Host,
Path = requestConfiguration.Path,
Query = requestConfiguration.Query,
Scheme = requestConfiguration.Scheme
};
return(uri.Uri);
}
private IRequestConfiguration getConfiguration(string method, string uriString, bool caseSensitive, object uriParameters)
{
Uri uri = getUri(uriString, caseSensitive, uriParameters);
RequestConfiguration configuration = new RequestConfiguration(uri, method);
foreach (var configurator in configurators)
{
configurator(configuration);
}
return configuration;
}
