public void PerformsLimitFillSell() { var model = new SecurityTransactionModel(); var order = new LimitOrder(Symbol, -100, 101.5m, Noon, type: SecurityType.Equity); var config = CreateTradeBarConfig(Symbol); var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config, 1); security.SetMarketPrice(Noon, new IndicatorDataPoint(Symbol, Noon, 101m)); var fill = model.LimitFill(security, order); Assert.AreEqual(0, fill.FillQuantity); Assert.AreEqual(0, fill.FillPrice); Assert.AreEqual(OrderStatus.None, fill.Status); Assert.AreEqual(OrderStatus.None, order.Status); security.SetMarketPrice(Noon, new TradeBar(Noon, Symbol, 102m, 103m, 101m, 102.3m, 100)); fill = model.LimitFill(security, order); // this fills worst case scenario, so it's at the limit price Assert.AreEqual(order.Quantity, fill.FillQuantity); Assert.AreEqual(Math.Max(order.LimitPrice, security.Low), fill.FillPrice); Assert.AreEqual(OrderStatus.Filled, fill.Status); Assert.AreEqual(OrderStatus.Filled, order.Status); }
public void PerformsLimitFillSell() { var model = new ForexTransactionModel(); var order = new LimitOrder(Symbol, -100, 101.5m, DateTime.Now, type: SecurityType.Forex); var config = CreateTradeBarDataConfig(SecurityType.Forex, Symbol); var security = new Security(SecurityExchangeHours.AlwaysOpen, config, 1); security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork)); security.SetMarketPrice(new IndicatorDataPoint(Symbol, DateTime.Now, 101m)); var fill = model.LimitFill(security, order); Assert.AreEqual(0, fill.FillQuantity); Assert.AreEqual(0, fill.FillPrice); Assert.AreEqual(OrderStatus.None, fill.Status); Assert.AreEqual(OrderStatus.None, order.Status); security.SetMarketPrice(new TradeBar(DateTime.Now, Symbol, 102m, 103m, 101m, 102.3m, 100)); fill = model.LimitFill(security, order); // this fills worst case scenario, so it's at the limit price Assert.AreEqual(order.Quantity, fill.FillQuantity); Assert.AreEqual(Math.Max(order.LimitPrice, security.Low), fill.FillPrice); Assert.AreEqual(OrderStatus.Filled, fill.Status); Assert.AreEqual(OrderStatus.Filled, order.Status); }
public void ClientCancelsLimitOrder() { var orderedResetEvent = new ManualResetEvent(false); var canceledResetEvent = new ManualResetEvent(false); var ib = _interactiveBrokersBrokerage; ib.OrderStatusChanged += (sender, orderEvent) => { if (orderEvent.Status == OrderStatus.Submitted) { orderedResetEvent.Set(); } if (orderEvent.Status == OrderStatus.Canceled) { canceledResetEvent.Set(); } }; // try to sell a single share at a ridiculous price, we'll cancel this later var order = new LimitOrder(Symbol, -buyQuantity, 100000, DateTime.UtcNow, null, Type); _orders.Add(order); ib.PlaceOrder(order); orderedResetEvent.WaitOneAssertFail(2500, "Limit order failed to be submitted."); Thread.Sleep(500); ib.CancelOrder(order); canceledResetEvent.WaitOneAssertFail(2500, "Canceled event did not fire."); var openOrders = ib.GetOpenOrders(); var cancelledOrder = openOrders.FirstOrDefault(x => x.BrokerId.Contains(order.BrokerId[0])); Assert.IsNull(cancelledOrder); }
public void PerformsLimitFillSell() { var model = new SecurityTransactionModel(); var order = new LimitOrder(Symbol, -100, 101.5m, DateTime.Now, type: SecurityType.Equity); var config = new SubscriptionDataConfig(typeof(TradeBar), SecurityType.Equity, Symbol, Resolution.Minute, true, true, true, true, false, 0); var security = new Security(config, 1); security.SetMarketPrice(DateTime.Now, new IndicatorDataPoint(Symbol, DateTime.Now, 101m)); var fill = model.LimitFill(security, order); Assert.AreEqual(0, fill.FillQuantity); Assert.AreEqual(0, fill.FillPrice); Assert.AreEqual(OrderStatus.None, fill.Status); Assert.AreEqual(OrderStatus.None, order.Status); security.SetMarketPrice(DateTime.Now, new TradeBar(DateTime.Now, Symbol, 102m, 103m, 101m, 102.3m, 100)); fill = model.LimitFill(security, order); // this fills worst case scenario, so it's at the limit price Assert.AreEqual(order.Quantity, fill.FillQuantity); Assert.AreEqual(Math.Max(order.LimitPrice, security.Low), fill.FillPrice); Assert.AreEqual(OrderStatus.Filled, fill.Status); Assert.AreEqual(OrderStatus.Filled, order.Status); }
/// <summary> /// Converts an Oanda order into a LEAN order. /// </summary> private Order ConvertOrder(JToken order) { var type = order["type"].ToString(); Order qcOrder; var instrument = order["instrument"].ToString(); var id = order["id"].ToString(); var units = order["units"].ConvertInvariant <decimal>(); var createTime = order["createTime"].ToString(); var securityType = SymbolMapper.GetBrokerageSecurityType(instrument); var symbol = SymbolMapper.GetLeanSymbol(instrument, securityType, Market.Oanda); var time = GetTickDateTimeFromString(createTime); var quantity = units; switch (type) { case "MARKET_IF_TOUCHED": var stopOrder = order.ToObject <MarketIfTouchedOrder>(); qcOrder = new StopMarketOrder { StopPrice = stopOrder.Price.ToDecimal() }; break; case "LIMIT": var limitOrder = order.ToObject <OandaLimitOrder>(); qcOrder = new LimitOrder(symbol, quantity, limitOrder.Price.ToDecimal(), time); break; case "STOP": var stopLimitOrder = order.ToObject <StopOrder>(); var price = stopLimitOrder.Price.ConvertInvariant <decimal>(); var limitPrice = stopLimitOrder.PriceBound.ConvertInvariant <decimal>(); qcOrder = new StopLimitOrder(symbol, quantity, price, limitPrice, time); break; case "MARKET": qcOrder = new MarketOrder(); break; default: throw new NotSupportedException( "An existing " + type + " working order was found and is currently unsupported. Please manually cancel the order before restarting the algorithm."); } qcOrder.Status = OrderStatus.None; qcOrder.BrokerId.Add(id); var gtdTime = order["gtdTime"]; if (gtdTime != null) { var expiry = GetTickDateTimeFromString(gtdTime.ToString()); qcOrder.Properties.TimeInForce = TimeInForce.GoodTilDate(expiry); } return(qcOrder); }
/// <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; 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); }
/// <summary> /// Converts an FXCM order to a QuantConnect order. /// </summary> /// <param name="fxcmOrder">The FXCM order</param> private Order ConvertOrder(ExecutionReport fxcmOrder) { Order order; if (fxcmOrder.getOrdType() == OrdTypeFactory.LIMIT) { order = new LimitOrder { LimitPrice = Convert.ToDecimal(fxcmOrder.getPrice()) }; } else if (fxcmOrder.getOrdType() == OrdTypeFactory.MARKET) { order = new MarketOrder(); } else if (fxcmOrder.getOrdType() == OrdTypeFactory.STOP) { order = new StopMarketOrder { StopPrice = Convert.ToDecimal(fxcmOrder.getPrice()) }; } else { throw new NotSupportedException("FxcmBrokerage.ConvertOrder(): The FXCM order type " + fxcmOrder.getOrdType() + " is not supported."); } var securityType = _symbolMapper.GetBrokerageSecurityType(fxcmOrder.getInstrument().getSymbol()); order.Symbol = _symbolMapper.GetLeanSymbol(fxcmOrder.getInstrument().getSymbol(), securityType, Market.FXCM); order.Quantity = Convert.ToInt32(fxcmOrder.getOrderQty() * (fxcmOrder.getSide() == SideFactory.BUY ? +1 : -1)); order.Status = ConvertOrderStatus(fxcmOrder.getFXCMOrdStatus()); order.BrokerId.Add(fxcmOrder.getOrderID()); order.Duration = ConvertDuration(fxcmOrder.getTimeInForce()); order.Time = FromJavaDate(fxcmOrder.getTransactTime().toDate()); return order; }
public void PerformsLimitFillBuy() { var model = new ForexTransactionModel(); var security = CreateSecurity(); var order = new LimitOrder(Symbols.USDJPY, 100, 101.5m, DateTime.Now, type: SecurityType.Forex); security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork)); security.SetMarketPrice(new IndicatorDataPoint(Symbols.USDJPY, DateTime.Now, 102m)); var fill = model.LimitFill(security, order); Assert.AreEqual(0, fill.FillQuantity); Assert.AreEqual(0, fill.FillPrice); Assert.AreEqual(OrderStatus.None, fill.Status); security.SetMarketPrice(new TradeBar(DateTime.Now, Symbols.USDJPY, 102m, 103m, 101m, 102.3m, 100)); fill = model.LimitFill(security, order); // this fills worst case scenario, so it's at the limit price Assert.AreEqual(order.Quantity, fill.FillQuantity); Assert.AreEqual(Math.Min(order.LimitPrice, security.High), fill.FillPrice); Assert.AreEqual(OrderStatus.Filled, fill.Status); }
public void PerformsLimitFillBuy() { var model = new SecurityTransactionModel(); var order = new LimitOrder(Symbols.SPY, 100, 101.5m, Noon); 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)); security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, Noon, 102m)); var fill = model.LimitFill(security, order); Assert.AreEqual(0, fill.FillQuantity); Assert.AreEqual(0, fill.FillPrice); Assert.AreEqual(OrderStatus.None, fill.Status); security.SetMarketPrice(new TradeBar(Noon, Symbols.SPY, 102m, 103m, 101m, 102.3m, 100)); fill = model.LimitFill(security, order); // this fills worst case scenario, so it's at the limit price Assert.AreEqual(order.Quantity, fill.FillQuantity); Assert.AreEqual(Math.Min(order.LimitPrice, security.High), fill.FillPrice); Assert.AreEqual(OrderStatus.Filled, fill.Status); }
public QuantConnect.Orders.Order ConvertToOrder(Teb.FIX.Model.Order tebOrder) { QuantConnect.Orders.Order o = null; if (tebOrder.OrdType == CashDefinition.ORDTYPE_MARKET) { o = new QuantConnect.Orders.MarketOrder(); } else { o = new QuantConnect.Orders.LimitOrder(); (o as LimitOrder).LimitPrice = tebOrder.Price.HasValue ? tebOrder.Price.Value : 0; } o.Duration = ConvertToTimeInForce(tebOrder.Core.TimeInForce);; o.Id = int.Parse(tebOrder.ClOrdID.Replace("CS", "")); o.Price = tebOrder.Price.HasValue ? tebOrder.Price.Value : 0; o.Quantity = ConvertToQuantity(tebOrder); o.Status = ConvertToStatus(tebOrder); o.Time = tebOrder.TransactTime.HasValue ? tebOrder.TransactTime.Value : DateTime.Now; o.Symbol = tebOrder.Symbol; o.BrokerId.Add(tebOrder.ConnectionClOrdID); return(o); }
/// <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; }
/// <summary> /// Default limit order fill model in the base security class. /// </summary> /// <param name="asset">Security asset we're filling</param> /// <param name="order">Order packet to model</param> /// <returns>Order fill information detailing the average price and quantity filled.</returns> /// <seealso cref="StopMarketFill(Security, StopMarketOrder)"/> /// <seealso cref="MarketFill(Security, MarketOrder)"/> public virtual OrderEvent LimitFill(Security asset, LimitOrder order) { //Initialise; var utcTime = asset.LocalTime.ConvertToUtc(asset.Exchange.TimeZone); var orderFee = GetOrderFee(asset, order); var fill = new OrderEvent(order, utcTime, orderFee); try { //If its cancelled don't need anymore checks: if (order.Status == OrderStatus.Canceled) return fill; //Get the range of prices in the last bar: decimal minimumPrice; decimal maximumPrice; DataMinMaxPrices(asset, out minimumPrice, out maximumPrice); //-> Valid Live/Model Order: switch (order.Direction) { case OrderDirection.Buy: //Buy limit seeks lowest price if (minimumPrice < order.LimitPrice) { //Set order fill: fill.Status = OrderStatus.Filled; // fill at the worse price this bar or the limit price, this allows far out of the money limits // to be executed properly fill.FillPrice = Math.Min(maximumPrice, order.LimitPrice); } break; case OrderDirection.Sell: //Sell limit seeks highest price possible if (maximumPrice > order.LimitPrice) { fill.Status = OrderStatus.Filled; // fill at the worse price this bar or the limit price, this allows far out of the money limits // to be executed properly fill.FillPrice = Math.Max(minimumPrice, order.LimitPrice); } break; } // assume the order completely filled if (fill.Status == OrderStatus.Filled) fill.FillQuantity = order.Quantity; } catch (Exception err) { Log.Error("SecurityTransactionModel.LimitFill(): " + err.Message); } return fill; }
public void ValidateLimitOrders() { var oanda = (OandaBrokerage)Brokerage; var symbol = Symbol; var quotes = oanda.GetRates(new List<string> { new OandaSymbolMapper().GetBrokerageSymbol(symbol) }); // Buy Limit order below market var limitPrice = Convert.ToDecimal(quotes[0].bid - 0.5); var order = new LimitOrder(symbol, 1, limitPrice, DateTime.Now); Assert.IsTrue(oanda.PlaceOrder(order)); // update Buy Limit order with no changes Assert.IsTrue(oanda.UpdateOrder(order)); // move Buy Limit order above market order.LimitPrice = Convert.ToDecimal(quotes[0].ask + 0.5); Assert.IsTrue(oanda.UpdateOrder(order)); }
/// <summary> /// Converts an Oanda order into a LEAN order. /// </summary> private Order ConvertOrder(JToken order) { var type = order["type"].ToString(); Order qcOrder; switch (type) { case "MARKET_IF_TOUCHED": var stopOrder = order.ToObject <MarketIfTouchedOrder>(); qcOrder = new StopMarketOrder { StopPrice = stopOrder.Price.ToDecimal() }; break; case "LIMIT": var limitOrder = order.ToObject <OandaLimitOrder>(); qcOrder = new LimitOrder { LimitPrice = limitOrder.Price.ToDecimal() }; break; case "STOP": var stopLimitOrder = order.ToObject <StopOrder>(); qcOrder = new StopLimitOrder { Price = Convert.ToDecimal(stopLimitOrder.Price), LimitPrice = Convert.ToDecimal(stopLimitOrder.PriceBound) }; break; case "MARKET": qcOrder = new MarketOrder(); break; default: throw new NotSupportedException( "An existing " + type + " working order was found and is currently unsupported. Please manually cancel the order before restarting the algorithm."); } var instrument = order["instrument"].ToString(); var id = order["id"].ToString(); var units = Convert.ToInt32(order["units"]); var createTime = order["createTime"].ToString(); var securityType = SymbolMapper.GetBrokerageSecurityType(instrument); qcOrder.Symbol = SymbolMapper.GetLeanSymbol(instrument, securityType, Market.Oanda); qcOrder.Time = GetTickDateTimeFromString(createTime); qcOrder.Quantity = units; qcOrder.Status = OrderStatus.None; qcOrder.BrokerId.Add(id); var orderByBrokerageId = OrderProvider.GetOrderByBrokerageId(id); if (orderByBrokerageId != null) { qcOrder.Id = orderByBrokerageId.Id; } var gtdTime = order["gtdTime"]; if (gtdTime != null) { qcOrder.Duration = OrderDuration.Custom; qcOrder.DurationValue = GetTickDateTimeFromString(gtdTime.ToString()); } return(qcOrder); }
/// <summary> /// Send a limit order to the transaction handler: /// </summary> /// <param name="symbol">String symbol for the asset</param> /// <param name="quantity">Quantity of shares for limit order</param> /// <param name="limitPrice">Limit price to fill this order</param> /// <param name="tag">String tag for the order (optional)</param> /// <returns>Order id</returns> public int LimitOrder(string symbol, int quantity, decimal limitPrice, string tag = "") { var error = PreOrderChecks(symbol, quantity, OrderType.Limit); if (error < 0) { return error; } var order = new LimitOrder(symbol, quantity, limitPrice, Time, tag, Securities[symbol].Type); //Add the order and create a new order Id. return Transactions.AddOrder(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; }
public void ClientPlacesLimitOrder() { bool orderFilled = false; var manualResetEvent = new ManualResetEvent(false); var ib = _interactiveBrokersBrokerage; decimal price = 100m; decimal delta = 85.0m; // if we can't get a price then make the delta huge ib.OrderStatusChanged += (sender, orderEvent) => { if (orderEvent.Status == OrderStatus.Filled) { orderFilled = true; manualResetEvent.Set(); } price = orderEvent.FillPrice; delta = 0.02m; }; // get the current market price, couldn't get RequestMarketData to fire tick events int id = 0; Order order = new MarketOrder(Symbols.USDJPY, buyQuantity, DateTime.UtcNow) { Id = ++id }; _orders.Add(order); ib.PlaceOrder(order); manualResetEvent.WaitOne(2000); manualResetEvent.Reset(); // make a box around the current price +- a little order = new LimitOrder(Symbols.USDJPY, buyQuantity, price - delta, DateTime.UtcNow, null) { Id = ++id }; _orders.Add(order); ib.PlaceOrder(order); order = new LimitOrder(Symbols.USDJPY, -buyQuantity, price + delta, DateTime.UtcNow, null) { Id = ++id }; _orders.Add(order); ib.PlaceOrder(order); manualResetEvent.WaitOne(1000); var orderFromIB = AssertOrderOpened(orderFilled, ib, order); Assert.AreEqual(OrderType.Limit, orderFromIB.Type); }
public void GetOpenOrders() { var ib = _interactiveBrokersBrokerage; var orderEventFired = new ManualResetEvent(false); ib.OrderStatusChanged += (sender, args) => { if (args.Status == OrderStatus.Submitted) { orderEventFired.Set(); } }; var order = new LimitOrder(Symbols.USDJPY, buyQuantity, 0.01m, DateTime.UtcNow); _orders.Add(order); ib.PlaceOrder(order); orderEventFired.WaitOne(1500); Thread.Sleep(250); var openOrders = ib.GetOpenOrders(); Assert.AreNotEqual(0, openOrders.Count); }
public void ClientUpdatesLimitOrder() { int id = 0; var ib = _interactiveBrokersBrokerage; bool filled = false; ib.OrderStatusChanged += (sender, args) => { if (args.Status == OrderStatus.Filled) { filled = true; } }; const decimal limitPrice = 10000m; var order = new LimitOrder(Symbols.USDJPY, -buyQuantity, limitPrice, DateTime.UtcNow) {Id = ++id}; _orders.Add(order); ib.PlaceOrder(order); var stopwatch = Stopwatch.StartNew(); while (!filled && stopwatch.Elapsed.TotalSeconds < 10) { //Thread.MemoryBarrier(); Thread.Sleep(1000); order.LimitPrice = order.LimitPrice/2; ib.UpdateOrder(order); } Assert.IsTrue(filled); }
/// <summary> /// Creates a deep-copy clone of this order /// </summary> /// <returns>A copy of this order</returns> public override Order Clone() { var order = new LimitOrder {LimitPrice = LimitPrice}; CopyTo(order); return order; }
/// <summary> /// Default limit order fill model in the base security class. /// </summary> /// <param name="asset">Security asset we're filling</param> /// <param name="order">Order packet to model</param> /// <returns>Order fill information detailing the average price and quantity filled.</returns> /// <seealso cref="StopMarketFill(Security, StopMarketOrder)"/> /// <seealso cref="MarketFill(Security, MarketOrder)"/> public virtual OrderEvent LimitFill(Security asset, LimitOrder order) { return _fillModel.LimitFill(asset, order); }