471 lines
20 KiB
C#
471 lines
20 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Concurrent;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Http;
|
|
using System.Net.Http.Headers;
|
|
using System.Threading.Tasks;
|
|
using Newtonsoft.Json;
|
|
using Core.Main;
|
|
using Core.Helper;
|
|
using Core.Main.DataObjects.PTMagicData;
|
|
|
|
namespace Core.MarketAnalyzer
|
|
{
|
|
public class BaseAnalyzer
|
|
{
|
|
public static string GetJsonStringFromURL(string url, LogHelper log, (string header, string value)[] headers = null)
|
|
{
|
|
HttpClient webClient = null;
|
|
if (webClient == null)
|
|
{
|
|
webClient = new HttpClient();
|
|
|
|
// Setup the one time conneciton characteristics
|
|
webClient.Timeout = new TimeSpan(0, 0, 30); // 30 second call timeout
|
|
webClient.DefaultRequestHeaders.ConnectionClose = false; // Keep alives
|
|
}
|
|
else
|
|
{
|
|
webClient.DefaultRequestHeaders.Clear();
|
|
}
|
|
|
|
// Accept JSON and Text
|
|
webClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
|
|
webClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("text/plain"));
|
|
|
|
// Setup the keep alive timeout
|
|
ServicePointManager.FindServicePoint(new Uri(url)).ConnectionLeaseTimeout = 300000; // 5 mins for keep alives
|
|
|
|
// Add any custom headers
|
|
if (headers != null)
|
|
{
|
|
foreach (var header in headers)
|
|
{
|
|
webClient.DefaultRequestHeaders.Add(header.header, header.value);
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
// log.DoLogInfo("Calling URL: " + url);
|
|
var response = webClient.GetAsync(url).Result;
|
|
string repsonseString = response.Content.ReadAsStringAsync().Result;
|
|
if (response.IsSuccessStatusCode)
|
|
{
|
|
return repsonseString;
|
|
}
|
|
else
|
|
{
|
|
// Error
|
|
var message = string.Format("Error whilst calling {0} - {1}", url, repsonseString);
|
|
log.DoLogError(message);
|
|
throw new Exception(message);
|
|
}
|
|
}
|
|
catch (TaskCanceledException tcEx)
|
|
{
|
|
// Conneciton timeout
|
|
log.DoLogError(string.Format("Timeout whilst calling {0} - {1}", url, tcEx.Message));
|
|
throw;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.DoLogError(string.Format("Error whilst calling {0} \nError: {1}", url, ex.Message));
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public static Dictionary<string, dynamic> GetJsonFromURL(string url, LogHelper log, (string header, string value)[] headers = null)
|
|
{
|
|
Dictionary<string, dynamic> jsonObject = null;
|
|
string jsonString = GetJsonStringFromURL(url, log, headers);
|
|
|
|
// Convert the response to JSON
|
|
jsonObject = JsonConvert.DeserializeObject<Dictionary<string, dynamic>>(jsonString);
|
|
return jsonObject;
|
|
}
|
|
|
|
public static Newtonsoft.Json.Linq.JObject GetSimpleJsonObjectFromURL(string url, LogHelper log, (string header, string value)[] headers = null)
|
|
{
|
|
Newtonsoft.Json.Linq.JObject jsonObject = null;
|
|
string jsonString = GetJsonStringFromURL(url, log, headers);
|
|
jsonObject = JsonConvert.DeserializeObject<Newtonsoft.Json.Linq.JObject>(jsonString);
|
|
return jsonObject;
|
|
}
|
|
|
|
public static List<dynamic> GetSimpleJsonListFromURL(string url, LogHelper log)
|
|
{
|
|
List<dynamic> jsonObject = null;
|
|
string jsonString = GetJsonStringFromURL(url, log, null);
|
|
jsonObject = JsonConvert.DeserializeObject<List<dynamic>>(jsonString);
|
|
return jsonObject;
|
|
}
|
|
|
|
public static Newtonsoft.Json.Linq.JArray GetSimpleJsonArrayFromURL(string url, LogHelper log)
|
|
{
|
|
Newtonsoft.Json.Linq.JArray jsonObject = null;
|
|
string jsonString = GetJsonStringFromURL(url, log, null);
|
|
jsonObject = JsonConvert.DeserializeObject<Newtonsoft.Json.Linq.JArray>(jsonString);
|
|
return jsonObject;
|
|
}
|
|
|
|
public static string GetLatestGitHubRelease(LogHelper log, string defaultVersion)
|
|
{
|
|
string result = defaultVersion;
|
|
|
|
try
|
|
{
|
|
string baseUrl = "https://api.github.com/repos/PTMagicians/PTMagic/releases/latest";
|
|
|
|
Newtonsoft.Json.Linq.JObject jsonObject = GetSimpleJsonObjectFromURL(baseUrl, log, new (string header, string value)[] { ("User-Agent", "PTMagic.Import") });
|
|
if (jsonObject != null)
|
|
{
|
|
result = jsonObject.GetValue("tag_name").ToString();
|
|
}
|
|
}
|
|
catch (WebException ex)
|
|
{
|
|
log.DoLogDebug("GitHub version check error: " + ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.DoLogDebug("GitHub version check error: " + ex.Message);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static double GetMainFiatCurrencyRate(string currency, string FreeCurrencyAPI, LogHelper log)
|
|
{
|
|
double result = 1;
|
|
string baseUrl = "http://free.currencyconverterapi.com/api/v5/convert?q=USD_" + currency + "&compact=y&apiKey=" + FreeCurrencyAPI;
|
|
|
|
log.DoLogDebug("http://free.currencyconverterapi.com - Getting latest exchange rates...");
|
|
Newtonsoft.Json.Linq.JObject jsonObject = GetSimpleJsonObjectFromURL(baseUrl, log, null);
|
|
if (jsonObject != null)
|
|
{
|
|
log.DoLogDebug("http://free.currencyconverterapi.com - Received latest exchange rates.");
|
|
|
|
result = (double)jsonObject["USD_" + currency]["val"];
|
|
log.DoLogInfo("http://free.currencyconverterapi.com - Latest exchange rate for USD to " + currency + " is " + result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static ConcurrentDictionary<string, MarketInfo> GetMarketInfosFromFile(PTMagicConfiguration systemConfiguration, LogHelper log)
|
|
{
|
|
ConcurrentDictionary<string, MarketInfo> result = new ConcurrentDictionary<string, MarketInfo>();
|
|
|
|
string marketInfoFilePath = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar + Constants.PTMagicPathData + Path.DirectorySeparatorChar + Constants.PTMagicPathExchange + Path.DirectorySeparatorChar + "MarketInfo.json";
|
|
if (File.Exists(marketInfoFilePath))
|
|
{
|
|
try
|
|
{
|
|
result = JsonConvert.DeserializeObject<ConcurrentDictionary<string, MarketInfo>>(System.IO.File.ReadAllText(marketInfoFilePath));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.DoLogDebug(ex.Message);
|
|
}
|
|
}
|
|
if (result == null)
|
|
{
|
|
result = new ConcurrentDictionary<string, MarketInfo>();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static void SaveMarketInfosToFile(ConcurrentDictionary<string, MarketInfo> marketInfos, PTMagicConfiguration systemConfiguration, LogHelper log)
|
|
{
|
|
FileHelper.WriteTextToFile(Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar + Constants.PTMagicPathData + Path.DirectorySeparatorChar + Constants.PTMagicPathExchange + Path.DirectorySeparatorChar, "MarketInfo.json", JsonConvert.SerializeObject(marketInfos));
|
|
}
|
|
|
|
public static Dictionary<string, Market> GetMarketDataFromFile(PTMagicConfiguration systemConfiguration, LogHelper log, string platform, DateTime maxDateTime, string marketCaption)
|
|
{
|
|
Dictionary<string, Market> result = new Dictionary<string, Market>();
|
|
DirectoryInfo dataDirectory = new DirectoryInfo(Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar + Constants.PTMagicPathData + Path.DirectorySeparatorChar + platform + Path.DirectorySeparatorChar);
|
|
|
|
// Get market files older than max datetime in descending order (newest file up top)
|
|
List<FileInfo> marketFiles = dataDirectory.EnumerateFiles("MarketData*")
|
|
.Select(x => { x.Refresh(); return x; })
|
|
.Where(x => x.LastWriteTimeUtc <= maxDateTime)
|
|
.ToArray().OrderByDescending(f => f.LastWriteTimeUtc).ToList();
|
|
|
|
FileInfo marketFile = null;
|
|
if (marketFiles.Count > 0)
|
|
{
|
|
marketFile = marketFiles.First();
|
|
|
|
log.DoLogDebug(platform + " - " + marketCaption + " market data loaded (" + marketFile.LastWriteTimeUtc.ToString() + ")");
|
|
}
|
|
else
|
|
{
|
|
log.DoLogDebug(platform + " - Not able to load " + marketCaption + " market data. Loading next youngest market file instead.");
|
|
|
|
// Get market files younger than max datetime in ascending order (oldest file up top)
|
|
marketFiles = dataDirectory.EnumerateFiles("MarketData*")
|
|
.Select(x => { x.Refresh(); return x; })
|
|
.Where(x => x.LastWriteTimeUtc >= maxDateTime)
|
|
.ToArray().OrderBy(f => f.LastWriteTimeUtc).ToList();
|
|
if (marketFiles.Count > 0)
|
|
{
|
|
marketFile = marketFiles.First();
|
|
log.DoLogDebug(platform + " - " + marketCaption + " market data loaded (" + marketFile.LastWriteTimeUtc.ToString() + ")");
|
|
}
|
|
}
|
|
try
|
|
{
|
|
// Get JSON object
|
|
result = JsonConvert.DeserializeObject<Dictionary<string, Market>>(marketFile.OpenText().ReadToEnd());
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.DoLogCritical(ex.Message, ex);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static Dictionary<string, List<MarketTrendChange>> BuildMarketTrends(string platform, string mainMarket, List<string> marketList, string sortBy, bool isGlobal, Dictionary<string, List<MarketTrendChange>> output, PTMagicConfiguration systemConfiguration, LogHelper log)
|
|
{
|
|
|
|
try
|
|
{
|
|
List<MarketTrend> marketTrends = systemConfiguration.AnalyzerSettings.MarketAnalyzer.MarketTrends.FindAll(mt => mt.Platform.Equals(platform, StringComparison.InvariantCultureIgnoreCase));
|
|
if (marketTrends.Count > 0)
|
|
{
|
|
Dictionary<string, Market> recentMarkets = BaseAnalyzer.GetMarketDataFromFile(systemConfiguration, log, platform, DateTime.UtcNow, "Recent");
|
|
|
|
foreach (MarketTrend marketTrend in marketTrends)
|
|
{
|
|
if (platform.Equals("Exchange", StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
log.DoLogInfo(platform + " - Building market trend changes for '" + marketTrend.Name + "' on main market '" + mainMarket + "' with " + marketList.Count.ToString() + " markets...");
|
|
}
|
|
else
|
|
{
|
|
log.DoLogInfo(platform + " - Building market trend changes for '" + marketTrend.Name + "'...");
|
|
}
|
|
|
|
Dictionary<string, Market> trendMarkets = BaseAnalyzer.GetMarketDataFromFile(systemConfiguration, log, platform, DateTime.UtcNow.AddMinutes(-marketTrend.TrendMinutes), marketTrend.Name);
|
|
|
|
List<MarketTrendChange> marketTrendChanges = BaseAnalyzer.GetMarketTrendChanges(platform, mainMarket, marketTrend, marketList, recentMarkets, trendMarkets, sortBy, isGlobal, systemConfiguration, log);
|
|
|
|
output.Add(marketTrend.Name, marketTrendChanges);
|
|
|
|
log.DoLogInfo(platform + " - " + marketTrendChanges.Count.ToString() + " Market trend changes built for '" + marketTrend.Name + "'.");
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.DoLogCritical(ex.Message, ex);
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
public static List<MarketTrendChange> GetMarketTrendChanges(
|
|
string platform,
|
|
string mainMarket,
|
|
MarketTrend marketTrend,
|
|
List<string> marketList,
|
|
Dictionary<string, Market> recentMarkets,
|
|
Dictionary<string, Market> trendMarkets,
|
|
string sortBy,
|
|
bool isGlobal,
|
|
PTMagicConfiguration systemConfiguration,
|
|
LogHelper log)
|
|
{
|
|
List<MarketTrendChange> result = new List<MarketTrendChange>();
|
|
|
|
var sortedMarkets = new SortedDictionary<string, Market>(recentMarkets).OrderBy(m => m.Value.Position);
|
|
if (sortBy.Equals("Volume"))
|
|
{
|
|
sortedMarkets = new SortedDictionary<string, Market>(recentMarkets).OrderByDescending(m => m.Value.Volume24h);
|
|
}
|
|
int marketCount = 1;
|
|
foreach (KeyValuePair<string, Market> recentMarketPair in sortedMarkets)
|
|
{
|
|
if (marketList.Count == 0 || marketList.Contains(recentMarketPair.Key))
|
|
{
|
|
bool excludeMainCurrency = systemConfiguration.AnalyzerSettings.MarketAnalyzer.ExcludeMainCurrency;
|
|
if (!marketTrend.ExcludeMainCurrency)
|
|
{
|
|
excludeMainCurrency = marketTrend.ExcludeMainCurrency;
|
|
}
|
|
|
|
if (platform.Equals("CoinMarketCap", StringComparison.InvariantCulture) && excludeMainCurrency)
|
|
{
|
|
// Check if this is the main currency (only for CoinMarketCap)
|
|
if (recentMarketPair.Value.Symbol.Equals(mainMarket, StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
|
|
// If the current market is the main currency, skip it
|
|
continue;
|
|
}
|
|
}
|
|
|
|
Market recentMarket;
|
|
string market = recentMarketPair.Value.Symbol.Replace(mainMarket, "");
|
|
string exchange = systemConfiguration.GeneralSettings.Application.Exchange.ToLower();
|
|
switch (exchange)
|
|
{
|
|
case "bittrex":
|
|
market = market.Replace("-", "");
|
|
break;
|
|
case "poloniex":
|
|
market = market.Replace("_", "");
|
|
break;
|
|
}
|
|
if (recentMarkets.TryGetValue(recentMarketPair.Key, out recentMarket))
|
|
{
|
|
// Strip main markets from lists, if exists
|
|
string ignored = marketTrend.IgnoredMarkets.ToUpper();
|
|
ignored = ignored.Replace(mainMarket, "");
|
|
switch (exchange)
|
|
{
|
|
case "bittrex":
|
|
ignored = ignored.Replace("-", "");
|
|
break;
|
|
case "poloniex":
|
|
ignored = ignored.Replace("_", "");
|
|
break;
|
|
}
|
|
List<string> ignoredMarkets = SystemHelper.ConvertTokenStringToList(ignored, ",");
|
|
if (ignoredMarkets.Contains(market))
|
|
{
|
|
log.DoLogDebug(platform + " - Market trend '" + marketTrend.Name + "' for '" + recentMarketPair.Key + "' is ignored in this trend.");
|
|
continue;
|
|
}
|
|
// Strip main markets from lists, if exists
|
|
string allowed = marketTrend.AllowedMarkets.ToUpper();
|
|
allowed = allowed.Replace(mainMarket, "");
|
|
switch (exchange)
|
|
{
|
|
case "bittrex":
|
|
allowed = allowed.Replace("-", "");
|
|
break;
|
|
case "poloniex":
|
|
allowed = allowed.Replace("_", "");
|
|
break;
|
|
}
|
|
List<string> allowedMarkets = SystemHelper.ConvertTokenStringToList(allowed, ",");
|
|
if (allowedMarkets.Count > 0 && !allowedMarkets.Contains(market))
|
|
{
|
|
log.DoLogDebug(platform + " - Market trend '" + marketTrend.Name + "' for '" + recentMarketPair.Key + "' is not allowed in this trend.");
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No recent market data
|
|
log.DoLogDebug(platform + " - Market trend '" + marketTrend.Name + "' for '" + recentMarketPair.Key + "' has no recent market trend data.");
|
|
continue;
|
|
}
|
|
|
|
Market trendMarket;
|
|
if (trendMarkets.TryGetValue(recentMarketPair.Key, out trendMarket))
|
|
{
|
|
double recentMarketPrice = recentMarket.Price;
|
|
double trendMarketPrice = trendMarket.Price;
|
|
if (!platform.Equals("CoinMarketCap", StringComparison.InvariantCulture) && marketTrend.TrendCurrency.Equals("Fiat", StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
if (recentMarket.MainCurrencyPriceUSD > 0 && trendMarket.MainCurrencyPriceUSD > 0)
|
|
{
|
|
recentMarketPrice = recentMarketPrice * recentMarket.MainCurrencyPriceUSD;
|
|
trendMarketPrice = trendMarketPrice * trendMarket.MainCurrencyPriceUSD;
|
|
}
|
|
}
|
|
|
|
double trendMarketChange = (recentMarketPrice - trendMarketPrice) / trendMarketPrice * 100;
|
|
|
|
MarketTrendChange mtc = new MarketTrendChange();
|
|
mtc.MarketTrendName = marketTrend.Name;
|
|
mtc.TrendMinutes = marketTrend.TrendMinutes;
|
|
mtc.TrendChange = trendMarketChange;
|
|
mtc.Market = recentMarket.Name;
|
|
mtc.LastPrice = recentMarket.Price;
|
|
mtc.Volume24h = recentMarket.Volume24h;
|
|
mtc.TrendDateTime = DateTime.UtcNow;
|
|
|
|
result.Add(mtc);
|
|
log.DoLogDebug(platform + " - Market trend '" + marketTrend.Name + "' for '" + recentMarketPair.Key + "' (Vol. " + recentMarket.Volume24h.ToString("#,#0.00") + ") is " + trendMarketChange.ToString("#,#0.00") + "% in " + SystemHelper.GetProperDurationTime(marketTrend.TrendMinutes * 60).ToLower() + ".");
|
|
marketCount++;
|
|
}
|
|
else
|
|
{
|
|
// No data market trend data
|
|
log.DoLogDebug(platform + " - Market trend '" + marketTrend.Name + "' for '" + recentMarketPair.Key + "' has no market trend data.");
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
if (marketTrend.MaxMarkets > 0 && isGlobal)
|
|
{
|
|
int maxMarkets = (marketTrend.MaxMarkets <= result.Count) ? marketTrend.MaxMarkets : result.Count;
|
|
result = result.GetRange(0, maxMarkets);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static Dictionary<string, double> BuildGlobalMarketTrends(Dictionary<string, List<MarketTrendChange>> globalMarketTrendChanges, PTMagicConfiguration systemConfiguration, LogHelper log)
|
|
{
|
|
Dictionary<string, double> result = new Dictionary<string, double>();
|
|
|
|
List<MarketTrend> marketTrends = systemConfiguration.AnalyzerSettings.MarketAnalyzer.MarketTrends;
|
|
if (marketTrends.Count > 0)
|
|
{
|
|
foreach (MarketTrend marketTrend in marketTrends)
|
|
{
|
|
log.DoLogInfo("Building market trend average for '" + marketTrend.Name + "'");
|
|
if (globalMarketTrendChanges.ContainsKey(marketTrend.Name))
|
|
{
|
|
List<MarketTrendChange> marketTrendChanges = globalMarketTrendChanges[marketTrend.Name];
|
|
if (marketTrendChanges != null && marketTrendChanges.Count > 0)
|
|
{
|
|
double totalTrendChange = 0;
|
|
int trendsCount = marketTrendChanges.Count;
|
|
foreach (MarketTrendChange marketTrendChange in marketTrendChanges)
|
|
{
|
|
if (marketTrend.TrendThreshold != 0)
|
|
{
|
|
if ((marketTrendChange.TrendChange > marketTrend.TrendThreshold) || (marketTrendChange.TrendChange < (marketTrend.TrendThreshold * -1)))
|
|
{
|
|
log.DoLogInfo("Market trend '" + marketTrend.Name + "' is ignoring " + marketTrendChange.Market + " for exceeding TrendThreshold.");
|
|
trendsCount += -1;
|
|
}
|
|
else
|
|
{
|
|
totalTrendChange += marketTrendChange.TrendChange;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
totalTrendChange += marketTrendChange.TrendChange;
|
|
}
|
|
}
|
|
double averageTrendChange = totalTrendChange / trendsCount;
|
|
result.Add(marketTrend.Name, averageTrendChange);
|
|
log.DoLogInfo("Built average market trend change '" + marketTrend.Name + "' (" + averageTrendChange.ToString("#,#0.00") + "% in " + marketTrend.TrendMinutes.ToString() + " minutes) for " + marketTrendChanges.Count.ToString() + " markets.");
|
|
}
|
|
else
|
|
{
|
|
result.Add(marketTrend.Name, 0);
|
|
log.DoLogWarn("No market trend changes found for '" + marketTrend.Name + "' - returning 0%");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result.Add(marketTrend.Name, 0);
|
|
log.DoLogWarn("Market trend '" + marketTrend.Name + "' not found in globalMarketTrendChanges[] - returning 0%");
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
}
|