/// <summary> /// Market order implementation: Send a market order and wait for it to be filled. /// </summary> /// <param name="symbol">Symbol of the MarketType Required.</param> /// <param name="quantity">Number of shares to request.</param> /// <param name="asynchronous">Send the order asynchrously (false). Otherwise we'll block until it fills</param> /// <param name="tag">Place a custom order property or tag (e.g. indicator data).</param> /// <returns>int Order id</returns> public int MarketOrder(string symbol, int quantity, bool asynchronous = false, string tag = "") { //Initalize the Market order parameters: var error = PreOrderChecks(symbol, quantity, OrderType.Market); if (error < 0) { return(error); } var order = new MarketOrder(symbol, quantity, Time, tag, Securities[symbol].Type); //Set the rough price of the order for buying power calculations order.Price = Securities[symbol].Price; //Add the order and create a new order Id. var orderId = Transactions.AddOrder(order); //Wait for the order event to process: //Enqueue means send to order queue but don't wait for response: if (!asynchronous) { //Wait for the market order to fill. //This is processed in a parallel thread. while (!Transactions.Orders.ContainsKey(orderId) || (Transactions.Orders[orderId].Status != OrderStatus.Filled && Transactions.Orders[orderId].Status != OrderStatus.Invalid && Transactions.Orders[orderId].Status != OrderStatus.Canceled) || _processingOrder) { Thread.Sleep(1); } } return(orderId); }
/// <summary> /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here. /// </summary> /// <param name="data">Slice object keyed by symbol containing the stock data</param> public override void OnData(Slice data) { if (!data.ContainsKey("SPY")) { return; } // After an order is placed, it will decrease in quantity by one for each minute, being cancelled altogether // if not filled within 10 minutes. if (Transactions.GetOpenOrders().Count == 0) { var goLong = Time.Day < 9; _negative = goLong ? 1 : -1; var orderRequest = new SubmitOrderRequest(OrderType.LimitIfTouched, SecurityType.Equity, "SPY", _negative * 10, 0, data["SPY"].Price - (decimal)_negative, data["SPY"].Price - (decimal)0.25 * _negative, UtcTime, $"LIT - Quantity: {_negative * 10}"); _request = Transactions.AddOrder(orderRequest); return; } // Order updating if request exists if (_request != null) { if (_request.Quantity == 1) { Transactions.CancelOpenOrders(); _request = null; return; } var newQuantity = _request.Quantity - _negative; _request.UpdateQuantity(newQuantity, $"LIT - Quantity: {newQuantity}"); } }
/// <summary> /// Send a stop 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="stopPrice">Stop price for this 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 StopLimitOrder(string symbol, int quantity, decimal stopPrice, decimal limitPrice, string tag = "") { var error = PreOrderChecks(symbol, quantity, OrderType.StopLimit); if (error < 0) { return(error); } var order = new StopLimitOrder(symbol, quantity, stopPrice, limitPrice, Time, tag, Securities[symbol].Type); //Add the order and create a new order Id. return(Transactions.AddOrder(order)); }
/// <summary> /// Market on close order implementation: Send a market order when the exchange closes /// </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 MarketOnClose(string symbol, int quantity, string tag = "") { var error = PreOrderChecks(symbol, quantity, OrderType.MarketOnClose); if (error < 0) { return(error); } var security = Securities[symbol]; var order = new MarketOnCloseOrder(symbol, security.Type, quantity, Time, security.Price, tag); return(Transactions.AddOrder(order)); }
/// <summary> /// Market order implementation: Send a market order and wait for it to be filled. /// </summary> /// <param name="symbol">Symbol of the MarketType Required.</param> /// <param name="quantity">Number of shares to request.</param> /// <param name="asynchronous">Send the order asynchrously (false). Otherwise we'll block until it fills</param> /// <param name="tag">Place a custom order property or tag (e.g. indicator data).</param> /// <returns>int Order id</returns> public int MarketOrder(string symbol, int quantity, bool asynchronous = false, string tag = "") { var security = Securities[symbol]; // check the exchange is open before sending a market order, if it's not open // then convert it into a market on open order if (!security.Exchange.ExchangeOpen) { var id = MarketOnOpen(symbol, quantity, tag); Debug("Converted OrderID: " + id + " into a MarketOnOpen order."); return(id); } //Initalize the Market order parameters: var error = PreOrderChecks(symbol, quantity, OrderType.Market); if (error < 0) { return(error); } var order = new MarketOrder(symbol, quantity, Time, tag, security.Type); //Set the rough price of the order for buying power calculations order.Price = security.Price; //Add the order and create a new order Id. var orderId = Transactions.AddOrder(order); //Wait for the order event to process: //Enqueue means send to order queue but don't wait for response: if (!asynchronous) { //Wait for the market order to fill. //This is processed in a parallel thread. while (!Transactions.Orders.ContainsKey(orderId) || (Transactions.Orders[orderId].Status != OrderStatus.Filled && Transactions.Orders[orderId].Status != OrderStatus.Invalid && Transactions.Orders[orderId].Status != OrderStatus.Canceled) || _processingOrder) { Thread.Sleep(1); } } return(orderId); }
/// <summary> /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here. /// </summary> /// <param name="data">Slice object keyed by symbol containing the stock data</param> public override void OnData(Slice data) { if (!data.Bars.ContainsKey(symbol)) { return; } // each month make an action if (Time.Month != LastMonth) { // we'll submit the next type of order from the queue var orderType = _orderTypesQueue.Dequeue(); //Log(""); Log("\r\n--------------MONTH: " + Time.ToString("MMMM") + ":: " + orderType + "\r\n"); //Log(""); LastMonth = Time.Month; Log("ORDER TYPE:: " + orderType); var isLong = Quantity > 0; var stopPrice = isLong ? (1 + StopPercentage) * data.Bars[symbol].High : (1 - StopPercentage) * data.Bars[symbol].Low; var limitPrice = isLong ? (1 - LimitPercentage) * stopPrice : (1 + LimitPercentage) * stopPrice; if (orderType == OrderType.Limit) { limitPrice = !isLong ? (1 + LimitPercentage) * data.Bars[symbol].High : (1 - LimitPercentage) * data.Bars[symbol].Low; } var request = new SubmitOrderRequest(orderType, SecType, symbol, Quantity, stopPrice, limitPrice, Time, orderType.ToString()); var ticket = Transactions.AddOrder(request); _tickets.Add(ticket); } else if (_tickets.Count > 0) { var ticket = _tickets.Last(); if (Time.Day > 8 && Time.Day < 14) { if (ticket.UpdateRequests.Count == 0 && ticket.Status.IsOpen()) { Log("TICKET:: " + ticket); ticket.Update(new UpdateOrderFields { Quantity = ticket.Quantity + Math.Sign(Quantity) * DeltaQuantity, Tag = "Change quantity: " + Time }); Log("UPDATE1:: " + ticket.UpdateRequests.Last()); } } else if (Time.Day > 13 && Time.Day < 20) { if (ticket.UpdateRequests.Count == 1 && ticket.Status.IsOpen()) { Log("TICKET:: " + ticket); ticket.Update(new UpdateOrderFields { LimitPrice = Security.Price * (1 - Math.Sign(ticket.Quantity) * LimitPercentageDelta), StopPrice = Security.Price * (1 + Math.Sign(ticket.Quantity) * StopPercentageDelta), Tag = "Change prices: " + Time }); Log("UPDATE2:: " + ticket.UpdateRequests.Last()); } } else { if (ticket.UpdateRequests.Count == 2 && ticket.Status.IsOpen()) { Log("TICKET:: " + ticket); ticket.Cancel(Time + " and is still open!"); Log("CANCELLED:: " + ticket.CancelRequest); } } } }
/// <summary> /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here. /// </summary> /// <param name="data">Slice object keyed by symbol containing the stock data</param> public override void OnData(Slice data) { if (!_security.HasData) { Log("::::: NO DATA :::::"); return; } // each month make an action if (Time.Minute != _lastMinute && Time.Second == 0) { Log(""); Log("--------------Minute: " + Time.Minute); Log(""); _lastMinute = Time.Minute; // we'll submit the next type of order from the queue var orderType = _orderTypesQueue.Dequeue(); Log("ORDER TYPE:: " + orderType); var isLong = _quantity > 0; var stopPrice = isLong ? (1 + StopPercentage) * _security.High : (1 - StopPercentage) * _security.Low; var limitPrice = isLong ? (1 - LimitPercentage) * stopPrice : (1 + LimitPercentage) * stopPrice; if (orderType == OrderType.Limit) { limitPrice = !isLong ? (1 + LimitPercentage) * _security.High : (1 - LimitPercentage) * _security.Low; } var request = new SubmitOrderRequest(orderType, SecType, Securities[_symbol].Symbol, _quantity, stopPrice, limitPrice, Time, orderType.ToString()); var ticket = Transactions.AddOrder(request); _tickets.Add(ticket); if ((decimal)Random.NextDouble() < ImmediateCancelPercentage) { Log("Immediate cancellation requested!"); _immediateCancellations.Add(ticket.OrderId); } } else if (_tickets.Count > 0) { var ticket = _tickets.Last(); if (Time.Second > 15 && Time.Second < 30) { if (ticket.UpdateRequests.Count == 0 && ticket.Status.IsOpen()) { Log(ticket.ToString()); ticket.Update(new UpdateOrderFields { Quantity = ticket.Quantity + Math.Sign(_quantity) * DeltaQuantity, Tag = "Change quantity: " + Time }); Log("UPDATE1:: " + ticket.UpdateRequests.Last()); } } else if (Time.Second > 29 && Time.Second < 45) { if (ticket.UpdateRequests.Count == 1 && ticket.Status.IsOpen()) { Log(ticket.ToString()); ticket.Update(new UpdateOrderFields { LimitPrice = _security.Price * (1 - Math.Sign(ticket.Quantity) * LimitPercentageDelta), StopPrice = _security.Price * (1 + Math.Sign(ticket.Quantity) * StopPercentageDelta), Tag = "Change prices: " + Time }); Log("UPDATE2:: " + ticket.UpdateRequests.Last()); } } else { if (ticket.UpdateRequests.Count == 2 && ticket.Status.IsOpen()) { Log(ticket.ToString()); ticket.Cancel(Time + " and is still open!"); Log("CANCELLED:: " + ticket.CancelRequest); } } } }
/// <summary> /// Submit a new order for quantity of symbol using type order. /// </summary> /// <param name="type">Buy/Sell Limit or Market Order Type.</param> /// <param name="symbol">Symbol of the MarketType Required.</param> /// <param name="quantity">Number of shares to request.</param> /// <param name="asynchronous">Send the order asynchrously (false). Otherwise we'll block until it fills</param> /// <param name="tag">Place a custom order property or tag (e.g. indicator data).</param> /// <seealso cref="Order(string, double, OrderType)"/> public int Order(string symbol, int quantity, OrderType type = OrderType.Market, bool asynchronous = false, string tag = "") { //Add an order to the transacion manager class: var orderId = -1; decimal price = 0; //Ordering 0 is useless. if (quantity == 0 || string.IsNullOrEmpty(symbol)) { return(-1); } //Internals use upper case symbols. symbol = symbol.ToUpper(); //If we're not tracking this symbol: throw error: if (!Securities.ContainsKey(symbol) && !_sentNoDataError) { _sentNoDataError = true; Error("You haven't requested " + symbol + " data. Add this with AddSecurity() in the Initialize() Method."); } //Set a temporary price for validating order for market orders: var security = Securities[symbol]; price = security.Price; if (price == 0) { Error("Asset price is $0. If using custom data make sure you've set the 'Value' property."); return(-1); } //Make sure the security has some data: if (!security.HasData) { Error("There is no data for this symbol yet, please check the security.HasData flag to ensure there is at least one data point."); return(-1); } //Check the exchange is open before sending a market order. if (type == OrderType.Market && !security.Exchange.ExchangeOpen) { Error("Market order and exchange not open"); return(-3); } //We've already processed too many orders: max 100 per day or the memory usage explodes if (Orders.Count > (_endDate - _startDate).TotalDays * 100) { Error("You have exceeded 100 orders per day"); return(-5); } //Add the order and create a new order Id. orderId = Transactions.AddOrder(new Order(symbol, security.Type, quantity, type, Time, price, tag)); //Wait for the order event to process: //Enqueue means send to order queue but don't wait for response: if (!asynchronous && type == OrderType.Market) { //Wait for the market order to fill. //This is processed in a parallel thread. while (!Transactions.Orders.ContainsKey(orderId) || (Transactions.Orders[orderId].Status != OrderStatus.Filled && Transactions.Orders[orderId].Status != OrderStatus.Invalid && Transactions.Orders[orderId].Status != OrderStatus.Canceled) || _processingOrder) { Thread.Sleep(1); } } return(orderId); }