private async void ProcessRequest(BaseRestRequest request)
{
try
{
ProcessingTimeTbx.Text = "";
ResultTreeView.ItemsSource = null;
RequestUrlTbx.Text = request.GetRequestUrl();
var start = DateTime.Now;
//Process the request by using the ServiceManager.
var response = await ServiceManager.GetResponseAsync(request);
var end = DateTime.Now;
var processingTime = end - start;
ProcessingTimeTbx.Text = string.Format(CultureInfo.InvariantCulture, "{0:0} ms", processingTime.TotalMilliseconds);
List <ObjectNode> nodes = new List <ObjectNode>();
nodes.Add(new ObjectNode("result", response));
ResultTreeView.ItemsSource = nodes;
ResponseTab.IsSelected = true;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public BaseRestResponse InvokeRecalculation(BaseRestRequest request)
{
var restRequest = HandleRequest(CoinMonitoringApiUrlHolder.RecalculateActions, request, Method.POST);
var response = HandleGenericResponse(Client.Execute <BaseRestResponse>(restRequest));
return(response.Data);
}
internal BadRequestException(BaseRestRequest request, RestResponse response) : base("Bad request: " + response.ResponseCode)
{
this.WebRequest = request;
this.WebResponse = response;
try
{
JObject j = JObject.Parse(response.Response);
if (j["code"] != null)
{
this.Code = (int)j["code"];
}
if (j["message"] != null)
{
this.JsonMessage = j["message"].ToString();
}
if (j["errors"] != null)
{
this.Errors = j["errors"].ToString();
}
}
catch { }
}
private async Task <IList <ChatMessageModel> > LoadMessagesAsync(BaseRestRequest request)
{
var result = await _httpClient.TrySendAndDeserializeAsync <QueryResult <MessageResponse> >(request,
_logger).ConfigureAwait(false);
return(Mapper.PagedDtoToPagingModel(result, Mapper.DtoToChatMessage)?.Data);
}
public async Task <string> SendAndGetResponseAsync(BaseRestRequest request, bool ignoreCache)
{
var response = await SendAsyncImpl(request, ignoreCache).ConfigureAwait(false);
if (response == null)
{
return(null);
}
if (!ignoreCache && response.StatusCode == HttpStatusCode.NotModified)
{
return(await _localCache.Get <string>(request.EndpointUrl).ConfigureAwait(false));
}
var stringResponse = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (!ignoreCache)
{
var lastModified = GetLastModifiedHeader(response.Content.Headers);
if (lastModified.HasValue)
{
await _localCache
.Add(request.EndpointUrl, lastModified.Value, stringResponse)
.ConfigureAwait(false);
}
}
#if DEBUG
Logger.Debug(stringResponse);
#endif
response.Dispose();
return(stringResponse);
}
this IRestHttpClient restHttpClient,
BaseRestRequest request,
ILogger logger,
Func <TDto, TModel> dtoToModelConverter)
{
try
{
this IRestHttpClient restHttpClient,
BaseRestRequest request,
ILogger logger,
Func <TDto, TModel> dtoToModelConverter,
bool ignoreCache)
{
try
{
if (!(restHttpClient is CachedHttpClient client))
public static async Task <TModel> GetModelAsync <TModel, TDto>(
this IRestHttpClient restHttpClient,
BaseRestRequest request,
ILogger logger,
Func <TDto, TModel> dtoToModelConverter)
{
var result = await restHttpClient.GetModelOrExceptionAsync(request, logger, dtoToModelConverter);
return(result.Model);
}
internal async Task <T> SendAndDeserializeAsync <T>(BaseRestRequest request, bool ignoreCache)
{
var stringResponse = await SendAndGetResponseAsync(request, ignoreCache).ConfigureAwait(false);
if (stringResponse == null)
{
return(default(T));
}
return(JsonSerializer.Deserialize <T>(stringResponse));
}
internal RateLimitException(BaseRestRequest request, RestResponse response) : base("Rate limited: " + response.ResponseCode)
{
this.WebRequest = request;
this.WebResponse = response;
JObject j = JObject.Parse(response.Response);
if (j["message"] != null)
{
JsonMessage = j["message"].ToString();
}
}
/// <summary>
/// This method has a lot of logic that is specific to the sample. To process a request you can easily just call the Execute method on the request.
/// </summary>
/// <param name="request"></param>
private async void ProcessRequest(BaseRestRequest request)
{
try
{
RequestProgressBar.Visibility = Visibility.Visible;
RequestProgressBarText.Text = string.Empty;
ResultTreeView.ItemsSource = null;
var start = DateTime.Now;
//Execute the request.
var response = await request.Execute((remainingTime) =>
{
if (remainingTime > -1)
{
_time = TimeSpan.FromSeconds(remainingTime);
Application.Current.Dispatcher.Invoke(() =>
{
RequestProgressBarText.Text = string.Format("Time remaining {0} ", _time);
});
_timer.Start();
}
});
RequestUrlTbx.Text = request.GetRequestUrl();
var end = DateTime.Now;
var processingTime = end - start;
ProcessingTimeTbx.Text = string.Format(CultureInfo.InvariantCulture, "{0:0} ms", processingTime.TotalMilliseconds);
RequestProgressBar.Visibility = Visibility.Collapsed;
var nodes = new List <ObjectNode>();
var tree = await ObjectNode.ParseAsync("result", response);
nodes.Add(tree);
ResultTreeView.ItemsSource = nodes;
ResponseTab.IsSelected = true;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
_timer.Stop();
RequestProgressBar.Visibility = Visibility.Collapsed;
}
static private Resource[] GetResourcesFromRequest(BaseRestRequest rest_request)
{
var r = ServiceManager.GetResponseAsync(rest_request).GetAwaiter().GetResult();
if (!(r != null && r.ResourceSets != null &&
r.ResourceSets.Length > 0 &&
r.ResourceSets[0].Resources != null &&
r.ResourceSets[0].Resources.Length > 0))
{
throw new Exception("No results found.");
}
return(r.ResourceSets[0].Resources);
}
internal RequestSizeException(BaseRestRequest request, RestResponse response) : base($"Request entity too large: {response.ResponseCode}. Make sure the data sent is within Discord's upload limit.")
{
this.WebRequest = request;
this.WebResponse = response;
try
{
var j = JObject.Parse(response.Response);
if (j["message"] != null)
{
this.JsonMessage = j["message"].ToString();
}
}
catch (Exception) { }
}
internal BadRequestException(BaseRestRequest request, RestResponse response) : base("Bad request: " + response.ResponseCode)
{
WebRequest = request;
WebResponse = response;
try
{
JObject j = JObject.Parse(response.Response);
if (j["message"] != null)
{
JsonMessage = j["message"].ToString();
}
}
catch (Exception) { }
}
internal RateLimitException(BaseRestRequest request, RestResponse response) : base("Rate limited: " + response.ResponseCode)
{
this.WebRequest = request;
this.WebResponse = response;
try
{
JObject j = DiscordJson.LoadJObject(response.Response);
if (j["message"] != null)
{
JsonMessage = j["message"].ToString();
}
}
catch (Exception) { }
}
internal UnauthorizedException(BaseRestRequest request, RestResponse response) : base("Unauthorized: " + response.ResponseCode)
{
this.WebRequest = request;
this.WebResponse = response;
try
{
var j = DiscordJson.LoadJObject(response.Response);
if (j["message"] != null)
{
JsonMessage = j["message"].ToString();
}
}
catch (Exception) { }
}
internal NotFoundException(BaseRestRequest request, RestResponse response) : base("Not found: " + response.ResponseCode)
{
this.WebRequest = request;
this.WebResponse = response;
try
{
JObject j = JObject.Parse(response.Response);
if (j["message"] != null)
{
JsonMessage = j["message"].ToString();
}
}
catch (Exception) { }
}
internal ServerErrorException(BaseRestRequest request, RestResponse response) : base("Internal Server Error: " + response.ResponseCode)
{
this.WebRequest = request;
this.WebResponse = response;
try
{
var j = JObject.Parse(response.Response);
if (j["message"] != null)
{
JsonMessage = j["message"].ToString();
}
}
catch (Exception) { }
}
public RestRequest HandleRequest(string requestUrl, BaseRestRequest request, Method method, Dictionary <string, string> urlParameterDictionary = null)
{
RestRequest restRequest = new RestRequest(requestUrl, method);
restRequest.AddBody(request);
if (urlParameterDictionary != null)
{
foreach (var urlParameters in urlParameterDictionary)
{
restRequest.AddUrlSegment(urlParameters.Key, urlParameters.Value);
}
}
_logger.DebugFormat($"Request for {requestUrl} created");
return(restRequest);
}
protected async Task <HttpResponseMessage> SendAsyncImpl(BaseRestRequest request, bool ignoreCache)
{
using (var httpClientHandler = GetHandler())
{
if (httpClientHandler.SupportsAutomaticDecompression)
{
httpClientHandler.AutomaticDecompression = DecompressionMethods.GZip;
}
using (var httpClient = new HttpClient(httpClientHandler))
{
httpClient.DefaultRequestHeaders.Accept.Clear();
httpClient.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue(HttpConsts.ApplicationJsonHeaderValue));
httpClient.DefaultRequestHeaders.CacheControl = new CacheControlHeaderValue {
NoCache = true
};
HttpResponseMessage response = null;
try
{
var httpRequest = new HttpRequestMessage
{
Method = request.Method,
RequestUri = GetFullUrl(request)
};
if (request.Method == HttpMethod.Post || request.Method == HttpMethod.Put)
{
httpRequest.Content = request.GetContent();
}
if (request.HasCustomHeaders)
{
foreach (var header in request.CustomHeaders)
{
httpRequest.Headers.Add(header.Header, header.Value);
}
}
else
{
if (IsAuthorized)
{
httpClient.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue(HttpConsts.Bearer, AccessToken);
}
if (request.Method == HttpMethod.Get && !ignoreCache)
{
var timeStamp = await _localCache
.GetExpiration(request.EndpointUrl)
.ConfigureAwait(false);
httpRequest.Headers.IfModifiedSince = timeStamp;
}
}
response = await httpClient.SendAsync(httpRequest).ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.Error(ex);
}
if (response != null && response.StatusCode == HttpStatusCode.NotModified)
{
return(response);
}
response = await HandleErrors(response, request).ConfigureAwait(false);
return(response);
}
}
}
private static async Task <Resource[]> GetResoucesFromRequestAsync(BaseRestRequest request)
{
var response = await request.Execute();
return(response.ResourceSets[0].Resources);
}
/// <summary>
/// Method triggers the request by calling the execute method of the BingMaps RESTToolKit.
/// <param name="request"></param>
private async void ProcessRequest(BaseRestRequest request)
{
try
{
RequestProgressBar.Visibility = Visibility.Visible;
RequestProgressBarText.Text = string.Empty;
ResultTreeView.ItemsSource = null;
var start = DateTime.Now;
//Executes the request.
var response = await request.Execute((remainingTime) =>
{
if (remainingTime > -1)
{
_time = TimeSpan.FromSeconds(remainingTime);
RequestProgressBarText.Text = string.Format("Time remaining {0} ", _time);
_timer.Start();
}
});
RequestUrlTbx.Text = request.GetRequestUrl();
var end = DateTime.Now;
var processingTime = end - start;
var nodes_warnings = new List <ObjectNode>();
var nodes_all = new List <ObjectNode>();
//Takes any Object and generates an Object Tree.
var tree = await ObjectNode.ParseAsync("result", response);
//List of warnings for trim function and visualisation in the view
var list_warnings = new List <KeyValuePair <string, string> >();
string filter_severity = "Severity";
ProcessingTimeTbx.Text = string.Format(CultureInfo.InvariantCulture, "{0:0} ms",
processingTime.TotalMilliseconds);
RequestProgressBar.Visibility = Visibility.Collapsed;
nodes_all.Add(tree);
SeverityRatings_panel.Children.Clear();
nodes_warnings.Add(tree);
ResultTreeViewFull.ItemsSource = nodes_all;
TrimTree(nodes_warnings, filter_severity, list_warnings);
ResultTreeView.ItemsSource = nodes_warnings;
foreach (var element in list_warnings)
{
switch (element.Value)
{
case "\"Minor\"":
case "\"LowImpact\"":
TextBlock Minor_Low_sev = new TextBlock
{
Text = element.ToString(),
Background = Brushes.LightGreen,
FontSize = 20
};
SeverityRatings_panel.Children.Add(Minor_Low_sev);
break;
case "\"Moderate\"":
TextBlock Moderate_sev = new TextBlock
{
Text = element.ToString(),
Background = Brushes.Orange,
FontSize = 20
};
SeverityRatings_panel.Children.Add(Moderate_sev);
break;
case "\"Serious\"":
TextBlock Serious_sev = new TextBlock
{
Text = element.ToString(),
Background = Brushes.PaleVioletRed,
FontSize = 20
};
SeverityRatings_panel.Children.Add(Serious_sev);
break;
default:
break;
}
}
ProcessWarnings(list_warnings);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
_timer.Stop();
RequestProgressBar.Visibility = Visibility.Collapsed;
}
public override Task <string> SendAndGetResponseAsync(BaseRestRequest request)
{
return(SendAndGetResponseAsync(request, false));
}
protected override Task <HttpResponseMessage> SendAsyncImpl(BaseRestRequest request)
{
return(SendAsyncImpl(request, false));
}
