public AppMainteanceManager(IAppStrategyManager stgManager)
{
this.stgManager = stgManager;
storeEventQueue = new BlockingCollection <AppEvent>();
CompleteDailyReset = new Dictionary <DateTime, DateTime>();
//startManager();
}
public AppOrderManager(IAppStrategyManager stgManager)
{
this.stgManager = stgManager;
OrderRepositry = new ConcurrentDictionary <string, OrderRecord>();
OrderPersister = new OrderPersistHelper(AppConstant.FILE_ORDER_REP);
OrderPersister.renameOldfile();
String[] stgNames = stgManager.getStgNames();
AppOrderStore = new ConcurrentDictionary <int, IAppOrder>();
ProcessedExecution = new ConcurrentDictionary <String, String>();
StoreStgOpenOrders = new ConcurrentDictionary <string, List <IAppOrder> >();
foreach (String name in stgNames)
{
StoreStgOpenOrders.AddOrUpdate(name, new List <IAppOrder>(), (key, oldValue) => oldValue);
}
StoreStgClosedOrders = new ConcurrentDictionary <string, List <IAppOrder> >();
foreach (String name in stgNames)
{
StoreStgClosedOrders.AddOrUpdate(name, new List <IAppOrder>(), (key, oldValue) => oldValue);
}
StoreStgPositions = new ConcurrentDictionary <string, AppPosition>();
foreach (String name in stgNames)
{
StoreStgPositions.AddOrUpdate(name, new AppPosition(), (key, oldValue) => oldValue);
}
}
public StrategyHelper(IAppStrategyManager appStgManager, String stgName, int stgIndex, SignalContext execution)
{
this.appStgManager = appStgManager;
this.appOrderManager = appStgManager.getAppOrderManager();
this.stgName = stgName;
this.stgIndex = stgIndex;
this.execution = execution;
}
private IAppMainteanceManager getInitMaintenaceManger(IAppStrategyManager stgManager)
{
IAppMainteanceManager maintenanceManager = new AppMainteanceManager(stgManager);
maintenanceManager.lunchTimeRTBReset = false;
maintenanceManager.morningTimeRTBReset = false;
maintenanceManager.dailyAllFlagsInit = true;
return(maintenanceManager);
}
private IAppStrategyManager getStgManager()
{
var stgManagerMock = new Mock <IAppStrategyManager>();
String[] names = { "S1_RND1", "S2_RBREAK_REVERSE1", "S3_RBREAK_TREND1" };
stgManagerMock.Setup(foo => foo.getStgNames()).Returns(names);
IAppStrategyManager stgManagerObj = stgManagerMock.Object;
return(stgManagerObj);
}
public AppEventManager(IAppStrategyManager stgManager)
{
this.stgManager = stgManager;
String[] stgNames = stgManager.getStgNames();
storeEventQueue = new Dictionary <String, BlockingCollection <AppEvent> >();
foreach (String name in stgNames)
{
storeEventQueue.Add(name, new BlockingCollection <AppEvent>());
}
}
public void test_markExeProcessed()
{
IAppStrategyManager stgManager = getStgManager();
IAppOrderManager orderManager = new AppOrderManager(stgManager);
ExecutionMessage exeMessage = getExeMessage_for_Sell3Contract();
String execId = exeMessage.Execution.ExecId;
Assert.IsFalse(orderManager.ProcessedExecution.ContainsKey(execId));
orderManager.markExeProcessed(execId);
Assert.IsTrue(orderManager.ProcessedExecution.ContainsKey(execId));
}
public void test_isExecutionProcessed()
{
IAppStrategyManager stgManager = getStgManager();
IAppOrderManager orderManager = new AppOrderManager(stgManager);
ExecutionMessage exeMessage = getExeMessage_for_Sell3Contract();
String execId = exeMessage.Execution.ExecId;
Assert.IsFalse(orderManager.isExecutionProcessed(execId));
orderManager.ProcessedExecution.AddOrUpdate(execId, execId, (key, oldValue) => oldValue);
Assert.IsTrue(orderManager.isExecutionProcessed(execId));
}
public void test_putTimeEvents()
{
IAppStrategyManager stgManager = getAppStrategyManager_for_putEvents();
AppEventManager eventManager = new AppEventManager(stgManager);
DateTime afterSetTime = new DateTime(2015, 11, 21, 9, 15, 55, DateTimeKind.Local);
DateTime afterSetTime2 = new DateTime(2015, 11, 21, 9, 16, 0, DateTimeKind.Local);
eventManager.putTimeEvents(afterSetTime);
eventManager.putTimeEvents(afterSetTime2);
Assert.AreEqual(2, eventManager.storeEventQueue["S1_RND1"].Count);
Assert.AreEqual(0, eventManager.storeEventQueue["S2_RBREAK_REVERSE1"].Count);
Assert.AreEqual(2, eventManager.storeEventQueue["S3_RBREAK_TREND1"].Count);
Assert.AreEqual(2, stgManager.getAppMainteanceManager().storeEventQueue.Count);
}
public AccountDetailManager(IBClient ibClient, DataGridView accountValueGrid, DataGridView accountPortfolioGrid, IBTradeApp appForm)
{
IbClient = ibClient;
AccountValueGrid = accountValueGrid;
this.accountPortfolioGrid = accountPortfolioGrid;
this.appForm = appForm;
String[] tags = ACCOUNT_VALUE_TAGS.Split(',');
valid_account_values = new Dictionary <string, string>();
foreach (String tag in tags)
{
valid_account_values.Add(tag, tag);
}
appStrategyManager = appForm.appStrategyManager;
}
public void test_addOpenAppOrder()
{
IAppStrategyManager stgManager = getStgManager();
IAppOrderManager orderManager = new AppOrderManager(stgManager);
IAppOrder appOrder = createOrder_for_addAppOrUpdateOrder();
int stgIndex = 2;
orderManager.addOpenAppOrder(stgIndex, appOrder);
String[] stgNames = stgManager.getStgNames();
List <IAppOrder> lstStgOpenOrders = orderManager.StoreStgOpenOrders[stgNames[stgIndex]];
IAppOrder retAppOrder = lstStgOpenOrders[lstStgOpenOrders.Count - 1];
Assert.IsNotNull(retAppOrder);
Assert.AreEqual(appOrder.OrderId, retAppOrder.OrderId);
}
private IAppStrategyManager getAppStrategyManager_for_putEvents()
{
var mock = new Mock <IAppStrategyManager>();
ConcurrentDictionary <String, String> activeStg = new ConcurrentDictionary <String, String>();
activeStg.AddOrUpdate("S1_RND1", "S1_RND1", (key, oldvalue) => "S1_RND1");
activeStg.AddOrUpdate("S3_RBREAK_TREND1", "S3_RBREAK_TREND1", (key, oldvalue) => "S3_RBREAK_TREND1");
String[] stgNames = { "S1_RND1", "S2_RBREAK_REVERSE1", "S3_RBREAK_TREND1" };
mock.Setup(foo => foo.getActiveStgNamesMap()).Returns(activeStg);
mock.Setup(foo => foo.getStgNames()).Returns(stgNames);
mock.Setup(foo => foo.getAppMainteanceManager()).Returns(new AppMainteanceManager(null));
IAppStrategyManager fooObj = mock.Object;
return(fooObj);
}
public void test_putTickPriceEvents()
{
IAppStrategyManager stgManager = getAppStrategyManager_for_putEvents();
AppEventManager eventManager = new AppEventManager(stgManager);
TickPriceMessage tickMessage1 = new TickPriceMessage(200001, 4, 22000, 0);
TickPriceMessage tickMessage2 = new TickPriceMessage(200002, 1, 22100, 0);
MarketDataMessage dataMessage = (MarketDataMessage)tickMessage1;
eventManager.putTickPriceEvents(tickMessage1, dataMessage);
dataMessage = (MarketDataMessage)tickMessage2;
eventManager.putTickPriceEvents(tickMessage2, dataMessage);
Assert.AreEqual(2, eventManager.storeEventQueue["S1_RND1"].Count);
Assert.AreEqual(0, eventManager.storeEventQueue["S2_RBREAK_REVERSE1"].Count);
Assert.AreEqual(2, eventManager.storeEventQueue["S3_RBREAK_TREND1"].Count);
Assert.AreEqual(0, stgManager.getAppMainteanceManager().storeEventQueue.Count);
}
public void test_updateAppOrderExecution()
{
IAppStrategyManager stgManager = getStgManager();
IAppOrderManager orderManager = new AppOrderManager(stgManager);
IAppOrder appOrder = createOrder_Sell3Contract();
orderManager.AppOrderStore.AddOrUpdate(appOrder.OrderId, appOrder, (key, oldValue) => oldValue);
ExecutionMessage exeMessage = getExeMessage_for_Sell3Contract();
orderManager.updateAppOrderExecution(exeMessage);
IAppOrder retAppOrder = orderManager.AppOrderStore[appOrder.OrderId];
IAppExecution appExe = retAppOrder.Executions[0];
Assert.AreEqual(1, retAppOrder.Executions.Count);
Assert.AreEqual(23000, appExe.AvgPrice);
Assert.AreEqual("1102", appExe.ExecId);
Assert.AreEqual(3, appExe.ExeShare);
Assert.AreEqual("2015-11-11 01:07:01", appExe.LastExecTime);
Assert.AreEqual(1001, appExe.OrderId);
Assert.AreEqual(AppConstant.SELL_SIGNAL, appExe.Side);
}
public void test_addOrderRecordToRepositry()
{
IAppStrategyManager stgManager = getStgManager();
IAppOrderManager orderManager = new AppOrderManager(stgManager);
IAppOrder appOrder = createOrder_Sell3Contract();
Order order = appOrder.IBOrder;
String strOrderId = order.OrderId.ToString();
OrderRecord orderR = new OrderRecord();
orderR.orderId = order.OrderId;
orderR.sno = appOrder.StratgeyShortName;
orderR.orderTime = new DateTime(2015, 12, 11, 03, 03, 10);
Assert.IsFalse(orderManager.OrderRepositry.ContainsKey(strOrderId));
orderManager.addOrderRecordToRepositry(strOrderId, orderR);
Assert.IsTrue(orderManager.OrderRepositry.ContainsKey(strOrderId));
OrderRecord retOrderR = orderManager.OrderRepositry[strOrderId];
Assert.AreEqual(order.OrderId, retOrderR.orderId);
Assert.AreEqual(orderR.orderTime, retOrderR.orderTime);
Assert.AreEqual(appOrder.StratgeyShortName, retOrderR.sno);
}
public void test_handleResetRTBRequest()
{
IRealTimeBarsManagerBridge rtsBarManager = new RealTimeBarsManagerMock();
var uiMock = new Mock <IIBTradeAppBridge>();
Contract contract = getContract();
TickerInfo ticker = getTickerInfo();
uiMock.Setup(foo => foo.getRealTimeBarsManager()).Returns(rtsBarManager);
uiMock.Setup(foo => foo.GetMDContract()).Returns(contract);
uiMock.Setup(foo => foo.getTickerInfo()).Returns(ticker);
IIBTradeAppBridge uiMockObj = uiMock.Object;
var mock = new Mock <IAppStrategyManager>();
mock.Setup(foo => foo.ParentUI).Returns(uiMockObj);
IAppStrategyManager mockObj = mock.Object;
DateTime time1 = new DateTime(2015, 12, 10, 10, 0, 0, DateTimeKind.Local);
DateTime time2 = new DateTime(2015, 12, 10, 12, 57, 1, DateTimeKind.Local);
DateTime time3 = new DateTime(2015, 12, 10, 12, 58, 1, DateTimeKind.Local);
IAppMainteanceManager maintenanceManager = getInitMaintenaceManger(mockObj);
AppTimeEvent timeEvent1 = getItemEvent(time1);
AppTimeEvent timeEvent2 = getItemEvent(time2);
AppTimeEvent timeEvent3 = getItemEvent(time3);
//[reset negative, time is before moring time and lunch time]
maintenanceManager.handleResetRTBRequest(timeEvent1);
Assert.IsFalse(maintenanceManager.morningTimeRTBReset);
Assert.IsFalse(maintenanceManager.lunchTimeRTBReset);
//[reset lunch positive, time is at lunch time]
maintenanceManager.handleResetRTBRequest(timeEvent2);
Assert.IsFalse(maintenanceManager.morningTimeRTBReset);
Assert.IsTrue(maintenanceManager.lunchTimeRTBReset);
//[reset lunch negative, time is just after lunch time]
maintenanceManager = getInitMaintenaceManger(mockObj);
maintenanceManager.handleResetRTBRequest(timeEvent3);
Assert.IsFalse(maintenanceManager.morningTimeRTBReset);
Assert.IsFalse(maintenanceManager.lunchTimeRTBReset);
DateTime time4 = new DateTime(2015, 12, 10, 07, 0, 0, DateTimeKind.Local);
DateTime time5 = new DateTime(2015, 12, 10, 09, 12, 1, DateTimeKind.Local);
DateTime time6 = new DateTime(2015, 12, 10, 09, 13, 1, DateTimeKind.Local);
AppTimeEvent timeEvent4 = getItemEvent(time4);
AppTimeEvent timeEvent5 = getItemEvent(time5);
AppTimeEvent timeEvent6 = getItemEvent(time6);
//[reset morning negative, time is before morning time]
maintenanceManager = getInitMaintenaceManger(mockObj);
maintenanceManager.handleResetRTBRequest(timeEvent4);
Assert.IsFalse(maintenanceManager.morningTimeRTBReset);
Assert.IsFalse(maintenanceManager.lunchTimeRTBReset);
//[reset morning positive, time is at morning time]
maintenanceManager = getInitMaintenaceManger(mockObj);
maintenanceManager.handleResetRTBRequest(timeEvent5);
Assert.IsTrue(maintenanceManager.morningTimeRTBReset);
Assert.IsFalse(maintenanceManager.lunchTimeRTBReset);
//[reset morning negative, time is after morning time]
maintenanceManager = getInitMaintenaceManger(mockObj);
maintenanceManager.handleResetRTBRequest(timeEvent6);
Assert.IsFalse(maintenanceManager.morningTimeRTBReset);
Assert.IsFalse(maintenanceManager.lunchTimeRTBReset);
//[reset morning & lunch, one cycle]
DateTime time7 = new DateTime(2015, 12, 11, 0, 0, 1, DateTimeKind.Local);
DateTime time8 = new DateTime(2015, 12, 11, 09, 12, 1, DateTimeKind.Local);
DateTime time9 = new DateTime(2015, 12, 11, 12, 57, 1, DateTimeKind.Local);
AppTimeEvent timeEvent7 = getItemEvent(time7);
AppTimeEvent timeEvent8 = getItemEvent(time8);
AppTimeEvent timeEvent9 = getItemEvent(time9);
maintenanceManager = getInitMaintenaceManger(mockObj);
//[time is 07:00]
maintenanceManager.handleResetRTBRequest(timeEvent4);
Assert.IsFalse(maintenanceManager.morningTimeRTBReset);
Assert.IsFalse(maintenanceManager.lunchTimeRTBReset);
//[time is 09:12]
maintenanceManager.handleResetRTBRequest(timeEvent5);
Assert.IsTrue(maintenanceManager.morningTimeRTBReset);
Assert.IsFalse(maintenanceManager.lunchTimeRTBReset);
//[time is 12:57]
maintenanceManager.handleResetRTBRequest(timeEvent2);
Assert.IsTrue(maintenanceManager.morningTimeRTBReset);
Assert.IsTrue(maintenanceManager.lunchTimeRTBReset);
//[time is 0:0 T+1]
maintenanceManager.resetDailyAllFlag(time7);
Assert.IsFalse(maintenanceManager.morningTimeRTBReset);
Assert.IsFalse(maintenanceManager.lunchTimeRTBReset);
//[time is 09:12 T+1]
maintenanceManager.handleResetRTBRequest(timeEvent8);
Assert.IsTrue(maintenanceManager.morningTimeRTBReset);
Assert.IsFalse(maintenanceManager.lunchTimeRTBReset);
//[time is 12:57 T+1]
maintenanceManager.handleResetRTBRequest(timeEvent9);
Assert.IsTrue(maintenanceManager.morningTimeRTBReset);
Assert.IsTrue(maintenanceManager.lunchTimeRTBReset);
}
public void injectStrategyManager(IAppStrategyManager stgManager)
{
this.stgManager = stgManager;
}
public void test_updatePosition()
{
List <IAppExecution> lstExecution = createExecution_for_updatePosition();
IAppStrategyManager stgManager = getStgManager();
IAppOrderManager orderManager = new AppOrderManager(stgManager);
int stgIndex = 2;
int numExe = 5;
int[] accBuyQ = new int[numExe];
int[] accSellQ = new int[numExe];
int[] netQ = new int[numExe];
double[] accBuyMoney = new double[numExe];
double[] accSellMoney = new double[numExe];
double[] totalPnL = new double[numExe];
accBuyQ[0] = 0;
accSellQ[0] = 6;
netQ[0] = -6;
accBuyMoney[0] = 0;
accSellMoney[0] = 6 * 22100;
totalPnL[0] = 0;
accBuyQ[1] = 3;
accSellQ[1] = 6;
netQ[1] = -3;
accBuyMoney[1] = 3 * 22000;
accSellMoney[1] = 6 * 22100;
totalPnL[1] = 0;
accBuyQ[2] = 6;
accSellQ[2] = accSellQ[1];
netQ[2] = 0;
accBuyMoney[2] = accBuyMoney[1] + 3 * 21900;
accSellMoney[2] = accSellMoney[1];
totalPnL[2] = 6 * 22100 - (3 * 22000 + 3 * 21900);
accBuyQ[3] = 7;
accSellQ[3] = accSellQ[2];
netQ[3] = 1;
accBuyMoney[3] = accBuyMoney[2] + 23000;
accSellMoney[3] = accSellMoney[2];
totalPnL[3] = totalPnL[2];
accBuyQ[4] = accBuyQ[3];
accSellQ[4] = 7;
netQ[4] = 0;
accBuyMoney[4] = accBuyMoney[3];
accSellMoney[4] = accSellMoney[3] + 23500;
totalPnL[4] = totalPnL[3] + (23500 - 23000);
orderManager.updatePosition(stgIndex, lstExecution[0]);
String[] stgNames = stgManager.getStgNames();
String stgName = stgNames[stgIndex];
AppPosition position = orderManager.StoreStgPositions[stgName];
Assert.AreEqual(accSellQ[0], position.AccSellQ);
Assert.AreEqual(accSellMoney[0], position.AccSellMoney);
Assert.AreEqual(netQ[0], position.NetQ);
orderManager.updatePosition(stgIndex, lstExecution[1]);
Assert.AreEqual(accBuyQ[1], position.AccBuyQ);
Assert.AreEqual(accBuyMoney[1], position.AccBuyMoney);
Assert.AreEqual(netQ[1], position.NetQ);
Assert.AreEqual(totalPnL[1], position.TotalPnL);
orderManager.updatePosition(stgIndex, lstExecution[2]);
Assert.AreEqual(accBuyQ[2], position.AccBuyQ);
Assert.AreEqual(accBuyMoney[2], position.AccBuyMoney);
Assert.AreEqual(netQ[2], position.NetQ);
Assert.AreEqual(totalPnL[2], position.TotalPnL);
orderManager.updatePosition(stgIndex, lstExecution[3]);
Assert.AreEqual(accBuyQ[3], position.AccBuyQ);
Assert.AreEqual(accBuyMoney[3], position.AccBuyMoney);
Assert.AreEqual(netQ[3], position.NetQ);
Assert.AreEqual(totalPnL[3], position.TotalPnL);
orderManager.updatePosition(stgIndex, lstExecution[4]);
Assert.AreEqual(accSellQ[4], position.AccSellQ);
Assert.AreEqual(accSellMoney[4], position.AccSellMoney);
Assert.AreEqual(netQ[4], position.NetQ);
Assert.AreEqual(totalPnL[4], position.TotalPnL);
}
public MarketDataManager(IBClient client, DataGridView dataGrid, IAppStrategyManager appStgManager)
: base(client, dataGrid)
{
this.appStrategyManager = appStgManager;
}
