public ExecutionReport(
QuickFix.OrderID aOrderID,
QuickFix.ExecID aExecID,
QuickFix.ExecTransType aExecTransType,
QuickFix.ExecType aExecType,
QuickFix.OrdStatus aOrdStatus,
QuickFix.Symbol aSymbol,
QuickFix.Side aSide,
QuickFix.OrderQty aOrderQty,
QuickFix.LastShares aLastShares,
QuickFix.LastPx aLastPx,
QuickFix.LeavesQty aLeavesQty,
QuickFix.CumQty aCumQty,
QuickFix.AvgPx aAvgPx)
: base(MsgType())
{
set(aOrderID);
set(aExecID);
set(aExecTransType);
set(aExecType);
set(aOrdStatus);
set(aSymbol);
set(aSide);
set(aOrderQty);
set(aLastShares);
set(aLastPx);
set(aLeavesQty);
set(aCumQty);
set(aAvgPx);
}
public OrderCancelReject(
QuickFix.OrderID aOrderID,
QuickFix.ClOrdID aClOrdID,
QuickFix.OrdStatus aOrdStatus,
QuickFix.CxlRejResponseTo aCxlRejResponseTo)
: base(MsgType())
{
set(aOrderID);
set(aClOrdID);
set(aOrdStatus);
set(aCxlRejResponseTo);
}
public OrderCancelReject(
QuickFix.OrderID aOrderID,
QuickFix.ClOrdID aClOrdID,
QuickFix.OrigClOrdID aOrigClOrdID,
QuickFix.OrdStatus aOrdStatus)
: base(MsgType())
{
set(aOrderID);
set(aClOrdID);
set(aOrigClOrdID);
set(aOrdStatus);
}
public QuickFix.OrdStatus getOrdStatus()
{ QuickFix.OrdStatus value = new QuickFix.OrdStatus();
getField(value); return value; }
/// <summary>
/// apply an order status change
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void TWS_orderStatus(object sender, AxTWSLib._DTwsEvents_orderStatusEvent e)
{
try
{
if (m_DriverLog.IsDebugEnabled)
{
m_DriverLog.Debug("TWS_openOrderEx:" + e.clientId.ToString() + ": " + e.ToString() + ": " + e.status.ToString());
}
QuickFix.OrdStatus myOrdStatus;
QuickFix.ExecType myExecType = new QuickFix.ExecType(QuickFix.ExecType.ORDER_STATUS);
double myLastFill = 0.0;
// get the order contect using the IB ID
DriverBase.OrderContext myCntx = null;
if (this.m_ApiIDOrderMap.ContainsKey(e.id.ToString()))
{
myCntx = m_ApiIDOrderMap[e.id.ToString()];
}
if (myCntx == null)
{
string myErr = "IB TWS: no context found for IB ID:" + e.id.ToString();
Exception myE = new Exception(myErr);
throw myE;
}
myLastFill = myCntx.LeavesQty - e.remaining;
myCntx.CumQty = e.filled;
// get the original order from the context
QuickFix.Message myOrder = myCntx.QFOrder;
switch (e.status)
{
case "PendingSubmit":
myOrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.PENDING_NEW);
sendExecReport(myOrder, new QuickFix.OrderID(e.id.ToString()), myOrdStatus, myExecType, myLastFill, e.remaining, e.filled, e.lastFillPrice, e.avgFillPrice);
break;
case "PendingCancel":
myOrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.PENDING_CANCEL);
sendExecReport(myOrder, new QuickFix.OrderID(e.id.ToString()), myOrdStatus, myExecType, myLastFill, e.remaining, e.filled, e.lastFillPrice, e.avgFillPrice);
break;
case "PreSubmitted":
break;
case "Inactive":
break;
case "Submitted":
if (e.filled > 0)
{
myOrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.PARTIALLY_FILLED);
myExecType = new QuickFix.ExecType(QuickFix.ExecType.PARTIAL_FILL);
}
else
{
myOrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.NEW);
}
// mark the context as done for the sub
SetContextCommand(myCntx, DriverBase.ORCommand.Submit, DriverBase.ORCommand.Undefined);
sendExecReport(myOrder, new QuickFix.OrderID(e.id.ToString()), myOrdStatus, myExecType, myLastFill, e.remaining, e.filled, e.lastFillPrice, e.avgFillPrice);
break;
case "Cancelled":
myOrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.CANCELED);
sendExecReport(myOrder, new QuickFix.OrderID(e.id.ToString()), myOrdStatus, myExecType, myLastFill, e.remaining, e.filled, e.lastFillPrice, e.avgFillPrice);
// mark the context as done for the sub
SetContextCommand(myCntx, DriverBase.ORCommand.Pull, DriverBase.ORCommand.Undefined);
break;
case "Filled":
myOrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.FILLED);
myExecType = new QuickFix.ExecType(QuickFix.ExecType.FILL);
sendExecReport(myOrder, new QuickFix.OrderID(e.id.ToString()), myOrdStatus, myExecType, myLastFill, e.remaining, e.filled, e.lastFillPrice, e.avgFillPrice);
// mark the context as done for the sub
SetContextCommand(myCntx, DriverBase.ORCommand.Undefined, DriverBase.ORCommand.Undefined);
break;
default:
_log.Error("TWS_orderStatus:unknown status" + e.status);
break;
}
}
catch (Exception myE)
{
_log.Error("TWS_orderStatus", myE);
}
}
/// <summary>
/// submit an order to IB using a incomming FIX new order single
/// </summary>
/// <param name="myMsg"></param>
private void submitOrder(KaiTrade.Interfaces.IMessage myMsg)
{
QuickFix.Message myQFOrder = null;
try
{
// Extract the raw FIX Message from the inbound message
string strOrder = myMsg.Data;
// Use QuickFix to handle the message
myQFOrder = new QuickFix.Message(strOrder);
// Use product manager to validate the product specified on
// the order exists for this adapter
// Get the product associated with the FIX message
//QuickFix.Symbol symbol = new QuickFix.Symbol();
//myQFOrder.getField(symbol);
QuickFix.Side mySide = new QuickFix.Side();
QuickFix.OrdType myOrdType = new QuickFix.OrdType();
QuickFix.OrderQty myOrderQty = new QuickFix.OrderQty();
QuickFix.Price myPrice = new QuickFix.Price();
QuickFix.StopPx myStopPx = new QuickFix.StopPx();
QuickFix.Account myAccount = new QuickFix.Account();
QuickFix.ClOrdID myClOrdID = new QuickFix.ClOrdID();
QuickFix.TimeInForce myTimeInForce = new QuickFix.TimeInForce();
// the account code is mandatory
if (myQFOrder.isSetField(myAccount))
{
myQFOrder.getField(myAccount);
}
else
{
this.SendAdvisoryMessage("IB TWS: you need to provide a valid account");
throw new Exception("IB TWS: you need to provide a valid account");
}
myQFOrder.getField(myClOrdID);
// Get the Order type
myQFOrder.getField(myOrdType);
// Get the QTY
myQFOrder.getField(myOrderQty);
// get the Side of the order
myQFOrder.getField(mySide);
// Set order duration
myQFOrder.getField(myTimeInForce);
// Prices
if (myQFOrder.isSetField(myPrice))
{
myQFOrder.getField(myPrice);
}
if (myQFOrder.isSetField(myStopPx))
{
myQFOrder.getField(myStopPx);
}
// get the contract
TWSLib.IContract myContract = getIBContract(myQFOrder);
if (myContract == null)
{
this.SendAdvisoryMessage("IB TWS: cannot find a valid contract");
throw new Exception("IB TWS: cannot find a valid contract");
}
// create an IB Order
TWSLib.IOrder myIBOrder = m_Host.TWS.createOrder();
myIBOrder.whatIf = 0;
myIBOrder.account = myAccount.getValue();
if(myOrdType.getValue() == QuickFix.OrdType.LIMIT)
{
myIBOrder.orderType = "LMT";
myIBOrder.lmtPrice = myPrice.getValue();
}
else if(myOrdType.getValue() == QuickFix.OrdType.MARKET)
{
myIBOrder.orderType = "MKT";
}
else if (myOrdType.getValue() == QuickFix.OrdType.STOP)
{
myIBOrder.orderType = "STP";
myIBOrder.auxPrice = myStopPx.getValue();
if (myPrice.getValue() == -1)
{
myIBOrder.lmtPrice = myStopPx.getValue();
}
else
{
myIBOrder.lmtPrice = myPrice.getValue();
}
}
else if (myOrdType.getValue() == QuickFix.OrdType.STOP_LIMIT)
{
myIBOrder.orderType = "STP";
myIBOrder.auxPrice = myStopPx.getValue();
if (myPrice.getValue() == -1)
{
myIBOrder.lmtPrice = myStopPx.getValue();
}
else
{
myIBOrder.lmtPrice = myPrice.getValue();
}
}
else
{
this.SendAdvisoryMessage("IB TWS: order type not supported");
throw new Exception("IB TWS: order type not supported");
}
myIBOrder.totalQuantity = (int) myOrderQty.getValue();
// Side
string myAction = KaiUtil.QFUtils.DecodeSide(mySide).ToUpper();
myIBOrder.action = myAction;
// Time in force
string myTIF = KaiUtil.QFUtils.DecodeTimeInForce(myTimeInForce).ToUpper();
myIBOrder.timeInForce = myTIF;
if (myOrdType.getValue() == QuickFix.OrdType.LIMIT)
{
myIBOrder.lmtPrice = myPrice.getValue();
}
DriverBase.OrderContext myCntx = RecordOrderContext(myClOrdID.getValue(), myQFOrder, null, m_NextID.ToString());
SetContextCommand(myCntx, DriverBase.ORCommand.Undefined, DriverBase.ORCommand.Submit);
myCntx.OrderQty = myIBOrder.totalQuantity;
myCntx.CumQty = 0;
m_Host.TWS.placeOrderEx(m_NextID++, myContract, myIBOrder);
}
catch (Exception myE)
{
_log.Error("submitOrder", myE);
// To provide the end user with more information
// send an advisory message, again this is optional
// and depends on the adpater
this.SendAdvisoryMessage("IB TWS:submitOrder: problem submitting order:" + myE.ToString());
QuickFix.OrdStatus myOrdStatus;
QuickFix.ExecType myExecType = new QuickFix.ExecType(QuickFix.ExecType.REJECTED);
myOrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.REJECTED);
QuickFix.OrderQty orderQty = new QuickFix.OrderQty();
if (myQFOrder != null)
{
myQFOrder.getField(orderQty);
QuickFix.OrdRejReason myRejReason = new QuickFix.OrdRejReason(QuickFix.OrdRejReason.OTHER);
sendExecReport(myQFOrder, new QuickFix.OrderID("UNKNOWN"), myOrdStatus, myExecType, 0.0, (int)orderQty.getValue(), 0, 0, 0, myE.Message, myRejReason);
}
}
}
void rejectOrder(string id, string msg)
{
try
{
QuickFix.OrdStatus myOrdStatus;
QuickFix.ExecType myExecType = new QuickFix.ExecType(QuickFix.ExecType.ORDER_STATUS);
double myLastFill = 0.0;
// get the order contect using the IB ID
DriverBase.OrderContext myCntx = null;
if (this.m_ApiIDOrderMap.ContainsKey(id))
{
myCntx = m_ApiIDOrderMap[id];
}
if (myCntx == null)
{
string myErr = "IB TWS: no context found for IB ID:" + id;
Exception myE = new Exception(myErr);
throw myE;
}
// get the original order from the context
QuickFix.Message myOrder = myCntx.QFOrder;
myOrdStatus = new QuickFix.OrdStatus(QuickFix.OrdStatus.REJECTED);
QuickFix.OrdRejReason reason = new QuickFix.OrdRejReason(QuickFix.OrdRejReason.UNKNOWN);
sendExecReport(myOrder, new QuickFix.OrderID(id), myOrdStatus, myExecType, myLastFill, 0, 0, 0, 0,msg, reason );
// mark the context as done for the sub
SetContextCommand(myCntx, DriverBase.ORCommand.Pull, DriverBase.ORCommand.Undefined);
}
catch (Exception myE)
{
_log.Error("rejectOrder", myE);
}
}
public bool isSet(QuickFix.OrdStatus field)
{
return(isSetField(field));
}
public QuickFix.OrdStatus getOrdStatus()
{
QuickFix.OrdStatus value = new QuickFix.OrdStatus();
getField(value); return(value);
}
public QuickFix.OrdStatus get(QuickFix.OrdStatus value)
{
getField(value); return(value);
}
public void set(QuickFix.OrdStatus value)
{
setField(value);
}
/// <summary>
/// Handle an incomming execution report
/// </summary>
/// <param name="myMsg"></param>
public void HandleExecReport(KaiTrade.Interfaces.Message myMsg)
{
try
{
if (m_Log.IsInfoEnabled)
{
m_Log.Info("OrderService:HandleExecReport:" + myMsg.Data);
}
if (m_ORLog.IsInfoEnabled)
{
m_ORLog.Info("OrderService:HandleExecReport:" + myMsg.Data);
}
// Get order manager
KaiTrade.Interfaces.OrderManager myOM = KTAFacade.Instance().Factory.GetOrderManager();
//Create a quickfix message object
QuickFix.Message myFixMsg = new QuickFix.Message(myMsg.Data);
QuickFix.ExecID myExecID = new QuickFix.ExecID();
myFixMsg.getField(myExecID);
// check if we have already processed this report
if (!myOM.RecordExecutionReport(myExecID.getValue(), myFixMsg))
{
// we have processed this already
m_Log.Warn("HandleExecReport: Duplicate Exec Report:" + myMsg.Data);
return;
}
// these fields must be present
QuickFix.OrderID myOrderID = new QuickFix.OrderID();
myFixMsg.getField(myOrderID);
QuickFix.ExecType myExecType = new QuickFix.ExecType();
myFixMsg.getField(myExecType);
QuickFix.OrdStatus myOrdStatus = new QuickFix.OrdStatus();
myFixMsg.getField(myOrdStatus);
// we need the clordid to update an existing order - if
// it is not present or unknow we create a synthetic order
QuickFix.ClOrdID myClOrdID = new QuickFix.ClOrdID();
KaiTrade.Interfaces.Order myOrder = null;
if (myFixMsg.isSetField(myClOrdID))
{
myFixMsg.getField(myClOrdID);
myOrder = myOM.GetOrderWithClOrdIDID(myClOrdID.getValue());
}
if (myOrder == null)
{
myOrder = CreateSyntheticOrder(myFixMsg);
}
// add the ExecRep to the Order
KaiTrade.Interfaces.Fill myFill = new K2DataObjects.FillData();
myFill.OrderID = myOrder.Identity;
myFill.SetUpFromFixExecReport(myFixMsg.ToString());
myOrder.FillsList.Add(myFill);
// update mandatory fields
myOrder.OrderID = myOrderID;
myOrder.OrdStatus = myOrdStatus;
QuickFix.Text myText = new QuickFix.Text();
if (myFixMsg.isSetField(myText))
{
myFixMsg.getField(myText);
myOrder.Text = myText.getValue();
}
QuickFix.Account myAccount = new QuickFix.Account();
if (myFixMsg.isSetField(myAccount))
{
myFixMsg.getField(myAccount);
myOrder.Account = myAccount;
}
// process the execution depanding on type of ExecReport
switch (myExecType.getValue())
{
case QuickFix.ExecType.NEW:
processGeneralExecRep(ref myOrder, myFixMsg);
/*
if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.neworder)
{
order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
}
else
{
m_Log.Error("HandleExecReport:OrderStatus new not expected");
}
* */
break;
case QuickFix.ExecType.FILL:
if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.neworder)
{
order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
}
processFill(ref myOrder, myFixMsg);
break;
case QuickFix.ExecType.PARTIAL_FILL:
if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.neworder)
{
order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
}
processFill(ref myOrder, myFixMsg);
break;
case QuickFix.ExecType.ORDER_STATUS:
processGeneralExecRep(ref myOrder, myFixMsg);
break;
default:
processGeneralExecRep(ref myOrder, myFixMsg);
break;
}
myOM.SetChanged(myOrder.Identity);
// Check if the order is part of a strategy
if (myOrder.ParentIdentity != null)
{
// get the strategy concerned
KaiTrade.Interfaces.IStrategy myStrat = KTAFacade.Instance().Factory.GetStrategyManager().GetStrategy(myOrder.ParentIdentity);
if (myStrat != null)
{
myStrat.HandleExecReport(myFixMsg, myOrder);
}
else
{
m_Log.Error("Strategy not found for:" + myOrder.ParentIdentity);
}
}
if (myOrder.OCAGroupName.Length > 0)
{
KTAFacade.Instance().Factory.GetOCOManager().OnOrderTraded(myOrder);
}
if (m_ORLog.IsInfoEnabled)
{
m_ORLog.Info("OrderService:HandleExecRep:Exit:" + myOrder.ToString());
}
}
catch (Exception myE)
{
m_Log.Error("HandleExecReport", myE);
}
}
/// <summary>
/// Create a synthetic order
/// </summary>
/// <param name="myMsg"></param>
/// <returns>n order</returns>
public KaiTrade.Interfaces.Order CreateSyntheticOrder(QuickFix.Message myFixMsg)
{
KaiTrade.Interfaces.Order myOrder = null;
try
{
if (m_Log.IsInfoEnabled)
{
m_Log.Info("exec report recd:" + myFixMsg.ToString());
}
// Get order manager
KaiTrade.Interfaces.OrderManager myOM = KTAFacade.Instance().Factory.GetOrderManager();
// these fields must be present
QuickFix.OrderID myOrderID = new QuickFix.OrderID();
myFixMsg.getField(myOrderID);
QuickFix.ExecType myExecType = new QuickFix.ExecType();
myFixMsg.getField(myExecType);
QuickFix.ExecID myExecID = new QuickFix.ExecID();
myFixMsg.getField(myExecID);
QuickFix.OrdStatus myOrdStatus = new QuickFix.OrdStatus();
myFixMsg.getField(myOrdStatus);
// Create the order
myOrder = myOM.CreateOrder();
// we need the clordid to update an existing order - if
// it is not present or unknow we create a synthetic order
QuickFix.ClOrdID myClOrdID = new QuickFix.ClOrdID();
if (myFixMsg.isSetField(myClOrdID))
{
myOrder.ClOrdID = myClOrdID;
}
}
catch (Exception myE)
{
m_Log.Error("CreateSyntheticOrder", myE);
}
return myOrder;
}
/// <summary>
/// Process general purpose exec i.e. some type of order status change
/// </summary>
/// <param name="myOrder"></param>
/// <param name="myExec"></param>
private void processGeneralExecRep(ref KaiTrade.Interfaces.Order myOrder, QuickFix.Message myExec)
{
if (m_ORLog.IsInfoEnabled)
{
m_ORLog.Info("processGeneralExecRep:");
}
QuickFix.OrdStatus myOrdStatus = new QuickFix.OrdStatus();
QuickFix.LeavesQty myLeavesQty = new QuickFix.LeavesQty();
QuickFix.CumQty myCumQty = new QuickFix.CumQty();
myExec.getField(myOrdStatus);
myOrder.OrdStatus = myOrdStatus;
switch (myOrdStatus.getValue())
{
case QuickFix.OrdStatus.CANCELED:
if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.cancel)
{
order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
}
myLeavesQty = new QuickFix.LeavesQty(0.0);
myOrder.LeavesQty = myLeavesQty;
break;
case QuickFix.OrdStatus.NEW:
if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.neworder)
{
order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
}
else if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.replace)
{
order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
}
else
{
m_Log.Error("HandleExecReport:OrderStatus new not expected");
}
myOrder.LeavesQty = new QuickFix.LeavesQty(myOrder.OrderQty.getValue());
myOrder.CumQty = new QuickFix.CumQty(0.0);
break;
case QuickFix.OrdStatus.REPLACED:
if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.replace)
{
order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
}
if (myExec.isSetField(myLeavesQty))
{
myExec.getField(myLeavesQty);
myOrder.LeavesQty = myLeavesQty;
}
if (myExec.isSetField(myCumQty))
{
myExec.getField(myCumQty);
myOrder.CumQty = myCumQty;
}
break;
case QuickFix.OrdStatus.PENDING_REPLACE:
if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.replace)
{
m_ORLog.Error("Pending replace received but last command is not replace");
}
break;
case QuickFix.OrdStatus.REJECTED:
if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.cancel)
{
order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
}
else if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.neworder)
{
order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
}
else if (order.LastOrderCommand == KaiTrade.Interfaces.LastOrderCommand.replace)
{
order.LastOrderCommand = KaiTrade.Interfaces.LastOrderCommand.none;
}
break;
default:
break;
}
}
/// <summary>
/// Process partial or fully filled
/// </summary>
/// <param name="myOrder"></param>
/// <param name="myExec"></param>
private void processFill(ref KaiTrade.Interfaces.Order myOrder, QuickFix.Message myExec)
{
K2ServiceInterface.ITransaction myTrn = null;
try
{
// if the object supports transactions do the update as a trn
myTrn = myOrder as K2ServiceInterface.ITransaction;
if (myTrn != null)
{
myTrn.StartUpdate();
}
// Get the currently executed quantity for chain of orders.
QuickFix.CumQty myCumQty = new QuickFix.CumQty();
myExec.getField(myCumQty);
myOrder.CumQty = myCumQty;
// Get quantity open for further execution (order qty - cum qty)
QuickFix.LeavesQty myLeavesQty = new QuickFix.LeavesQty();
myExec.getField(myLeavesQty);
myOrder.LeavesQty = myLeavesQty;
QuickFix.LastPx myLastPx = new QuickFix.LastPx();
if (myExec.isSetField(myLastPx))
{
myExec.getField(myLastPx);
myOrder.LastPx = myLastPx;
}
QuickFix.AvgPx myAvgPx = new QuickFix.AvgPx();
if (myExec.isSetField(myAvgPx))
{
myExec.getField(myAvgPx);
myOrder.AvgPx = myAvgPx;
}
QuickFix.LastQty myLastQty = new QuickFix.LastQty();
if (myExec.isSetField(myLastQty))
{
myExec.getField(myLastQty);
myOrder.LastQty = myLastQty;
}
QuickFix.OrdStatus myOrdStatus = new QuickFix.OrdStatus();
myExec.getField(myOrdStatus);
myOrder.OrdStatus = myOrdStatus;
// always signal the end of the update
if (myTrn != null)
{
myTrn.EndUpdate();
}
}
catch (Exception myE)
{
m_Log.Error("processFill", myE);
// always signal the end of the update
if (myTrn != null)
{
myTrn.EndUpdate();
}
}
}
