public async Task <bool> PostOrderTicket(OrderTicket orderTicket) { var httpContent = new StringContent(JsonConvert.SerializeObject(orderTicket), Encoding.UTF8, "application/json"); var responseMessage = await client.PostAsync($"{App.BackendUrl}/api/filmshoworder", httpContent); return(responseMessage.IsSuccessStatusCode); }
public void SetValue_WithRelatedObject_ObjectDeleted() { var order = DomainObjectIDs.Order1.GetObject <Order> (); order.Delete(); CreateAccessor(order, "OrderTicket").SetValue(OrderTicket.NewObject()); }
/// <summary> /// Event handler for streaming events /// </summary> /// <param name="trade">The event object</param> private void OnTradeUpdate(ITradeUpdate trade) { Log.Trace($"AlpacaBrokerage.OnTradeUpdate(): Event:{trade.Event} OrderId:{trade.Order.OrderId} OrderStatus:{trade.Order.OrderStatus} FillQuantity: {trade.Order.FilledQuantity} Price: {trade.Price}"); Order order; OrderTicket ticket = null; lock (_locker) { order = _orderProvider.GetOrderByBrokerageId(trade.Order.OrderId.ToString()); if (order != null) { ticket = _orderProvider.GetOrderTicket(order.Id); } } if (order != null && ticket != null) { if (trade.Event == TradeEvent.Fill || trade.Event == TradeEvent.PartialFill) { order.PriceCurrency = _securityProvider.GetSecurity(order.Symbol).SymbolProperties.QuoteCurrency; var status = trade.Event == TradeEvent.Fill ? OrderStatus.Filled : OrderStatus.PartiallyFilled; // The Alpaca API does not return the individual quantity for each partial fill, but the cumulative filled quantity var fillQuantity = trade.Order.FilledQuantity - Math.Abs(ticket.QuantityFilled); OnOrderEvent(new OrderEvent(order, DateTime.UtcNow, OrderFee.Zero, "Alpaca Fill Event") { Status = status, FillPrice = trade.Price.Value, FillQuantity = fillQuantity * (order.Direction == OrderDirection.Buy ? 1 : -1) }); } else if (trade.Event == TradeEvent.Canceled) { OnOrderEvent(new OrderEvent(order, DateTime.UtcNow, OrderFee.Zero, "Alpaca Cancel Order Event") { Status = OrderStatus.Canceled }); } else if (trade.Event == TradeEvent.OrderCancelRejected) { var message = $"Order cancellation rejected: OrderId: {order.Id}"; OnMessage(new BrokerageMessageEvent(BrokerageMessageType.Warning, -1, message)); } } else { Log.Error($"AlpacaBrokerage.OnTradeUpdate(): order id not found: {trade.Order.OrderId}"); } }
private bool CheckOrdersForFill(OrderTicket longOrder) { if (longOrder.Status == OrderStatus.Filled) { return(true); } return(false); }
private bool CheckOrdersForFill(OrderTicket ticket) { if (ticket.Status == OrderStatus.Filled) { return(true); } return(false); }
public override void SetUp() { base.SetUp(); _orderTicket = DomainObjectIDs.OrderTicket1.GetObject <OrderTicket> (); _order = _orderTicket.Order; _eventReceiver = CreateEventReceiver(); }
/// <summary> /// Scans for a breakout from the opening range bar /// </summary> private void ScanForEntrance() { // scan for entrances, we only want to do this before 10am if (Time.TimeOfDay.Hours >= 10) { return; } // expect capture 10% of the daily range var expectedCaptureRange = 0.1m * ATR14; var allowedDollarLoss = MaximumPorfolioRiskPercentPerPosition * Portfolio.TotalPortfolioValue; var shares = (int)(allowedDollarLoss / expectedCaptureRange); // max out at a little below our stated max, prevents margin calls and such var maxShare = CalculateOrderQuantity(Symbol, .75m * MaximumLeverage); shares = Math.Min(shares, maxShare); // the stop percentage defined by dollars loss var stopLossPercentage = allowedDollarLoss / (shares * Security.Close); // min out at 1x leverage //var minShare = CalculateOrderQuantity(Symbol, MaximumLeverage/2m); //shares = Math.Max(shares, minShare); // we're looking for a breakout of the opening range bar in the direction of the medium term trend if (ShouldEnterLong) { // breakout to the upside, go long (fills synchronously) MarketTicket = MarketOrder(Symbol, shares); Log("Enter long @ " + MarketTicket.AverageFillPrice.SmartRounding() + " Shares: " + shares); Plot(Symbol, "Enter", MarketTicket.AverageFillPrice); // we'll start with a global, non-trailing stop loss EnablePsarTrailingStop = false; // submit stop loss order for max loss on the trade var stopPrice = Security.Low * (1 - stopLossPercentage); StopLossTicket = StopMarketOrder(Symbol, -shares, stopPrice); Log("Submitted stop loss @ " + stopPrice.SmartRounding()); } else if (ShouldEnterShort) { // breakout to the downside, go short MarketTicket = MarketOrder(Symbol, - -shares); Log("Enter short @ " + MarketTicket.AverageFillPrice.SmartRounding()); Plot(Symbol, "Enter", MarketTicket.AverageFillPrice); // we'll start with a global, non-trailing stop loss EnablePsarTrailingStop = false; // submit stop loss order for max loss on the trade var stopPrice = Security.High * (1 + stopLossPercentage); StopLossTicket = StopMarketOrder(Symbol, -shares, stopPrice); Log("Submitted stop loss @ " + stopPrice.SmartRounding() + " Shares: " + shares); } }
public void PartiallyFilledOrdersAreTakenIntoAccount(Language language) { var actualOrdersSubmitted = new List <SubmitOrderRequest>(); var algorithm = new QCAlgorithm(); algorithm.SubscriptionManager.SetDataManager(new DataManagerStub(algorithm)); algorithm.SetPandasConverter(); var security = algorithm.AddEquity(Symbols.AAPL.Value); security.SetMarketPrice(new TradeBar { Value = 250 }); algorithm.SetFinishedWarmingUp(); var openOrderRequest = new SubmitOrderRequest(OrderType.Market, SecurityType.Equity, Symbols.AAPL, 100, 0, 0, DateTime.MinValue, ""); openOrderRequest.SetOrderId(1); var openOrderTicket = new OrderTicket(algorithm.Transactions, openOrderRequest); openOrderTicket.AddOrderEvent(new OrderEvent(1, Symbols.AAPL, DateTime.MinValue, OrderStatus.PartiallyFilled, OrderDirection.Buy, 250, 70, OrderFee.Zero)); var orderProcessor = new Mock <IOrderProcessor>(); orderProcessor.Setup(m => m.Process(It.IsAny <SubmitOrderRequest>())) .Returns((SubmitOrderRequest request) => new OrderTicket(algorithm.Transactions, request)) .Callback((SubmitOrderRequest request) => actualOrdersSubmitted.Add(request)); orderProcessor.Setup(m => m.GetOpenOrders(It.IsAny <Func <Order, bool> >())) .Returns(new List <Order> { new MarketOrder(Symbols.AAPL, 100, DateTime.MinValue) }); orderProcessor.Setup(m => m.GetOpenOrderTickets(It.IsAny <Func <OrderTicket, bool> >())) .Returns(new List <OrderTicket> { openOrderTicket }); algorithm.Transactions.SetOrderProcessor(orderProcessor.Object); var model = GetExecutionModel(language); algorithm.SetExecution(model); var changes = new SecurityChanges(Enumerable.Empty <Security>(), Enumerable.Empty <Security>()); model.OnSecuritiesChanged(algorithm, changes); var targets = new IPortfolioTarget[] { new PortfolioTarget(Symbols.AAPL, 80) }; model.Execute(algorithm, targets); Assert.AreEqual(1, actualOrdersSubmitted.Count); // Remaining quantity for partially filled order = 100 - 70 = 30 // Quantity submitted = 80 - 30 = 50 Assert.AreEqual(50, actualOrdersSubmitted.Sum(x => x.Quantity)); }
public override void OnData(Slice data) { //if (!isSent) // return; if (!data.Bars.ContainsKey(Symbol(BIST_SECURITY_NAME))) { return; } if (!security.Exchange.ExchangeOpen) { Debug("----------- security exchange is not open"); return; } decimal holdingQty = Portfolio.GetHoldingsQuantity(Symbol(BIST_SECURITY_NAME)); Debug("............Purchase Start.............. "); Debug("----------- Portfolio is invested? : " + Portfolio.Invested); Debug("----------- Portfolio.Count : " + Portfolio.Count); Debug("----------- Holding Quantity : " + holdingQty); Debug("----------- HasOpenPosition? : " + TradeBuilder.HasOpenPosition(Symbol(BIST_SECURITY_NAME))); //int quantity = (int)Math.Floor(Portfolio.Cash / data["AAPL"].Close); TradeBar bar = data.Bars[BIST_SECURITY_NAME]; if (bar.DataType != MarketDataType.TradeBar) { return; } DisplayBarInfo(bar); OrderTicket marketTicket = PlaceMarketOrder(bar); DisplayTicketInfo(marketTicket); OrderTicket limitTicket = PlaceLimitOrder(bar); DisplayTicketInfo(limitTicket); DisplayPortfolioInfo(); //UpdateOrder(ticket); //CancelOrder(ticket); DisplayOpenOrders(); Debug("............Purchase End.............. "); }
public void CommitSavesRelatedObjectsToParentTransaction() { Order order = Order.NewObject(); Official official = DomainObjectIDs.Official1.GetObject <Official>(); order.Official = official; order.Customer = DomainObjectIDs.Customer1.GetObject <Customer> (); OrderItem orderItem = OrderItem.NewObject(); order.OrderItems.Add(orderItem); Assert.That(order.Official, Is.SameAs(official)); Assert.That(order.OrderItems.Count, Is.EqualTo(1)); Assert.That(order.OrderItems.ContainsObject(orderItem), Is.True); Assert.That(order.OrderTicket, Is.Null); OrderItem newOrderItem; OrderTicket newOrderTicket; using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope()) { newOrderItem = OrderItem.NewObject(); orderItem.Delete(); order.OrderItems.Add(newOrderItem); order.OrderItems.Add(OrderItem.NewObject()); newOrderTicket = OrderTicket.NewObject(); order.OrderTicket = newOrderTicket; Assert.That(order.Official, Is.SameAs(official)); Assert.That(order.OrderItems.Count, Is.EqualTo(2)); Assert.That(order.OrderItems.ContainsObject(orderItem), Is.False); Assert.That(order.OrderItems.ContainsObject(newOrderItem), Is.True); Assert.That(order.OrderTicket, Is.Not.Null); Assert.That(order.OrderTicket, Is.SameAs(newOrderTicket)); ClientTransactionScope.CurrentTransaction.Commit(); Assert.That(order.State, Is.EqualTo(StateType.Unchanged)); Assert.That(order.Official, Is.SameAs(official)); Assert.That(order.OrderItems.Count, Is.EqualTo(2)); Assert.That(order.OrderItems.ContainsObject(orderItem), Is.False); Assert.That(order.OrderItems.ContainsObject(newOrderItem), Is.True); Assert.That(order.OrderTicket, Is.Not.Null); Assert.That(order.OrderTicket, Is.SameAs(newOrderTicket)); } Assert.That(order.Official, Is.SameAs(official)); Assert.That(order.OrderItems.Count, Is.EqualTo(2)); Assert.That(order.OrderItems.ContainsObject(orderItem), Is.False); Assert.That(order.OrderItems.ContainsObject(newOrderItem), Is.True); Assert.That(order.OrderTicket, Is.Not.Null); Assert.That(order.OrderTicket, Is.SameAs(newOrderTicket)); }
public void SetValue_WithRelatedObject() { var order = DomainObjectIDs.Order1.GetObject <Order> (); var newTicket = OrderTicket.NewObject(); CreateAccessor(order, "OrderTicket").SetValue(newTicket); Assert.That(order.OrderTicket, Is.SameAs(newTicket)); }
public void VirtualObjectEndPoint_HasChangedHandling_WithNestedSubTransactions() { SetDatabaseModifyable(); OrderTicket orderTicket1 = DomainObjectIDs.OrderTicket1.GetObject <OrderTicket> (); Order order1 = orderTicket1.Order; OrderTicket orderTicket2 = DomainObjectIDs.OrderTicket2.GetObject <OrderTicket> (); Order order3 = orderTicket2.Order; Order order4 = DomainObjectIDs.Order3.GetObject <Order> (); OrderTicket orderTicket3 = order4.OrderTicket; RelationEndPointID propertyID = RelationEndPointID.Create(order4.ID, typeof(Order).FullName + ".OrderTicket"); using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope()) { order4.OrderTicket = orderTicket1; orderTicket3.Order = order1; Assert.That(GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID).HasChanged, Is.True); Assert.That(((IObjectEndPoint)GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID)).OriginalOppositeObjectID, Is.EqualTo(orderTicket3.ID)); using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope()) { Assert.That(order4.OrderTicket, Is.EqualTo(orderTicket1)); Assert.That(GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID).HasChanged, Is.False); Assert.That(((IObjectEndPoint)GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID)).OriginalOppositeObjectID, Is.EqualTo(orderTicket1.ID)); order4.OrderTicket = orderTicket2; orderTicket1.Order = order3; Assert.That(GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID).HasChanged, Is.True); Assert.That(((IObjectEndPoint)GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID)).OriginalOppositeObjectID, Is.EqualTo(orderTicket1.ID)); ClientTransaction.Current.Commit(); Assert.That(GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID).HasChanged, Is.False); Assert.That(((IObjectEndPoint)GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID)).OriginalOppositeObjectID, Is.EqualTo(orderTicket2.ID)); } Assert.That(GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID).HasChanged, Is.True); Assert.That(((IObjectEndPoint)GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID)).OriginalOppositeObjectID, Is.EqualTo(orderTicket3.ID)); ClientTransaction.Current.Commit(); Assert.That(GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID).HasChanged, Is.False); Assert.That(((IObjectEndPoint)GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID)).OriginalOppositeObjectID, Is.EqualTo(orderTicket2.ID)); } Assert.That(GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID).HasChanged, Is.True); Assert.That(((IObjectEndPoint)GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID)).OriginalOppositeObjectID, Is.EqualTo(orderTicket3.ID)); ClientTransaction.Current.Commit(); Assert.That(GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID).HasChanged, Is.False); Assert.That(((IObjectEndPoint)GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(propertyID)).OriginalOppositeObjectID, Is.EqualTo(orderTicket2.ID)); }
/// <summary> /// Remove this order from outstanding queue: user is requesting a cancel. /// </summary> /// <param name="request">Request containing the specific order id to remove</param> public OrderTicket CancelOrder(CancelOrderRequest request) { OrderTicket ticket; if (!_orderTickets.TryGetValue(request.OrderId, out ticket)) { Log.Error("BrokerageTransactionHandler.CancelOrder(): Unable to locate ticket for order."); return(OrderTicket.InvalidCancelOrderId(_algorithm.Transactions, request)); } try { // if we couldn't set this request as the cancellation then another thread/someone // else is already doing it or it in fact has already been cancelled if (!ticket.TrySetCancelRequest(request)) { // the ticket has already been cancelled request.SetResponse(OrderResponse.Error(request, OrderResponseErrorCode.InvalidRequest, "Cancellation is already in progress.")); return(ticket); } //Error check var order = GetOrderByIdInternal(request.OrderId); if (order != null && request.Tag != null) { order.Tag = request.Tag; } if (order == null) { Log.Error("BrokerageTransactionHandler.CancelOrder(): Cannot find this id."); request.SetResponse(OrderResponse.UnableToFindOrder(request)); } else if (order.Status.IsClosed()) { Log.Error("BrokerageTransactionHandler.CancelOrder(): Order already " + order.Status); request.SetResponse(OrderResponse.InvalidStatus(request, order)); } else if (_algorithm.IsWarmingUp) { request.SetResponse(OrderResponse.WarmingUp(request)); } else { // send the request to be processed request.SetResponse(OrderResponse.Success(request), OrderRequestStatus.Processing); _orderRequestQueue.Add(request); } } catch (Exception err) { Log.Error(err); request.SetResponse(OrderResponse.Error(request, OrderResponseErrorCode.ProcessingError, err.Message)); } return(ticket); }
private void HandleOrder(OrderTicket orderTicket) { if (orderTicket.SubmitRequest.Status == OrderRequestStatus.Error) { _ordersDenied.Add(orderTicket); return; } _ordersAllowed.Add(orderTicket); }
public void GetOriginalRelatedObjectForBothDeleted() { OrderTicket orderTicket = _order.OrderTicket; _order.Delete(); orderTicket.Delete(); Assert.That(_order.GetOriginalRelatedObject("Remotion.Data.DomainObjects.UnitTests.TestDomain.Order.OrderTicket"), Is.Not.Null); Assert.That(orderTicket.GetOriginalRelatedObject("Remotion.Data.DomainObjects.UnitTests.TestDomain.OrderTicket.Order"), Is.Not.Null); }
public override void SetUp() { base.SetUp(); _newOrder = Order.NewObject(); _newOrderContainer = _newOrder.InternalDataContainer; _newOrderTicket = OrderTicket.NewObject(_newOrder); _orderNumberProperty = GetPropertyDefinition(typeof(Order), "OrderNumber"); }
public override void OnData(Slice data) { spyClosePrices.Add(data[spy].Close); if (IsWarmingUp) { return; } updateHighWaterMark(data); if (Portfolio.Invested) { updateTrailingStop(); return; // TODO recalculate position size here because instrument volatility might have changed. } if ((previousPosition == LONG || previousPosition == NONE) && fastMA < slowMA) { // go short Debug("---"); Debug("Going short at " + data[spy].Close); int numberOfShares = calculatePositionSize(data); Debug("number of shares= " + numberOfShares); var stopPrice = calculateStopPriceForShort(); Debug("stop price= " + stopPrice); orderTicket = MarketOrder(spy, -numberOfShares); trailingStopOrderTicket = StopMarketOrder(spy, numberOfShares, stopPrice); currentPosition = SHORT; } if ((previousPosition == SHORT || previousPosition == NONE) && fastMA > slowMA) { // go long Debug("---"); Debug("Going Long at " + data[spy].Close); int numberOfShares = calculatePositionSize(data); Debug("number of shares= " + numberOfShares); var stopPrice = calculateStopPriceForLong(); Debug("stop price= " + stopPrice); orderTicket = MarketOrder(spy, numberOfShares); trailingStopOrderTicket = StopMarketOrder(spy, -numberOfShares, stopPrice); currentPosition = LONG; } }
/// <summary> /// Add an order to collection and return the unique order id or negative if an error. /// </summary> /// <param name="request">A request detailing the order to be submitted</param> /// <returns>New unique, increasing orderid</returns> public OrderTicket AddOrder(SubmitOrderRequest request) { request.SetResponse(OrderResponse.Success(request), OrderRequestStatus.Processing); var ticket = new OrderTicket(_algorithm.Transactions, request); _orderTickets.TryAdd(ticket.OrderId, ticket); // send the order to be processed after creating the ticket _orderRequestQueue.Enqueue(request); return(ticket); }
public void Validate_IntegrationTest_RelationsOk() { using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope()) { var orderTicket = OrderTicket.NewObject(); orderTicket.Order = Order.NewObject(); var persistableData = PersistableDataObjectMother.Create(ClientTransaction.Current, orderTicket); Assert.That(() => _validator.Validate(ClientTransaction.Current, persistableData), Throws.Nothing); } }
public void GetOriginalRelatedObjectFromOppositeObject() { Order oldRelatedOrder = _orderTicket.Order; _orderTicket.Delete(); OrderTicket deletedOrderTicket = (OrderTicket)oldRelatedOrder.GetOriginalRelatedObject("Remotion.Data.DomainObjects.UnitTests.TestDomain.Order.OrderTicket"); Assert.That(deletedOrderTicket, Is.Not.Null); Assert.That(deletedOrderTicket.ID, Is.EqualTo(_orderTicket.ID)); }
public void SetValue_WithRelatedObject_PerformsBidirectionalChange() { var order = DomainObjectIDs.Order1.GetObject <Order> (); var newTicket = OrderTicket.NewObject(); var oldTicket = order.OrderTicket; CreateAccessor(order, "OrderTicket").SetValue(newTicket); Assert.That(newTicket.Order, Is.SameAs(order)); Assert.That(oldTicket.Order, Is.Null); }
public void SubTransaction_CanAccessObject_CreatedInParent() { Order order = Order.NewObject(); ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction(); using (subTransaction.EnterDiscardingScope()) { order.OrderNumber = 5; order.OrderTicket = OrderTicket.NewObject(); } }
/// <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 (Time.TimeOfDay.TotalHours == 10) { ticket = LimitOrder("SPY", 10, .98m * data.Bars["SPY"].Low); } if (Time.TimeOfDay.TotalHours == 11) { ticket.Update(new UpdateOrderFields {LimitPrice = data.Bars["SPY"].Low}); } }
private Order GetTestGraph() { Order root = Order.NewObject(); root.Official = Official.NewObject(); root.OrderTicket = OrderTicket.NewObject(); root.OrderItems.Add(OrderItem.NewObject()); root.OrderItems.Add(OrderItem.NewObject()); root.Customer = Customer.NewObject(); root.Customer.Ceo = Ceo.NewObject(); return(root); }
/// <summary> /// Create a stop market order and return the newly created order id; or negative if the order is invalid /// </summary> /// <param name="symbol">String symbol for the asset we're trading</param> /// <param name="quantity">Quantity to be traded</param> /// <param name="stopPrice">Price to fill the stop order</param> /// <param name="tag">Optional string data tag for the order</param> /// <returns>Int orderId for the new order.</returns> public OrderTicket StopMarketOrder(Symbol symbol, decimal quantity, decimal stopPrice, string tag = "") { var security = Securities[symbol]; var request = CreateSubmitOrderRequest(OrderType.StopMarket, security, quantity, tag, stopPrice: stopPrice, properties: DefaultOrderProperties?.Clone()); var response = PreOrderChecks(request); if (response.IsError) { return OrderTicket.InvalidSubmitRequest(Transactions, request, response); } return Transactions.AddOrder(request); }
public void SetValueWithoutTypeCheck() { Order newOrder = Order.NewObject(); newOrder.Properties["Remotion.Data.DomainObjects.UnitTests.TestDomain.Order.OrderNumber"].SetValueWithoutTypeCheck(7); Assert.That(newOrder.OrderNumber, Is.EqualTo(7)); OrderTicket orderTicket = OrderTicket.NewObject(); newOrder.Properties["Remotion.Data.DomainObjects.UnitTests.TestDomain.Order.OrderTicket"].SetValueWithoutTypeCheck(orderTicket); Assert.That(newOrder.OrderTicket, Is.SameAs(orderTicket)); }
public void SubTransaction_CanAccessObject_LoadedInParent() { Order order = DomainObjectIDs.Order1.GetObject <Order> (); ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction(); using (subTransaction.EnterDiscardingScope()) { ++order.OrderNumber; Dev.Null = order.OrderTicket; order.OrderTicket = OrderTicket.NewObject(); } }
public override void SetUp() { base.SetUp(); _order1 = ExecuteInWriteableSubTransaction(() => DomainObjectIDs.Order1.GetObject <Order> ()); _orderTicket1 = ExecuteInWriteableSubTransaction(() => DomainObjectIDs.OrderTicket1.GetObject <OrderTicket> ()); _orderTicket2 = ExecuteInWriteableSubTransaction(() => DomainObjectIDs.OrderTicket2.GetObject <OrderTicket> ()); _orderTicket3 = ExecuteInWriteableSubTransaction(() => DomainObjectIDs.OrderTicket3.GetObject <OrderTicket> ()); ExecuteInWriteableSubTransaction(() => _order1.OrderTicket = _orderTicket2); ExecuteInWriteableSubTransaction(() => _orderTicket3.Order.EnsureDataAvailable()); }
/// <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 OrderTicket MarketOnCloseOrder(Symbol symbol, int quantity, string tag = "") { var security = Securities[symbol]; var request = CreateSubmitOrderRequest(OrderType.MarketOnClose, security, quantity, tag); var response = PreOrderChecks(request); if (response.IsError) { return(OrderTicket.InvalidSubmitRequest(Transactions, request, response)); } return(Transactions.AddOrder(request)); }
public void CommitWithMandatoryOneToOneRelationNotSet() { Order order = DomainObjectIDs.Order1.GetObject<Order> (); OrderTicket newOrderTicket = DomainObjectIDs.OrderTicket2.GetObject<OrderTicket> (); order.OrderTicket = newOrderTicket; Assert.That ( () => TestableClientTransaction.Commit(), Throws.TypeOf<MandatoryRelationNotSetException>().With.Message.EqualTo ( "Mandatory relation property 'Remotion.Data.DomainObjects.UnitTests.TestDomain.OrderTicket.Order' of domain object" + " 'OrderTicket|058ef259-f9cd-4cb1-85e5-5c05119ab596|System.Guid' cannot be null.")); }
/// <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 OrderTicket LimitOrder(Symbol symbol, int quantity, decimal limitPrice, string tag = "") { var security = Securities[symbol]; var request = CreateSubmitOrderRequest(OrderType.Limit, security, quantity, tag, limitPrice: limitPrice); var response = PreOrderChecks(request); if (response.IsError) { return(OrderTicket.InvalidSubmitRequest(Transactions, request, response)); } return(Transactions.AddOrder(request)); }
/// <summary> /// Logs the OrderEvent Transaction /// </summary> /// <param name="orderEvent">the OrderEvent being logged</param> /// <param name="includeHeader">Includes the field names</param> public OrderTransaction Create(OrderEvent orderEvent, OrderTicket ticket, bool includeHeader = true) { var security = _algorithm.Securities[ticket.Symbol]; Order order = _algorithm.Transactions.GetOrderById(orderEvent.OrderId); OrderTransaction t = new OrderTransaction(); // According to Scottrade a Buy is a negative amount (funds flow from my account to the seller's) // However the Quantity filled is a negative number for Sell/Short and a positive for Buy/Long // So multiply by -1 to give order value the correct sign decimal orderValue = -1 * ticket.QuantityFilled * ticket.AverageFillPrice; if (order != null) { var orderDateTime = _algorithm.Time; DateTime settleDate = orderDateTime.AddDays(orderDateTime.DayOfWeek < DayOfWeek.Wednesday ? 3 : 5); // Order Fees are a cost and negative to my account, therefore a negative number var orderFees = security.TransactionModel.GetOrderFee(security, order) * -1; #region "Create OrderTransaction" t.ActionId = orderEvent.Direction.ToString() == "Buy" ? 1 : 13; t.ActionNameUS = orderEvent.Direction.ToString(); t.Amount = orderValue; t.Broker = "IB"; t.CUSIP = "CUSIP"; t.Commission = orderFees; t.Description = string.Format("{0} {1} shares of {2} at ${3}", orderEvent.Direction, ticket.Quantity, orderEvent.Symbol, order.Price); t.Direction = orderEvent.Direction; t.Exchange = ""; t.Fees = 0; // need to calculate based upon difference in Portfolio[symbol].HoldingsValue between buy and sell t.Id = 0; t.Interest = 0; t.Net = orderValue + orderFees; t.OrderId = order.Id; t.OrderType = ticket.OrderType; t.Price = ticket.AverageFillPrice; t.Quantity = ticket.Quantity; t.RecordType = "Trade"; t.SettledDate = settleDate; t.Symbol = ticket.Symbol.Value; t.TaxLotNumber = String.Empty; t.TradeDate = orderDateTime; t.TradeNumber = 0; #endregion } return t; }
public void OnOrderEvent(OrderEvent fill) { if (fill.Status != OrderStatus.Filled) { return; } // if we just finished entering, place a stop loss as well if (Security.Invested) { var stop = Security.Holdings.IsLong ? fill.FillPrice*(1 - PercentGlobalStopLoss) : fill.FillPrice*(1 + PercentGlobalStopLoss); _currentStopLoss = _algorithm.StopMarketOrder(Symbol, -Quantity, stop, "StopLoss at: " + stop); } // check for an exit, cancel the stop loss else { if (_currentStopLoss != null && _currentStopLoss.Status.IsOpen()) { // cancel our current stop loss _currentStopLoss.Cancel("Exited position"); _currentStopLoss = null; } } }
public void AddTicket(OrderTicket ticket) { _tickets[ticket.OrderId] = ticket; }
/// <summary> /// Scans for a breakout from the opening range bar /// </summary> private void ScanForEntrance() { // scan for entrances, we only want to do this before 10am if (Time.TimeOfDay.Hours >= 10) return; // expect capture 10% of the daily range var expectedCaptureRange = 0.1m*ATR14; var allowedDollarLoss = MaximumPorfolioRiskPercentPerPosition * Portfolio.TotalPortfolioValue; var shares = (int) (allowedDollarLoss/expectedCaptureRange); // determine a position size based on an acceptable loss in proporton to our total portfolio value //var shares = (int) (MaximumLeverage*MaximumPorfolioRiskPercentPerPosition*Portfolio.TotalPortfolioValue/(0.4m*ATR14)); // max out at a little below our stated max, prevents margin calls and such var maxShare = CalculateOrderQuantity(Symbol, MaximumLeverage); shares = Math.Min(shares, maxShare); // min out at 1x leverage //var minShare = CalculateOrderQuantity(Symbol, MaximumLeverage/2m); //shares = Math.Max(shares, minShare); // we're looking for a breakout of the opening range bar in the direction of the medium term trend if (ShouldEnterLong) { // breakout to the upside, go long (fills synchronously) MarketTicket = MarketOrder(Symbol, shares); Log("Enter long @ " + MarketTicket.AverageFillPrice.SmartRounding() + " Shares: " + shares); Plot(Symbol, "Enter", MarketTicket.AverageFillPrice); // we'll start with a global, non-trailing stop loss EnablePsarTrailingStop = false; // submit stop loss order for max loss on the trade var stopPrice = Security.Low*(1 - GlobalStopLossPercent); StopLossTicket = StopMarketOrder(Symbol, -shares, stopPrice); if (EnableOrderUpdateLogging) { Log("Submitted stop loss @ " + stopPrice.SmartRounding()); } } else if (ShouldEnterShort) { // breakout to the downside, go short MarketTicket = MarketOrder(Symbol, - -shares); Log("Enter short @ " + MarketTicket.AverageFillPrice.SmartRounding()); Plot(Symbol, "Enter", MarketTicket.AverageFillPrice); // we'll start with a global, non-trailing stop loss EnablePsarTrailingStop = false; // submit stop loss order for max loss on the trade var stopPrice = Security.High*(1 + GlobalStopLossPercent); StopLossTicket = StopMarketOrder(Symbol, -shares, stopPrice); if (EnableOrderUpdateLogging) { Log("Submitted stop loss @ " + stopPrice.SmartRounding() + " Shares: " + shares); } } }
private bool CheckPairOrdersForFills(OrderTicket longOrder, OrderTicket shortOrder) { if (longOrder.Status == OrderStatus.Filled) { Log(shortOrder.OrderType + ": Cancelling short order, long order is filled."); shortOrder.Cancel("Long filled."); return true; } if (shortOrder.Status == OrderStatus.Filled) { Log(longOrder.OrderType + ": Cancelling long order, short order is filled."); longOrder.Cancel("Short filled"); return true; } return false; }
public bool TryEnter(out OrderTicket ticket) { ticket = null; if (Security.Invested) { // can't enter if we're already in return false; } int qty = 0; decimal limit = 0m; if (IsUptrend) { // 100 order lots qty = LotSize; limit = Security.Low; } else if (IsDowntrend) { limit = Security.High; qty = -LotSize; } if (qty != 0) { ticket = _algorithm.LimitOrder(Symbol, qty, limit, "TryEnter at: " + limit); } return qty != 0; }
/// <summary> /// Executes the Instant Trend strategy /// </summary> /// <param name="data">TradeBars - the current OnData</param> /// <param name="tradesize"></param> /// <param name="trendCurrent">IndicatorDataPoint - the current trend value trend</param> /// <param name="orderId">int - the orderId if one is placed, -1 if order has not filled and 0 if no order was placed</param> public string ExecuteStrategy(TradeBars data, int tradesize, IndicatorDataPoint max, IndicatorDataPoint min, RateOfChangePercent rocp, ref SimpleMovingAverage sma20, out int orderId) { maximum = max; minimum = min; Price.Add(idp(data[_symbol].EndTime, (data[_symbol].Close + data[_symbol].Open) / 2)); orderId = 0; comment = string.Empty; if (_algorithm.Portfolio[_symbol].IsLong) nStatus = 1; if (_algorithm.Portfolio[_symbol].IsShort) nStatus = -1; #region "Strategy Execution" bReverseTrade = false; try { if (!_algorithm.Portfolio.Invested) { if (PricePassedAValley() && rocp.Current.Value < 0) { ticket = GetLong(tradesize); orderId = ticket.OrderId; comment = "Bot new position ppMin && rocp < 0"; } if (PricePassedAPeak() && rocp.Current.Value > 0) { ticket = GetShort(tradesize); orderId = ticket.OrderId; comment = "Sld new position ppMin && rocp < 0"; } } else { if (PricePassedAValley() && _algorithm.Portfolio[_symbol].IsShort) { if (Price[0].Value > sma20.Current.Value && (Math.Abs(sma20.Current.Value - Price[0].Value) / Price[0].Value) > .001m) { ticket = ReverseToLong(); comment = "Rev2Long Passed a Valley"; } } if (PricePassedAPeak() && _algorithm.Portfolio[_symbol].IsLong) { if (Price[0].Value < sma20.Current.Value && (Math.Abs(sma20.Current.Value - Price[0].Value) / Price[0].Value) > .001m) { ticket = ReverseToShort(); comment = "Rev2Short Passed a Peak"; } } } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.StackTrace); } #endregion return comment; }
private void AlterLongLimit(KeyValuePair<Symbol, TradeBar> data, OrderTicket liveticket, SignalInfo currentSignalInfo) { //Log(string.Format("Trade Attempts: {0} OrderId {1}", currentSignalInfo.TradeAttempts, liveticket.OrderId)); if (currentSignalInfo.TradeAttempts++ > 3) { liveticket.Cancel(); //Log(string.Format("Order {0} cancellation sent. Trade attempts > 3.", liveticket.OrderId)); } }
private void CheckNumberOfTradeAttempts(KeyValuePair<Symbol, TradeBar> data, OrderTicket liveticket) { //Log(string.Format("Trade Attempts: {0} OrderId {1}", currentSignalInfo.TradeAttempts, liveticket.OrderId)); if (Strategy[data.Key].TradeAttempts++ > 3) { liveticket.Cancel(); //Log(string.Format("Order {0} cancellation sent. Trade attempts > 3.", liveticket.OrderId)); } }
/// <summary> /// Add an order to collection and return the unique order id or negative if an error. /// </summary> /// <param name="request">A request detailing the order to be submitted</param> /// <returns>New unique, increasing orderid</returns> public OrderTicket AddOrder(SubmitOrderRequest request) { request.SetResponse(OrderResponse.Success(request), OrderRequestStatus.Processing); var ticket = new OrderTicket(_algorithm.Transactions, request); _orderTickets.TryAdd(ticket.OrderId, ticket); // send the order to be processed after creating the ticket _orderRequestQueue.Enqueue(request); return ticket; }
/// <summary> /// Sets the <see cref="OrderTicket"/> used to liquidate this position /// </summary> /// <param name="ticket">The ticket that represents the order to liquidate this position</param> public void SetOrderTicket(OrderTicket ticket) { Ticket = ticket; }
private void AlterShortLimit(KeyValuePair<Symbol, TradeBar> data, OrderTicket liveticket) { var limit = liveticket.Get(OrderField.LimitPrice); decimal newLimit = limit; //currentSignalInfo.TradeAttempts++; if (newLimit < data.Value.Low) { newLimit = data.Value.Close - 0.01m; } OrderResponse response = liveticket.Update(new UpdateOrderFields { LimitPrice = newLimit, Tag = "Update #" + (liveticket.UpdateRequests.Count + 1) }); if (response.IsSuccess) { Log(string.Format("Long Order {0}. Status: {1} Updated {2} to new price {3}.", liveticket.OrderId, liveticket.Status, limit, newLimit)); } else { if (!response.IsProcessed) { Log(string.Format("Order {0} not yet processed to new price {1}", liveticket.OrderId, limit)); } if (response.IsError) { Log(response.ToString()); } } }
/// <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) { // we don't need to run any of this during our warmup phase if (IsWarmingUp) return; // when we're done warming up, register our indicators to start plotting if (!IsWarmingUp && !FinishedWarmup) { // this is a run once flag for when we're finished warmup FinishedWarmup = true; // plot our hourly indicators automatically, wait for them to ready PlotIndicator("ADX", ADX14); PlotIndicator("ADX", ADX14.NegativeDirectionalIndex, ADX14.PositiveDirectionalIndex); PlotIndicator("ATR", true, ATR14); PlotIndicator("STD", true, STD14); PlotIndicator("ATR", true, SmoothedATR14); } // update our PSAR PSARMin.Update((TradeBar) Security.GetLastData()); // plot price until an hour after we close so we can see our execution skillz if (ShouldPlot) { // we can plot price more often if we want Plot(Symbol, "Price", Security.Close); // only plot psar on the minute if (PSARMin.IsReady) { Plot(Symbol, PSARMin); } } // first wait for our opening range bar to be set to today if (OpeningBarRange == null || OpeningBarRange.EndTime.Date != Time.Date || OpeningBarRange.EndTime == Time) return; // we only trade max once per day, so if we've already exited the stop loss, bail if (StopLossTicket != null && StopLossTicket.Status == OrderStatus.Filled) { // null these out to signal that we're done trading for the day OpeningBarRange = null; StopLossTicket = null; return; } // now that we have our opening bar, test to see if we're already in a positio if (!Security.Invested) { ScanForEntrance(); } else { // if we haven't exited yet then manage our stop loss, this controls our exit point if (Security.Invested) { ManageStopLoss(); } else if (StopLossTicket != null && StopLossTicket.Status.IsOpen()) { StopLossTicket.Cancel(); } } }
/// <summary> /// Add an order to collection and return the unique order id or negative if an error. /// </summary> /// <param name="request">A request detailing the order to be submitted</param> /// <returns>New unique, increasing orderid</returns> public OrderTicket AddOrder(SubmitOrderRequest request) { var response = !_algorithm.IsWarmingUp ? OrderResponse.Success(request) : OrderResponse.WarmingUp(request); request.SetResponse(response); var ticket = new OrderTicket(_algorithm.Transactions, request); _orderTickets.TryAdd(ticket.OrderId, ticket); // send the order to be processed after creating the ticket if (response.IsSuccess) { _orderRequestQueue.Enqueue(request); } else { // add it to the orders collection for recall later var order = Order.CreateOrder(request); order.Status = OrderStatus.Invalid; order.Tag = "Algorithm warming up."; ticket.SetOrder(order); _orders.TryAdd(request.OrderId, order); } return ticket; }
private static DateTime InitializeTest(out BasicTemplateAlgorithm algorithm, out Security security, out PartialMarketFillModel model, out MarketOrder order, out OrderTicket ticket) { var referenceTimeNY = new DateTime(2015, 12, 21, 13, 0, 0); var referenceTimeUtc = referenceTimeNY.ConvertToUtc(TimeZones.NewYork); algorithm = new BasicTemplateAlgorithm(); algorithm.SetDateTime(referenceTimeUtc); var transactionHandler = new BacktestingTransactionHandler(); transactionHandler.Initialize(algorithm, new BacktestingBrokerage(algorithm), new TestResultHandler(Console.WriteLine)); Task.Run(() => transactionHandler.Run()); algorithm.Transactions.SetOrderProcessor(transactionHandler); var config = new SubscriptionDataConfig(typeof(TradeBar), Symbols.SPY, Resolution.Second, TimeZones.NewYork, TimeZones.NewYork, false, false, false); security = new Security(SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork), config); model = new PartialMarketFillModel(algorithm.Transactions, 2); algorithm.Securities.Add(security); algorithm.Securities[Symbols.SPY].FillModel = model; security.SetMarketPrice(new Tick { Symbol = Symbols.SPY, Value = 100 }); algorithm.SetFinishedWarmingUp(); order = new MarketOrder(Symbols.SPY, 100, referenceTimeUtc) { Id = 1 }; var request = new SubmitOrderRequest(OrderType.Market, security.Type, security.Symbol, order.Quantity, 0, 0, algorithm.UtcTime, null); ticket = algorithm.Transactions.ProcessRequest(request); return referenceTimeUtc; }
private void CalculateTradeProfit(OrderTicket ticket) { tradeprofit = Securities[Symbols[0]].Holdings.LastTradeProfit; tradenet = tradeprofit - tradefees; lasttradefees = Securities[Symbols[0]].Holdings.TotalFees; }
/// <summary> /// Add an order to collection and return the unique order id or negative if an error. /// </summary> /// <param name="request">A request detailing the order to be submitted</param> /// <returns>New unique, increasing orderid</returns> public OrderTicket AddOrder(SubmitOrderRequest request) { var response = !_algorithm.IsWarmingUp ? OrderResponse.Success(request) : OrderResponse.WarmingUp(request); request.SetResponse(response); var ticket = new OrderTicket(_algorithm.Transactions, request); _orderTickets.TryAdd(ticket.OrderId, ticket); // send the order to be processed after creating the ticket if (response.IsSuccess) { _orderRequestQueue.Add(request); } else { // add it to the orders collection for recall later var order = Order.CreateOrder(request); // ensure the order is tagged with a currency var security = _algorithm.Securities[order.Symbol]; order.PriceCurrency = security.SymbolProperties.QuoteCurrency; order.Status = OrderStatus.Invalid; order.Tag = "Algorithm warming up."; ticket.SetOrder(order); _orders.TryAdd(request.OrderId, order); } return ticket; }
public bool TryExit(out OrderTicket ticket) { const decimal exitTolerance = 1 + 2 * PercentTolerance; ticket = null; if (!Security.Invested) { // can't exit if we haven't entered return false; } decimal limit = 0m; if (Security.Holdings.IsLong && Close*exitTolerance < EMA) { limit = Security.High; } else if (Security.Holdings.IsShort && Close > EMA*exitTolerance) { limit = Security.Low; } if (limit != 0) { ticket = _algorithm.LimitOrder(Symbol, -Quantity, limit, "TryExit at: " + limit); } return -Quantity != 0; }