protected async Task LoadMissions(Robot host, ApplicationDbContext db)
{
try
{
_client.DefaultRequestHeaders.Accept.Clear();
var response = await _client.SendAsync(HttpRequestMessage(host, "/missions"));
if (response.IsSuccessStatusCode)
{
await using var responseStream = await response.Content.ReadAsStreamAsync();
var missions =
await JsonSerializer.DeserializeAsync <List <Mission> >(responseStream, _options);
foreach (var mission in missions)
{
mission.RobotId = host.Id;
if (!db.Missions.Any(m => m.Name.Contains(mission.Name) &&
m.RobotId.Equals(mission.RobotId)))
{
db.Missions.Add(mission);
}
}
host.IsOnline = true;
db.Robots.Update(host);
db.SaveChanges();
}
}
catch (Exception e)
{
SetRobotOffline(host, db, e);
}
}
public async Task <ListWithMetadata <T> > GetListAsync <T>(string resourceUri)
{
var response = await HttpClient.GetAsync(resourceUri);
var stream = await response.Content.ReadAsStreamAsync();
if (response.StatusCode == HttpStatusCode.NotFound)
{
var notFound = await JsonSerializer.DeserializeAsync <NotFoundProblemDetails>(stream, new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
throw new ApiError(notFound, HttpStatusCode.NotFound);
}
var result = await JsonSerializer.DeserializeAsync <List <T> >(stream, new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
if (response.Headers.TryGetValues("x-pagination", out var values))
{
var paginationMeta = JsonSerializer.Deserialize <PaginationMetadata>(values.First(), _jsonDeserOpt);
return(new ListWithMetadata <T>
{
Data = result,
Metadata = paginationMeta
});
}
return(new ListWithMetadata <T>
{
Data = result,
Metadata = new PaginationMetadata()
});
}
public async Task <CityViewModelResponse> GetTempByCity(string cityName)
{
var request = new HttpRequestMessage(HttpMethod.Get,
"http://api.openweathermap.org/data/2.5/weather?q=" + cityName + "&units=metric&lang=pt_br&appid=142d374d2ea6105f400f36546592a3d4");
var client = _clientFactory.CreateClient();
var response = await client.SendAsync(request);
Stream responseStream;
if (!response.IsSuccessStatusCode)
{
responseStream = await response.Content.ReadAsStreamAsync();
var objBadRequest = await JsonSerializer.DeserializeAsync
<BadRequestViewModelAPI>(responseStream);
throw new Exception(objBadRequest.message);
}
responseStream = await response.Content.ReadAsStreamAsync();
var objApi = await JsonSerializer.DeserializeAsync
<CityAPI>(responseStream);
return(_mapper.Map <CityViewModelResponse>(objApi));
}
public async Task CanDeserialize(SampleDataDescriptor sampleDataFile)
{
await using var sampleData = File.OpenRead(sampleDataFile.FullPath);
var payload = await JsonSerializer.DeserializeAsync <TType>(sampleData, this.Options);
Assert.NotNull(payload);
}
protected async Task GetQueue(Robot host, ApplicationDbContext db)
{
if (!host.IsOnline)
{
return;
}
try
{
_client.DefaultRequestHeaders.Accept.Clear();
var httpResponse = await _client.SendAsync(HttpRequestMessage(host, "/mission_queue"));
if (httpResponse.IsSuccessStatusCode)
{
await using var responseStream = await httpResponse.Content.ReadAsStreamAsync();
var response =
await JsonSerializer.DeserializeAsync <List <MissionQueuesResponse> >(responseStream, _options);
foreach (var queuesResponse in response)
{
queuesResponse.RobotId = host.Id;
var isAvailable = db.MissionQueuesResponse
.Where(s => s.Id.Equals(queuesResponse.Id))
.Any(s => s.RobotId.Equals(host.Id));
if (isAvailable)
{
db.MissionQueuesResponse.Update(new MissionQueuesResponse
{
Id = queuesResponse.Id,
Robot = host,
RobotId = host.Id,
State = queuesResponse.State,
Url = queuesResponse.Url
});
}
else
{
var missq = new MissionQueuesResponse
{
Id = queuesResponse.Id,
Robot = host,
RobotId = host.Id,
State = queuesResponse.State,
Url = queuesResponse.Url
};
await db.MissionQueuesResponse.AddAsync(missq);
}
}
await db.SaveChangesAsync();
}
}
catch (Exception e)
{
_logger.LogCritical("The Robot may be is offline");
}
}
private static async Task <MuntContext> DeserializeMuntContext(Stream stream)
{
return(await JsonSerializer.DeserializeAsync <MuntContext>(new StreamReader(stream).BaseStream,
new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
Converters = { new JsonStringEnumConverter() }
}));
}
public async Task <IEnumerable <UserFormViewModel> > GetUsersAsync()
{
return(await JsonSerializer.DeserializeAsync <IEnumerable <UserFormViewModel> >(
await _httpClient.GetStreamAsync("api/users"),
new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
}));
}
new public async Task <List <EventMarker> > GetAll()
{
var response = await JsonSerializer.DeserializeAsync <IEnumerable <EventMarker> >
(await _httpClient.GetStreamAsync($"api/" + ControllerName), new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
return(response.ToList());
}
public async Task <TEntity> GetById(int id)
{
var response = await JsonSerializer.DeserializeAsync <TEntity>
(await _httpClient.GetStreamAsync($"api/" + ControllerName + $"/{id}"), new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
return(response);
}
public async Task CanSerialize(string sampleDataPath)
{
await using var sampleData = File.OpenRead(sampleDataPath);
var payload = await JsonSerializer.DeserializeAsync <TType>(sampleData, this.Options);
Assert.NotNull(payload);
await using var stream = new MemoryStream();
await JsonSerializer.SerializeAsync(stream, payload !, this.Options);
}
public IEnumerable <Factory> DeSerializeJSON(string fileName) //работает
{
using (FileStream fs = new FileStream(fileName, FileMode.Open))
{
var options = new JsonSerializerOptions {
IncludeFields = true
};
var result = JsonSerializer.DeserializeAsync <List <Factory> >(fs, options).Result;
return(result);
}
}
public async Task <Tool> Get(string id)
{
var result = await _client.GetAsync(id, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false);
using var streamReader = new StreamReader(await result.Content.ReadAsStreamAsync());
await using var contentStream = await result.Content.ReadAsStreamAsync();
return(await JsonSerializer.DeserializeAsync <Tool>(contentStream, new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
IgnoreNullValues = true
}));
}
private async Task <T> GetAsync <T>(string url, CancellationToken cancellationToken)
{
var responseMessage = await _httpClient.GetAsync(url, cancellationToken);
var responseStream = await responseMessage.Content.ReadAsStreamAsync();
if (responseMessage.StatusCode == HttpStatusCode.OK)
{
return(await JsonSerializer.DeserializeAsync <T>(responseStream, _jsonSerializerOptions, cancellationToken));
}
var error = await JsonSerializer.DeserializeAsync <ApiError>(responseStream, _jsonSerializerOptions, cancellationToken);
throw new ApiException(error);
}
private async Task AssertStoredLog(HttpResponseMessage response)
{
await Task.Delay(500);
await using var logFileStream = File.OpenRead(_logFilePath);
var logContext = (await JsonSerializer.DeserializeAsync <LogContext[]>(logFileStream, SerializerOptions))
.Single();
logContext.Request.ShouldBe(response.RequestMessage);
logContext.Response.ShouldBe(response);
Assert.Equal(logContext.Protocol, $"HTTP/{response.Version}");
}
public async Task <T> CreateAsync <T>(string resourceUri, T resource)
{
var response = await HttpClient.PostAsJsonAsync(resourceUri, resource);
if (response.IsSuccessStatusCode)
{
var result = await JsonSerializer.DeserializeAsync <T>(await response.Content.ReadAsStreamAsync(),
new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
return(result);
}
await ThrowException(response);
throw new Exception("Server returned error");
}
public async Task <OpenWeatherDto> GetWeather(LatLonParameters latLonParameters)
{
var lat = latLonParameters.Lat;
var lon = latLonParameters.Lon;
var requestUri =
$"https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid={APIKeys.OpenWeatherApiKey}&units=imperial";
// Look for cached version
if (_memoryCache.TryGetValue(requestUri, out OpenWeatherDto weatherDto))
{
// We found it in cache, use this.
return(weatherDto);
}
var request = new HttpRequestMessage(HttpMethod.Get, requestUri);
// request.Headers.Add("Accept", "application/vnd.github.v3+json");
// request.Headers.Add("User-Agent", "HttpClientFactory-Sample");
var client = _clientFactory.CreateClient();
var response = await client.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
return(null);
}
await using var responseStream = await response.Content.ReadAsStreamAsync();
weatherDto = await JsonSerializer.DeserializeAsync <OpenWeatherDto>(responseStream,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true,
});
// Save to cache
var cacheEntryOptions = new MemoryCacheEntryOptions()
// Keep in cache for this time, reset time if accessed.
.SetAbsoluteExpiration(TimeSpan
.FromMinutes(1));
// Save data in cache.
_memoryCache.Set(requestUri, weatherDto, cacheEntryOptions);
return(weatherDto);
}
public async Task <TModel> PatchAsync <TModel>(string resourceUri, JsonPatchDocument patchDocument)
{
var serializedItemToUpdate = JsonConvert.SerializeObject(patchDocument);
var response = await HttpClient.PatchAsync(resourceUri, new StringContent(serializedItemToUpdate, null, "application/json"));
if (response.IsSuccessStatusCode)
{
var result = await JsonSerializer.DeserializeAsync <TModel>(await response.Content.ReadAsStreamAsync(),
new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
return(result);
}
await ThrowException(response);
throw new Exception("Server returned error");
}
public async Task <T> SendAsync <T>(HttpRequestMessage request, bool insensitiveCase = false)
{
var result = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false);
await using (var responseStream = await result.Content.ReadAsStreamAsync())
{
if (insensitiveCase)
{
return(await JsonSerializer.DeserializeAsync <T>(responseStream, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true,
}));
}
return(await JsonSerializer.DeserializeAsync <T>(responseStream));
}
}
public async Task <OpenUVDto> GetCurrentUVIndex(LatLonParameters latLngParameters)
{
var lat = latLngParameters.Lat;
var lon = latLngParameters.Lon;
var requestUri = $"https://api.openuv.io/api/v1/uv?lat={lat}&lng={lon}";
// Look for cached version
if (_memoryCache.TryGetValue(requestUri, out OpenUVDto openUvDto))
{
// We found it in cache, use this.
return(openUvDto);
}
var request = new HttpRequestMessage(HttpMethod.Get, requestUri);
request.Headers.Add("x-access-token", APIKeys.OpenUVIndexApiKey);
var client = _clientFactory.CreateClient();
var response = await client.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
return(null);
}
await using var responseStream = await response.Content.ReadAsStreamAsync();
openUvDto = await JsonSerializer.DeserializeAsync <OpenUVDto>(responseStream, new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true,
});
// Save to cache
var cacheEntryOptions = new MemoryCacheEntryOptions()
// Keep in cache for this time, reset time if accessed.
.SetAbsoluteExpiration(TimeSpan
.FromMinutes(
30)); // We are allowed 50 hits per day. We will only ever hit this 48 times. (2 * 24 = 48)
// Save data in cache.
_memoryCache.Set(requestUri, openUvDto, cacheEntryOptions);
return(openUvDto);
}
public async Task <ServiceResponse> DeserializeResponse(Type type, byte[] message, HttpDataSerializerOptions options = null)
{
var opts = TextJsonSerializerSettings.CreateJsonSerializerOptions(options, _debugMode);
try
{
using (var ms = new MemoryStream(message))
{
var result = await JsonSerializer.DeserializeAsync(ms, type, opts);
return((ServiceResponse)result);
}
}
catch (JsonException ex)
{
_logger.LogError("Cannot deserialize request", ex);
throw;
}
}
public async Task <Response> CreatePost(Request req)
{
try {
var postReq = await JsonSerializer.DeserializeAsync <AuthPostRequest>(req.Body, options);
if (!TryAuth(postReq.Auth))
{
return(ErrorResp(new JSON {
["success"] = false,
["message"] = "auth failed",
}, status: StatusCode.Unauthorized));
}
var post = postReq.Post;
post.WrittenDate = DateTime.Now;
if (string.IsNullOrEmpty(post.Name))
{
return(ErrorResp("name should not be empty"));
}
if (string.IsNullOrEmpty(post.Title))
{
return(ErrorResp("title should not be empty"));
}
if (string.IsNullOrEmpty(post.Content))
{
return(ErrorResp("content should not be empty"));
}
posts.Insert(post);
db.Checkpoint();
return(new JsonResponse(new JSON {
["success"] = true,
["id"] = post.Id,
}));
}
catch (JsonException ex) {
return(ErrorResp("invalid json", ex));
}
catch (Exception ex) {
return(ErrorResp("server error", ex, StatusCode.InternalServerError));
}
}
public async Task <T> DeserializeResponse <T>(byte[] message, HttpDataSerializerOptions options = null) where T : new()
{
var opts = TextJsonSerializerSettings.CreateJsonSerializerOptions(options, _debugMode);
try
{
using (var ms = new MemoryStream(message))
{
var result = await JsonSerializer.DeserializeAsync <T>(ms, opts);
return(result);
}
}
catch (JsonException ex)
{
_logger.LogError("Cannot deserialize response", ex);
throw new CodeWorksSerializationException("Cannot deserialize JSON payload", ex);
}
}
public async Task SurvivesRoundTrip(SampleDataDescriptor sampleDataFile)
{
await using var sampleData = File.OpenRead(sampleDataFile.FullPath);
var deserialized = await JsonSerializer.DeserializeAsync <TType>(sampleData, this.Options);
Assert.NotNull(deserialized);
await using var stream = new MemoryStream();
await JsonSerializer.SerializeAsync(stream, deserialized !, this.Options);
await stream.FlushAsync();
stream.Seek(0, SeekOrigin.Begin);
sampleData.Seek(0, SeekOrigin.Begin);
var serialized = await JsonDocument.ParseAsync(stream);
var original = await JsonDocument.ParseAsync(sampleData);
JsonAssert.Equivalent(original, serialized, this.AssertOptions);
}
public async Task <BaseRequest> DeserializeRequest(
Type type,
byte[] message,
HttpDataSerializerOptions options = null)
{
var opts = TextJsonSerializerSettings.CreateJsonSerializerOptions(options, _debugMode);
if (message.Length == 0)
{
return((BaseRequest)Activator.CreateInstance(type));
}
try
{
using (var ms = new MemoryStream(message))
{
var result = await JsonSerializer.DeserializeAsync(ms, type, opts);
return((BaseRequest)result);
}
}
catch (JsonException ex)
{
var contents = Encoding.UTF8.GetString(message);
if (ex.StackTrace.Contains("JsonConverterEnum"))
{
// INVALID ENUM FOUND - TRY AND FIGURE IT OUT
var property = ex.Path.Substring(2, ex.Path.Length - 2);
throw new ValidationErrorException("Invalid enum value provided", property);
}
if (string.IsNullOrWhiteSpace(contents))
{
return((BaseRequest)Activator.CreateInstance(type));
}
_logger.LogError(ex, $"Cannot deserialize request payload {contents}");
throw new CodeWorksSerializationException($"Cannot parse payload as JSON. Payload={contents}", contents);
}
}
public async Task <UserPaginationViewModel> GetByPageAsync(string trueName,
Gender?gender,
IsEnabled?isEnabled,
int current,
int pageSize,
string orderByPropertyName,
bool isAsc)
{
//return await JsonSerializer.DeserializeAsync<UserPaginationViewModel>(
// await _httpClient.GetStreamAsync("api/users/pagination"),
// new JsonSerializerOptions
// {
// PropertyNameCaseInsensitive = true
// });
return(await JsonSerializer.DeserializeAsync <UserPaginationViewModel>(
await _httpClient.GetStreamAsync("api/users/pagination"),
new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
}));
}
private async Task ThrowException(HttpResponseMessage response)
{
if (response.StatusCode == HttpStatusCode.UnprocessableEntity)
{
var unprocessableResult = await JsonSerializer.DeserializeAsync <UnprocessableEntityProblemDetails>(
await response.Content.ReadAsStreamAsync(),
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
throw new ApiError(unprocessableResult, HttpStatusCode.UnprocessableEntity);
}
if (response.StatusCode == HttpStatusCode.InternalServerError)
{
throw new Exception("Server returned error");
}
if (response.StatusCode == HttpStatusCode.BadRequest)
{
throw new Exception("Server returned Bad Request error");
}
}
public async Task <ListWithMetadata <T> > GetListAnonymousAsync <T>(string resourceUri)
{
var response = await AnonymousHttpClient.GetAsync(resourceUri);
var result = await JsonSerializer.DeserializeAsync <List <T> >(await response.Content.ReadAsStreamAsync(), _jsonDeserOpt);
if (response.Headers.TryGetValues("x-pagination", out var values))
{
var paginationMeta = JsonSerializer.Deserialize <PaginationMetadata>(values.First(), _jsonDeserOpt);
return(new ListWithMetadata <T>
{
Data = result,
Metadata = paginationMeta
});
}
return(new ListWithMetadata <T>
{
Data = result,
Metadata = new PaginationMetadata()
});
}
public async Task <ActionResult <List <CardVoteViewModel> > > GetVoteResult()
{
var request = new HttpRequestMessage(HttpMethod.Get,
"api/cards/votes");
var client = _clientFactory.CreateClient("spring.festival.card.api");
var response = await client.SendAsync(request);
if (response.IsSuccessStatusCode)
{
await using var responseStream = await response.Content.ReadAsStreamAsync();
var cardVotes = await JsonSerializer.DeserializeAsync
<List <CardVoteViewModel> >(responseStream,
new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
return(Ok(cardVotes));
}
return(NoContent());
}
public async Task <CityViewModelResponse> GetTempByLonLat(string lat, string lon)
{
var teste = new CityViewModelResponse();
var request = new HttpRequestMessage(HttpMethod.Get,
"http://api.openweathermap.org/data/2.5/weather?lat=" + lat + "&lon=" + lon + "&units=metric&appid=142d374d2ea6105f400f36546592a3d4");
var client = _clientFactory.CreateClient();
var response = await client.SendAsync(request);
Stream responseStream;
JsonSerializerOptions options;
if (!response.IsSuccessStatusCode)
{
responseStream = await response.Content.ReadAsStreamAsync();
options = new JsonSerializerOptions
{
DictionaryKeyPolicy = JsonNamingPolicy.CamelCase,
WriteIndented = true
};
var objBadRequest = await JsonSerializer.DeserializeAsync
<BadRequestViewModelAPI>(responseStream, options);
throw new Exception(objBadRequest.message);
}
responseStream = await response.Content.ReadAsStreamAsync();
options = new JsonSerializerOptions
{
DictionaryKeyPolicy = JsonNamingPolicy.CamelCase,
WriteIndented = true
};
var objApi = await JsonSerializer.DeserializeAsync
<CityAPI>(responseStream, options);
teste = _mapper.Map <CityViewModelResponse>(objApi);
return(teste);
}
public static async Task <TV> DeserializeAsync <TV>(Stream stream,
JsonSerializerOptions jsonSerializerOptions = null)
{
try
{
return(jsonSerializerOptions is null
? await JsonSerializer.DeserializeAsync <TV>(stream)
: await JsonSerializer.DeserializeAsync <TV>(stream, jsonSerializerOptions));
}
catch (Exception ex)
{
Logger.Error(ex, ex.Message);
stream.Seek(0, SeekOrigin.Begin);
using var reader = new StreamReader(stream, Encoding.UTF8);
var value = await reader.ReadToEndAsync();
Logger.Error($"Raw response: {value}");
throw new FormatException(value);
}
}
