/// <summary>
/// Executes the specified request against the alpha stream rest server
/// </summary>
/// <typeparam name="T">The response type</typeparam>
/// <param name="request">The request object that will be transformed into a rest request</param>
/// <returns>The response</returns>
public async Task <T> Execute <T>(IRequest <T> request)
{
var restRequest = request.ToRestRequest();
if (RequestTracingEnabled)
{
var pathAndQuery = client.BuildUri(restRequest).ToString().Replace(DefaultBaseUrl, string.Empty);
Trace.TraceInformation($"{restRequest.Method} {pathAndQuery}");
var body = restRequest.GetBody();
if (body != null)
{
Trace.TraceInformation($"Request Body: {Environment.NewLine}{body.FormatAsJsonIfPossible()}");
}
}
// add required authorization headers
var stamp = GetUnixTimeStamp();
restRequest.AddHeader("Timestamp", stamp.ToString());
client.Authenticator = new HttpBasicAuthenticator(
credentials.ClientId,
credentials.CreateSecureHash(stamp)
);
var taskCompletionSource = new TaskCompletionSource <JToken>();
client.ExecuteAsync(restRequest, response =>
{
if (ResponseTracingEnabled)
{
Trace.TraceInformation("Response Body: " + Environment.NewLine + response.Content.FormatAsJsonIfPossible());
LastRestResponse = response.Content;
}
if (response.StatusCode == HttpStatusCode.OK)
{
try
{
taskCompletionSource.SetResult(JToken.Parse(response.Content));
return;
}
catch (Exception exception)
{
Trace.TraceError("Error Deserializing Response: " + Environment.NewLine + exception.ToString());
}
}
// either received a non 200 status code or failed to parse as the requested type
taskCompletionSource.SetException(AlphaServiceException.ForResponse(response));
});
var jtokenResponse = await taskCompletionSource.Task.ConfigureAwait(false);
return(jtokenResponse.ToObject <T>());
}
private async Task <IRestResponse> ExecuteRestRequest(IRestRequest query)
{
var result = await _restClient.ExecuteAsync(query, CancellationToken.None);
if (!result.IsSuccessful)
{
throw new HttpRequestException(result.StatusCode + ": " + result.ErrorMessage);
}
return(result);
}
public async Task <List <PokemonRegion> > GetPokemonRegions(string urlCompose)
{
client.BaseUrl = new Uri(options.Value.PokeApiUrl);
request.Resource = urlCompose;
var response = await client.ExecuteAsync(request);
if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
{
throw new NotFoundException(response.Content);
}
var jsonObject = JObject.Parse(response.Content);
var pokemons = JsonConvert.DeserializeObject <List <PokemonRegion> >
(jsonObject.SelectToken("results").ToString());
return(pokemons);
}
public async Task <byte[]> GetMapImage(float lat, float lon)
{
var request =
new RestRequest(
$"styles/v1/mapbox/dark-v10/static/pin-s({lon},{lat})/{lon},{lat},7,0,0/350x350");
var response = await _client.ExecuteAsync(request);
return(response.RawBytes);
}
public static IRestResponse Execute(this IRestClient restClient, IRestRequest request)
{
var task = new TaskCompletionSource <IRestResponse>();
var asyncHandle = restClient.ExecuteAsync(request, response => {
task.SetResult(response);
});
return(task.Task.Result);
}
private async Task <T> ExecuteAsync <T>(IRestRequest request)
{
request.AddHeader("accept", "application/vnd.github.v3+json");
var response = await _client.ExecuteAsync <T>(request).ConfigureAwait(false);
return(response.IsSuccessful && response.ErrorException is null ?
response.Data :
throw new Exception("An error response received from GitHub server. Response Status: " + response.StatusCode, response.ErrorException));
}
private Task <T> ExecuteAsync <T>(IRestClient client, IRestRequest request, Func <IRestResponse, T> selector)
{
LogRequest(request);
var completionSource = new TaskCompletionSource <T>();
client.ExecuteAsync(request, response => ProcessResponse(selector, response, completionSource));
return(completionSource.Task);
}
public async Task <T> ExecuteAsync <T>(RestRequest request) where T : new()
{
var response = await restClient.ExecuteAsync <T>(request);
if (response.ErrorException != null)
{
LogException(response.ErrorException);
}
return(response.Data);
}
public static async Task <IRestResponse <T> > ExecuteWithLogsAsync <T>(this IRestClient client, IRestRequest request, ILogger logger)
{
var response = await client.ExecuteAsync <T>(request);
if (response.StatusCode != HttpStatusCode.OK)
{
logger.LogError($"REST call failed for => {response.ResponseUri.AbsoluteUri} {response.Content}");
}
return(response);
}
private async Task <T> ExecuteAsync <T>(IRestRequest request)
{
request.AddHeader("cache-control", "no-cache");
request.AddQueryParameter("api_key", _endpoint.APIKey);
request.AddQueryParameter("format", "json");
var response = await _client.ExecuteAsync <T>(request).ConfigureAwait(false);
return(response.IsSuccessful && response.ErrorException is null ? response.Data : throw new Exception("An error response received from UptimeRobot server. Response Status: " + response.StatusCode, response.ErrorException));
}
public void ExecuteAsyncOnNullRestClientThrowsArgumentNullException()
{
// Arrange
IRestClient nullRestClient = null;
// Act
// Assert
Assert.Throws <ArgumentNullException>(() => nullRestClient.ExecuteAsync(CreateRestRequest(), CancellationToken.None));
}
protected Task <IRestResponse> GetResponseContentAsync(IRestClient theClient, RestRequest theRequest)
{
var tcs = new TaskCompletionSource <IRestResponse>();
theClient.ExecuteAsync(theRequest, response =>
{
tcs.SetResult(response);
});
return(tcs.Task);
}
public static void SimpleAsync(this IRestClient client, IRestRequest req, Action <IRestResponse> Callback)
{
//parse
var url = new Uri(req.Resource);
client.BaseUrl = new Uri(url.Scheme + "://" + url.Host);
req.Resource = url.PathAndQuery;
var res = client.ExecuteAsync(req, Callback);
}
public async Task <string> ExecuteRequestAsync(RestRequest request)
{
request.AddHeader("Content-Type", "application/json");
var response = await _client.ExecuteAsync(request);
StatusDescription = response.StatusDescription.ToString();
return(response.Content);
}
private async Task <AirQualityData> Execute(IRestRequest request)
{
var response = await restClient.ExecuteAsync <AirQualityResponse>(request);
if (!response.IsSuccessful || response.Data.Status != "ok")
{
return(null); // TODO: Handle error
}
return(response.Data.Data);
}
protected Task <IRestResponse <T> > GetAsyncRequestAwaiter <T>() where T : new()
{
IRestRequest request = PrepareRequest();
IRestClient client = PrepareClient();
var tcs = new TaskCompletionSource <IRestResponse <T> >();
client.ExecuteAsync <T>(request, response => tcs.SetResult(response));
return(tcs.Task);
}
private async Task <T> Execute <T>(string url)
{
_request.Parameters.Clear();
_request.Resource = url;
_request.Method = Method.GET;
_request.AddHeader("Content-type", "application/json");
foreach (var header in _misApiModel.Value.Headers)
{
_request.AddHeader(header.Key, header.Value);
}
var response = await _client.ExecuteAsync(_request);
if (response.StatusCode == HttpStatusCode.OK || response.StatusCode == HttpStatusCode.NotFound)
{
return(JsonConvert.DeserializeObject <T>(response.Content));
}
throw new ApplicationException(response.Content);
}
public RestRequestAsyncHandle GetServersAsync(string token, Action <List <Server> > callback)
{
var request = new RestRequest("servers", Method.GET);
request.AddHeader("Authorization", $"Bearer {token}");
return(_client.ExecuteAsync <List <Server> >(request, (response) =>
{
callback(response.Data);
}));
}
public void OneTimeSetup()
{
_serviceUnavailableClient = Substitute.For <IRestClient>();
_serviceUnavailableClient.Execute(Arg.Any <IRestRequest>()).Returns(new RestResponse {
StatusCode = HttpStatusCode.ServiceUnavailable
});
_serviceUnavailableClient.ExecuteAsync(Arg.Any <IRestRequest>(), Arg.Any <Method>(), Arg.Any <CancellationToken>())
.Returns(new RestResponse {
StatusCode = HttpStatusCode.ServiceUnavailable
});
}
private Task <NewsRoot> GetNewsData()
{
return(_cache.GetOrAddAsync($"{GetType().FullName}_news_data", () => DoAsync(async() =>
{
var request = new RestRequest(Method.GET);
var result = _newsClient.ExecuteAsync <NewsRoot>(request);
return (await result)?.Data ?? new NewsRoot();
}, TimeSpan.FromSeconds(1)), new MemoryCacheEntryOptions {
AbsoluteExpiration = DateTime.Now.AddMinutes(5)
}));
}
public async Task <decimal> GetSalaryAsync(string employeeCode, string inn)
{
var request = new RestRequest($"/{inn}", Method.POST);
var body = new { BuhCode = employeeCode };
request.AddJsonBody(body);
var result = await _restClient.ExecuteAsync <decimal>(request);
return(result.Data);
}
public static Task <IRestResponse> RestExecuteAsync(this IRestClient client, IRestRequest request)
{
var tcs = new TaskCompletionSource <IRestResponse>();
client.ExecuteAsync(request, response =>
{
tcs.SetResult(response);
});
return(tcs.Task);
}
private static void SetupTokenResultSuccess(IRestClient restClient, string token)
{
var facebookResponse = Substitute.For <IRestResponse <AccessTokenResult> >();
facebookResponse.IsSuccessful.Returns(true);
facebookResponse.StatusCode.Returns(HttpStatusCode.OK);
facebookResponse.Data.Returns(new AccessTokenResult {
AccessToken = token
});
restClient.ExecuteAsync <AccessTokenResult>(Arg.Any <RestRequest>()).Returns(Task.FromResult(facebookResponse));
}
private async Task <T> ExecuteAsync <T>(IRestRequest request, CancellationToken cancellationToken) where T : new()
{
var response = await _client.ExecuteAsync <T>(request, cancellationToken).ConfigureAwait(false);
if (response.IsSuccessful && response.ErrorException is null)
{
return(response.Data);
}
throw new Exception("An error response received from Jenkins server.", response.ErrorException);
}
private static void SetupTokenResultSuccess(IRestClient restClient, string token, string secret)
{
var twitterResponse = Substitute.For <IRestResponse <TokenResult> >();
twitterResponse.IsSuccessful.Returns(true);
twitterResponse.StatusCode.Returns(HttpStatusCode.OK);
twitterResponse.Data.Returns(new TokenResult {
OauthToken = token, OauthTokenSecret = secret
});
restClient.ExecuteAsync <TokenResult>(Arg.Any <RestRequest>()).Returns(Task.FromResult(twitterResponse));
}
public async Task <bool> KeyAvailable(string key, CancellationToken cancellationToken)
{
var request = new RestRequest(string.Empty, Method.GET, DataFormat.None).AddQueryParameter("command", "key_available").AddQueryParameter("key", key);
var response = await _client.ExecuteAsync(request, cancellationToken);
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
throw new Exception($"Failed to successfully query against BYOND, response code {response.StatusCode}");
}
var match = BYONDCommandResponse.Match(response.Content);
if (!match.Success)
{
throw new Exception($"Invalid response from BYOND, unexpected response pattern. Response content: {response.Content}");
}
var responseComponents = match.Groups["response"].Value.Split(',');
return(responseComponents[0] == "true");
}
public async Task <RemoteBudget> CreateNewBudget()
{
if (string.IsNullOrWhiteSpace(accessControlManager?.Jwt))
{
throw new ArgumentNullException();
}
restClient.Timeout = -1;
var request = new RestRequest("budget/budgets", Method.PUT);
request.AddHeader("Authorization", $"Bearer {accessControlManager.Jwt}");
request.AddHeader("Cache-Control", "no-cache");
request.AddHeader("Content-Type", "application/x-www-form-urlencoded");
request.AddParameter("date", DateTime.Now.ToString("yyyy-MM-dd"));
request.AddParameter("currency", "usd");
IRestResponse response = await restClient.ExecuteAsync(request);
if (response.StatusCode != HttpStatusCode.OK && response.StatusCode != HttpStatusCode.Created)
{
throw new Exception($"Unexpected response from created budget call: {response.StatusCode} - {response.Content}");
}
try
{
var json = Cleaner.CleanJson(response.Content);
var jsonObject = JObject.Parse(json);
var budget = JsonConvert.DeserializeObject <RemoteBudget>(json);
return(budget);
}
catch (Exception e)
{
throw new Exception($"Unable to parse response from Get Budgets: {response.Content}", e);
}
}
public async Task <WeatherResponse> GetCities(double lat, double lon)
{
var request = new RestRequest("find")
.AddParameter("lat", lat)
.AddParameter("lon", lon)
.AddParameter("cnt", 50)
.AddParameter("appid", "ce82774295db466472b892ef8345ae11")
.AddParameter("units", "metric");
var response = await _client.ExecuteAsync <WeatherResponse>(request);
return(response.Data);
}
public async Task <TResponse> ExecutePutAsync <TRequest, TResponse>(string endpoint, TRequest request)
{
_restClient.AddDefaultHeader("Content-Type", "application/json");
var restRequest = new RestRequest(endpoint, Method.PUT, DataFormat.Json);
var json = JsonConvert.SerializeObject(request, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
restRequest.AddParameter("application/json", json, ParameterType.RequestBody);
var response = await _restClient.ExecuteAsync <TResponse>(restRequest).ConfigureAwait(false);
if (response.IsSuccessful)
{
return(response.Data);
}
var error = new JsonDeserializer().Deserialize <Error>(response);
throw new DevToApiException(error);
}
public async Task <GenerateTokenResponse> GenerateTokenAsync()
{
var path = $"v3/Usuario/ValidarLogin";
var request = ConfigureRequest(path, Method.POST);
var validaLogin = new GenerateTokenRequest()
{
dsUsuario = _options.User,
dsSenha = _options.Password
};
request.AddJsonBody(validaLogin);
var response = await _client.ExecuteAsync(request);
if (!response.IsSuccessful)
{
throw new SmartShareException("Error from SmartShare.", response.Content);
}
return(JsonConvert.DeserializeObject <GenerateTokenResponse>(response.Content));
}
private void GetTypes(
string geometry,
string query,
string token,
string aoi,
IRestClient client,
string layerName,
int attempts = 0)
{
var request =
new RestRequest(
string.Format("/insight-vector/api/shape/query/{0}/types?q={1}", geometry, query),
Method.POST);
request.AddHeader("Authorization", "Bearer " + token);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", aoi, ParameterType.RequestBody);
attempts++;
client.ExecuteAsync<ResponseData>(
request,
resp => this.GetTypesResponseProcess(resp, geometry, query, token, aoi, client, layerName, attempts));
}
private void GetPages(
string pageId,
string token,
IRestClient client,
StreamWriter fileStreamWriter,
string layerName,
int attempts = 0)
{
var request = new RestRequest("/insight-vector/api/esri/paging", Method.POST);
request.AddHeader("Authorization", "Bearer " + token);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("ttl", "5m");
request.AddParameter("fields", "attributes");
request.AddParameter("pagingId", pageId);
attempts++;
client.ExecuteAsync<PagedData2>(
request,
resp => this.ProcessPageResponse(resp, token, pageId, client, layerName, attempts, fileStreamWriter));
}