public static void TryBuildPayload()
{
if (IsSubscribed)
{
Current++;
if (Current >= Frequency)
{
Current = 0;
lock (LockObj)
{
Dictionary <string, string> items = new Dictionary <string, string>();
if (Global.State.AlgoTraderSubscriptions["main"] == true)
{
AlgoTraderMain main = new AlgoTraderMain();
main.CurrentTime = AlgoTraderState.CurrentTime.ToString();
main.SelectedSymbol = SelectedSymbol;
main.SelectedStrategyName = AlgoTraderMethods.GetStrategyName(SelectedStrategyId);
main.SelectedStrategyId = SelectedStrategyId;
using (var output = new StringWriter())
{
JSON.Serialize(main, output, Options.PrettyPrint);
items.Add("algoTraderMain", output.ToString());
}
}
if (Global.State.AlgoTraderSubscriptions["log"] == true)
{
UIObjects.AlgoTraderLog log = new UIObjects.AlgoTraderLog();
log.Log = Global.State.AlgoTrader.TC.Log.Read(Verbosity.Verbose);
//log.Log = System.Web.HttpUtility.JavaScriptStringEncode(Global.State.AlgoTrader.TC.Log.Read(Verbosity.Verbose));
using (var output = new StringWriter())
{
JSON.Serialize(log, output, Options.PrettyPrint);
items.Add("algoTraderLog", output.ToString());
}
}
if (Global.State.AlgoTraderSubscriptions["overview"] == true)
{
AlgoTraderOverview overview = buildOverviewObject();
using (var output = new StringWriter())
{
JSON.Serialize(overview, output, Options.PrettyPrint);
items.Add("algoTraderOverview", output.ToString());
}
}
if (Global.State.AlgoTraderSubscriptions["chart"] == true)
{
AlgoTraderChart chart = buildChartObject();
using (var output = new StringWriter())
{
JSON.Serialize(chart, output, Options.Default);
items.Add("algoTraderChart", output.ToString());
}
}
Payload = SerializerMethods.DictionarySerializedValuesToJSON(items);
}
}
}
}
public static AlgoTraderChart buildChartObject()
{
AlgoTraderChart result = new AlgoTraderChart();
if (
AlgoTraderShared.NodesData == null ||
!AlgoTraderShared.NodesData.ContainsKey(SelectedSymbol) ||
AlgoTraderShared.NodesData[SelectedSymbol] == null ||
AlgoTraderShared.NodesData[SelectedSymbol].Nodes == null ||
AlgoTraderShared.NodesData[SelectedSymbol].Nodes.Count == 0 ||
AlgoTraderShared.NodesData[SelectedSymbol].Nodes.Count < (GraphCanvasWidth) + 500
)
{
return(result);
}
int lastNodeIndex = AlgoTraderShared.NodesData[SelectedSymbol].Nodes.Count - 1;
int startNodeIndex = (lastNodeIndex - (GraphCanvasWidth)) + 1;
decimal midPrice = AlgoTraderShared.NodesData[SelectedSymbol].Nodes[lastNodeIndex].TradePrice;
decimal askPrice = AlgoTraderShared.NodesData[SelectedSymbol].Nodes[lastNodeIndex].AskPrice;
decimal bidPrice = AlgoTraderShared.NodesData[SelectedSymbol].Nodes[lastNodeIndex].BidPrice;
result.CurrentTradePrice = UC.DecimalToUSD(midPrice, 2);
result.CurrentAskPrice = UC.DecimalToUSD(askPrice, 2);
result.CurrentBidPrice = UC.DecimalToUSD(bidPrice, 2);
//decimal highPrice = midPrice + 0.20M;
//decimal lowPrice = midPrice - 0.20M;
decimal highPrice = midPrice + 0.8M;
decimal lowPrice = midPrice - 0.8M;
decimal priceSpan = highPrice - lowPrice;
// high price plot is 0
// low price plot is GraphCanvasHeight
result.Data.Add(new List <AlgoTraderChartPoint>()); // tradeprice
result.Data.Add(new List <AlgoTraderChartPoint>()); // ask price
result.Data.Add(new List <AlgoTraderChartPoint>()); // bid price
//int count = 0;
decimal askPriceYAvgLast = 0M;
decimal bidPriceYAvgLast = 0M;
decimal tradePriceYAvgLast = 0M;
for (int n = startNodeIndex; n <= lastNodeIndex; n += 1)
{
decimal askPriceYAvg = 0M;
decimal bidPriceYAvg = 0M;
decimal tradePriceYAvg = 0M;
int count = 0;
bool askEstimated = false;
bool bidEstimated = false;
bool tradeEstimated = false;
for (int m = 0; m < 1; m++)
{
if (n + m < AlgoTraderShared.NodesData[SelectedSymbol].Nodes.Count)
{
Node node = AlgoTraderShared.NodesData[SelectedSymbol].Nodes[n + m];
if (node.AskPriceEstimated)
{
askEstimated = true;
}
if (node.BidPriceEstimated)
{
bidEstimated = true;
}
if (node.TradePriceEstimated)
{
tradeEstimated = true;
}
askPriceYAvg += ((highPrice - node.AskPrice) / priceSpan) * GraphCanvasHeight;
bidPriceYAvg += ((highPrice - node.BidPrice) / priceSpan) * GraphCanvasHeight;
tradePriceYAvg += ((highPrice - node.TradePrice) / priceSpan) * GraphCanvasHeight;
count++;
}
}
askPriceYAvg = askPriceYAvg / count;
bidPriceYAvg = bidPriceYAvg / count;
tradePriceYAvg = tradePriceYAvg / count;
AlgoTraderChartPoint ask_atcp = new AlgoTraderChartPoint();
AlgoTraderChartPoint bid_atcp = new AlgoTraderChartPoint();
AlgoTraderChartPoint trade_atcp = new AlgoTraderChartPoint();
ask_atcp.Y = askPriceYAvg;
bid_atcp.Y = bidPriceYAvg;
trade_atcp.Y = tradePriceYAvg;
if (askPriceYAvg < askPriceYAvgLast)
{
ask_atcp.R = 1D;
ask_atcp.G = 0D;
ask_atcp.B = 0D;
}
else if (askPriceYAvg > askPriceYAvgLast)
{
ask_atcp.R = 1D;
ask_atcp.G = 0D;
ask_atcp.B = 0D;
}
else
{
ask_atcp.R = 1D;
ask_atcp.G = 0D;
ask_atcp.B = 0D;
}
if (askEstimated)
{
//ask_atcp.R = 0.4D;
ask_atcp.A = 0.15D;
}
else
{
ask_atcp.A = 1D;
}
if (bidPriceYAvg < bidPriceYAvgLast)
{
bid_atcp.R = 0D;
bid_atcp.G = 0D;
bid_atcp.B = 1D;
}
else if (bidPriceYAvg > bidPriceYAvgLast)
{
bid_atcp.R = 0D;
bid_atcp.G = 0D;
bid_atcp.B = 1D;
}
else
{
bid_atcp.R = 0D;
bid_atcp.G = 0D;
bid_atcp.B = 1D;
}
if (bidEstimated)
{
//bid_atcp.B = 0.4D;
bid_atcp.A = 0.15D;
}
else
{
bid_atcp.A = 1D;
}
if (tradePriceYAvg < tradePriceYAvgLast)
{
trade_atcp.R = 0D;
trade_atcp.G = 1D;
trade_atcp.B = 0D;
}
else if (tradePriceYAvg > tradePriceYAvgLast)
{
trade_atcp.R = 0D;
trade_atcp.G = 1D;
trade_atcp.B = 0D;
}
else
{
trade_atcp.R = 0D;
trade_atcp.G = 1D;
trade_atcp.B = 0D;
}
if (tradeEstimated)
{
//bid_atcp.G = 0.4D;
trade_atcp.A = 0.15D;
}
else
{
trade_atcp.A = 1D;
}
askPriceYAvgLast = askPriceYAvg;
bidPriceYAvgLast = bidPriceYAvg;
tradePriceYAvgLast = tradePriceYAvg;
result.Data[0].Add(trade_atcp);
result.Data[1].Add(ask_atcp);
result.Data[2].Add(bid_atcp);
}
return(result);
//long lastEndNano = AlgoTraderShared.NodesData[SelectedSymbol].Nodes[lastNodeIndex].EndNano;
//long chartTimeSpan = AlgoTraderShared.NodesData[SelectedSymbol].GetNodesWithNanos
}