public void setPendingSignal2(String side, double price, IAppOrder order, String remark)
{
PendingSignalSide2 = side;
PendingSignalPrice2 = price;
PendingOrder2 = order;
PendingSignalRemark2 = remark;
}
public IAppOrder[] getPendingOrders()
{
IAppOrder[] orders = new IAppOrder[2];
orders[0] = PendingOrder1;
orders[1] = PendingOrder2;
return(orders);
}
public void setPendingSignal1(String side, double price, IAppOrder order, String remark)
{
PendingSignalSide1 = side;
PendingSignalPrice1 = price;
PendingOrder1 = order;
PendingSignalRemark1 = remark;
}
public double getFilledPrice()
{
double totalAmount = 0.0;
double totalQuantity = 0.0;
IAppOrder tempOrder = getClosedAppOrder();
/*
* if (pendingOrder1 != null && AppObjectUtil.isOrderClosed(pendingOrder1))
* tempOrder = pendingOrder1;
* if (pendingOrder2 != null && AppObjectUtil.isOrderClosed(pendingOrder2))
* tempOrder = pendingOrder2;
*/
if (tempOrder == null)
{
return(double.NaN);
}
foreach (IAppExecution exe in tempOrder.Executions)
{
totalAmount += exe.AvgPrice * exe.ExeShare;
totalQuantity += exe.ExeShare;
}
return(totalAmount / totalQuantity);
}
public void completePendingSignal()
{
IAppOrder order = getClosedAppOrder();
if (order != null)
{
if (order != null)
{
lock (order)
{
int pos = 0;
if (AppConstant.BUY_SIGNAL.Equals(order.BuySell))
{
pos = order.TotalQuantity;
PnL = PnL - getFilledPrice() * getQuantityForExecution();
}
if (AppConstant.SELL_SIGNAL.Equals(order.BuySell))
{
pos = -order.TotalQuantity;
PnL = PnL + getFilledPrice() * getQuantityForExecution();
}
CurrentMarketPosition += pos;
}
}
order.Position = CurrentMarketPosition;
}
}
public void test_SaveRows1()
{
File.Delete(WRITER_PATH);
writer_suffix_path = String.Format("{0:_yyyyMMdd}", DateTime.Now);
PositionPersistHelper helper = new PositionPersistHelper(WRITER_PATH, writer_suffix_path);
IAppOrder buyOrder = createBuyOrder_10Contract_10Complete(10, "Enter Buy", "Random Buy Rule");
IAppOrder sellOrder = createSellOrder_10Contract_10Complete(0, "Exit Sell", "Random Sell Rule");
List <IAppOrder> orders = new List <IAppOrder>();
orders.Add(buyOrder);
orders.Add(sellOrder);
helper.SaveRows("S_RND1", orders);
List <String[]> records = getContentFromFile();
String[] record1 = records[1];
String[] record2 = records[2];
Assert.AreEqual("10", record1[1].Trim());
Assert.AreEqual("BUY", record1[2].Trim());
Assert.AreEqual("20000", record1[3].Trim());
Assert.AreEqual("20140", record1[4].Trim());
Assert.AreEqual("0", record1[5].Trim());
Assert.AreEqual("Enter Buy", record1[6].Trim());
Assert.AreEqual("Random Buy Rule", record1[7].Trim());
Assert.AreEqual("0", record2[1].Trim());
Assert.AreEqual("SELL", record2[2].Trim());
Assert.AreEqual("20400", record2[3].Trim());
Assert.AreEqual("20400", record2[4].Trim());
Assert.AreEqual("2600", record2[5].Trim());
Assert.AreEqual("Exit Sell", record2[6].Trim());
Assert.AreEqual("Random Sell Rule", record2[7].Trim());
}
public void addAppOrUpdateOrder(IAppOrder order)
{
lock (AppOrderStore)
{
AppOrderStore.AddOrUpdate(order.OrderId, order, (key, oldValue) => order);
}
}
/*
* public AppOrder getAppOrderFromStore(int orderId)
* {
* if (AppOrderStore.ContainsKey(orderId))
* return AppOrderStore[orderId];
* return null;
* }
*
* public AppOrder getOpenAppOrderFromStore(int stgIndex, int orderId)
* {
* String[] stgNames = stgManager.getStgNames();
* List<AppOrder> lstStgOpenOrders = StoreStgOpenOrders[stgNames[stgIndex]];
* AppOrder orderFound = null;
* foreach (AppOrder order in lstStgOpenOrders)
* {
* if (order.OrderId == orderId)
* orderFound = order;
* }
* return orderFound;
* }
*
* public AppOrder getClosedAppOrderFromStore(int stgIndex, int orderId)
* {
* String[] stgNames = stgManager.getStgNames();
* List<AppOrder> lstStgClosedOrders = StoreStgClosedOrders[stgNames[stgIndex]];
* AppOrder orderFound = null;
* foreach (AppOrder order in lstStgClosedOrders)
* {
* if (order.OrderId == orderId)
* orderFound = order;
* }
* return orderFound;
* }*/
public void addOpenAppOrder(int stgIndex, IAppOrder order)
{
String[] stgNames = stgManager.getStgNames();
List <IAppOrder> lstStgOpenOrders = StoreStgOpenOrders[stgNames[stgIndex]];
lock (lstStgOpenOrders)
{
lstStgOpenOrders.Add(order);
}
}
public void test_addAppOrUpdateOrder()
{
IAppOrderManager orderManager = new AppOrderManager(getStgManager());
IAppOrder appOrder = createOrder_for_addAppOrUpdateOrder();
orderManager.addAppOrUpdateOrder(appOrder);
IAppOrder retAppOrder = orderManager.AppOrderStore[appOrder.OrderId];
Assert.IsNotNull(retAppOrder);
Assert.AreEqual(appOrder.OrderId, retAppOrder.OrderId);
}
public IAppOrder getClosedAppOrder()
{
IAppOrder tempOrder = null;
if (PendingOrder1 != null && AppObjectUtil.isOrderClosed(PendingOrder1))
{
tempOrder = PendingOrder1;
}
if (PendingOrder2 != null && AppObjectUtil.isOrderClosed(PendingOrder2))
{
tempOrder = PendingOrder2;
}
return(tempOrder);
}
public void closeOpenAppOrder(int stgIndex, IAppOrder order)
{
String[] stgNames = stgManager.getStgNames();
List <IAppOrder> lstStgOpenOrders = StoreStgOpenOrders[stgNames[stgIndex]];
List <IAppOrder> lstStgClosedOrder = StoreStgClosedOrders[stgNames[stgIndex]];
lock (lstStgOpenOrders)
{
lock (lstStgClosedOrder)
{
lstStgOpenOrders.Remove(order);
lstStgClosedOrder.Add(order);
}
}
}
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);
}
public void processExecution(ExecutionMessage message)
{
IAppOrderManager orderManager = appStgManager.getAppOrderManager();
String[] stgNames = appStgManager.getStgNames();
if (!appStgManager.getAppOrderManager().AppOrderStore.ContainsKey(message.Execution.OrderId))
{
return;
}
if (!orderManager.isExecutionProcessed(message.Execution.ExecId))
{
AppExecution execution = orderManager.updateAppOrderExecution(message);
IAppOrder order = orderManager.AppOrderStore[message.Execution.OrderId];
AppOrder cloneOrder = (AppOrder)order.Clone();
if (AppObjectUtil.isOrderClosed(cloneOrder))
{
orderManager.closeOpenAppOrder(order.StrategyIndex, order);
}
orderManager.updatePosition(order.StrategyIndex, execution);
String stgName = stgNames[order.StrategyIndex];
AppPosition stgPosition = orderManager.StoreStgPositions[stgName];
log.Info("Total PnL : " + stgPosition.TotalPnL);
orderManager.markExeProcessed(message.Execution.ExecId);
//***New for send order executed email***
IAppEventManager appEventManager = appStgManager.getAppEventManager();
appEventManager.putOrderExeEvents(message, stgName);
/*TSAppExecution execution = appForm.StrategyManager.updateAppOrderExecution(message);
* TSAppOrder order = appForm.StrategyManager.AppOrderStore[message.Execution.OrderId];
* TSAppOrder cloneOrder = (TSAppOrder)order.Clone();
* if (StrategyManager.isOrderClosed(cloneOrder))
* {
* appForm.StrategyManager.closeOpenAppOrder(order.StrategyIndex, order);
* //appForm.StrategyManager.removeOpenAppOrder(order.StrategyIndex, order);
* //appForm.StrategyManager.addClosedAppOrder(order.StrategyIndex, order);
* }
* appForm.StrategyManager.updatePosition(order.StrategyIndex, execution);
* String stgName = appForm.StrategyManager.StgNames[order.StrategyIndex];
* AppPosition stgPosition = appForm.StrategyManager.StoreStgPositions[stgName];
* log.Info("Total PnL : " + stgPosition.TotalPnL);
* //log.Info("Total PnL : " + appForm.StrategyManager.StgPositions[order.StrategyIndex].TotalPnL);
* appForm.StrategyManager.markExeProcessed(message.Execution.ExecId);*/
}
log.Info("Order Executed");
log.Info("*********************************************");
}
public void cancelPendingTrade(int index)
{
IAppOrder tempOrder = null;
if (index == 1)
{
tempOrder = execution.PendingOrder1;
}
else
{
tempOrder = execution.PendingOrder2;
}
if (tempOrder != null && !AppObjectUtil.isOrderClosed(tempOrder))
{
appStgManager.getOrderManager().CancelOrder(tempOrder.IBOrder);
}
}
public static Boolean isOrderClosed(IAppOrder order)
{
int numFilled = 0;
foreach (IAppExecution exe in order.Executions)
{
numFilled += exe.ExeShare;
}
if (order.TotalQuantity == numFilled)
{
return(true);
}
else
{
return(false);
}
}
public void modifyPendingTrade(int index, double triggerPoint, String triggerRule, string remark)
{
DateTime currentTimeStamp = DateTime.Now;
Contract contract = appStgManager.CurrentContract;
IAppOrder tempOrder = null;
if (index == 1)
{
tempOrder = execution.PendingOrder1;
}
else
{
tempOrder = execution.PendingOrder2;
}
tempOrder.IBOrder.AuxPrice = triggerPoint;
tempOrder.TriggerRule = triggerRule;
tempOrder.TriggerPrice = triggerPoint;
tempOrder.Remark = remark;
appStgManager.getOrderManager().PlaceOrder(contract, tempOrder.IBOrder);
}
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 AppExecution updateAppOrderExecution(ExecutionMessage message)
{
int orderId = message.Execution.OrderId;
IAppOrder retOrder = AppOrderStore[orderId];
String execId = message.Execution.ExecId;
String lastExecTime = message.Execution.Time;
String side = retOrder.BuySell;
double avgPrice = message.Execution.AvgPrice;
int exeShare = message.Execution.Shares;
AppExecution execution = new AppExecution();
execution.OrderId = orderId;
execution.ExecId = execId;
execution.LastExecTime = lastExecTime;
execution.Side = side;
execution.AvgPrice = avgPrice;
execution.ExeShare = exeShare;
retOrder.addExecution(execution);
return(execution);
}
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 testIsOrderClosed_with10contract_5Complete()
{
IAppOrder order10Contract = createOrder_10Contract_5Complete();
Assert.AreEqual(false, AppObjectUtil.isOrderClosed(order10Contract));
}
public void testIsOrderClosed_with1contract()
{
IAppOrder order1Contract = createOrder_1Contract_1Complete();
Assert.AreEqual(true, AppObjectUtil.isOrderClosed(order1Contract));
}
