private async Task <AccessToken> GetNewAccessToken() { _logger.LogDebug("Requesting new access token for Devianart"); var url = string.Format(AUTHORIZATION_URI, _credentials.ClientId, _credentials.ClientSecret); var response = await _client.GetAsync(url); var responseStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false); var tokenReponse = await _deserializer.Deserialize <AccessTokenResponse>(responseStream).ConfigureAwait(false); if (tokenReponse.Status != "success") { _logger.LogError("Failed to get new access token for Devianart"); throw new InvalidOperationException("DeviantArt authentication failed"); } var token = new AccessToken { Token = tokenReponse.AccessToken, ExpirationDate = DateTimeOffset.Now.AddSeconds(tokenReponse.ExpiresIn).AddSeconds(-5 * 60) }; return(token); }
public async Task <Album> GetAlbumByIdAsync(int albumId) { using (var photoLookUp = await _client.GetAsync($"{_settings.BaseUrl}/albums/{albumId}")) { return((photoLookUp.IsSuccessStatusCode) ? _jsonDeserializer.Deserialize <Album>(await photoLookUp.Content.ReadAsStringAsync()) : null); } }
public async Task <Photo> GetPhotoByIdAsync(int id) { using (var photoLookUp = await _client.GetAsync($"{_settings.BaseUrl}/photos/{id}")) { return((photoLookUp.IsSuccessStatusCode) ? _jsonDeserializer.Deserialize <Photo>(await photoLookUp.Content.ReadAsStringAsync()) : null); } }
public object Parse(string json) { var jsonDocumentOptions = new JsonDocumentOptions(); var jsonDocument = JsonDocument.Parse(json, jsonDocumentOptions); return(_deserializer.Deserialize(jsonDocument.RootElement)); }
public void Handle(string message) { var deserializedMessage = _jsonDeserializer.Deserialize <Metadata>(message); var updateResource = _mapper.Map <UpdateResource>(deserializedMessage); _commandBus.Handle(updateResource); }
protected T Get <T>(string url) { try { ResponseMessage = HttpClient.SendRequest(url, Authorizable); ResponseContent = ResponseMessage.Content.ReadAsStringAsync().Result; object instance = Deserializer.Deserialize <T>(ResponseContent); if (Response != null) { Response.ReadResponse(ResponseContent, ResponseMessage); } return((T)instance); } catch (Exception e) { if (ResponseMessage.StatusCode == HttpStatusCode.Unauthorized) { throw new UnauthorizedException(); } throw e; } }
public async Task <VehicleData> GetVehicleDataAsync(string vehicleLicense) { using (var vehicleDataLookUp = await _client.GetAsync(String.Format(_settings.FullUrl, _settings.Apikey, vehicleLicense))) { return((vehicleDataLookUp.IsSuccessStatusCode) ? _jsonDeserializer.Deserialize <VehicleData>(await vehicleDataLookUp.Content.ReadAsStringAsync()) : null); } }
public static object DeserializeProperty( IJsonDeserializer deserializer, JsonElement element, string propertyName) { return(element.TryGetProperty(propertyName, out var propertyValue) ? deserializer.Deserialize(propertyValue) : null); }
private async Task <TEntity> DeserializeTeamsObjectAsync <TEntity>(HttpResponseMessage result) where TEntity : TeamsObject { using (var streamReader = new StreamReader(await result.Content.ReadAsStreamAsync())) { using (var jsonTextReader = new JsonTextReader(streamReader)) { return(_serializer.Deserialize <TEntity>(jsonTextReader)); } } }
public void Handle(string message) { try { _logger.LogInfo($"Handling sensor message: {message}"); var json = _jsonDeserializer.Deserialize <JObject>(message); var dataType = (DataType)Enum.Parse(typeof(DataType), json["datatype"].ToString(), true); _handlers[dataType].Handle(message); } catch (Exception exception) { _logger.LogError("Error while handling sensor message", exception); } }
public void Handle(string message) { var deserializedMessage = _jsonDeserializer.Deserialize <Measurement>(message); foreach (var measurementValue in deserializedMessage.MeasuresArray) { var addMeasurement = new AddMeasurement() { Guid = measurementValue.MeasureId, Timestamp = deserializedMessage.Timestamp, Value = measurementValue.Value }; _commandBus.Handle(addMeasurement); } }
public async Task <ForeignExchangeDTO> GetConvertionRates() { var currencies = await this.cache.GetOrCreateAsync("ConvertionRates", async entry => { entry.AbsoluteExpiration = dateTimeProvider.UtcNow.AddDays(1); string resourceUrl = $"https://api.exchangeratesapi.io/latest?base={GlobalConstants.BaseCurrency}&symbols={GlobalConstants.Currencies}"; string currenciesString = await foreignExchangeApiCaller.GetCurrencyData(resourceUrl); var convertionRates = jsonDeserializer.Deserialize <ForeignExchangeDTO>(currenciesString); return(convertionRates); }); return(currencies); }
public async Task Return_UserPhotoAlbum_WhenValid_UserId_IsProvided() { //https://github.com/aspnet/AspNetCore/issues/4545 //https://docs.microsoft.com/en-us/aspnet/core/test/integration-tests?view=aspnetcore-2.2#test-app-prerequisites //https://github.com/aspnet/Hosting/issues/1191 //http://anthonygiretti.com/2018/11/26/common-features-in-asp-net-core-2-1-webapi-testing/ //https://stackoverflow.com/questions/42222919/why-serviceprovider-is-unable-to-create-instance-of-controller-in-asp-net-core using (var fixture = new TestServerFixture()) { var sut = await _client.GetAsync("/api/PhotoAlbum/5"); sut.IsSuccessStatusCode.ShouldBeTrue(); var val = await sut.Content.ReadAsStringAsync(); var res = _deserializer.Deserialize <PhotoAlbums>(val); res.ShouldBeOfType <PhotoAlbums>(); } }
/// <summary> Получить список возможных объектов прогнозирвоания </summary> /// <returns>Список объектов по которым можно узнать прогноз потребления электроэнергии</returns> public IList <ForecastObject> GetDataFromServer() { string jsonData; #if DEBUG var exePath = AppDomain.CurrentDomain.BaseDirectory; var rootFolder = Directory.GetParent(exePath).Parent.Parent.Parent.FullName; var jsonFile = Path.Combine(rootFolder, "WPF-client.Test", "TestData", "predict.json"); jsonData = File.ReadAllText(jsonFile); #else var request = new RestRequest(ServerUrl.ForecastsObjectUrl, Method.GET); var response = _restClient.Execute(request); jsonData = response.Content; #endif var forecastsObjects = _jsonDeserializer.Deserialize(jsonData); return(forecastsObjects); }
public async Task <RestaurantResults> GetAsync(string outcode) { if (string.IsNullOrEmpty(outcode)) { return(new RestaurantResults()); } var headers = new[] { new KeyValuePair <string, string>(AcceptLanguage, _webConfig.HeaderAcceptLanguageValue), new KeyValuePair <string, string>(AcceptTenant, _webConfig.HeaderAcceptTenantValue), new KeyValuePair <string, string>(Authorization, _webConfig.HeaderAuthorizationValue), new KeyValuePair <string, string>(Host, _webConfig.HeaderHostValue) }; var restaurantsApiUrl = $"{_webConfig.RestaurantsApiUrl}{outcode}"; var restaurants = await(await _httpClient.GetAsync(restaurantsApiUrl, headers)).Content.ReadAsStringAsync(); return(_jsonDeserializer.Deserialize <RestaurantResults>(restaurants)); }
public IDictionary <string, object> Decode(string jwt, string secret) { var parts = jwt.Split('.'); if (parts.Length != 3) { throw new Exception(string.Format("Incorrect token count. Expected 3, received : {0}", parts.Length)); } var payload = _jsonDeserializer.Deserialize <IDictionary <string, object> >(_base64Decoder.Decode(parts[1])); var signature = parts[2]; VerifyExpiration(payload); var rawSignature = parts[0] + "." + parts[1]; if (!VerifySignature(rawSignature, secret, signature)) { throw new InvalidTokenSignatureException("Signature verification failed"); } return(payload); }
/// <summary> /// Performs an asynchronous HTTP request to the Stack Exchange API, with the specified data, and request method. /// </summary> /// <typeparam name="T">The type implementing <see cref="IStackExchangeModel"/>, to which the response gets deserialized to.</typeparam> /// <param name="path">The path relative to <see cref="ApiBaseUrl"/> to which the request should be made.</param> /// <param name="data">The data to be sent along with the HTTP request.</param> /// <param name="requestMethod">The HTTP method used for the request.</param> public async Task <Models.Wrapper <T> > PerformRequestAsync <T>(string path, Dictionary <string, string> data, HttpRequestMethod requestMethod) where T : IStackExchangeModel { if (data == null) { data = new Dictionary <string, string>(); } if (!IsAnonymous) { data.Add("key", Key); if (HasAccessToken) { data.Add("access_token", accessToken); } } var url = ApiBaseUrl.AppendPathSegment(path); var response = await httpRequester.PerformRequestAsync(url, data, requestMethod).ConfigureAwait(false); return(jsonDeserializer.Deserialize <Models.Wrapper <T> >(response.Content)); }
public static T FromJson <T>(string json) where T : new() { return(_jsonDeserializer.Deserialize <T>(new DataObject(json))); }
private async Task <EtcdResponse> SendRequest(HttpMethod method, string requestUri, IEnumerable <KeyValuePair <string, string> > formFields = null) { HttpClientEx startClient = _currentClient; HttpClientEx currentClient = _currentClient; for (; ;) { try { using (HttpRequestMessage requestMessage = new HttpRequestMessage(method, requestUri)) { if (formFields != null) { requestMessage.Content = new FormUrlEncodedContent(formFields); } using (HttpResponseMessage responseMessage = await currentClient.SendAsync(requestMessage)) { string json = null; if (responseMessage.Content != null) { json = await responseMessage.Content.ReadAsStringAsync(); } if (!responseMessage.IsSuccessStatusCode) { if (!string.IsNullOrWhiteSpace(json)) { ErrorResponse errorResponse = null; try { errorResponse = _jsonDeserializer.Deserialize <ErrorResponse>(json); } catch { } if (errorResponse != null) { throw EtcdGenericException.Create(requestMessage, errorResponse); } } currentClient = currentClient.Next; if (currentClient != startClient) { // try the next continue; } else { responseMessage.EnsureSuccessStatusCode(); } } // if currentClient != _currentClient, update _currentClient if (currentClient != startClient) { Interlocked.CompareExchange(ref _currentClient, currentClient, startClient); } if (!string.IsNullOrWhiteSpace(json)) { EtcdResponse resp = _jsonDeserializer.Deserialize <EtcdResponse>(json); resp.EtcdServer = currentClient.BaseAddress.OriginalString; resp.EtcdClusterID = GetStringHeader(responseMessage, "X-Etcd-Cluster-Id"); resp.EtcdIndex = GetLongHeader(responseMessage, "X-Etcd-Index"); resp.RaftIndex = GetLongHeader(responseMessage, "X-Raft-Index"); resp.RaftTerm = GetLongHeader(responseMessage, "X-Raft-Term"); long previousIndex = _lastIndex; if (resp.EtcdIndex > previousIndex) { Interlocked.CompareExchange(ref _lastIndex, resp.EtcdIndex, previousIndex); } this.ClusterID = resp.EtcdClusterID; return(resp); } return(null); } } } catch (EtcdRaftException) { currentClient = currentClient.Next; if (currentClient != startClient) { continue; // try the next } else { throw; // tried all clients, all failed } } catch (EtcdGenericException) { throw; } catch (Exception) { currentClient = currentClient.Next; if (currentClient != startClient) { continue; // try the next } else { throw; // tried all clients, all failed } } } }
/// <summary> /// JSON反序列化 /// </summary> public static bool Deserialize <T>(string jstr, out T obj) where T : new() { return(JsonDeserializer.Deserialize <T>(jstr, out obj)); }
public static async Task <T> GetJsonRead <T>(string JsonQuary, IJsonDeserializer <T> jsonDeserializer = null) { try { // ask for Json string Json = ""; bool success = false; await Task.Run(() => { Parallel.Invoke(() => { // for no internet connection // or bad Json quary Thread.Sleep(5000); if (!success) { throw new Exception(); } }, async() => { Json = await ApiClient.HttpClient.GetStringAsync(JsonQuary); success = true; }); }); //return final variable return(jsonDeserializer == null?JsonConvert.DeserializeObject <T>(Json) : jsonDeserializer.Deserialize(Json)); } catch { Console.WriteLine("Something Went Wrong.. Please Try Again."); return(default);
public Configuration Load() { return(_jsonDeserializer.Deserialize <Configuration>(File.ReadAllText(_configPath))); }