public void ToDataTable_Should_Ignore_Incompatible_Types_If_Specified()
{
var list = new List <DataTableItem>();
var item1 = new DataTableItem("1");
list.Add(item1);
var dataTable = list.ToDataTable(IncompatibleDataColumnTypeHandling.Ignore);
dataTable.Columns.Contains("IncompatibleValue").Should().BeFalse();
}
public void ToDataTable_Should_Use_AsString_On_Incompatible_Types_If_Specified()
{
var list = new List <DataTableItem>();
var item1 = new DataTableItem("1");
list.Add(item1);
var dataTable = list.ToDataTable(IncompatibleDataColumnTypeHandling.AsString);
dataTable.Rows[0]["IncompatibleValue"].Should().Be(DBNull.Value);
}
public void ToDataTable_Overload_Should_Use_ToString_On_Incompatible_Types()
{
var list = new List <DataTableItem>();
var item1 = new DataTableItem("1");
list.Add(item1);
var dataTable = list.ToDataTable(CultureInfo.CurrentCulture);
dataTable.Rows[0]["IncompatibleValue"].Should().Be("ToStringWasUsed");
}
public void ToDataTable_Should_Use_ToString_On_Incompatible_Types_By_Default()
{
var list = new List <DataTableItem>();
var item1 = new DataTableItem("1");
list.Add(item1);
var dataTable = list.ToDataTable();
dataTable.Rows[0]["IncompatibleValue"].Should().Be("ToStringWasUsed");
}
public void ToDataTable_Should_Try_To_Convert_Incompatible_Types_ToString()
{
var list = new List <DataTableItem>();
var item1 = new DataTableItem("1");
list.Add(item1);
var dataTable = list.ToDataTable();
dataTable.Rows[0]["FormattableValue"].Should().Be("IsFormattable");
}
public void ToDataTable_Should_Return_Equivalent_DataTable()
{
var list = new List <DataTableItem>();
var item1 = new DataTableItem("1");
list.Add(item1);
list.Add(new DataTableItem("2"));
var dataTable = list.ToDataTable();
dataTable.Rows.Count.Should().Be(2);
dataTable.Rows[0]["Id"].Should().Be("1");
dataTable.Rows[1]["Id"].Should().Be("2");
dataTable.Rows[0]["StringValue"].Should().Be(item1.StringValue);
dataTable.Rows[0]["NullString"].Should().Be(DBNull.Value);
dataTable.Rows[0]["BoolValue"].Should().Be(item1.BoolValue);
dataTable.Rows[0]["NullBool"].Should().Be(DBNull.Value);
dataTable.Rows[0]["ByteValue"].Should().Be(item1.ByteValue);
dataTable.Rows[0]["NullByte"].Should().Be(DBNull.Value);
dataTable.Rows[0]["CharValue"].Should().Be(item1.CharValue);
dataTable.Rows[0]["NullChar"].Should().Be(DBNull.Value);
dataTable.Rows[0]["DateTimeValue"].Should().Be(item1.DateTimeValue);
dataTable.Rows[0]["NullDateTime"].Should().Be(DBNull.Value);
dataTable.Rows[0]["DecimalValue"].Should().Be(item1.DecimalValue);
dataTable.Rows[0]["NullDecimal"].Should().Be(DBNull.Value);
dataTable.Rows[0]["DoubleValue"].Should().Be(item1.DoubleValue);
dataTable.Rows[0]["NullDouble"].Should().Be(DBNull.Value);
dataTable.Rows[0]["GuidValue"].Should().Be(item1.GuidValue);
dataTable.Rows[0]["NullGuid"].Should().Be(DBNull.Value);
dataTable.Rows[0]["ShortValue"].Should().Be(item1.ShortValue);
dataTable.Rows[0]["NullShort"].Should().Be(DBNull.Value);
dataTable.Rows[0]["IntValue"].Should().Be(item1.IntValue);
dataTable.Rows[0]["NullInt"].Should().Be(DBNull.Value);
dataTable.Rows[0]["LongValue"].Should().Be(item1.LongValue);
dataTable.Rows[0]["NullLong"].Should().Be(DBNull.Value);
dataTable.Rows[0]["SByteValue"].Should().Be(item1.SByteValue);
dataTable.Rows[0]["NullSByte"].Should().Be(DBNull.Value);
dataTable.Rows[0]["FloatValue"].Should().Be(item1.FloatValue);
dataTable.Rows[0]["NullFloat"].Should().Be(DBNull.Value);
dataTable.Rows[0]["TimeSpanValue"].Should().Be(item1.TimeSpanValue);
dataTable.Rows[0]["NullTimeSpan"].Should().Be(DBNull.Value);
dataTable.Rows[0]["UShortValue"].Should().Be(item1.UShortValue);
dataTable.Rows[0]["NullUShort"].Should().Be(DBNull.Value);
dataTable.Rows[0]["UIntValue"].Should().Be(item1.UIntValue);
dataTable.Rows[0]["NullUInt"].Should().Be(DBNull.Value);
dataTable.Rows[0]["ULongValue"].Should().Be(item1.ULongValue);
dataTable.Rows[0]["NullULong"].Should().Be(DBNull.Value);
(dataTable.Rows[0]["ByteArrayValue"] as byte[])[0].Should().Be(item1.ByteArrayValue[0]);
dataTable.Rows[0]["NullByteArray"].Should().Be(DBNull.Value);
dataTable.Rows[0]["NullableIntNotNull"].Should().Be(item1.NullableIntNotNull);
}
public static AlgoTraderOverview buildOverviewObject()
{
AlgoTraderOverview result = new AlgoTraderOverview();
/* ###################### SYMBOLS ###################### */
AlgoTraderDataTable symbolsDataTable = new AlgoTraderDataTable();
symbolsDataTable.Name = "overview-symbols";
if (String.IsNullOrEmpty(SelectedSymbol))
{
symbolsDataTable.HideColumn = (!String.IsNullOrEmpty(SelectedStrategyId) ? 1 : -1);
symbolsDataTable.Show = true;
symbolsDataTable.Title = "Symbols (" + AlgoTraderShared.WatchList.Count.ToString() + ")";
StringBuilder sb = new StringBuilder();
// name, strategies, positions, orders, actions, realized, unrealized
List <DataTableItem> dataTableItems = new List <DataTableItem>();
for (int n = 0; n < AlgoTraderShared.WatchList.Count; n++)
{
WatchItem wi = AlgoTraderShared.WatchList[n];
string symbol = wi.Symbol;
DataTableItem dataTableItem = new DataTableItem();
dataTableItem.ColumnValues.Add("symbol", wi.Symbol);
dataTableItem.ColumnValues.Add("strategies", wi.Strategies.Count);
//dataTableItem.Name = wi.Symbol;
//dataTableItem.SubItems = wi.Strategies.Count;
dataTableItem.ColumnValues.Add("orders", AlgoTraderShared.Orders.FindAll(o => o.Symbol == symbol).Count);
dataTableItem.ColumnValues.Add("actions", AlgoTraderShared.StrategyActions.FindAll(a => a.Symbol == symbol).Count);
List <Position> positions = AlgoTraderShared.Positions.FindAll(p => p.Symbol == symbol);
dataTableItem.ColumnValues.Add("positions", positions.Count);
// do realized
List <Position> closedPositions = positions.FindAll(p => p.Status == PositionStatus.Closed);
decimal netRealized = 0M;
for (int m = 0; m < closedPositions.Count; m++)
{
netRealized += closedPositions[m].SoldAt - closedPositions[m].BoughtAt;
}
dataTableItem.ColumnValues.Add("realized", netRealized);
// do unrealized
List <Position> openPositions = positions.FindAll(p => p.Status == PositionStatus.Open);
decimal latestAskPrice = -1M;
decimal latestBidPrice = -1M;
if (openPositions.Count > 0)
{
List <Node> nodes = AlgoTraderShared.NodesData[symbol].Nodes;
latestAskPrice = nodes[nodes.Count - 1].AskPrice;
latestBidPrice = nodes[nodes.Count - 1].BidPrice;
}
decimal netUnrealized = 0M;
for (int m = 0; m < openPositions.Count; m++)
{
Position p = openPositions[m];
decimal sellPrice = 0M;
decimal buyPrice = 0M;
if (p.Side == PositionSide.Long)
{
// if long, find the sell price by getting the latest bid price
sellPrice = latestBidPrice;
buyPrice = p.BoughtAt;
}
else if (p.Side == PositionSide.Short)
{
// if short, find the buy price by getting the latest ask price
buyPrice = latestAskPrice;
sellPrice = p.SoldAt;
}
else
{
throw new Exception("a what?");
}
netUnrealized += sellPrice - buyPrice;
}
dataTableItem.ColumnValues.Add("unrealized", netUnrealized);
dataTableItems.Add(dataTableItem);
}
TrySortDataTable(ref dataTableItems, "overview-symbols", "symbol");
// // name, strategies, positions, orders, actions, realized, unrealized
// <tr><td></td><td class=\"sub-items-col\"></td><td></td><td></td><td></td><td></td><td></td></tr>
for (int n = 0; n < dataTableItems.Count; n++)
{
sb.Append("<tr>");
sb.Append("<td>" + dataTableItems[n].ColumnValues["symbol"] + "</td>");
sb.Append("<td class=\"sub-items-col\">" + dataTableItems[n].ColumnValues["strategies"] + "</td>");
sb.Append("<td>" + dataTableItems[n].ColumnValues["positions"] + "</td>");
sb.Append("<td>" + dataTableItems[n].ColumnValues["orders"] + "</td>");
sb.Append("<td>" + dataTableItems[n].ColumnValues["actions"] + "</td>");
sb.Append("<td data-sort-value=\"" + dataTableItems[n].ColumnValues["realized"] + "\">" + UC.DecimalToUSD((decimal)dataTableItems[n].ColumnValues["realized"], 4) + "</td>");
sb.Append("<td data-sort-value=\"" + dataTableItems[n].ColumnValues["unrealized"] + "\">" + UC.DecimalToUSD((decimal)dataTableItems[n].ColumnValues["unrealized"], 4) + "</td>");
sb.Append("</tr>");
}
symbolsDataTable.TBodyHtml = sb.ToString();
}
result.DataTables.Add(symbolsDataTable);
/* ###################### STRATEGIES ###################### */
AlgoTraderDataTable strategiesDataTable = new AlgoTraderDataTable();
strategiesDataTable.Name = "overview-strategies";
if (String.IsNullOrEmpty(SelectedStrategyId))
{
strategiesDataTable.HideColumn = (!String.IsNullOrEmpty(SelectedSymbol) ? 1 : -1);
strategiesDataTable.Show = true;
string[] usableStrategiesKeys = Global.State.UsableStrategies.Keys.ToArray();
strategiesDataTable.Title = "Strategies (" + usableStrategiesKeys.Length.ToString() + ")";
StringBuilder sb = new StringBuilder();
// name, strategies, positions, orders, actions, realized, unrealized
List <DataTableItem> dataTableItems = new List <DataTableItem>();
if (AlgoTraderShared.WatchList.Count > 0)
{
for (int n = 0; n < usableStrategiesKeys.Length; n++)
{
string strategy = Global.State.UsableStrategies[usableStrategiesKeys[n]];
DataTableItem dataTableItem = new DataTableItem();
dataTableItem.ColumnValues.Add("strategy", strategy);
// probably super inefficient
dataTableItem.ColumnValues.Add("symbols", AlgoTraderShared.WatchList.Count(w => w.Strategies.Exists(s => s.GetType().Name == strategy)));
//dataTableItem.Name = wi.Symbol;
//dataTableItem.SubItems = wi.Strategies.Count;
dataTableItem.ColumnValues.Add("orders", AlgoTraderShared.Orders.FindAll(o => o.StrategyName == strategy && (String.IsNullOrEmpty(SelectedSymbol) || o.Symbol == SelectedSymbol)).Count);
dataTableItem.ColumnValues.Add("actions", AlgoTraderShared.StrategyActions.FindAll(a => a.StrategyName == strategy && (String.IsNullOrEmpty(SelectedSymbol) || a.Symbol == SelectedSymbol)).Count);
List <Position> positions = AlgoTraderShared.Positions.FindAll(p => p.StrategyName == strategy && (String.IsNullOrEmpty(SelectedSymbol) || p.Symbol == SelectedSymbol));
dataTableItem.ColumnValues.Add("positions", positions.Count);
// do realized
List <Position> closedPositions = positions.FindAll(p => p.Status == PositionStatus.Closed);
decimal netRealized = 0M;
for (int m = 0; m < closedPositions.Count; m++)
{
netRealized += closedPositions[m].SoldAt - closedPositions[m].BoughtAt;
}
dataTableItem.ColumnValues.Add("realized", netRealized);
// do unrealized
List <Position> openPositions = positions.FindAll(p => p.Status == PositionStatus.Open);
decimal netUnrealized = 0M;
for (int m = 0; m < openPositions.Count; m++)
{
Position p = openPositions[m];
decimal sellPrice = 0M;
decimal buyPrice = 0M;
List <Node> nodes = AlgoTraderShared.NodesData[p.Symbol].Nodes;
if (p.Side == PositionSide.Long)
{
// if long, find the sell price by getting the latest bid price
sellPrice = nodes[nodes.Count - 1].BidPrice;
buyPrice = p.BoughtAt;
}
else if (p.Side == PositionSide.Short)
{
// if short, find the buy price by getting the latest ask price
buyPrice = nodes[nodes.Count - 1].AskPrice;
sellPrice = p.SoldAt;
}
else
{
throw new Exception("a what?");
}
netUnrealized += sellPrice - buyPrice;
}
dataTableItem.ColumnValues.Add("unrealized", netUnrealized);
dataTableItems.Add(dataTableItem);
}
}
TrySortDataTable(ref dataTableItems, "overview-strategies", "strategy");
for (int n = 0; n < dataTableItems.Count; n++)
{
sb.Append("<tr>");
sb.Append("<td style=\"text-align:left;\">" + dataTableItems[n].ColumnValues["strategy"] + "</td>");
sb.Append("<td class=\"sub-items-col\">" + dataTableItems[n].ColumnValues["symbols"] + "</td>");
sb.Append("<td>" + dataTableItems[n].ColumnValues["positions"] + "</td>");
sb.Append("<td>" + dataTableItems[n].ColumnValues["orders"] + "</td>");
sb.Append("<td>" + dataTableItems[n].ColumnValues["actions"] + "</td>");
sb.Append("<td data-sort-value=\"" + dataTableItems[n].ColumnValues["realized"] + "\">" + UC.DecimalToUSD((decimal)dataTableItems[n].ColumnValues["realized"], 4) + "</td>");
sb.Append("<td data-sort-value=\"" + dataTableItems[n].ColumnValues["unrealized"] + "\">" + UC.DecimalToUSD((decimal)dataTableItems[n].ColumnValues["unrealized"], 4) + "</td>");
sb.Append("</tr>");
}
strategiesDataTable.TBodyHtml = sb.ToString();
}
result.DataTables.Add(strategiesDataTable);
return(result);
}
