/// <summary> /// Get the list movie now showing /// </summary> /// <returns></returns> public async Task <List <Movie> > GetNowShowingMovies() { var result = new List <Movie>(); var reqResult = await _httpHandler.GetAsync(URL_MOVIES); string content = await reqResult.Content.ReadAsStringAsync(); JObject responseObj = JObject.Parse(content); List <JToken> entries = responseObj["movieShowing"] != null ? responseObj["movieShowing"].ToList() : new List <JToken>(); foreach (JToken entry in entries) { Movie tmpMovie = new Movie(); tmpMovie.MovieId = entry["id"] != null ? entry["id"].ToString() : string.Empty; tmpMovie.EnglishName = entry["name"] != null ? entry["name"].ToString() : string.Empty; tmpMovie.VietNameseName = entry["subName"] != null && !string.IsNullOrWhiteSpace(entry["subName"].ToString()) ? entry["subName"].ToString() : tmpMovie.EnglishName; tmpMovie.PosterUrl = entry["imagePortrait"] != null?string.Format(URL_POSTER, entry["imagePortrait"].ToString()) : string.Empty; tmpMovie.ViewGradeNameEN = entry["age"] != null ? entry["age"].ToString() : string.Empty; tmpMovie.ViewGradeCode = entry["age"] != null ? entry["age"].ToString() : tmpMovie.ViewGradeNameEN; tmpMovie.PlayTime = entry["duration"] != null ? (int)entry["duration"] : 0; tmpMovie.Rating = entry["point"] != null ? (double)entry["point"] : 0; tmpMovie.Description = entry["description"] != null ? entry["description"].ToString() : string.Empty; result.Add(tmpMovie); } return(result); }
/// <summary> /// Search GIPHY's library of millions of GIFs for a word or phrase. /// </summary> /// <param name="parameter">Specifies search parameters</param> /// <returns>Root object</returns> public async Task <RootObject> Search(SearchParameter parameter) { if (parameter is null) { throw new NullReferenceException("Paramter cannot be null"); } if (string.IsNullOrEmpty(parameter.Query)) { throw new FormatException("Query paramter cannot be null or empty."); } /* Finish exception checks */ string url = $@"{ _searchUrl }?api_key={ _apiKey }&q={ parameter.Query }&limit={ parameter.Limit }&offset={ parameter.Offset }&lang={ parameter.Language }&rating={ parameter.Rating.ToString() }"; var response = await _httpHandler.GetAsync(url); if (!response.IsSuccessStatusCode) { throw new HttpRequestException(response.ReasonPhrase); } return(await response.Content.ReadAsAsync <RootObject>()); }
/// <summary> /// /// </summary> /// <param name="categoryName"></param> /// <param name="itemName"></param> /// <returns></returns> public async Task <Guid> GetReferenceDataGuId(string categoryName, string itemName) { using (loggingHelper.RMTraceManager.StartTrace("Integration.GetReferenceDataGuId")) { string methodName = MethodHelper.GetActualAsyncMethodName(); loggingHelper.Log(methodName + LoggerTraceConstants.COLON + LoggerTraceConstants.MethodExecutionStarted, TraceEventType.Verbose, null, LoggerTraceConstants.Category, LoggerTraceConstants.PostalAddressAPIPriority, LoggerTraceConstants.PostalAddressIntegrationServiceMethodEntryEventId, LoggerTraceConstants.Title); Guid referenceId = Guid.Empty; HttpResponseMessage result = await httpHandler.GetAsync(referenceDataWebAPIName + "simpleLists?listName=" + categoryName); if (!result.IsSuccessStatusCode) { var responseContent = result.ReasonPhrase; throw new ServiceException(responseContent); } Tuple <string, SimpleListDTO> apiResult = JsonConvert.DeserializeObject <Tuple <string, SimpleListDTO> >(result.Content.ReadAsStringAsync().Result); if (apiResult != null && apiResult.Item2 != null && apiResult.Item2.ListItems != null && apiResult.Item2.ListItems.Count > 0) { referenceId = apiResult.Item2.ListItems.Where(n => n.Value.Equals(itemName, StringComparison.OrdinalIgnoreCase)).SingleOrDefault().Id; } loggingHelper.Log(methodName + LoggerTraceConstants.COLON + LoggerTraceConstants.MethodExecutionCompleted, TraceEventType.Verbose, null, LoggerTraceConstants.Category, LoggerTraceConstants.PostalAddressAPIPriority, LoggerTraceConstants.PostalAddressIntegrationServiceMethodExitEventId, LoggerTraceConstants.Title); return(referenceId); } }
public async Task <KeyedCollection <string, PwnedPassword> > GetPasswordResultsAsync(string shaHash) { if (shaHash is null) { throw new ArgumentNullException(nameof(shaHash)); } if (shaHash.Length < 5) { throw new ArgumentException("shaHash prefix must be at least five characters"); } string prefix = shaHash.Substring(0, 5); var response = await _httpHandler.GetAsync($"range/{prefix}"); string results = await response.Content.ReadAsStringAsync(); if (!response.IsSuccessStatusCode) { throw new ApplicationException($"Error response received from server: {results}"); } var resultsArray = results.Replace("\n", "").Split('\r'); var pwnedPasswords = new PwnedPasswordList(); pwnedPasswords.AddRange(resultsArray.Select(result => new PwnedPassword(prefix, result))); return(pwnedPasswords); }
internal async Task <FundaResponse> GetFundaResponse(string city, string amenity, int page = 1, int pageSize = 25) { string urlCity = string.IsNullOrWhiteSpace(city) ? string.Empty : "/" + city; string urlAmenity = string.IsNullOrWhiteSpace(amenity) ? string.Empty : "/" + amenity; return(await Policy.Handle <HttpRequestException>().WaitAndRetryAsync(100, retryAttempt => { Console.WriteLine($"retry : {retryAttempt}"); return TimeSpan.FromSeconds(retryAttempt); }).ExecuteAsync(async() => { using (var response = await httpHandler.GetAsync(configuration.GetValue <string>("fundaUrl") .Replace("{urlCity}", urlCity) .Replace("{urlAmenity}", urlAmenity) .Replace("{page}", page.ToString()) .Replace("{pageSize}", pageSize.ToString()))) { if (!response.IsSuccessStatusCode) { throw new HttpRequestException(); } string apiResponse = await response.Content.ReadAsStringAsync(); return JsonConvert.DeserializeObject <FundaResponse>(apiResponse); } })); }
/// <summary> Gets the name of the reference data categories by category. </summary> <param /// name="categoryNames">The category names.</param> <returns>List of <see cref="ReferenceDataCategoryDTO"></returns> public async Task <List <ReferenceDataCategoryDTO> > GetReferenceDataNameValuePairs(List <string> categoryNames) { using (loggingHelper.RMTraceManager.StartTrace("Integration.GetReferenceDataNameValuePairs")) { string methodName = typeof(NetworkManagerIntegrationService) + "." + nameof(GetReferenceDataNameValuePairs); loggingHelper.LogMethodEntry(methodName, priority, entryEventId); List <ReferenceDataCategoryDTO> listReferenceCategories = new List <ReferenceDataCategoryDTO>(); List <NameValuePair> nameValuePairs = new List <NameValuePair>(); foreach (var category in categoryNames) { HttpResponseMessage result = await httpHandler.GetAsync(referenceDataWebAPIName + "nameValuePairs?appGroupName=" + category); if (!result.IsSuccessStatusCode) { var responseContent = result.ReasonPhrase; throw new ServiceException(responseContent); } Tuple <string, List <NameValuePair> > apiResult = JsonConvert.DeserializeObject <Tuple <string, List <NameValuePair> > >(result.Content.ReadAsStringAsync().Result); nameValuePairs.AddRange(apiResult.Item2); } listReferenceCategories.AddRange(ReferenceDataHelper.MapDTO(nameValuePairs)); loggingHelper.LogMethodExit(methodName, priority, exitEventId); return(listReferenceCategories); } }
public async Task WhenFetchingFromTheApiService_CallsTheHttpClientWithGivenPath() { var api = new ApiService(_fakeClient); var response = await api.FetchAsync("api/call"); A.CallTo(() => _fakeClient.GetAsync("api/call")).MustHaveHappened(); }
/// <summary> /// Sets the query string param, http method(get), uri string, version, client id, client secret and access token. /// </summary> /// <returns> /// Gets the respective result. /// </returns> public string GetRequestResolver(Dictionary <string, string> queryParams, string version, string clientId, string clientSecret, string uriPath, AccessToken accessToken, DateTime dateTime) { GetRefreshToken(version, clientId, clientSecret, accessToken, dateTime); var response = _httpHandler.GetAsync(queryParams, version, uriPath, accessToken.Type, accessToken.Token); var content = response.Content.ReadAsStringAsync().Result; return(content); }
public async Task <bool> Download(string curFileName) { var response = await client.GetAsync($"{baseUrl}{fileServiceName}/{curFileName}"); if (!response.IsSuccessStatusCode) { return(false); } using (var stream = response.Content.ReadAsStreamAsync()) { var fileInfo = new FileInfo(curFileName); using (var fileStream = fileInfo.Create()) { await stream.Result.CopyToAsync(fileStream); } } return(true); }
/// <summary> /// Get the street DTO for operational object. /// </summary> /// <param name="networkLinkID">networkLink unique identifier Guid.</param> /// <returns>Nearest street and the intersection point.</returns> public async Task <NetworkLinkDTO> GetNetworkLink(Guid networkLinkID) { using (loggingHelper.RMTraceManager.StartTrace("Integration.GetNetworkLink")) { string methodName = typeof(AccessLinkIntegrationService) + "." + nameof(GetNearestNamedRoad); loggingHelper.LogMethodEntry(methodName, priority, entryEventId); HttpResponseMessage result = await httpHandler.GetAsync(networkManagerDataWebAPIName + "networklink/" + networkLinkID); if (!result.IsSuccessStatusCode) { var responseContent = result.ReasonPhrase; throw new ServiceException(responseContent); } NetworkLinkDTO networkLink = JsonConvert.DeserializeObject <NetworkLinkDTO>(result.Content.ReadAsStringAsync().Result); loggingHelper.LogMethodExit(methodName, priority, exitEventId); return(networkLink); } }
public GoogleResponseDto SearchByExpression(string searchTerm) { var query = $"{_baseAddress}v1?key={_apiKey}&cx={_cx}&q={searchTerm}"; var response = _handler.GetAsync(query).Result; var content = response.Content.ReadAsStringAsync().Result; var result = JsonConvert.DeserializeObject <GoogleResponseDto>(content); return(result); }
public async void GetMovieAsync_should_return_movie() { // Arrange var json = "{'Title':'Star Wars: Episode IV - A New Hope','Year':'1977','Rated':'PG','Released':'25 May 1977','Runtime':'121 min','Genre':'Action, Adventure, Fantasy, Sci-Fi','Director':'George Lucas'," + "'Writer':'George Lucas','Actors':'Mark Hamill, Harrison Ford, Carrie Fisher, Peter Cushing','Plot':'Luke Skywalker joins.','Language':'English','Country':'USA','Awards':'Won 6 Oscars. Another 52 wins & 29 nominations.'," + "'Poster':'https://m.media-amazon.com/images/M/MV5BNzVlY2MwMjktM2E4OS00Y2Y3LWE3ZjctYzhkZGM3YzA1ZWM2XkEyXkFqcGdeQXVyNzkwMjQ5NzM@._V1_SX300.jpg'," + "'Ratings':[{'Source':'Internet Movie Database','Value':'8.6/10'},{'Source':'Rotten Tomatoes','Value':'92%'},{'Source':'Metacritic','Value':'90/100'}]," + "'Metascore':'90','imdbRating':'8.6','imdbVotes':'1,227,656','imdbID':'tt0076759','Type':'movie','DVD':'N/A','BoxOffice':'$460,998,507','Production':'Lucasfilm Ltd.','Website':'N/A','Response':'True'}"; HttpContent content = new StringContent(json); A.CallTo(() => _httpHandler.GetAsync(A <string> .Ignored)) .Returns(new HttpResponseMessage() { StatusCode = HttpStatusCode.OK, Content = content }); // Act var result = await _sourceMovieService.GetMovieAsync("a"); // Assert A.CallTo(() => _httpHandler.GetAsync(A <string> .Ignored)).MustHaveHappenedOnceExactly(); Assert.NotNull(result); Assert.Equal("Star Wars: Episode IV - A New Hope", result.Title); Assert.Equal("1977", result.Year); Assert.Equal("PG", result.Rated); Assert.Equal("25 May 1977", result.Released); Assert.Equal("121 min", result.Runtime); Assert.Equal("Action, Adventure, Fantasy, Sci-Fi", result.Genre); Assert.Equal("George Lucas", result.Director); Assert.Equal("George Lucas", result.Writer); Assert.Equal("Mark Hamill, Harrison Ford, Carrie Fisher, Peter Cushing", result.Actors); Assert.Equal("Luke Skywalker joins.", result.Plot); Assert.Equal("English", result.Language); Assert.Equal("USA", result.Country); Assert.Equal("Won 6 Oscars. Another 52 wins & 29 nominations.", result.Awards); Assert.Equal("https://m.media-amazon.com/images/M/MV5BNzVlY2MwMjktM2E4OS00Y2Y3LWE3ZjctYzhkZGM3YzA1ZWM2XkEyXkFqcGdeQXVyNzkwMjQ5NzM@._V1_SX300.jpg", result.Poster); Assert.Equal("8.6", result.ImdbRating); Assert.Equal("1,227,656", result.ImdbVotes); Assert.Equal("tt0076759", result.ImdbID); }
private async Task <UserRepos> ExecuteUserReposRequest(string userName, int page, int per_page) { Uri baseUri = new Uri(GITHUB_HOST); Uri fullUri = new Uri(baseUri, "users/" + userName + "/repos?page=" + page + "&per_page=" + per_page); HttpResponseMessage responseMessage = await HttpHandler.GetAsync(fullUri); if (responseMessage.StatusCode == HttpStatusCode.NotFound) { return(new UserRepos()); } else if (responseMessage.StatusCode != HttpStatusCode.OK) { return(null); } responseMessage.EnsureSuccessStatusCode(); // If there is an error, this will throw string result = await responseMessage.Content.ReadAsStringAsync(); MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(result)); DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(UserRepo[])); UserRepo[] userRepos = (UserRepo[])jsonSerializer.ReadObject(stream); // foreach (UserRepo repo in userRepos) { UserRepo repoPRs = await GetPullRequetsByRepoName(userName, repo.name); //Filter Open PRs and reassign var openPRs = from p in repoPRs.PullRequests where p.state == "open" select p; repo.PullRequests = openPRs.ToList(); } // Order by no of PRs in the list userRepos = userRepos.OrderByDescending(x => x.PullRequests.Count).ToArray(); return(new UserRepos { Repos = new List <UserRepo>(userRepos) }); }
public async Task <Location> GetGeocodeJsone(string addressText) { var encodedAddress = HttpUtility.UrlEncode(addressText); HttpResponseMessage httpResponse = await _client.GetAsync($"{_baseUrl}/geocode/json?address={encodedAddress}&key={_apiKey}"); if (!httpResponse.IsSuccessStatusCode) { _logger.LogError(""); throw new Exception("Cannot retrieve tasks"); } var content = await httpResponse.Content.ReadAsStringAsync(); GeocodeResponse deserializedResponce = JsonConvert.DeserializeObject <GeocodeResponse>(content); Location result = null; if (deserializedResponce.Status == "OK" && deserializedResponce.Results.Length != 0) { result = new Location(); result.Latitude = deserializedResponce.Results.Select(x => x.Geometry.Location.Lat).FirstOrDefault(); result.Longitude = deserializedResponce.Results.Select(x => x.Geometry.Location.Lng).FirstOrDefault(); var country = deserializedResponce.Results.Select(x => x.AddressComponents.Where(y => y.Types.Contains("country"))).FirstOrDefault().FirstOrDefault().ShortName; var cultureInfosList = CultureInfo.GetCultures(CultureTypes.AllCultures).Where(c => c.Name.EndsWith("-" + country)); result.CountryCode = country != "GB"? cultureInfosList.FirstOrDefault().ToString() : cultureInfosList.LastOrDefault().ToString(); result.FormattedAddress = deserializedResponce.Results.Select(x => x.FormatedAddress).FirstOrDefault(); var utcTimeNow = DateTime.UtcNow; TimeSpan utcDateNowSpan = utcTimeNow - new DateTime(1970, 1, 1, 0, 0, 0); var googleTimeZoneResponce = this.GetTimeZoneJsone(result, utcDateNowSpan).Result; if (googleTimeZoneResponce.Status == "OK") { result.GoogleTimeZone = googleTimeZoneResponce; } } return(result); }
public async Task <TDto> GetAsync(string uri) { var response = await _httpHandler.GetAsync(uri).ConfigureAwait(false); if (response.IsSuccessStatusCode) { var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false); return(JsonConvert.DeserializeObject <TDto>(content, new UnixDateTimeConverter())); } return(null); }
private async Task <SourceMovieDto> GetMovieFromSourceAsync(string source) { using (var response = await _httpHandler.GetAsync(source)) { string apiResponse = await response.Content.ReadAsStringAsync(); if (apiResponse.Contains("Movie not found!")) { return(null); } return(JsonConvert.DeserializeObject <SourceMovieDto>(apiResponse)); } }
/// <inheritdoc/> public async Task <List <Domain.PetOwner> > GetAsync() { var request = BuildRequest(_petOwnersServiceUri); var response = await _httpHandler.GetAsync(request); if (!response.IsSuccessStatusCode) { throw new ApplicationException($"Cannot communicate with the pet owners service. Details: {response.StatusCode} - {response.ReasonPhrase}"); } var deserializedContent = await GetResponseContent <List <Domain.PetOwner> >(response); return(deserializedContent); }
public async Task <HttpResponseMessage> DownloadTvShowDataAsync(string seriesName) { string seriesUrl = ApiUrlBase + seriesName; HttpResponseMessage tvShowResponseMessage = await _httpHandler.GetAsync(seriesUrl); // <2> Check if Response status is OK. If not -> handle it if (!_responseHelper.IsResponseStatusOk(tvShowResponseMessage)) { _responseHelper.HandleError(tvShowResponseMessage); } // </2> return(tvShowResponseMessage); }
/// <summary> /// Coordinates will be in the format [longitude, latitude]. /// Our zones are not bound by zip code borders.If you need to check to see if an address is within a given zone, use the Delivery Quote /// </summary> /// <returns>if sucessful DeliveryZoneCollection else error</returns> public async Task <IResponse> GetDeliveryZonesAsync() { var response = new Response(); var contentString = ""; using (var zoneResponse = await _httpClient.GetAsync("/v1/delivery_zones").ConfigureAwait(false)) { try { contentString = await zoneResponse?.Content.ReadAsStringAsync(); zoneResponse.EnsureSuccessStatusCode(); response._response = new DeliveryZoneCollection { DeliveryZones = Newtonsoft.Json.JsonConvert.DeserializeObject <IEnumerable <DeliveryZone> >(contentString) };; response.Kind = ResponseKinds.delivery_zones; } catch (Exception ex) { response._response = GetErrorResponse(contentString, zoneResponse.StatusCode, ex); response.Kind = ResponseKinds.error; } } return(response); }
/// <summary> /// Retreive reference data details from /// </summary> /// <param name="categoryName">categoryname</param> /// <param name="itemName">Reference data Name</param> /// <returns>GUID</returns> public Guid GetReferenceDataGuId(string categoryName, string itemName) { using (loggingHelper.RMTraceManager.StartTrace("IntegrationService.GetReferenceDataGuId")) { string methodName = typeof(DeliveryPointIntegrationService) + "." + nameof(GetReferenceDataGuId); loggingHelper.LogMethodEntry(methodName, priority, entryEventId); string actionUrl = "/simplelists?listName=" + categoryName; string requestUrl = referenceDataWebAPIName + actionUrl; HttpResponseMessage result = httpHandler.GetAsync(requestUrl).Result; if (!result.IsSuccessStatusCode) { var responseContent = result.ReasonPhrase; throw new ServiceException(responseContent); } Tuple <string, SimpleListDTO> simpleListDTO = JsonConvert.DeserializeObject <Tuple <string, SimpleListDTO> >(result.Content.ReadAsStringAsync().Result); var getReferenceDataGuId = simpleListDTO.Item2.ListItems.Where(li => li.Value.Trim().Equals(itemName.Trim(), StringComparison.OrdinalIgnoreCase)).SingleOrDefault().Id; loggingHelper.LogMethodExit(methodName, priority, exitEventId); return(getReferenceDataGuId); } }
public async Task <List <PgAccount> > GetPgAccounts(string identifier, int maxLevel, int quantity) { try { var builder = new UriBuilder($"{_baseurl}/{GetAccounturl}") { Query = $"system_id={identifier}&count={quantity}&min_level=0&max_level={maxLevel-1}&banned_or_new=true" }; var response = await _client.GetAsync(builder.Uri.ToString()); if (response.IsSuccessStatusCode) { var ret = new List <PgAccount>(); if (quantity > 0) { if (quantity == 1) { var retAccount = await response.Content.ReadAsAsync <PgAccount>(); retAccount.SystemId = identifier; ret.Add(retAccount); } else { var retAccouts = await response.Content.ReadAsAsync <List <PgAccount> >(); if (retAccouts != null) { foreach (var t in retAccouts) { t.SystemId = identifier; ret.Add(t); } } } } return(ret); } _logger.Error(response); return(null); } catch (Exception e) { _logger.Error(e); return(null); } }
public BingResponseDto SearchByExpression(string searchTerm) { _handler.AddHeader(_subscriptionKey); var query = $"{_baseAddress}search?q={searchTerm}&customconfig={_customConfigId}&mkt=en-US"; System.Threading.Thread.Sleep(1000); var response = _handler.GetAsync(query).Result; var content = response.Content.ReadAsStringAsync().Result; var result = JsonConvert.DeserializeObject <BingResponseDto>(content); return(result); }
public async Task <TResponse> GetAsync <TResponse>(string queryPath) { Uri requestUri = new Uri(_uri, queryPath); Console.WriteLine($"GET: {queryPath}"); HttpResponseMessage response = await _httpHandler.GetAsync(requestUri); response.EnsureSuccessStatusCode(); string jsonResponse = await response.Content.ReadAsStringAsync(); Console.WriteLine("Response:"); Console.WriteLine(jsonResponse); TResponse responseT = JsonConvert.DeserializeObject <TResponse>(jsonResponse); return(responseT); }
public async Task <List <Whisky> > GetScrapedWhiskies(Random random, HtmlConverter converter, string scraper) { var url = ConfigurationManager.AppSettings[scraper + "url"]; var startNumber = Convert.ToInt32(ConfigurationManager.AppSettings[scraper + "startNumber"]); var endNumber = Convert.ToInt32(ConfigurationManager.AppSettings[scraper + "endNumber"]); var increaseNumber = Convert.ToInt32(ConfigurationManager.AppSettings[scraper + "increaseNumber"]); var xPathMain = ConfigurationManager.AppSettings[scraper + "xPathMain"]; var xPathType = ConfigurationManager.AppSettings[scraper + "xPathType"]; var xPathPriceBase = ConfigurationManager.AppSettings[scraper + "xPathPriceBase"]; var xPathPriceDecimals = ConfigurationManager.AppSettings[scraper + "xPathPriceDecimals"]; var xPathDiscountBase = ConfigurationManager.AppSettings[scraper + "xPathPriceDiscountBase"]; var xPathDiscountDecimals = ConfigurationManager.AppSettings[scraper + "xPathPriceDiscountDecimals"]; var xPathName = ConfigurationManager.AppSettings[scraper + "xPathName"]; var xPathStock = ConfigurationManager.AppSettings[scraper + "xPathInStock"]; var xPathStockMatch = ConfigurationManager.AppSettings[scraper + "xPathInStockMatch"]; var whiskeysTotal = new List <Whisky>(); for (var i = startNumber; i < endNumber; i += increaseNumber) { var urlToScrape = url.Replace("{i}", $"{i}"); // Wait random time to not over request webpage if (i != 0) { _utils.Sleep(random.Next(3000, 23000)); } var response = await _httpHandler.GetAsync(urlToScrape); if (!response.IsSuccessStatusCode) { _logger.LogError($"No 200 statuscode for: {urlToScrape}"); } var pageContent = await _httpHandler.ReadAsStringAsync(response.Content); var whiskeys = converter.ReadHtmlDocument(pageContent, xPathMain, xPathPriceBase, xPathName, xPathStock, xPathStockMatch, scraper, xPathType, xPathPriceDecimals, xPathDiscountBase, xPathDiscountDecimals); whiskeysTotal.AddRange(whiskeys); } return(whiskeysTotal); }
public virtual async Task <ApiResponse> FetchAsync(string path) { IncrementRequestId(); var response = new ApiResponse { RequestId = RequestId }; HttpResponseMessage message = await _httpClient.GetAsync(path); if (message.IsSuccessStatusCode) { var data = await message.Content.ReadAsAsync <Show[]>(); response.RequestId = RequestId; response.Shows = data.Where(s => s.StartDate >= DateTime.Now).OrderBy(s => s.StartDate).ToArray(); } return(response); }
private async Task <T> Get <T>(string endpoint) where T : class { HttpResponseMessage result = null; try { result = await _client.GetAsync(endpoint); result.EnsureSuccessStatusCode(); return(JsonConvert.DeserializeObject <T>(await result.Content.ReadAsStringAsync())); } catch (HttpRequestException) when((int)result?.StatusCode == 429) { throw new TooManyRequestsException(); } catch (HttpRequestException) when(result?.StatusCode == System.Net.HttpStatusCode.NotFound) { throw new EndOfShowsException(); } }
public async Task <T> Get(string url) { try { var response = await _httpClient.GetAsync(url); if (!response.IsSuccessStatusCode) { return(default(T)); } var result = await response.Content.ReadAsAsync <T>(); result.Url = url; return(result); } catch (HttpRequestException) { return(default(T)); } }
//private async Task<T> GetAsync<T>(string uri, CancellationToken cancellationToken) //{ // HttpResponseMessage response = await _client.GetAsync(uri, cancellationToken); // if (response.IsSuccessStatusCode) // { // var json = await response.Content.ReadAsStringAsync(); // var result = JsonConvert.DeserializeObject<T>(json); // return result; // } // return default(T); //} public async Task <IEnumerable <Meal> > GetMeals(CancellationToken token) { var meals = new List <Meal>(); try { var response = await _handler.GetAsync("api/meals/"); if (response.IsSuccessStatusCode) { var json = await response.Content.ReadAsStringAsync(); meals = JsonConvert.DeserializeObject <List <Meal> >(json); } } catch (Exception ex) { throw ex; } return(meals); }
public async Task <IJwtToken> ValidateTokenAsync(IOauthToken token) { IJwtToken jwtToken; using (HttpResponseMessage response = await client.GetAsync(config.JwtKeySetEndpoint)) { Stream stream = await response.Content.ReadAsStreamAsync(); JwtKeySet keySet = await JsonSerializer.DeserializeAsync <JwtKeySet>(stream); var headers = JWT.Headers(token.AccessToken); var jwk = keySet.Keys[1]; RSACryptoServiceProvider key = new RSACryptoServiceProvider(); key.ImportParameters(new RSAParameters { Modulus = Base64Url.Decode(jwk.n), Exponent = Base64Url.Decode(jwk.e) }); jwtToken = JWT.Decode <JwtToken>(token.AccessToken, key); if (jwtToken.Issuer != "login.eveonline.com") { throw new Exception("Invalid JWT Token!"); } uint unixTimestamp = (uint)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds; if (jwtToken.Expiery < unixTimestamp) { throw new Exception("Invalid JWT Token"); } } return(jwtToken); }
public async Task <FilmViewModel> GetAllFilms() { var uri = "/api/films/"; var result = _httpHandler.GetAsync(uri).Result; var vm = JsonConvert.DeserializeObject <FilmViewModel>(result); var filmDb = _repository.GetAllFilms().ToList(); if (!filmDb.Any()) { return(vm); } foreach (var filmResult in vm.Results) { var first = filmDb.FirstOrDefault(f => f.EpisodeId == filmResult.Episode_Id); if (first != null) { filmResult.Ranking = first.Average; } } return(vm); }