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");
}
