public IReadOnlyCollection <PurchaseInformation> FirstUpload(out int maxNumberPage)
{
string url = mUrlBuilder.Build(mParameters);
var result = mClient.GetResult(url);
var parsedResult = mMarketPlaceParser.Parse(result);
try
{
maxNumberPage = mMaxNumberPageParser.Parse(result);
}
catch (System.NullReferenceException)
{
maxNumberPage = 1;
}
return(parsedResult);
}
public async Task <string> BuildUrlAsync(string schme, string apiPath)
{
var serviceEndPoints = await GetEndpoints(serviceName);
//负载均衡
var _roundRobinLoadBlancer = new Ocelot.LoadBalancer.LoadBalancers.RoundRobin(() => Task.FromResult(serviceEndPoints));
//服务主机名和端口
var _servicehostAndPort = await _roundRobinLoadBlancer.Lease();
if (!_servicehostAndPort.IsError)
{
var downStreamUrl = urlBuilder.Build(apiPath, schme, _servicehostAndPort.Data);
if (!downStreamUrl.IsError)
{
return(downStreamUrl.Data.Value);
}
else
{
throw new System.Net.Http.HttpRequestException("");
}
}
else
{
throw new System.Net.Http.HttpRequestException("LoadBalancer");
}
}
public async Task <string> GenerateAsync()
{
var url = _urlBuilder.Build();
var uri = new Uri(url);
var result = await _clientFactory.Factory().GetResultAsync(uri).ConfigureAwait(false);
var name = _parser.Parse(result);
return(name);
}
public async Task <List <Lib.Build> > GetWithStatus(BuildStatus statusFilter, BuildProviderSettings buildProviderSettings)
{
try
{
var excludedBuildDefinitionIds = buildProviderSettings.ExcludedBuildDefinitionIds ?? new List <long>();
var urls = _urlBuilder.Build(buildProviderSettings.Instance, buildProviderSettings.Collection, buildProviderSettings.TeamProjects);
var responses = new List <BuildDefinitionsResponse>();
foreach (var tfsUrl in urls)
{
var request = tfsUrl
.WithBasicAuth(buildProviderSettings.AccessToken, string.Empty)
.AppendPathSegment("build")
.AppendPathSegment("builds")
.SetQueryParam("statusFilter", statusFilter.ToString())
.SetQueryParam("maxBuildsPerDefinition", 1)
.SetQueryParam("queryOrder", "finishTimeDescending");
_logger.Information($"Getting build definitions from url {request.Url}");
var res = await request.GetAsync();
var response = await request.GetJsonAsync <BuildDefinitionsResponse>();
responses.Add(response);
}
return(responses
.SelectMany(response => response
.Builds
.Where(bd => !excludedBuildDefinitionIds.Contains(bd.Id))
.Select(_mapper.Map <Build, Lib.Build>))
.ToList());
}
catch (FlurlHttpTimeoutException)
{
// FlurlHttpTimeoutException derives from FlurlHttpException; catch here only
// if you want to handle timeouts as a special case
_logger.Error("Request timed out.");
}
catch (FlurlHttpException ex)
{
// ex.Message contains rich details, inclulding the URL, verb, response status,
// and request and response bodies (if available)
_logger.Error($"Calling {ex.Call.FlurlRequest.Url} returned the following error:");
_logger.Error(ex.Message);
_logger.Error($"Status code: {ex.Call.HttpStatus.ToString()}");
_logger.Error($"Request Body: {ex.Call.RequestBody}");
_logger.Error($"Response Body: {await ex.GetResponseStringAsync()}");
}
return(new List <Lib.Build>());
}
public async Task <Models.Customer> GetUserAsync(string email)
{
if (string.IsNullOrWhiteSpace(email))
{
throw new AppException("User email required");
}
var parameters = new Dictionary <string, string>();
parameters.Add("email", email);
var response = await _client.GetAsync(_urlBuilder.Build("GetUserDetails", parameters));
if (!response.IsSuccessStatusCode)
{
throw new AppException($"Invalid email {email}");
}
return(JsonConvert.DeserializeObject <Models.Customer>(await response.Content.ReadAsStringAsync()));
}
public async Task Invoke(HttpContext context)
{
_logger.LogDebug("started calling downstream url creator middleware");
var dsPath = _replacer
.Replace(DownstreamRoute.ReRoute.DownstreamPathTemplate, DownstreamRoute.TemplatePlaceholderNameAndValues);
if (dsPath.IsError)
{
_logger.LogDebug("IDownstreamPathPlaceholderReplacer returned an error, setting pipeline error");
SetPipelineError(dsPath.Errors);
return;
}
var dsScheme = DownstreamRoute.ReRoute.DownstreamScheme;
var dsHostAndPort = HostAndPort;
var dsUrl = _urlBuilder.Build(dsPath.Data.Value, dsScheme, dsHostAndPort);
if (dsUrl.IsError)
{
_logger.LogDebug("IUrlBuilder returned an error, setting pipeline error");
SetPipelineError(dsUrl.Errors);
return;
}
_logger.LogDebug("downstream url is {downstreamUrl.Data.Value}", dsUrl.Data.Value);
SetDownstreamUrlForThisRequest(dsUrl.Data.Value);
_logger.LogDebug("calling next middleware");
await _next.Invoke(context);
_logger.LogDebug("succesfully called next middleware");
}
/// <summary>
/// Executes a REST request indirectly via a callback function <paramref name="executeCallback"/>,
/// and using a user-defined callback function <paramref name="responseBuilderCallback"/> for
/// constructing the resulting <see cref="Response"/> object.
/// </summary>
/// <remarks>
/// The callback method <paramref name="executeCallback"/> is responsible for setting the body
/// of the request, if any, before executing the request. The callback method returns a string
/// representation of the body of the final request when available, otherwise returns a string
/// indicating the body is no longer available (e.g. was sent as a stream, or is binary). The
/// result is only required for passing as an argument to <see cref="IRequestLogger.Log"/>.
///
/// <para>The Boolean argument to <paramref name="responseBuilderCallback"/> indicates whether
/// or not an exception was thrown while executing the request. The value is <c>true</c>
/// if an exception occurred, otherwise <c>false</c>.</para>
/// </remarks>
/// <param name="url">The base URI.</param>
/// <param name="method">The HTTP method to use for the request.</param>
/// <param name="responseBuilderCallback">A user-specified function used to construct the resulting <see cref="Response"/>
/// object from the <see cref="HttpWebResponse"/> and a Boolean value specifying whether or not a <see cref="WebException"/>
/// was thrown during the request. If this value is <c>null</c>, a default method is used to construct
/// the resulting <see cref="Response"/> object.</param>
/// <param name="headers">
/// A collection of custom HTTP headers to include with the request. If the value is
/// <c>null</c>, no custom headers are added to the HTTP request.
/// </param>
/// <param name="queryStringParameters">
/// A collection of parameters to add to the query string portion of the request URI.
/// If the value is <c>null</c>, no parameters are added to the query string.
/// </param>
/// <param name="settings">
/// The settings to use for the request. If the value is <c>null</c>, the default settings returned
/// by <see cref="DefaultRequestSettings"/> will be used for the request.
/// </param>
/// <param name="executeCallback"></param>
/// <returns>Returns a <see cref="Response"/> object containing the HTTP status code, headers,
/// and body from the REST response.</returns>
/// <exception cref="ArgumentNullException">
/// If <paramref name="url"/> is <c>null</c>.
/// <para>-or-</para>
/// <para>If <paramref name="executeCallback"/> is <c>null</c>.</para>
/// </exception>
/// <exception cref="NotSupportedException">If <paramref name="method"/> is not supported by the service.</exception>
public virtual Response ExecuteRequest(Uri url, HttpMethod method, Func <HttpWebResponse, bool, Response> responseBuilderCallback, Dictionary <string, string> headers, Dictionary <string, string> queryStringParameters, RequestSettings settings, Func <HttpWebRequest, string> executeCallback)
{
if (url == null)
{
throw new ArgumentNullException("url");
}
if (executeCallback == null)
{
throw new ArgumentNullException("executeCallback");
}
url = _urlBuilder.Build(url, queryStringParameters);
if (settings == null)
{
settings = DefaultRequestSettings;
}
return(_retryLogic.Execute(() =>
{
Response response;
var startTime = DateTimeOffset.UtcNow;
string requestBodyText = null;
try
{
var req = WebRequest.Create(url) as HttpWebRequest;
req.Method = method.ToString();
req.ContentType = settings.ContentType;
req.Accept = settings.Accept;
req.AllowAutoRedirect = settings.AllowAutoRedirect;
if (settings.ContentLength > 0 || settings.AllowZeroContentLength)
{
req.ContentLength = settings.ContentLength;
}
if (settings.ConnectionLimit != null)
{
req.ServicePoint.ConnectionLimit = settings.ConnectionLimit.Value;
}
req.Timeout = (int)settings.Timeout.TotalMilliseconds;
if (!string.IsNullOrEmpty(settings.UserAgent))
{
req.UserAgent = settings.UserAgent;
}
if (settings.Credentials != null)
{
req.Credentials = settings.Credentials;
}
if (headers != null)
{
foreach (var header in headers)
{
req.Headers.Add(header.Key, header.Value);
}
}
requestBodyText = executeCallback(req);
using (var resp = req.GetResponse() as HttpWebResponse)
{
if (responseBuilderCallback != null)
{
response = responseBuilderCallback(resp, false);
}
else
{
response = BuildWebResponse(resp);
}
}
}
catch (WebException ex)
{
if (ex.Response == null)
{
throw;
}
using (var resp = ex.Response as HttpWebResponse)
{
if (responseBuilderCallback != null)
{
response = responseBuilderCallback(resp, true);
}
else
{
response = BuildWebResponse(resp);
}
}
}
var endTime = DateTimeOffset.UtcNow;
// Log the request
if (_logger != null)
{
_logger.Log(method, url.OriginalString, headers, requestBodyText, response, startTime, endTime, settings.ExtendedLoggingData);
}
if (response != null && settings.ResponseActions != null && settings.ResponseActions.ContainsKey(response.StatusCode))
{
var action = settings.ResponseActions[response.StatusCode];
if (action != null)
{
action(response);
}
}
return response;
}, settings.Non200SuccessCodes, settings.RetryCount, settings.RetryDelay));
}
private void WhenIBuildTheUrl()
{
_result = _urlBuilder.Build(_dsPath, _dsScheme, new HostAndPort(_dsHost, _dsPort));
}
public GoogleSearchResponse Search(string query)
{
var url = _urlBuilder.Build(_config, query);
return(GetResults(url));
}
