public async Task <List <TradeBait> > GetNewTradeBait() { // TODO: maybe instead of this process, just post a message saying there has been new trade bait and that you can message to see what it is var deserializer = new JsonResponseDeserializer(); var info = new ResponseDeserializerInfo(); var res = await _mfl.GetTradeBait(); var jsonString = await res.Content.ReadAsStringAsync(); try //Single { var tradeSingle = deserializer.Deserialize <TradeBaitParent>(jsonString, res, info).TradeBaits.tradeBait; return(new List <TradeBait> { tradeSingle }); } catch (Exception) { Console.WriteLine("not a single trade"); } try //multi { return(deserializer.Deserialize <TradeBaitsParent>(jsonString, res, info).tradeBaits.tradeBait); } catch (Exception) { return(null); } }
public override T Deserialize <T>( string?content, HttpResponseMessage response, ResponseDeserializerInfo info) { var headers = response.Headers; if (!(headers.TryGetValues(FusionHeaders.PublisherId, out var values) && values.Any())) { // No PublisherId -> not a publication / replica return(InnerDeserialize <T>(content, response, info)); } var handler = DeserializeComputedHandlerProvider.Instance[typeof(T)]; var result = handler.Handle(this, new DeserializeMethodArgs(content, response, info)); if (result is null) { return((T)result !); } if (result is T value) // T is IComputed<?> { return(value); } return((T)((IComputed)result).Value !); }
public async Task <List <TradeSingle> > GetCompletedTrades() { var deserializer = new JsonResponseDeserializer(); var info = new ResponseDeserializerInfo(); var tradeRes = await _mfl.GetRecentTrade(); var jsonString = await tradeRes.Content.ReadAsStringAsync(); try //Single { var tradeSingle = deserializer.Deserialize <TradeTransactionSingle>(jsonString, tradeRes, info) .transactions.transaction; return(new List <TradeSingle> { tradeSingle }); } catch (Exception) { Console.WriteLine("not a single trade"); } try //multi { return(deserializer.Deserialize <TradeTransactionMulti>(jsonString, tradeRes, info) .transactions.transaction); } catch (Exception) { return(null); } }
public virtual IComputed <T> DeserializeComputed <T>( string?content, HttpResponseMessage response, ResponseDeserializerInfo info) { Result <T> result; if (!response.IsSuccessStatusCode) { var message = $"{response.StatusCode}: {response.ReasonPhrase}"; var error = new TargetInvocationException(message, null); result = new Result <T>(default !, error);
public override T Deserialize <T>( string?content, HttpResponseMessage response, ResponseDeserializerInfo info) { try { return(JsonConvert.DeserializeObject <T>(content ?? string.Empty, _settings) !); } catch (Exception e) { throw DeserializationFailed(response, e); } }
//TODO: Needs Testing! public async Task <List <PendingTradeDTO> > FindPendingTrades(int year) { var DTOs = new List <PendingTradeDTO>(); var responses = new List <Task <HttpResponseMessage> >(); for (int i = 2; i < 13; i++) { string franchiseNum = i.ToString("D4"); responses.Add(_api.GetPendingTrades(year, franchiseNum)); } await Task.WhenAll(responses); var deserializer = new JsonResponseDeserializer(); var info = new ResponseDeserializerInfo(); foreach (var task in responses) { var response = task.Result; var resString = string.Empty; var bodyContent = response.Content.ReadAsStreamAsync().ContinueWith(t => { var streamRes = t.Result; using (var reader = new StreamReader(streamRes)) { resString = reader.ReadToEnd(); } }); //response.StringContent; bodyContent.Wait(); if (resString.Contains("pendingTrade\":[")) { //TODO: parse response as JObject instead?? newtonsoft.json var tradesList = deserializer.Deserialize <MflPendingTradesListRoot>(resString, response, info); var multiTrades = _mapper.Map <List <MflPendingTrade>, List <PendingTradeDTO> >(tradesList.pendingTrades.PendingTrade); DTOs.AddRange(multiTrades); } else if (resString.Contains("pendingTrade\":{")) { var singleTrade = deserializer.Deserialize <MflPendingSingleTradeRoot>(resString, response, info); var singleDTO = _mapper.Map <MflPendingTrade, PendingTradeDTO>(singleTrade.pendingTrades.PendingTrade); DTOs.Add(singleDTO); } } //select only unique trade ids return(DTOs.GroupBy(t => t.tradeId).Select(t => t.First()).ToList()); }
public override T Deserialize <T>( string?content, HttpResponseMessage response, ResponseDeserializerInfo info) { var headers = response.Headers; if (headers.TryGetValues(FusionHeaders.Publication, out var values)) { var header = values.FirstOrDefault(); if (!header.IsNullOrEmpty()) { var psi = JsonConvert.DeserializeObject <PublicationStateInfo>(header); PublicationStateInfoCapture.Capture(psi); } } return(InnerDeserializer.Deserialize <T>(content, response, info)); }
public override T Deserialize <T>(string content, HttpResponseMessage response, ResponseDeserializerInfo info) { if (response.IsSuccessStatusCode) { return(DeserializeSuccessfulResult <T>(content, response, info)); } return(DeserializeUnsuccessfulResult <T>(content, response, info)); }
/// <summary> /// Deserializes an unsuccessful response and throws a <see cref="ClientException" /> where applicable /// </summary> /// <param name="content"></param> /// <param name="response"></param> /// <param name="info"></param> /// <typeparam name="T"></typeparam> /// <returns></returns> public virtual T DeserializeUnsuccessfulResult <T>(string content, HttpResponseMessage response, ResponseDeserializerInfo info) { if (string.IsNullOrEmpty(content)) { throw new ClientException <HttpResponseMessage>(response.ReasonPhrase, response.StatusCode, response); } if (response.Content.Headers.ContentType.MediaType == "application/problem+json") { var problemDetails = base.Deserialize <ValidationProblemDetails>(content, response, info); throw new ClientException <ProblemDetails>(problemDetails.Title, response.StatusCode, problemDetails); } throw new ClientException <HttpResponseMessage>(content, response.StatusCode, response); }
public override T Deserialize <T>(string content, HttpResponseMessage response, ResponseDeserializerInfo info) { try { var responseEnvelope = JsonConvert.DeserializeObject <ResponseEnvelope <T> >(content, _jsonSettings); return(responseEnvelope.Data.Result); } catch (Exception e) { throw new BitmovinApiException("Error when deserializing response", response.StatusCode, null, e); } }
public override T Deserialize <T>(string content, HttpResponseMessage response, ResponseDeserializerInfo info) { if (response.StatusCode == HttpStatusCode.NotFound) { // Return an empty page. if (typeof(T).IsGenericType && typeof(T).GetGenericTypeDefinition() == typeof(ResultPage <>)) { return((T)Activator.CreateInstance(typeof(ResultPage <>).MakeGenericType(typeof(T).GetGenericArguments().Single()))); } else { return(default(T)); } } else if (!response.IsSuccessStatusCode) { throw new ApiException(response.RequestMessage.Method, response.RequestMessage.RequestUri, response.StatusCode, response.ReasonPhrase, response.Headers, response.Content.Headers, response.Content.ReadAsStringAsync().Result); } return(_impl.Deserialize <T>(content, response, info)); }
public void Deconstruct(out string?content, out HttpResponseMessage response, out ResponseDeserializerInfo info) { content = Content; response = Response; info = Info; }
public DeserializeMethodArgs(string?content, HttpResponseMessage response, ResponseDeserializerInfo info) { Content = content; Response = response; Info = info; }
public override T Deserialize <T>(string content, HttpResponseMessage response, ResponseDeserializerInfo info) { T1 GetHeaderValue <T1>(string name, Func <string, T1> parse) { if (!response.Headers.TryGetValues(name, out var values)) { throw new InvalidOperationException($"The response doesn't include the expected {name} header."); } var value = values.FirstOrDefault(); if (value == null) { throw new InvalidOperationException( $"The response doesn't include the expected {name} header."); } try { return(parse(value)); } catch (Exception ex) { throw new InvalidOperationException($"The response includes unexpected {name} value: '{value}' can't be converted to {typeof(T).FullName}.", ex); } } RateLimits.DailyLimit = GetHeaderValue("x-rl-daily-limit", int.Parse); RateLimits.DailyRemaining = GetHeaderValue("x-rl-daily-remaining", int.Parse); RateLimits.DailyReset = GetHeaderValue("x-rl-daily-reset", DateTimeOffset.Parse); RateLimits.HourlyLimit = GetHeaderValue("x-rl-hourly-limit", int.Parse); RateLimits.HourlyRemaining = GetHeaderValue("x-rl-hourly-remaining", int.Parse); RateLimits.HourlyReset = GetHeaderValue("x-rl-hourly-reset", DateTimeOffset.Parse); return(DeserializeJson <T>(content)); }
public override T Deserialize <T>(string content, HttpResponseMessage response, ResponseDeserializerInfo info) { if (typeof(T) == typeof(FileContent)) { var instance = Activator.CreateInstance <T>(); var fileContent = instance as FileContent; fileContent.FileName = response.Content.Headers.ContentDisposition.FileName; fileContent.MimeType = response.Content.Headers.ContentType.MediaType; fileContent.Content = response.Content.ReadAsByteArrayAsync().Result; return(instance); } return(base.Deserialize <T>(content, response, info)); }
public override T Deserialize <T>(string content, HttpResponseMessage response, ResponseDeserializerInfo info) { // Consider caching generated XmlSerializers var serializer = new JsonResponseDeserializer(); if (content.Contains("Error")) { return(default(T)); } return(base.Deserialize <T>(content, response, info)); }
/// <summary> /// Read the response string from the response, deserialize, and return a deserialized object /// </summary> /// <typeparam name="T">Type of object to deserialize into</typeparam> /// <param name="content">String content read from the response</param> /// <param name="response">HttpResponseMessage. Consider calling response.Content.ReadAsStringAsync() to retrieve a string</param> /// <param name="info">The information.</param> /// <returns>Deserialized response</returns> /// <exception cref="ArgumentException">Response was not JSON or XML</exception> public override T Deserialize <T>(string content, HttpResponseMessage response, ResponseDeserializerInfo info) { switch (response.Content.Headers.ContentType.MediaType) { case "text/json": case "application/json": return(this.DeserializeJson <T>(content)); case "text/xml": case "application/xml": return(this.DeserializeXml <T>(content)); default: if (AutoDetectForUnknownContentTypes) { Serilog.Log.Verbose("Attempting to autodetect content type"); try { return(this.DeserializeJson <T>(content)); } catch { Serilog.Log.Verbose("Failedt to deserialize as json content"); } try { return(this.DeserializeXml <T>(content)); } catch { Serilog.Log.Verbose("Failedt to deserialize as xml content"); } } //return base.Deserialize<T>(content, response, new ResponseDeserializerInfo()); break; } throw new ArgumentException($"Response was not JSON or XML (Content Type: {response.Content.Headers.ContentType.MediaType})"); }
public async Task PostCompletedTradeToGroup() { var deserializer = new JsonResponseDeserializer(); var info = new ResponseDeserializerInfo(); var tradeRes = await _mfl.GetRecentTrade(); var strForBot = ""; var jsonString = await tradeRes.Content.ReadAsStringAsync(); var owner1 = ""; var owner2 = ""; var assets1 = ""; var assets2 = ""; try { //Single var tradeSingle = deserializer.Deserialize <TradeTransactionSingle>(jsonString, tradeRes, info) .transactions.transaction; DateTime tenMinAgo = DateTime.Now.AddMinutes(-11); var tradeTime = DateTimeOffset.FromUnixTimeSeconds(Int64.Parse(tradeSingle.timestamp)); // check if trade was not in the last 10 minutes to bail early if (tradeTime < tenMinAgo) { return; } owners.TryGetValue(Int32.Parse(tradeSingle.franchise), out owner1); owners.TryGetValue(Int32.Parse(tradeSingle.franchise2), out owner2); strForBot += $"{_rumor.GetSources()}{owner1} and {owner2} have completed a trade. \n"; var multiplePlayers1 = _rumor.CheckForMultiplePlayers(tradeSingle.franchise1_gave_up); var multiplePlayers2 = _rumor.CheckForMultiplePlayers(tradeSingle.franchise2_gave_up); assets1 = multiplePlayers1 ? await _rumor.ListTradeInfoWithMultiplePlayers(tradeSingle.franchise1_gave_up) : await _rumor.ListTradeInfoWithSinglePlayer(tradeSingle.franchise1_gave_up); assets2 = multiplePlayers2 ? await _rumor.ListTradeInfoWithMultiplePlayers(tradeSingle.franchise2_gave_up) : await _rumor.ListTradeInfoWithSinglePlayer(tradeSingle.franchise2_gave_up); strForBot += $"{owner1} sends: \n{assets1} \n{owner2} sends: \n{assets2}"; await BotPost(strForBot); return; } catch (Exception e) { Console.WriteLine("not a single trade"); } try { //Multiple var multiTrade = deserializer.Deserialize <TradeTransactionMulti>(jsonString, tradeRes, info) .transactions.transaction; var tenMinAgo = DateTime.Now.AddMinutes(-11); foreach (var trade in multiTrade) { var tradeTime = DateTimeOffset.FromUnixTimeSeconds(Int64.Parse(trade.timestamp)); // check if trade was not in the last 10 minutes to bail early if (tradeTime >= tenMinAgo) { owners.TryGetValue(Int32.Parse(trade.franchise), out owner1); owners.TryGetValue(Int32.Parse(trade.franchise2), out owner2); strForBot += $"{_rumor.GetSources()}{owner1} and {owner2} have completed a trade. \n"; var multiplePlayers1 = _rumor.CheckForMultiplePlayers(trade.franchise1_gave_up); var multiplePlayers2 = _rumor.CheckForMultiplePlayers(trade.franchise2_gave_up); assets1 = multiplePlayers1 ? await _rumor.ListTradeInfoWithMultiplePlayers(trade.franchise1_gave_up) : await _rumor.ListTradeInfoWithSinglePlayer(trade.franchise1_gave_up); assets2 = multiplePlayers2 ? await _rumor.ListTradeInfoWithMultiplePlayers(trade.franchise2_gave_up) : await _rumor.ListTradeInfoWithSinglePlayer(trade.franchise2_gave_up); strForBot += $"{owner1} sends: \n{assets1} \n{owner2} sends: \n{assets2}"; await BotPost(strForBot); } } } catch (Exception e) { Console.WriteLine("not a multi trade"); } }
public override T Deserialize <T>(string content, HttpResponseMessage response, ResponseDeserializerInfo info) => _serializer.ReadUtf16 <T>(content); // TODO: Why is this not bytes?
public async Task PostTradeRumor() { var deserializer = new JsonResponseDeserializer(); var info = new ResponseDeserializerInfo(); var res = await _mfl.GetTradeBait(); var strForBot = ""; var jsonString = await res.Content.ReadAsStringAsync(); try { var tradeBait = deserializer.Deserialize <TradeBaitParent>(jsonString, res, info).tradeBaits.tradeBait; strForBot += _rumor.GetSources(); owners.TryGetValue(Int32.Parse(tradeBait.franchise_id), out var ownerName); strForBot += $"{ownerName} "; // check if this is a new post or not. var postDate = DateTimeOffset.FromUnixTimeSeconds(Convert.ToInt64(tradeBait.timestamp)); if (postDate < DateTime.Now.AddMinutes(-11)) { return; } // add verbiage strForBot += _rumor.AddBaitAction(); var hasEarlyPicks = _rumor.CheckForFirstRounders(tradeBait.willGiveUp); var multiplePlayers = _rumor.CheckForMultiplePlayers(tradeBait.willGiveUp); if (multiplePlayers) { var players = (await _mfl.GetPlayersDetails(tradeBait.willGiveUp)).players.player; strForBot += _rumor.ListPlayers(players, hasEarlyPicks); } else { var player = (await _mfl.GetPlayerDetails(tradeBait.willGiveUp)).players.player; strForBot += _rumor.ListPlayer(player, hasEarlyPicks); } await BotPost(strForBot); return; } catch (Exception e) { Console.WriteLine("not a single trade"); } try { var tradeBaits = deserializer.Deserialize <TradeBaitsParent>(jsonString, res, info).tradeBaits.tradeBait; foreach (var post in tradeBaits) { var postDate = DateTimeOffset.FromUnixTimeSeconds(Convert.ToInt64(post.timestamp)); if (postDate > DateTime.Now.AddDays(-1)) { strForBot += _rumor.GetSources(); owners.TryGetValue(Int32.Parse(post.franchise_id), out var ownerName); strForBot += $"{ownerName} "; strForBot += _rumor.AddBaitAction(); // add verbage var hasEarlyPicks = _rumor.CheckForFirstRounders(post.willGiveUp); if (_rumor.CheckForMultiplePlayers(post.willGiveUp)) { var players = (await _mfl.GetPlayersDetails(post.willGiveUp)).players.player; strForBot += _rumor.ListPlayers(players, hasEarlyPicks); } else { var player = (await _mfl.GetPlayerDetails(post.willGiveUp)).players.player; strForBot += _rumor.ListPlayer(player, hasEarlyPicks); } await BotPost(strForBot); } } } catch (Exception e) { Console.WriteLine("not a multi trade"); } }
/// <summary> /// Deserializes a successful response /// </summary> /// <param name="content"></param> /// <param name="response"></param> /// <param name="info"></param> /// <typeparam name="T"></typeparam> /// <returns></returns> public virtual T DeserializeSuccessfulResult <T>(string content, HttpResponseMessage response, ResponseDeserializerInfo info) { return(base.Deserialize <T>(content, response, info)); }
public override T Deserialize <T>(string content, HttpResponseMessage response, ResponseDeserializerInfo info) { switch (response.Content.Headers.ContentType.MediaType) { case "application/json": return(DeserializeJson <T>(content)); case "application/xml": case "application/atom+xml": return(DeserializeXml <T>(content)); } throw new ArgumentException("Response was not JSON or XML"); }