public async Task <SearchResult> GetSearchResultAsync(string text)
{
var endpoint = string.Format(_config.Value.SearchEndpointFormat, _config.Value.Uri, text);
var responseString = await _httpClientWrapper.GetAsync(endpoint);
return(JsonConvert.DeserializeObject <SearchResult>(responseString));
}
private async Task <TResult> getFromServerAndUnwrap <TResult>(string path)
where TResult : IEVEXmlResult
{
var url = buildUri(path);
var response = await _httpClient.GetAsync <ResponseWrapper <TResult> >(url);
return(response.Result);
}
public async Task <IList <Product> > GetProducts()
{
var response = await _httpClient.GetAsync("https://localhost:44395/api/products");
var result = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <IList <Product> >(result));
}
public async Task GetProducts_ShouldReturnPriceInLowToHighOrder()
{
_httpClientWrapper.GetAsync <List <Product> >(Arg.Any <string>())
.Returns(Task.FromResult(_products));
var service = new ProductService(_shopperHistoryService, _connectionSettings, _httpClientWrapper);
var result = await service.GetProducts("low");
Assert.AreEqual(_products.OrderBy(p => p.Price), result);
}
public async Task <PaystackBaseResponse <ResolveAccountResponse> > ResolveAccountNumber(string accountNumber, string bankCode)
{
var token = _externalAuthService.GetPaystackToken();
var headers = new Dictionary <string, string> {
{ "Authorization", $"Bearer {token}" }
};
var response = await _httpClient.GetAsync <PaystackBaseResponse <ResolveAccountResponse> >
($"{_paystackSettings.BaseUrl}{_paystackSettings.ResolveAccountUrl}?account_number={accountNumber}&bank_code={bankCode}", headers);
return(response);
}
public async Task <LocationIqReverseResponse> GetLocationDetailsAsync(string postcode)
{
string searchTerm = postcode.IsPostcode() ? postcode.SplitPostcode() : postcode;
string forwardSearchResult = await _httpClient.GetAsync($"https://eu1.locationiq.com/v1/search.php?key={_locationIqApiKey}&q={searchTerm}&countrycodes=gb&format=json");
List <LocationIqForwardResponse> locationIqForwardResponse = JsonConvert.DeserializeObject <List <LocationIqForwardResponse> >(forwardSearchResult);
string reverseLookupResult = await _httpClient.GetAsync($"https://eu1.locationiq.com/v1/reverse.php?key={_locationIqApiKey}&lat={locationIqForwardResponse[0].Latitude}&lon={locationIqForwardResponse[0].Longitude}&countrycodes=gb&format=json");
return(JsonConvert.DeserializeObject <LocationIqReverseResponse>(reverseLookupResult));
}
public async Task <Entry <dynamic> > GetEntryAsync(string entryId)
{
Entry <dynamic> entry;
string requestUri = $"spaces/{this.space}/entries/{entryId}";
using (HttpResponseMessage response = await httpClient.GetAsync(requestUri))
using (HttpContent content = response.Content)
{
string result = await content.ReadAsStringAsync();
entry = await Task.Factory.StartNew <Entry <dynamic> >(() => JsonConvert.DeserializeObject <Entry <dynamic> >(result));
}
return(entry);
}
public async Task <DocumentToDownload> GetSecureDocument(string assetId, string groupSlug)
{
try
{
var document = await _documentsRepository.GetSecureDocument(assetId, groupSlug);
if (document == null)
{
_logger.LogWarning($"No document was returned for assetId: {assetId}");
return(null);
}
var result = await _httpClient.GetAsync($"https:{document.Url}");
return(new DocumentToDownload
{
FileData = await result.Content.ReadAsByteArrayAsync(),
MediaType = document.MediaType
});
}
catch (Exception ex)
{
_logger.LogError(new EventId(0), ex, $"There was a problem getting document with assetId: {assetId} for group {groupSlug}");
return(null);
}
}
public async Task <string> SearchAsync(SearchRequest searchRequest)
{
if (searchRequest == null)
{
throw new ArgumentNullException(nameof(searchRequest));
}
var queryParameters = new Dictionary <string, string>
{
{ ZwsIdParamName, _zillowServiceSettings.ZwsId },
{ AddressParamName, searchRequest.AddressLine },
{ CityStateZipParamName, GetCityStateZipQueryStringParameter(searchRequest) },
{ ZestimateRentParamName, searchRequest.ZestimateRent.ToString() },
};
var url = QueryHelpers.AddQueryString(_zillowServiceSettings.SearchServiceUrl, queryParameters);
var response = await _httpClient.GetAsync(new Uri(url));
try
{
response.EnsureSuccessStatusCode();
return(await response.Content.ReadAsStringAsync());
}
catch (Exception exception)
{
_logger.LogError(SearchEvents.HttpRequestFailed, exception, "Http Request failed");
throw;
}
}
/// <summary>
/// Geocodes an address using the Bing Maps Locations API
/// </summary>
/// <param name="address">Input address</param>
/// <param name="city">Input city</param>
/// <param name="stateProvince">Input state or province</param>
/// <param name="postalCode">Input postal code</param>
/// <param name="country">Input country</param>
/// <returns>IList<SingleAddressResponse></returns>
public async Task <IList <SingleAddressGeocodeResponse> > GeocodeAddressAsync(
string address = null,
string city = null,
string stateProvince = null,
string postalCode = null,
string country = null
)
{
_ = Uri.TryCreate(new Uri(BingOptions.ApiRootUrl), BingOptions.GeocodeSingleAddressEndpoint, out Uri apiUri);
var uriBuilder = new UriBuilder(apiUri);
var requestParams = GetDefaultBingParams();
requestParams.AddIfNotNull("addressLine", address);
requestParams.AddIfNotNull("locality", city);
requestParams.AddIfNotNull("adminDistrict", stateProvince);
requestParams.AddIfNotNull("postalCode", postalCode);
requestParams.AddIfNotNull("countryRegion", country);
uriBuilder.Query = requestParams.ToString();
HttpResponseMessage responseMessage = await HttpClientWrapper.GetAsync(uriBuilder.Uri).ConfigureAwait(false);
var responseBody = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
var responseObject = JsonConvert.DeserializeObject <LocationResponse>(responseBody);
return(TranslateBingLocationResponse(responseObject));
}
public string GetSummary()
{
var url = "http://google.com";
var result = _HttpClient.GetAsync("https://google.com").Result;
return($"<p><a href=\"{url}\" target=\"_blank\" >{url}</a> status: {result.StatusCode}</p>");
}
public Nasa Fetch()
{
var response = _client.GetAsync(NasaUrl).Result;
var data = response.Content.ReadAsStringAsync().Result;
return(JsonConvert.DeserializeObject <Nasa>(data));
}
public async System.Threading.Tasks.Task GetFilterParameters_CallsApi()
{
// arrange
string endpoint = "endPoint";
configuration[EndPoints.Api.GetFilterParameters].Returns(endpoint);
FilterParametersDto parameters = new FilterParametersDto()
{
Countries = new List <CountryDto>(),
ItemTypes = new List <ItemTypeDto>(),
OrderPriorities = new List <OrderPriorityDto>(),
Regions = new List <RegionDto>(),
SalesChannels = new List <SalesChannelDto>()
};
GetSalesRequestDto requestDto = GetSalesRequestDtoBuilder.Build();
httpClient.GetAsync <FilterParametersDto>(endpoint).Returns(parameters);
// act
await saleService.GetFilterParameters(requestDto);
// assert
await httpClient.Received(1).GetAsync <FilterParametersDto>(endpoint);
}
public async Task <BookFindResponse> FindBookByIsbnAsync(string isbn)
{
var query = HttpUtility.ParseQueryString(string.Empty);
query["bibkeys"] = $"ISBN:{isbn}";
query["jscmd"] = "data";
query["format"] = "json";
var queryString = "?" + query.ToString();
var response = await httpClientWrapper.GetAsync(queryString);
var responseObject = JsonConvert.DeserializeObject <JObject>(await response.Content.ReadAsStringAsync());
BookFindResponse result = null;
if (responseObject.ToString() != "{}")
{
var dict = responseObject.ToObject <Dictionary <string, JObject> >();
var val = dict.First().Value;
result = new BookFindResponse
{
Author = val["authors"][0]["name"].ToString(),
Isbn = isbn,
Title = val["title"].ToString(),
Genres = new List <string>()
};
if (val["subjects"] != null)
{
result.Genres = val["subjects"].Select(x => x["name"].ToString());
}
}
return(result);
}
public async Task <GetJobDetailsResponse> GetJobDetailsAsync(int jobID)
{
string path = $"/api/GetJobDetails?userID=-1&jobID=" + jobID;
string absolutePath = $"{path}";
using (HttpResponseMessage response = await _httpClientWrapper.GetAsync(HttpClientConfigName.RequestService, absolutePath, CancellationToken.None).ConfigureAwait(false))
{
string jsonResponse = await response.Content.ReadAsStringAsync();
var getJobDetailsResponse = JsonConvert.DeserializeObject <ResponseWrapper <GetJobDetailsResponse, CommunicationServiceErrorCode> >(jsonResponse);
if (getJobDetailsResponse.HasContent && getJobDetailsResponse.IsSuccessful)
{
return(getJobDetailsResponse.Content);
}
return(null);
}
}
public async Task <SearchDiagnosticResponse> GetSearchDiagnosticResponseAsync(
Instance instance,
CancellationToken token)
{
try
{
using (var diagResponse = await _httpClient.GetAsync(
instance.DiagUrl,
HttpCompletionOption.ResponseContentRead,
token))
{
if (!diagResponse.IsSuccessStatusCode)
{
throw new HttpResponseException(
diagResponse.StatusCode,
diagResponse.ReasonPhrase,
$"The HTTP response when hitting {instance.DiagUrl} was {(int)diagResponse.StatusCode} " +
$"{diagResponse.ReasonPhrase}, which is not successful.");
}
var diagContent = diagResponse.Content;
var searchDiagResultRaw = await diagContent.ReadAsStringAsync();
SearchDiagnosticResponse response = null;
switch (instance.ServiceType)
{
case ServiceType.AzureSearch:
var tempResponse = JsonConvert.DeserializeObject <AzureSearchDiagnosticResponse>(searchDiagResultRaw);
response = ConvertAzureSearchResponse(tempResponse);
break;
}
return(response);
}
}
catch (JsonException je)
{
_logger.LogError("Error: Failed to deserialize response from diagnostic endpoint: {Error}", je.Message);
throw je;
}
catch (Exception e)
{
_logger.LogError("Error: Failed to get diagnostic response due to unexpected error: {Error}", e.Message);
throw e;
}
}
public async Task <ConvertedCurrencyValue> ConvertCurrencyAsync(PriceConversionRequest priceConversionRequest)
{
if (priceConversionRequest == null)
{
throw new ArgumentNullException("Price Conversion request is null");
}
await _priceConversionRequestValidator.ValidateAndThrowAsync(priceConversionRequest);
var exchangeRateApiUrlSection = _configuration.GetSection("ExchangeRateApiUrl");
if (string.IsNullOrEmpty(exchangeRateApiUrlSection?.Value))
{
var error = "Exchange rates API not configured";
_logger.LogError(error);
throw new Exception(error);
}
var exchangeRateApiUrl = $"{exchangeRateApiUrlSection.Value}/{priceConversionRequest.SourceCurrency}.json";
var cancellationToken = new CancellationTokenSource().Token;
var response = await _clientWrapper.GetAsync <ExchangeRatesResponse>(exchangeRateApiUrl, cancellationToken).ConfigureAwait(false);
if (!response.Success || response.Data?.Rates == null)
{
return(null);
}
var rates = response.Data.Rates;
double convertedPrice;
switch (priceConversionRequest.TargetCurrency.ToUpper())
{
case "USD":
convertedPrice = priceConversionRequest.Price * rates.USD;
break;
case "EUR":
convertedPrice = priceConversionRequest.Price * rates.EUR;
break;
case "GBP":
convertedPrice = priceConversionRequest.Price * rates.GBP;
break;
default: return(null);
}
if (DateTime.TryParse(response.Data.Date, out var lastUpdated))
{
var time = new TimeSpan(response.Data.TimeLastUpdated);
lastUpdated = lastUpdated.Add(time);
}
return(new ConvertedCurrencyValue
{
NewPrice = convertedPrice,
ConvertedFromCurrency = priceConversionRequest.SourceCurrency,
ConvertedToCurrency = priceConversionRequest.TargetCurrency,
LastUpdated = lastUpdated
});
}
public async Task <List <RepoInformation> > GetRepoList(string searchUserName)
{
var uri = new Uri(GITHUBAPI + searchUserName + "/repos");
var httpRequestMessage = new HttpRequestMessage();
List <RepoInformation> repos = null;
try
{
var responseMessage = await _wrapper.GetAsync(uri, httpRequestMessage).ConfigureAwait(false);
repos = JsonConvert.DeserializeObject <List <RepoInformation> >(responseMessage.ToString());
}
catch
{
}
return(repos);
}
/// <summary>
/// Makes a get request to a URL and handles the result from Contentful
/// </summary>
/// <param name="url">The URL to send the request to</param>
/// <param name="cancellationToken">The cancellation token for the request</param>
/// <returns>A HttpResponseMessage with the success status code & content</returns>
/// <exception cref="ContentfulException">Thrown if the request to Contentful returned a status code other than 200 (OK)</exception>
internal async Task <HttpResponseMessage> MakeGetRequestAsync(string url, CancellationToken cancellationToken)
{
var result = await HttpClient.GetAsync(url, cancellationToken);
if (result.IsSuccessStatusCode)
{
return(result);
}
throw new ContentfulException((int)result.StatusCode, await result.Content.ReadAsStringAsync());
}
public async Task <IEnumerable <Contact> > GetContactsAsync(string url)
{
var response = await _httpClient.GetAsync(url);
response.EnsureSuccessStatusCode();
var json = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <IEnumerable <Contact> >(json));
}
public async Task <PostCodeIoNearestRootResponse> GetNearbyPostCodesAsync(string postcode, CancellationToken cancellationToken)
{
string path = $"postcodes/{postcode}/nearest";
// 804.672km = 0.5 miles
string query = "limit=100&radius=805";
string absolutePath = $"{path}?{query}";
PostCodeIoNearestRootResponse postCodeIoNearestRootResponse;
using (HttpResponseMessage response = await _httpClientWrapper.GetAsync(HttpClientConfigName.PostcodeIo, absolutePath, cancellationToken).ConfigureAwait(false))
{
response.EnsureSuccessStatusCode();
Stream stream = await response.Content.ReadAsStreamAsync();
postCodeIoNearestRootResponse = stream.ReadAndDeserializeFromJson <PostCodeIoNearestRootResponse>();
}
return(postCodeIoNearestRootResponse);
}
static void Main(string[] args)
{
_serviceWrapper = new HttpClientWrapper(new System.Net.Http.HttpClient());
var location = _serviceWrapper.GetAsync <Location>("https://www.metaweather.com/api/location/862592/").Result;
Console.WriteLine($"{location.Title} - {location.Time}");
Console.ReadLine();
}
private async Task <string> GetJsonBlobAsync(string requestUrl)
{
var response = await httpClient.GetAsync(requestUrl);
if (!response.IsSuccessStatusCode)
{
throw new InvalidOperationException("Unable to retrieve content from api");
}
return(await response.Content.ReadAsStringAsync());
}
public async Task <int> GetChampionCountByPostcode(string postcode, CancellationToken cancellationToken)
{
string path = $"api/GetChampionCountByPostcode?postcode={postcode}";
using (HttpResponseMessage response = await _httpClientWrapper.GetAsync(HttpClientConfigName.UserService, path, cancellationToken).ConfigureAwait(false))
{
string jsonResponse = await response.Content.ReadAsStringAsync();
var getChampionCountByPostcodeResponse = JsonConvert.DeserializeObject <ResponseWrapper <GetChampionCountByPostcodeResponse, UserServiceErrorCode> >(jsonResponse);
if (getChampionCountByPostcodeResponse.HasContent && getChampionCountByPostcodeResponse.IsSuccessful)
{
return(getChampionCountByPostcodeResponse.Content.Count);
}
else
{
throw new System.Exception(getChampionCountByPostcodeResponse.Errors.ToString());
}
}
}
private TResponse GetResponse <TResponse>(string queryString)
{
var url = BuildHttpClientUrl(
GatewayHost,
GatewayApiPath,
GatewayPort,
queryString);
return(Send <TResponse>(async() => await _client
.GetAsync(url)));
}
public async Task <GetUsersResponse> GetUsers()
{
string path = $"api/GetUsers";
using (HttpResponseMessage response = await _httpClientWrapper.GetAsync(HttpClientConfigName.UserService, path, CancellationToken.None).ConfigureAwait(false))
{
string jsonResponse = await response.Content.ReadAsStringAsync();
var usersResponse = JsonConvert.DeserializeObject <ResponseWrapper <GetUsersResponse, UserServiceErrorCode> >(jsonResponse);
if (usersResponse.HasContent && usersResponse.IsSuccessful)
{
return(usersResponse.Content);
}
else
{
throw new System.Exception(usersResponse.Errors.ToString());
}
}
}
public async Task <GetGroupCredentialsResponse> GetGroupCredentials(int groupId)
{
string path = $"/api/GetGroupCredentials?groupID=" + groupId;
string absolutePath = $"{path}";
using (HttpResponseMessage response = await _httpClientWrapper.GetAsync(HttpClientConfigName.GroupService, absolutePath, CancellationToken.None).ConfigureAwait(false))
{
string jsonResponse = await response.Content.ReadAsStringAsync();
var getJobsResponse = JsonConvert.DeserializeObject <ResponseWrapper <GetGroupCredentialsResponse, GroupServiceErrorCode> >(jsonResponse);
if (getJobsResponse.HasContent && getJobsResponse.IsSuccessful)
{
return(getJobsResponse.Content);
}
return(null);
}
}
public async Task <string> GetContent(string criteria, int numberOfResults = 100)
{
var googleUrl = $"https://www.google.com.au/search?num={numberOfResults}&q={criteria.GetQueryStringFriendlyParameters()}";
var response = await _httpClientWrapper.GetAsync(googleUrl);
if (response.IsSuccessStatusCode)
{
return(await response.Content.ReadAsStringAsync());
}
return(null);
}
private async Task <History> GetHistory(DateTime startDate, DateTime endDate, string baseCurrency, string targetCurrency)
{
string response = await _httpClientWrapper.GetAsync($"https://api.exchangeratesapi.io/history?" +
$"start_at={startDate:yyyy-MM-dd}" +
$"&end_at={endDate:yyyy-MM-dd}" +
$"&symbols={targetCurrency}" +
$"&base={baseCurrency}");
History history = await GetResponse <History>(response);
return(history);
}
private async Task <T> GetImposterAsync <T>(int port, CancellationToken cancellationToken = default)
{
using (var response = await _httpClient.GetAsync($"{ImpostersResource}/{port}", cancellationToken).ConfigureAwait(false))
{
await HandleResponse(response, HttpStatusCode.OK, $"Failed to retrieve imposter with port {port}",
(message) => new ImposterNotFoundException(message)).ConfigureAwait(false);
var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
return(JsonConvert.DeserializeObject <T>(content));
}
}
