public OrderStatusMessage(int orderId, Contract contract, IBApi.Order order, OrderState orderstate)
{
MessageType = MessageType.OrderStatus;
OrderId = orderId;
Contract = contract;
Order = order;
OrderState = orderstate;
}
public void openOrder(int orderId, Contract contract, IBApi.Order order, OrderState orderState)
{
//1. Add to open order queue
OpenOrderMessage ooM = new OpenOrderMessage();
ooM.Order = order;
ooM.Contract = contract;
ooM.OrderId = orderId;
ooM.MessageType = MessageType.OpenOrder;
ooM.OrderState = orderState;
MessageHandler.messageBox.Enqueue(ooM);
}
// orderStatus, openOrderEnd, EClientSocket::placeOrder, EClientSocket::reqAllOpenOrders, EClientSocket::reqAutoOpenOrders
public virtual void openOrder(int orderId, Contract contract, IBApi.Order order, OrderState orderState)
{
// log warning
if (!String.IsNullOrEmpty(orderState.WarningText))
OnDebug(orderState.WarningText);
if (orderState.Status != "Submitted" && orderState.Status != "Filled" && orderState.Status != "PreSubmitted")
{
// igore other states
return;
}
Order o = new Order();
o.OrderStatus = (OrderStatus)EnumDescConverter.GetEnumValue(typeof(OrderStatus), orderState.Status);
if (_iborderIdToOrderInfo.ContainsKey(orderId))
{
if (_iborderIdToOrderInfo[orderId].IsAcknowledged)
return; // already acknowledged
_iborderIdToOrderInfo[orderId].IsAcknowledged = true;
// update account as it might not have been set explicitly
// account is used for cancelling order
_iborderIdToOrderInfo[orderId].Account = order.Account;
}
else // the order was placed directly in Tws
{
long soId = (long)orderId;
_iborderIdToOrderInfo.Add(orderId, new OrderInfo(soId, order.Account, true));
OnDebug("Got order not from strategy. Id = " + orderId + ", " + "symbol = " + contract.Symbol);
}
o.Id = _iborderIdToOrderInfo[orderId].StrategyOrderId; // strategy Order Id
o.Account = order.Account;
o.OrderSize = Math.Abs(order.TotalQuantity) * ((order.Action == "BUY") ? 1 : -1);
// Order full symbol includes localsymbol, exchange, multiplier, sectype
// o.LocalSymbol = contract.LocalSymbol;
// o.Exchange = contract.Exchange;
// o.Security = (SecurityType)EnumDescConverter.GetEnumValue(typeof(SecurityType), contract.SecType);
o.FullSymbol = ContractToSecurityFullName(contract);
o.TrailPrice = ((order.OrderType == "TRAIL") || (order.OrderType == "TRAIL LIMIT")) ? (decimal)order.AuxPrice : 0m;
o.StopPrice = ((order.OrderType == "STP") || (order.OrderType == "STP LMT")) ? (decimal)order.AuxPrice : 0m;
o.LimitPrice = ((order.OrderType == "LMT") || (order.OrderType == "TRAIL LIMIT") || (order.OrderType == "STP LMT")) ? (decimal)order.LmtPrice : 0m;
o.Currency = contract.Currency;
// o.Currency = (CurrencyType)EnumDescConverter.GetEnumValue(typeof(CurrencyType), contract.Currency);
// o.TIF = order.Tif; // Todo: add Tif
o.OrderDate = Util.ToIntDate(DateTime.Now);
o.OrderTime = Util.ToIntTime(DateTime.Now);
if (contract.SecType != "BAG")
{
OnGotOrder(o);
// send deferred fills if any
// iterate backwards for possible removal
for (int i = _duplicateIBIdToDeferredTrade.Count - 1; i > -1; i--)
{
if (_duplicateIBIdToDeferredTrade[i].Key == orderId)
{
Trade trade = _duplicateIBIdToDeferredTrade[i].Value;
trade.Id = o.Id; // strategy id
_duplicateIBIdToDeferredTrade.RemoveAt(i);
OnGotFill(trade);
}
}
}
}
/// <summary>
/// Maps OrderType enum
/// </summary>
private static OrderType ConvertOrderType(IBApi.Order order)
{
switch (order.OrderType)
{
case IB.OrderType.Limit: return OrderType.Limit;
case IB.OrderType.Stop: return OrderType.StopMarket;
case IB.OrderType.StopLimit: return OrderType.StopLimit;
case IB.OrderType.MarketOnClose: return OrderType.MarketOnClose;
case IB.OrderType.Market:
if (order.Tif == IB.TimeInForce.MarketOnOpen)
{
return OrderType.MarketOnOpen;
}
return OrderType.Market;
default:
throw new ArgumentException(order.OrderType, "order.OrderType");
}
}
private Order ConvertOrder(IBApi.Order ibOrder, Contract contract)
{
// this function is called by GetOpenOrders which is mainly used by the setup handler to
// initialize algorithm state. So the only time we'll be executing this code is when the account
// has orders sitting and waiting from before algo initialization...
// because of this we can't get the time accurately
Order order;
var mappedSymbol = MapSymbol(contract);
var orderType = ConvertOrderType(ibOrder);
switch (orderType)
{
case OrderType.Market:
order = new MarketOrder(mappedSymbol,
Convert.ToInt32(ibOrder.TotalQuantity),
new DateTime() // not sure how to get this data
);
break;
case OrderType.MarketOnOpen:
order = new MarketOnOpenOrder(mappedSymbol,
Convert.ToInt32(ibOrder.TotalQuantity),
new DateTime());
break;
case OrderType.MarketOnClose:
order = new MarketOnCloseOrder(mappedSymbol,
Convert.ToInt32(ibOrder.TotalQuantity),
new DateTime()
);
break;
case OrderType.Limit:
order = new LimitOrder(mappedSymbol,
Convert.ToInt32(ibOrder.TotalQuantity),
Convert.ToDecimal(ibOrder.LmtPrice),
new DateTime()
);
break;
case OrderType.StopMarket:
order = new StopMarketOrder(mappedSymbol,
Convert.ToInt32(ibOrder.TotalQuantity),
Convert.ToDecimal(ibOrder.AuxPrice),
new DateTime()
);
break;
case OrderType.StopLimit:
order = new StopLimitOrder(mappedSymbol,
Convert.ToInt32(ibOrder.TotalQuantity),
Convert.ToDecimal(ibOrder.AuxPrice),
Convert.ToDecimal(ibOrder.LmtPrice),
new DateTime()
);
break;
default:
throw new InvalidEnumArgumentException("orderType", (int) orderType, typeof (OrderType));
}
order.BrokerId.Add(ibOrder.OrderId.ToString());
return order;
}
public void UpdateOrder(IBApi.Order o)
{
//1. Find & Replace
var i = ActiveOrders.FindIndex(x => x.OrderId == o.OrderId);
ActiveOrders[i] = o;
}
public void AddOrder(IBApi.Order o)
{
ActiveOrders.Add(o);
}
public bool ValidateOrder(IBApi.Order o)
{
bool orderStatus = true;
//1. Size Limit
if (o.TotalQuantity > contractLimit)
return false;
//2. Price Limit
//3.
return orderStatus;
}
