/// <summary> /// Creates a deep-copy clone of this order /// </summary> /// <returns>A copy of this order</returns> public override Order Clone() { var order = new MarketOnOpenOrder(); CopyTo(order); return(order); }
/// <summary> /// Creates an order of the correct type /// </summary> private static Order CreateOrder(OrderType orderType, JObject jObject) { Order order; switch (orderType) { case OrderType.Market: order = new MarketOrder(); break; case OrderType.Limit: order = new LimitOrder { LimitPrice = jObject["LimitPrice"] == null ? default(decimal) : jObject["LimitPrice"].Value <decimal>() }; break; case OrderType.StopMarket: order = new StopMarketOrder { StopPrice = jObject["StopPrice"] == null ? default(decimal) : jObject["StopPrice"].Value <decimal>() }; break; case OrderType.StopLimit: order = new StopLimitOrder { LimitPrice = jObject["LimitPrice"] == null ? default(decimal) : jObject["LimitPrice"].Value <decimal>(), StopPrice = jObject["StopPrice"] == null ? default(decimal) : jObject["StopPrice"].Value <decimal>() }; break; case OrderType.LimitIfTouched: order = new LimitIfTouchedOrder { LimitPrice = jObject["LimitPrice"] == null ? default(decimal) : jObject["LimitPrice"].Value <decimal>(), TriggerPrice = jObject["TriggerPrice"] == null ? default(decimal) : jObject["TriggerPrice"].Value <decimal>() }; break; case OrderType.MarketOnOpen: order = new MarketOnOpenOrder(); break; case OrderType.MarketOnClose: order = new MarketOnCloseOrder(); break; case OrderType.OptionExercise: order = new OptionExerciseOrder(); break; default: throw new ArgumentOutOfRangeException(); } return(order); }
private static Order CreateOrder(int orderId, OrderType type, Symbol symbol, decimal quantity, DateTime time, string tag, IOrderProperties properties, decimal limitPrice, decimal stopPrice, decimal triggerPrice) { Order order; switch (type) { case OrderType.Market: order = new MarketOrder(symbol, quantity, time, tag, properties); break; case OrderType.Limit: order = new LimitOrder(symbol, quantity, limitPrice, time, tag, properties); break; case OrderType.StopMarket: order = new StopMarketOrder(symbol, quantity, stopPrice, time, tag, properties); break; case OrderType.StopLimit: order = new StopLimitOrder(symbol, quantity, stopPrice, limitPrice, time, tag, properties); break; case OrderType.LimitIfTouched: order = new LimitIfTouchedOrder(symbol, quantity, triggerPrice, limitPrice, time, tag, properties); break; case OrderType.MarketOnOpen: order = new MarketOnOpenOrder(symbol, quantity, time, tag, properties); break; case OrderType.MarketOnClose: order = new MarketOnCloseOrder(symbol, quantity, time, tag, properties); break; case OrderType.OptionExercise: order = new OptionExerciseOrder(symbol, quantity, time, tag, properties); break; default: throw new ArgumentOutOfRangeException(); } order.Status = OrderStatus.New; order.Id = orderId; return(order); }
/// <summary> /// Creates an <see cref="Order"/> to match the specified <paramref name="request"/> /// </summary> /// <param name="request">The <see cref="SubmitOrderRequest"/> to create an order for</param> /// <returns>The <see cref="Order"/> that matches the request</returns> public static Order CreateOrder(SubmitOrderRequest request) { Order order; switch (request.OrderType) { case OrderType.Market: order = new MarketOrder(request.Symbol, request.Quantity, request.Time, request.Tag, request.OrderProperties); break; case OrderType.Limit: order = new LimitOrder(request.Symbol, request.Quantity, request.LimitPrice, request.Time, request.Tag, request.OrderProperties); break; case OrderType.StopMarket: order = new StopMarketOrder(request.Symbol, request.Quantity, request.StopPrice, request.Time, request.Tag, request.OrderProperties); break; case OrderType.StopLimit: order = new StopLimitOrder(request.Symbol, request.Quantity, request.StopPrice, request.LimitPrice, request.Time, request.Tag, request.OrderProperties); break; case OrderType.MarketOnOpen: order = new MarketOnOpenOrder(request.Symbol, request.Quantity, request.Time, request.Tag, request.OrderProperties); break; case OrderType.MarketOnClose: order = new MarketOnCloseOrder(request.Symbol, request.Quantity, request.Time, request.Tag, request.OrderProperties); break; case OrderType.OptionExercise: order = new OptionExerciseOrder(request.Symbol, request.Quantity, request.Time, request.Tag, request.OrderProperties); break; default: throw new ArgumentOutOfRangeException(); } order.Status = OrderStatus.New; order.Id = request.OrderId; if (request.Tag != null) { order.Tag = request.Tag; } return(order); }
private Order ConvertOrder(IB.Order ibOrder, IB.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, ibOrder.TotalQuantity, new DateTime() // not sure how to get this data ); break; case OrderType.MarketOnOpen: order = new MarketOnOpenOrder(mappedSymbol, ibOrder.TotalQuantity, new DateTime()); break; case OrderType.MarketOnClose: order = new MarketOnCloseOrder(mappedSymbol, ibOrder.TotalQuantity, new DateTime() ); break; case OrderType.Limit: order = new LimitOrder(mappedSymbol, ibOrder.TotalQuantity, ibOrder.LimitPrice, new DateTime() ); break; case OrderType.StopMarket: order = new StopMarketOrder(mappedSymbol, ibOrder.TotalQuantity, ibOrder.AuxPrice, new DateTime() ); break; case OrderType.StopLimit: order = new StopLimitOrder(mappedSymbol, ibOrder.TotalQuantity, ibOrder.AuxPrice, ibOrder.LimitPrice, new DateTime() ); break; default: throw new InvalidEnumArgumentException("orderType", (int) orderType, typeof (OrderType)); } order.BrokerId.Add(ibOrder.OrderId.ToString()); return order; }
/// <summary> /// Creates an <see cref="Order"/> to match the specified <paramref name="request"/> /// </summary> /// <param name="request">The <see cref="SubmitOrderRequest"/> to create an order for</param> /// <returns>The <see cref="Order"/> that matches the request</returns> public static Order CreateOrder(SubmitOrderRequest request) { Order order; switch (request.OrderType) { case OrderType.Market: order = new MarketOrder(request.Symbol, request.Quantity, request.Time, request.Tag, request.SecurityType); break; case OrderType.Limit: order = new LimitOrder(request.Symbol, request.Quantity, request.LimitPrice, request.Time, request.Tag, request.SecurityType); break; case OrderType.StopMarket: order = new StopMarketOrder(request.Symbol, request.Quantity, request.StopPrice, request.Time, request.Tag, request.SecurityType); break; case OrderType.StopLimit: order = new StopLimitOrder(request.Symbol, request.Quantity, request.StopPrice, request.LimitPrice, request.Time, request.Tag, request.SecurityType); break; case OrderType.MarketOnOpen: order = new MarketOnOpenOrder(request.Symbol, request.SecurityType, request.Quantity, request.Time, request.Tag); break; case OrderType.MarketOnClose: order = new MarketOnCloseOrder(request.Symbol, request.SecurityType, request.Quantity, request.Time, request.Tag); break; default: throw new ArgumentOutOfRangeException(); } order.Status = OrderStatus.New; order.Id = request.OrderId; if (request.Tag != null) { order.Tag = request.Tag; } return order; }
/// <summary> /// Creates an order of the correct type /// </summary> private static Order CreateOrder(OrderType orderType, JObject jObject) { Order order; switch (orderType) { case OrderType.Market: order = new MarketOrder(); break; case OrderType.Limit: order = new LimitOrder {LimitPrice = jObject["LimitPrice"].Value<decimal>()}; break; case OrderType.StopMarket: order = new StopMarketOrder { StopPrice = jObject["StopPrice"].Value<decimal>() }; break; case OrderType.StopLimit: order = new StopLimitOrder { LimitPrice = jObject["LimitPrice"].Value<decimal>(), StopPrice = jObject["StopPrice"].Value<decimal>() }; break; case OrderType.MarketOnOpen: order = new MarketOnOpenOrder(); break; case OrderType.MarketOnClose: order = new MarketOnCloseOrder(); break; default: throw new ArgumentOutOfRangeException(); } return order; }
public void PerformsMarketOnOpenUsingOpenPrice() { var reference = new DateTime(2015, 06, 05, 9, 0, 0); // before market open var model = new SecurityTransactionModel(); var order = new MarketOnOpenOrder(Symbol, SecurityType.Equity, 100, reference); var config = CreateTradeBarConfig(Symbol); var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config, 1) { Exchange = new EquityExchange(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours()) }; var time = reference; security.SetMarketPrice(time, new TradeBar(time, Symbol, 1m, 2m, 0.5m, 1.33m, 100)); var fill = model.MarketOnOpenFill(security, order); Assert.AreEqual(0, fill.FillQuantity); // market opens after 30min, so this is just before market open time = reference.AddMinutes(29); security.SetMarketPrice(time, new TradeBar(time, Symbol, 1.33m, 2.75m, 1.15m, 1.45m, 100)); fill = model.MarketOnOpenFill(security, order); Assert.AreEqual(0, fill.FillQuantity); // market opens after 30min time = reference.AddMinutes(30); security.SetMarketPrice(time, new TradeBar(time, Symbol, 1.45m, 2.0m, 1.1m, 1.40m, 100)); fill = model.MarketOnOpenFill(security, order); Assert.AreEqual(order.Quantity, fill.FillQuantity); Assert.AreEqual(security.Open, fill.FillPrice); }
public void PerformsMarketOnOpenUsingOpenPrice() { var reference = new DateTime(2015, 06, 05, 9, 0, 0); // before market open var model = new SecurityTransactionModel(); var order = new MarketOnOpenOrder(Symbols.SPY, 100, reference); var config = CreateTradeBarConfig(Symbols.SPY); var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config, new Cash(CashBook.AccountCurrency, 0, 1m), SymbolProperties.GetDefault(CashBook.AccountCurrency)); security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork)); var time = reference; TimeKeeper.SetUtcDateTime(time.ConvertToUtc(TimeZones.NewYork)); security.SetMarketPrice(new TradeBar(time, Symbols.SPY, 1m, 2m, 0.5m, 1.33m, 100)); var fill = model.MarketOnOpenFill(security, order); Assert.AreEqual(0, fill.FillQuantity); // market opens after 30min, so this is just before market open time = reference.AddMinutes(29); TimeKeeper.SetUtcDateTime(time.ConvertToUtc(TimeZones.NewYork)); security.SetMarketPrice(new TradeBar(time, Symbols.SPY, 1.33m, 2.75m, 1.15m, 1.45m, 100)); fill = model.MarketOnOpenFill(security, order); Assert.AreEqual(0, fill.FillQuantity); // market opens after 30min time = reference.AddMinutes(30); TimeKeeper.SetUtcDateTime(time.ConvertToUtc(TimeZones.NewYork)); security.SetMarketPrice(new TradeBar(time, Symbols.SPY, 1.45m, 2.0m, 1.1m, 1.40m, 100)); fill = model.MarketOnOpenFill(security, order); Assert.AreEqual(order.Quantity, fill.FillQuantity); Assert.AreEqual(security.Open, fill.FillPrice); }
/// <summary> /// Creates a deep-copy clone of this order /// </summary> /// <returns>A copy of this order</returns> public override Order Clone() { var order = new MarketOnOpenOrder(); CopyTo(order); return order; }
/// <summary> /// Market on Open Fill Model. Return an order event with the fill details /// </summary> /// <param name="asset">Asset we're trading with this order</param> /// <param name="order">Order to be filled</param> /// <returns>Order fill information detailing the average price and quantity filled.</returns> public OrderEvent MarketOnOpenFill(Security asset, MarketOnOpenOrder order) { var utcTime = asset.LocalTime.ConvertToUtc(asset.Exchange.TimeZone); var orderFee = GetOrderFee(asset, order); var fill = new OrderEvent(order, utcTime, orderFee); if (order.Status == OrderStatus.Canceled) return fill; try { // MOO should never fill on the same bar or on stale data // Imagine the case where we have a thinly traded equity, ASUR, and another liquid // equity, say SPY, SPY gets data every minute but ASUR, if not on fill forward, maybe // have large gaps, in which case the currentBar.EndTime will be in the past // ASUR | | | [order] | | | | | | | // SPY | | | | | | | | | | | | | | | | | | | | var currentBar = asset.GetLastData(); var localOrderTime = order.Time.ConvertFromUtc(asset.Exchange.TimeZone); if (currentBar == null || localOrderTime >= currentBar.EndTime) return fill; // if the MOO was submitted during market the previous day, wait for a day to turn over if (asset.Exchange.DateTimeIsOpen(localOrderTime) && localOrderTime.Date == asset.LocalTime.Date) { return fill; } // wait until market open // make sure the exchange is open before filling if (!IsExchangeOpen(asset)) return fill; fill.FillPrice = asset.Open; fill.Status = OrderStatus.Filled; //Calculate the model slippage: e.g. 0.01c var slip = GetSlippageApproximation(asset, order); //Apply slippage switch (order.Direction) { case OrderDirection.Buy: fill.FillPrice += slip; break; case OrderDirection.Sell: fill.FillPrice -= slip; break; } // assume the order completely filled if (fill.Status == OrderStatus.Filled) fill.FillQuantity = order.Quantity; } catch (Exception err) { Log.Error(err); } return fill; }
/// <summary> /// Market on open order implementation: Send a market order when the exchange opens /// </summary> /// <param name="symbol">The symbol to be ordered</param> /// <param name="quantity">The number of shares to required</param> /// <param name="tag">Place a custom order property or tag (e.g. indicator data).</param> /// <returns>The order ID</returns> public int MarketOnOpenOrder(string symbol, int quantity, string tag = "") { var error = PreOrderChecks(symbol, quantity, OrderType.MarketOnOpen); if (error < 0) { return error; } var security = Securities[symbol]; var order = new MarketOnOpenOrder(symbol, security.Type, quantity, Time, security.Price, tag); return Transactions.AddOrder(order); }
/// <summary> /// Market on Open Fill Model. Return an order event with the fill details /// </summary> /// <param name="asset">Asset we're trading with this order</param> /// <param name="order">Order to be filled</param> /// <returns>Order fill informaton detailing the average price and quantity filled.</returns> public OrderEvent MarketOnOpenFill(Security asset, MarketOnOpenOrder order) { var fill = new OrderEvent(order); if (order.Status == OrderStatus.Canceled) return fill; try { // MOO should never fill on the same bar or on stale data // Imagine the case where we have a thinly traded equity, ASUR, and another liquid // equity, say SPY, SPY gets data every minute but ASUR, if not on fill forward, maybe // have large gaps, in which case the currentBar.EndTime will be in the past // ASUR | | | [order] | | | | | | | // SPY | | | | | | | | | | | | | | | | | | | | var currentBar = asset.GetLastData(); if (order.Time >= currentBar.EndTime) return fill; // if the MOO was submitted during market the previous day, wait for a day to turn over if (asset.Exchange.DateTimeIsOpen(order.Time) && order.Time.Date == asset.Time.Date) { return fill; } // wait until market open // make sure the exchange is open before filling if (!asset.Exchange.IsOpenDuringBar(currentBar.Time, currentBar.EndTime, false)) return fill; order.Price = asset.Open; order.Status = OrderStatus.Filled; //Calculate the model slippage: e.g. 0.01c var slip = GetSlippageApproximation(asset, order); //Apply slippage switch (order.Direction) { case OrderDirection.Buy: order.Price += slip; break; case OrderDirection.Sell: order.Price -= slip; break; } //For backtesting, we assuming the order is 100% filled on first attempt. fill.FillPrice = order.Price; fill.FillQuantity = order.Quantity; fill.Status = order.Status; } catch (Exception err) { Log.Error(err); } return fill; }
/// <summary> /// Market on Open Fill Model. Return an order event with the fill details /// </summary> /// <param name="asset">Asset we're trading with this order</param> /// <param name="order">Order to be filled</param> /// <returns>Order fill information detailing the average price and quantity filled.</returns> public OrderEvent MarketOnOpenFill(Security asset, MarketOnOpenOrder order) { return _fillModel.MarketOnOpenFill(asset, order); }