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