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;
}
