public static void PullTickerHistoryRecent(CurrencyPair pair)
{
if (!AllowTickerUpdate)
{
return;
}
if (tickerData == null)
{
tickerData = new TSList <TSList <TickerChangedEventArgs> >();
}
allowUpdatePairs = new List <CurrencyPair>();
List <PoloniexAPI.MarketTools.ITrade> trades = WebApiCustom.GetTrades(pair);
if (trades != null)
{
TickerChangedEventArgs[] fakeTickers = new TickerChangedEventArgs[trades.Count];
for (int i = 0; i < trades.Count; i++)
{
MarketData md = new MarketData(trades[i].PricePerCoin);
TickerChangedEventArgs ticker = new TickerChangedEventArgs(pair, md);
fakeTickers[i] = ticker;
}
TSList <TickerChangedEventArgs> tickerList = new TSList <TickerChangedEventArgs>(fakeTickers);
tickerList.Sort();
tickerData.Add(tickerList);
allowUpdatePairs.Add(pair);
}
}
public static void AddTickerData(TickerChangedEventArgs ticker, bool ignoreTimeFilter = false)
{
if (!AllowTickerUpdate)
{
return;
}
if (allowUpdatePairs == null)
{
return;
}
if (!allowUpdatePairs.Contains(ticker.CurrencyPair))
{
return;
}
int storeTime;
lock (TickerStoreTime) {
if (!TickerStoreTime.TryGetValue(ticker.CurrencyPair, out storeTime))
{
storeTime = TickerStoreTimeDefault;
}
}
long deleteTime = ticker.Timestamp - storeTime;
lock (tickerData) {
for (int i = 0; i < tickerData.Count; i++)
{
if (tickerData[i] == null)
{
continue;
}
if (tickerData[i].Count == 0)
{
continue;
}
if (tickerData[i][0].CurrencyPair == ticker.CurrencyPair)
{
while (tickerData[i][0].Timestamp < deleteTime)
{
tickerData[i].First().Dispose();
tickerData[i].RemoveAt(0);
}
if (!ignoreTimeFilter && ticker.Timestamp - tickerData[i].Last().Timestamp < 5)
{
return;
}
tickerData[i].Add(ticker);
Trading.Manager.NotifyTickerUpdate(ticker.CurrencyPair);
return;
}
}
TSList <TickerChangedEventArgs> list = new TSList <TickerChangedEventArgs>();
list.Add(ticker);
tickerData.Add(list);
Trading.Manager.NotifyTickerUpdate(ticker.CurrencyPair);
}
}
public static void Initialize()
{
if (!Directory.Exists(FolderName))
{
Directory.CreateDirectory(FolderName);
}
NetMessages = new TSList <MessageTypes.NetMessage>();
ErrorMessages = new TSList <MessageTypes.ErrorMessage>();
BasicMessages = new TSList <MessageTypes.Message>();
}
private static void InitializeDatabase()
{
database = new TSList <T>(Provider.GetAllObjects <T>());
database.ForEach((x) =>
{
UnifiedSystem.HandleObjectCreation <T>(x);
});
loaded = true;
}
public TPManager(CurrencyPair pair, Strategies.Strategy strategy)
{
this.pair = pair;
invokeQueue = new TSList <InvokePair>();
if (pair.BaseCurrency == "USDT" && pair.QuoteCurrency == "BTC")
{
strategy = new Strategies.BaseTrendMonitor(pair);
}
else
{
this.strategy = strategy;
}
}
public void ThreadSafeToArrayTest()
{
var l = new TSList <int>(Enumerable.Range(1, _testRange));
for (var i = 0; i < 10; i++)
{
var t = new Thread(DummyEnumerator);
t.Start(l);
}
for (var i = 0; i < 10; i++)
{
l.ToArray();
}
}
public void ThreadSafeFindTest()
{
var l = new TSList<int>(Enumerable.Range(1, _testRange));
for (var i = 0; i < 10; i++)
{
var t = new Thread(DummyEnumerator);
t.Start(l);
}
for (var i = 0; i < 10; i++)
{
l.Find(y => y == 10);
}
}
public void ThreadSafeFindTest()
{
var l = new TSList <int>(Enumerable.Range(1, _testRange));
for (var i = 0; i < 10; i++)
{
var t = new Thread(DummyEnumerator);
t.Start(l);
}
for (var i = 0; i < 10; i++)
{
l.Find(y => y == 10);
}
}
public void ThreadSafeTrimExcessTest()
{
var l = new TSList <int>(Enumerable.Range(1, _testRange));
for (var i = 0; i < 10; i++)
{
var t = new Thread(DummyEnumerator);
t.Start(l);
}
for (var i = 0; i < 10; i++)
{
l.TrimExcess();
l.AddRange(Enumerable.Range(1, _testRange / 2));
}
}
public TPManager(CurrencyPair pair)
{
this.pair = pair;
invokeQueue = new TSList <InvokePair>();
switch (pair.BaseCurrency)
{
case "USDT":
strategy = new Strategies.BaseTrendMonitor(pair);
break;
default:
strategy = new Strategies.MeanRevADX(pair);
break;
}
}
public void ThreadSafeIndexOfTest()
{
var l = new TSList <int>(Enumerable.Range(1, _testRange));
for (var i = 0; i < 10; i++)
{
var t = new Thread(DummyEnumerator);
t.Start(l);
}
for (var i = 1; i < 10; i++)
{
var x = l.IndexOf(i);
Assert.AreEqual(i, l[x]);
}
}
public void ThreadSafeIndexOfTest()
{
var l = new TSList<int>(Enumerable.Range(1, _testRange));
for (var i = 0; i < 10; i++)
{
var t = new Thread(DummyEnumerator);
t.Start(l);
}
for (var i = 1; i < 10; i++)
{
var x = l.IndexOf(i);
Assert.AreEqual(i, l[x]);
}
}
public void ThreadSafeIndexerTest()
{
var l = new TSList <int>(Enumerable.Range(1, _testRange));
for (var i = 0; i < 10; i++)
{
var t = new Thread(DummyEnumerator);
t.Start(l);
}
for (var i = 0; i < 10; i++)
{
var x = l[i];
l[i] = x + 1;
Assert.AreEqual(x + 1, l[i]);
}
}
public static void LoadMessagesFromFiles()
{
if (BasicMessages == null)
{
BasicMessages = new TSList <MessageTypes.Message>();
}
if (ErrorMessages == null)
{
ErrorMessages = new TSList <MessageTypes.ErrorMessage>();
}
BasicMessages.Clear();
ErrorMessages.Clear();
string filePathBasic = FolderName + "/" + FilenameGenericLog;
string filePathError = FolderName + "/" + FilenameErrorLog;
// load basic messages
try {
string[] lines = Utility.FileManager.ReadFile(filePathBasic);
for (int i = 0; i < lines.Length; i++)
{
MessageTypes.Message m = MessageTypes.Message.Parse(lines[i]);
BasicMessages.Add(m);
}
}
catch (Exception) { }
// load error messages
try {
string[] lines = Utility.FileManager.ReadFile(filePathError);
for (int i = 0; i < lines.Length; i++)
{
MessageTypes.ErrorMessage m = MessageTypes.ErrorMessage.Parse(lines[i]);
ErrorMessages.Add(m);
}
}
catch (Exception) { }
PoloniexBot.GUI.GUIManager.SetTradeHistoryMessages(BasicMessages, ErrorMessages);
}
public void ThreadSafeTrimExcessTest()
{
var l = new TSList<int>(Enumerable.Range(1, _testRange));
for (var i = 0; i < 10; i++)
{
var t = new Thread(DummyEnumerator);
t.Start(l);
}
for (var i = 0; i < 10; i++)
{
l.TrimExcess();
l.AddRange(Enumerable.Range(1, _testRange / 2));
}
}
public void ThreadSafeToArrayTest()
{
var l = new TSList<int>(Enumerable.Range(1, _testRange));
for (var i = 0; i < 10; i++)
{
var t = new Thread(DummyEnumerator);
t.Start(l);
}
for (var i = 0; i < 10; i++)
{
l.ToArray();
}
}
public static TSList <TSList <TickerChangedEventArgs> > LoadTradeData(bool addTickers = true)
{
CLI.Manager.PrintLog("Clearing trade pairs");
Trading.Manager.ClearAllPairs();
CLI.Manager.PrintLog("Clearing current ticker data");
if (allowUpdatePairs != null)
{
allowUpdatePairs.Clear();
}
if (tickerData == null)
{
tickerData = new TSList <TSList <TickerChangedEventArgs> >();
}
ClearTickerData();
CLI.Manager.PrintLog("Loading ticker data from file");
string[] lines = Utility.FileManager.ReadFile("data/ticker data");
if (lines == null || lines.Length == 0)
{
throw new Exception("Failed reading file - no lines returned");
}
TSList <TSList <TickerChangedEventArgs> > tickerStoreReference;
if (addTickers)
{
tickerStoreReference = tickerData;
}
else
{
tickerStoreReference = new TSList <TSList <TickerChangedEventArgs> >();
}
for (int i = 0; i < lines.Length; i++)
{
string[] parts = lines[i].Split(':');
CurrencyPair currPair = CurrencyPair.Parse(parts[0]);
long currTimestamp = long.Parse(parts[1]);
double currPrice = double.Parse(parts[2]);
double volume24Base = double.Parse(parts[3]);
TickerChangedEventArgs currTicker = new TickerChangedEventArgs(currPair, new MarketData(currPrice));
currTicker.Timestamp = currTimestamp;
currTicker.MarketData.Volume24HourBase = volume24Base;
if (allowUpdatePairs == null)
{
allowUpdatePairs = new List <CurrencyPair>();
}
if (!allowUpdatePairs.Contains(currPair))
{
allowUpdatePairs.Add(currPair);
}
// add to list
bool added = false;
for (int j = 0; j < tickerStoreReference.Count; j++)
{
if (tickerStoreReference[j][0].CurrencyPair == currPair)
{
tickerStoreReference[j].Add(currTicker);
added = true;
break;
}
}
if (!added)
{
tickerStoreReference.Add(new TSList <TickerChangedEventArgs>());
tickerStoreReference.Last().Add(currTicker);
}
}
CLI.Manager.PrintLog("Loading complete (" + lines.Length + " tickers)");
return(tickerStoreReference);
}
public static bool PullTickerHistory(CurrencyPair pair, long startTimestamp, long endTimestamp)
{
if (!AllowTickerUpdate)
{
return(false);
}
if (tickerData == null)
{
tickerData = new TSList <TSList <TickerChangedEventArgs> >();
}
if (allowUpdatePairs == null)
{
allowUpdatePairs = new List <CurrencyPair>();
}
// pull last trades
List <PoloniexAPI.MarketTools.ITrade> trades = new List <ITrade>();
int failedAttempts = 0;
while (true)
{
try {
List <PoloniexAPI.MarketTools.ITrade> temp = WebApiCustom.GetTrades(pair, (int)startTimestamp, (int)endTimestamp);
trades.AddRange(temp);
if (temp.Count < 300)
{
break;
}
endTimestamp = Utility.DateTimeHelper.DateTimeToUnixTimestamp(temp.Last().Time);
failedAttempts = 0;
ThreadManager.ReportAlive("Data.Store");
Thread.Sleep(1500);
}
catch (Exception e) {
// Console.WriteLine(e.Message + "\n" + e.StackTrace);
Console.WriteLine(pair + " - ERROR");
failedAttempts++;
if (failedAttempts >= 5)
{
return(false);
}
Thread.Sleep(4000);
}
}
// convert into fake tickers
if (trades.Count == 0)
{
return(false);
}
TickerChangedEventArgs[] fakeTickers = new TickerChangedEventArgs[trades.Count];
for (int j = 0; j < trades.Count; j++)
{
MarketData md = new MarketData(trades[j].PricePerCoin);
TickerChangedEventArgs ticker = new TickerChangedEventArgs(pair, md);
ticker.Timestamp = DateTimeHelper.DateTimeToUnixTimestamp(trades[j].Time);
fakeTickers[j] = ticker;
}
// dump them into ticker data
TSList <TickerChangedEventArgs> tickerList = new TSList <TickerChangedEventArgs>(fakeTickers);
tickerList.Sort();
tickerData.Add(tickerList);
allowUpdatePairs.Add(pair);
return(true);
}
public InMemoryFactsProvider(MolapHashTypes hashingType)
{
_hashingtype = hashingType;
_innerList = new TSList <FactsRow <T> >();
this.Init();
}
public static void SetTradeHistoryMessages(TSList <Utility.Log.MessageTypes.Message> basicMessages, TSList <Utility.Log.MessageTypes.ErrorMessage> errorMessages)
{
mainForm.tradeHistoryControl1.basicMessages = basicMessages;
mainForm.tradeHistoryControl1.errorMessages = errorMessages;
mainForm.tradeHistoryControl1.Invalidate();
}
// --------------------------
public static void UpdateTradeHistory(TSList <Utility.TradeTracker.TradeData> trades, TSList <Utility.TradeTracker.TradeData> doneTrades)
{
mainForm.tradeHistoryControl1.openPositions = trades;
mainForm.tradeHistoryControl1.closedPositions = doneTrades;
mainForm.tradeHistoryControl1.Invalidate();
}
public void ThreadSafeIndexerTest()
{
var l = new TSList<int>(Enumerable.Range(1, _testRange));
for (var i = 0; i < 10; i++)
{
var t = new Thread(DummyEnumerator);
t.Start(l);
}
for (var i = 0; i < 10; i++)
{
var x = l[i];
l[i] = x + 1;
Assert.AreEqual(x + 1, l[i]);
}
}
// ------------------------------------------
public static void BuildPatternDatabase()
{
if (Repo == null)
{
Repo = new List <KeyValuePair <CurrencyPair, List <Pattern> > >();
}
TSList <TSList <TickerChangedEventArgs> > allTickers = Data.Store.LoadTradeData(false);
if (allTickers == null)
{
return;
}
int minTime = Period * PeriodCount;
for (int i = 0; i < allTickers.Count; i++)
{
if (allTickers[i].Count == 0)
{
continue;
}
CurrencyPair currPair = allTickers[i].First().CurrencyPair;
long startTime = allTickers[i].First().Timestamp + minTime;
int startIndex = 0;
long lastTimestamp = 0;
for (int j = 0; j < allTickers[i].Count; j++)
{
long currTimestamp = allTickers[i][j].Timestamp;
if (currTimestamp > startTime)
{
break;
}
lastTimestamp = currTimestamp;
startIndex = j;
}
int endIndex = allTickers[i].Count - 1;
long endTime = allTickers[i][endIndex].Timestamp;
for (int j = endIndex; j >= 0; j--)
{
if (allTickers[i][j].Timestamp + Period < endTime)
{
break;
}
endIndex = j;
}
List <Pattern> repoList = null;
for (int j = 0; j < Repo.Count; j++)
{
if (currPair == Repo[j].Key)
{
repoList = Repo[j].Value;
break;
}
}
if (repoList == null)
{
repoList = new List <Pattern>();
Repo.Add(new KeyValuePair <CurrencyPair, List <Pattern> >(currPair, repoList));
}
for (int j = startIndex; j < endIndex; j++)
{
long currTimestamp = allTickers[i][j].Timestamp;
if (j % 1000 == 0)
{
float progress = ((float)j / endIndex) * 100;
Console.WriteLine("Progress: " + i + "/" + allTickers.Count + " - " + progress.ToString("F2") + "%");
}
if (currTimestamp < lastTimestamp + 300)
{
continue;
}
lastTimestamp = currTimestamp;
Pattern p = BuildPattern(allTickers[i].ToArray(), j, true);
repoList.Add(p);
}
SaveToFile();
}
}
