/// <inheritdoc />
public override string ToString()
{
var str = base.ToString() + $",TrId={TransactionId},Orig={OriginalTransactionId},Stat={Statistics.Select(p => $"{p.Key}={p.Value}").Join(",")}";
if (!StrategyId.IsDefault())
{
str += $",Id={StrategyId}";
}
if (!StrategyTypeId.IsEmpty())
{
str += $",TypeId={StrategyTypeId}";
}
if (Command != null)
{
str += $",Command={Command}";
}
if (Error != null)
{
str += $",Error={Error.Message}";
}
return(str);
}
/// <inheritdoc />
public override string ToString()
{
var str = base.ToString();
if (!IsSubscribe)
{
str += $",IsSubscribe={IsSubscribe}";
}
if (SecurityId != null)
{
str += $",Sec={SecurityId}";
}
if (!StrategyId.IsEmpty())
{
str += $",Strategy={StrategyId}";
}
if (Side != null)
{
str += $",Side={Side.Value}";
}
return(str);
}
internal void AddBracketOrder_WithNoTakeProfit_CorrectlyAddsOrdersWithIndexes()
{
// Arrange
var bracketOrder = StubBracketOrderProvider.Create(false);
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
// Act
this.database.AddBracketOrder(bracketOrder, traderId, accountId, strategyId, positionId);
// Assert
Assert.Equal(bracketOrder.Entry, this.database.GetOrder(bracketOrder.Entry.Id));
Assert.Equal(bracketOrder.StopLoss, this.database.GetOrder(bracketOrder.StopLoss.Id));
Assert.Equal(positionId, this.database.GetPositionId(bracketOrder.Entry.Id));
Assert.Equal(positionId, this.database.GetPositionId(bracketOrder.StopLoss.Id));
Assert.Equal(traderId, this.database.GetTraderId(bracketOrder.Entry.Id));
Assert.Equal(traderId, this.database.GetTraderId(bracketOrder.StopLoss.Id));
Assert.Equal(2, this.database.GetOrders().Count);
Assert.Equal(2, this.database.GetOrders(traderId).Count);
Assert.Equal(2, this.database.GetOrders(traderId, strategyId).Count);
Assert.Contains(bracketOrder.Entry.Id, this.database.GetOrderIds());
Assert.Contains(bracketOrder.Entry.Id, this.database.GetOrders());
Assert.Contains(bracketOrder.Entry.Id, this.database.GetOrders(traderId));
Assert.Contains(bracketOrder.Entry.Id, this.database.GetOrders(traderId, strategyId));
Assert.DoesNotContain(bracketOrder.Entry.Id, this.database.GetOrderWorkingIds());
Assert.DoesNotContain(bracketOrder.Entry.Id, this.database.GetOrderCompletedIds());
Assert.DoesNotContain(bracketOrder.Entry.Id, this.database.GetOrdersWorking());
Assert.DoesNotContain(bracketOrder.Entry.Id, this.database.GetOrdersCompleted());
Assert.Contains(bracketOrder.StopLoss.Id, this.database.GetOrderIds());
Assert.Contains(bracketOrder.StopLoss.Id, this.database.GetOrders());
Assert.Contains(bracketOrder.StopLoss.Id, this.database.GetOrders(traderId));
Assert.Contains(bracketOrder.StopLoss.Id, this.database.GetOrders(traderId, strategyId));
}
/// <inheritdoc />
public override string ToString()
{
var str = base.ToString() + $",TransId={TransactionId},OrdType={OrderType},Pf={PortfolioName}(ClCode={ClientCode}),Cond={Condition},MR={IsMargin}";
if (!Comment.IsEmpty())
{
str += $",Comment={Comment}";
}
if (!UserOrderId.IsEmpty())
{
str += $",UID={UserOrderId}";
}
if (!StrategyId.IsEmpty())
{
str += $",Strategy={StrategyId}";
}
if (!BrokerCode.IsEmpty())
{
str += $",BrID={BrokerCode}";
}
return(str);
}
internal void UpdateOrder_WhenOrderCompleted_CorrectlyUpdatesIndexes()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
this.database.AddOrder(order, traderId, accountId, strategyId, positionId);
order.Apply(StubEventMessageProvider.OrderSubmittedEvent(order));
this.database.UpdateOrder(order);
order.Apply(StubEventMessageProvider.OrderRejectedEvent(order));
// Act
this.database.UpdateOrder(order);
// Assert
Assert.Contains(order.Id, this.database.GetOrderIds());
Assert.Contains(order.Id, this.database.GetOrderIds(traderId));
Assert.Contains(order.Id, this.database.GetOrderIds(traderId, strategyId));
Assert.Contains(order.Id, this.database.GetOrderCompletedIds());
Assert.Contains(order.Id, this.database.GetOrderCompletedIds(traderId));
Assert.Contains(order.Id, this.database.GetOrderCompletedIds(traderId, strategyId));
Assert.DoesNotContain(order.Id, this.database.GetOrderWorkingIds());
Assert.Contains(order.Id, this.database.GetOrders(traderId));
Assert.Contains(order.Id, this.database.GetOrders(traderId, strategyId));
Assert.Contains(order.Id, this.database.GetOrdersCompleted(traderId));
Assert.Contains(order.Id, this.database.GetOrdersCompleted(traderId, strategyId));
}
internal void GetPositionsClosed_WhenNotPositionsInCache_ReturnsEmptyDictionary()
{
// Arrange
var order1 = new StubOrderBuilder()
.WithOrderId("O-123456-1")
.BuildMarketOrder();
var order2 = new StubOrderBuilder()
.WithOrderId("O-123456-2")
.WithOrderSide(OrderSide.Sell)
.BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var strategyId = new StrategyId("SCALPER", "001");
var positionId = new PositionId("P-123456");
this.database.AddOrder(order1, traderId, accountId, strategyId, positionId);
this.database.AddOrder(order2, traderId, accountId, strategyId, positionId);
var position = new Position(positionId, StubEventMessageProvider.OrderFilledEvent(order1));
this.database.AddPosition(position);
position.Apply(StubEventMessageProvider.OrderFilledEvent(order2));
this.database.UpdatePosition(position);
// Act
this.database.ClearCaches();
// Assert
Assert.Empty(this.database.GetPositionsClosed());
Assert.Empty(this.database.GetPositionsClosed(traderId));
Assert.Empty(this.database.GetPositionsClosed(traderId, strategyId));
}
internal void UpdatePosition_WhenPositionOpen_CorrectlyUpdatesIndexes()
{
// Arrange
var order = new StubOrderBuilder().BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var strategyId = new StrategyId("SCALPER", "001");
var positionId = new PositionId("P-123456");
this.database.AddOrder(order, traderId, accountId, strategyId, positionId);
var position = new Position(positionId, StubEventMessageProvider.OrderPartiallyFilledEvent(
order,
Quantity.Create(50000),
Quantity.Create(50000)));
this.database.AddPosition(position);
// Act
position.Apply(StubEventMessageProvider.OrderFilledEvent(order));
this.database.UpdatePosition(position);
// Assert
Assert.Equal(position, this.database.GetPosition(positionId));
Assert.Contains(position.Id, this.database.GetPositions());
Assert.Contains(position.Id, this.database.GetPositions(traderId));
Assert.Contains(position.Id, this.database.GetPositions(traderId, strategyId));
Assert.Contains(position.Id, this.database.GetPositionsOpen());
Assert.Contains(position.Id, this.database.GetPositionsOpen(traderId));
Assert.Contains(position.Id, this.database.GetPositionsOpen(traderId, strategyId));
Assert.Contains(position.Id, this.database.GetPositionIds());
Assert.Contains(position.Id, this.database.GetPositionOpenIds());
Assert.DoesNotContain(position.Id, this.database.GetPositionClosedIds());
}
internal void GetOrdersCompleted_WhenDoesNotExistInCache_ReturnsEmptyDictionary()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
this.database.AddOrder(order, traderId, accountId, strategyId, positionId);
order.Apply(StubEventMessageProvider.OrderSubmittedEvent(order));
this.database.UpdateOrder(order);
order.Apply(StubEventMessageProvider.OrderRejectedEvent(order));
this.database.UpdateOrder(order);
// Act
this.database.ClearCaches();
// Assert
Assert.Empty(this.database.GetOrders());
Assert.Empty(this.database.GetOrders(traderId));
Assert.Empty(this.database.GetOrders(traderId, strategyId));
Assert.Empty(this.database.GetOrdersWorking());
Assert.Empty(this.database.GetOrdersWorking(traderId));
Assert.Empty(this.database.GetOrdersWorking(traderId, strategyId));
Assert.Empty(this.database.GetOrdersCompleted());
Assert.Empty(this.database.GetOrdersCompleted(traderId));
Assert.Empty(this.database.GetOrdersCompleted(traderId, strategyId));
}
internal void GetPositionsOpen_WhenNotPositionsInCache_ReturnsEmptyDictionary()
{
// Arrange
var order = new StubOrderBuilder().BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var strategyId = new StrategyId("SCALPER", "001");
var positionId = new PositionId("P-123456");
this.database.AddOrder(order, traderId, accountId, strategyId, positionId);
var position = new Position(positionId, StubEventMessageProvider.OrderPartiallyFilledEvent(
order,
Quantity.Create(50000),
Quantity.Create(50000)));
this.database.AddPosition(position);
position.Apply(StubEventMessageProvider.OrderFilledEvent(order));
this.database.UpdatePosition(position);
// Act
this.database.ClearCaches();
// Assert
Assert.Empty(this.database.GetPositionsOpen());
Assert.Empty(this.database.GetPositionsOpen(traderId));
Assert.Empty(this.database.GetPositionsOpen(traderId, strategyId));
}
internal void AddOrder_WithNoOrdersInDatabase_CorrectlyAddsOrderWithIndexes()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
// Act
this.database.AddOrder(order, traderId, accountId, strategyId, positionId);
// Assert
Assert.Equal(order, this.database.GetOrder(order.Id));
Assert.Equal(positionId, this.database.GetPositionId(order.Id));
Assert.Equal(traderId, this.database.GetTraderId(order.Id));
Assert.Single(this.database.GetOrders());
Assert.Single(this.database.GetOrders(traderId));
Assert.Single(this.database.GetOrders(traderId, strategyId));
Assert.Contains(order.Id, this.database.GetOrders());
Assert.Contains(order.Id, this.database.GetOrders(traderId));
Assert.Contains(order.Id, this.database.GetOrders(traderId, strategyId));
Assert.Contains(traderId, this.database.GetTraderIds());
Assert.Contains(accountId, this.database.GetAccountIds());
Assert.Contains(strategyId, this.database.GetStrategyIds(traderId));
}
/// <inheritdoc />
public override string ToString()
{
var str = base.ToString() + $",T(S)={ServerTime:yyyy/MM/dd HH:mm:ss.fff},({ExecutionType}),Sec={SecurityId},O/T={HasOrderInfo}/{HasTradeInfo},Ord={OrderId}/{TransactionId}/{OriginalTransactionId},Fail={Error},Price={OrderPrice},OrdVol={OrderVolume},TrVol={TradeVolume},Bal={Balance},TId={TradeId},Pf={PortfolioName},TPrice={TradePrice},UId={UserOrderId},Type={OrderType},State={OrderState},Cond={Condition}";
if (!StrategyId.IsEmpty())
{
str += $",Strategy={StrategyId}";
}
if (PositionEffect != null)
{
str += $",PosEffect={PositionEffect.Value}";
}
if (PostOnly != null)
{
str += $",PostOnly={PostOnly.Value}";
}
if (Initiator != null)
{
str += $",Initiator={Initiator.Value}";
}
if (SeqNum != 0)
{
str += $",SeqNum={SeqNum}";
}
return(str);
}
/// <summary>
/// Add the given order identifier to the index.
/// </summary>
/// <param name="orderId">The order identifier to add.</param>
/// <param name="positionId">The position identifier to add.</param>
/// <param name="strategyId">The strategy identifier to add.</param>
public void AddIdentifiers(OrderId orderId, PositionId positionId, StrategyId strategyId)
{
this.indexOrders.Add(orderId);
this.indexPositions.Add(positionId);
this.indexStrategies.Add(strategyId);
if (this.indexStrategyOrders.TryGetValue(strategyId, out var orderIds))
{
orderIds.Add(orderId);
}
else
{
this.indexStrategyOrders[strategyId] = new HashSet <OrderId> {
orderId
};
}
if (this.indexStrategyPositions.TryGetValue(strategyId, out var positionIds))
{
positionIds.Add(positionId);
}
else
{
this.indexStrategyPositions[strategyId] = new HashSet <PositionId> {
positionId
};
}
}
internal void OnSubmitOrderCommand_WhenCommandValid_OperatesDatabaseAndSendsToGateway()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
var command = new SubmitOrder(
traderId,
accountId,
strategyId,
positionId,
order,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
// Act
this.engine.Endpoint.SendAsync(command).Wait();
Task.Delay(100).Wait(); // Buffer to avoid intermittent tests
// Assert
Assert.Null(this.engine.UnhandledMessages.FirstOrDefault());
Assert.Equal(2, this.engine.ProcessedCount);
Assert.Equal(1, this.engine.CommandCount);
Assert.Single(this.tradingGateway.CalledMethods);
Assert.Single(this.tradingGateway.ReceivedObjects);
Assert.Equal("SubmitOrder", this.tradingGateway.CalledMethods[0]);
Assert.Equal(order, this.tradingGateway.ReceivedObjects[0]);
}
internal void OnOrderFilledEvent_WithNoPosition_OpensPosition()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
var submitOrder = new SubmitOrder(
traderId,
accountId,
strategyId,
positionId,
order,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
// Act
this.engine.Endpoint.SendAsync(submitOrder).Wait();
this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderSubmittedEvent(order)).Wait();
this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderAcceptedEvent(order)).Wait();
this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderFilledEvent(order)).Wait();
Task.Delay(100).Wait(); // Buffer to avoid intermittent tests
// Assert
Assert.Single(this.database.GetPositions());
}
internal void OnOrderPartiallyFilledEvent_UpdatesOrderSendsToPublisher()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
var submitOrder = new SubmitOrder(
traderId,
accountId,
strategyId,
positionId,
order,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
// Act
this.engine.Endpoint.SendAsync(submitOrder).Wait();
this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderAcceptedEvent(order)).Wait();
this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderPartiallyFilledEvent(
order,
Quantity.Create(50000),
Quantity.Create(50000))).Wait();
Task.Delay(100).Wait(); // Buffer to avoid intermittent tests
// Assert
Assert.Null(this.engine.UnhandledMessages.FirstOrDefault());
Assert.Equal(4, this.engine.ProcessedCount);
Assert.Equal(1, this.engine.CommandCount);
Assert.Equal(2, this.engine.EventCount);
Assert.Equal(3, this.receiver.Messages.Count);
Assert.Equal(OrderState.PartiallyFilled, order.State);
}
internal void OnModifyOrderCommand_WhenOrderAlreadyBeingModified_DoesNotSendToGateway()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildStopMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
var submit = new SubmitOrder(
traderId,
accountId,
strategyId,
positionId,
order,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
var modify1 = new ModifyOrder(
traderId,
accountId,
order.Id,
order.Quantity,
Price.Create(1.00010m, 5),
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
var modify2 = new ModifyOrder(
traderId,
accountId,
order.Id,
order.Quantity,
Price.Create(1.00010m, 5),
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
// Act
this.engine.Endpoint.SendAsync(submit).Wait();
this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderAcceptedEvent(order)).Wait();
this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderWorkingEvent(order)).Wait();
this.engine.Endpoint.SendAsync(modify1).Wait();
this.engine.Endpoint.SendAsync(modify2).Wait();
Task.Delay(100).Wait(); // Buffer to avoid intermittent tests
// Assert
Assert.Null(this.engine.UnhandledMessages.FirstOrDefault());
Assert.Equal(6, this.engine.ProcessedCount);
Assert.Equal(3, this.engine.CommandCount);
Assert.Equal(2, this.engine.EventCount);
Assert.Equal(2, this.tradingGateway.CalledMethods.Count);
Assert.Equal(2, this.tradingGateway.ReceivedObjects.Count);
Assert.Equal("SubmitOrder", this.tradingGateway.CalledMethods[0]);
Assert.Equal("ModifyOrder", this.tradingGateway.CalledMethods[1]);
Assert.Equal(3, this.receiver.Messages.Count);
}
/// <inheritdoc />
public override string ToString()
{
var str = base.ToString() + $",TrId={TransactionId},Orig={OriginalTransactionId},Stat={Statistics.Select(p => $"{p.Key}={p.Value}").JoinComma()}";
if (!StrategyId.IsDefault())
{
str += $",Id={StrategyId}";
}
if (!StrategyTypeId.IsEmpty())
{
str += $",TypeId={StrategyTypeId}";
}
return(str);
}
internal void AddBracketOrder_WhenStopLossOrderAlreadyExists_ReturnsFailureResult()
{
// Arrange
var bracketOrder = StubBracketOrderProvider.Create();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
this.database.AddOrder(bracketOrder.StopLoss, traderId, accountId, strategyId, positionId);
// Act
var result = this.database.AddBracketOrder(bracketOrder, traderId, accountId, strategyId, positionId);
// Assert
Assert.True(result.IsFailure);
}
internal void AddOrder_WhenOrderAlreadyExists_ReturnsFailureResult()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
this.database.AddOrder(order, traderId, accountId, strategyId, positionId);
// Act
var result = this.database.AddOrder(order, traderId, accountId, strategyId, positionId);
// Assert
Assert.True(result.IsFailure);
}
internal void ClearCaches_WithOrderInCaches_CorrectlyClearsCache()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
this.database.AddOrder(order, traderId, accountId, strategyId, positionId);
// Act
this.database.ClearCaches();
// Assert
Assert.Null(this.database.GetOrder(order.Id));
}
internal void UpdatePosition_WhenMultipleOrdersForPositionLeavingPositionOpen_CorrectlyUpdatesIndexes()
{
// Arrange
var order1 = new StubOrderBuilder()
.WithOrderId("O-123456-1")
.BuildMarketOrder();
var order2 = new StubOrderBuilder()
.WithOrderId("O-123456-2")
.BuildMarketOrder();
var order3 = new StubOrderBuilder()
.WithOrderId("O-123456-3")
.BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var strategyId = new StrategyId("SCALPER", "001");
var positionId = new PositionId("P-123456");
this.database.AddOrder(order1, traderId, accountId, strategyId, positionId);
this.database.AddOrder(order2, traderId, accountId, strategyId, positionId);
this.database.AddOrder(order3, traderId, accountId, strategyId, positionId);
var position = new Position(positionId, StubEventMessageProvider.OrderFilledEvent(order1));
this.database.AddPosition(position);
position.Apply(StubEventMessageProvider.OrderFilledEvent(order2));
this.database.UpdatePosition(position);
// Act
position.Apply(StubEventMessageProvider.OrderFilledEvent(order3));
this.database.UpdatePosition(position);
// Assert
Assert.Equal(position, this.database.GetPosition(positionId));
Assert.Contains(position.Id, this.database.GetPositionsOpen());
Assert.Contains(position.Id, this.database.GetPositionsOpen(traderId));
Assert.Contains(position.Id, this.database.GetPositionsOpen(traderId, strategyId));
Assert.Contains(position.Id, this.database.GetPositionIds());
Assert.Contains(position.Id, this.database.GetPositionOpenIds());
Assert.DoesNotContain(position.Id, this.database.GetPositionClosedIds());
}
/// <summary>
/// Initializes a new instance of the <see cref="SubmitOrder"/> class.
/// </summary>
/// <param name="traderId">The trader identifier.</param>
/// <param name="accountId">The account identifier.</param>
/// <param name="strategyId">The strategy identifier.</param>
/// <param name="positionId">The position identifier.</param>
/// <param name="order">The order to submit.</param>
/// <param name="commandId">The command identifier.</param>
/// <param name="commandTimestamp">The command timestamp.</param>
public SubmitOrder(
TraderId traderId,
AccountId accountId,
StrategyId strategyId,
PositionId positionId,
Order order,
Guid commandId,
ZonedDateTime commandTimestamp)
: base(
CommandType,
commandId,
commandTimestamp)
{
this.TraderId = traderId;
this.AccountId = accountId;
this.StrategyId = strategyId;
this.PositionId = positionId;
this.Order = order;
}
internal void GetOrders_WhenDoesNotExistInCache_ReturnsEmptyDictionary()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
this.database.AddOrder(order, traderId, accountId, strategyId, positionId);
// Act
this.database.ClearCaches();
// Assert
Assert.Empty(this.database.GetOrders());
Assert.Empty(this.database.GetOrders(traderId));
Assert.Empty(this.database.GetOrders(traderId, strategyId));
}
/// <inheritdoc />
public override string ToString()
{
var str = base.ToString() + $",Sec={SecurityId},P={PortfolioName},CL={ClientCode},L={LimitType},Changes={Changes.Select(c => c.ToString()).JoinComma()}";
if (!StrategyId.IsEmpty())
{
str += $",Strategy={StrategyId}";
}
if (!Description.IsEmpty())
{
str += $",Description={Description}";
}
if (Side != null)
{
str += $",Side={Side}";
}
return(str);
}
internal void LoadOrdersCache_WhenOrdersInDatabase_CorrectlyCachesOrders()
{
// Arrange
var order1 = new StubOrderBuilder().EntryOrder("O-123456-1").BuildStopMarketOrder();
var order2 = new StubOrderBuilder().EntryOrder("O-123456-2").BuildStopMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
this.database.AddOrder(order1, traderId, accountId, strategyId, positionId);
this.database.AddOrder(order2, traderId, accountId, strategyId, positionId);
order2.Apply(StubEventMessageProvider.OrderSubmittedEvent(order2));
this.database.UpdateOrder(order2);
order2.Apply(StubEventMessageProvider.OrderAcceptedEvent(order2));
this.database.UpdateOrder(order2);
order2.Apply(StubEventMessageProvider.OrderWorkingEvent(order2));
this.database.UpdateOrder(order2);
order2.Apply(StubEventMessageProvider.OrderCancelledEvent(order2));
this.database.UpdateOrder(order2);
this.database.ClearCaches();
// Act
this.database.LoadOrdersCache();
// Assert
Assert.Equal(order1, this.database.GetOrders()[order1.Id]);
Assert.Equal(order2, this.database.GetOrders()[order2.Id]);
Assert.Equal(1, this.database.GetOrders()[order1.Id].EventCount);
Assert.Equal(5, this.database.GetOrders()[order2.Id].EventCount);
Assert.Equal(OrderState.Initialized, this.database.GetOrders()[order1.Id].State);
Assert.Equal(OrderState.Cancelled, this.database.GetOrders()[order2.Id].State);
}
internal void Flush_WithOrderInDatabase_FlushesData()
{
// Arrange
var order = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
var traderId = TraderId.FromString("TESTER-000");
var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");
var positionId = new PositionId("P-123456");
var strategyId = new StrategyId("SCALPER", "001");
this.database.AddOrder(order, traderId, accountId, strategyId, positionId);
// Act
this.database.Flush();
// Assert
Assert.Null(this.database.GetTraderId(order.Id));
Assert.Empty(this.database.GetOrders(traderId));
Assert.Empty(this.database.GetOrders(traderId, strategyId));
Assert.DoesNotContain(order.Id, this.database.GetOrders(traderId));
Assert.DoesNotContain(order.Id, this.database.GetOrders(traderId, strategyId));
Assert.DoesNotContain(traderId, this.database.GetTraderIds());
Assert.DoesNotContain(accountId, this.database.GetAccountIds());
Assert.DoesNotContain(strategyId, this.database.GetStrategyIds(traderId));
}
/// <summary> /// Returns the Redis key. /// </summary> /// <param name="traderId">The trader identifier.</param> /// <param name="strategyId">The strategy identifier.</param> /// <returns>The key string.</returns> internal static string IndexTraderStrategyOrdersKey(TraderId traderId, StrategyId strategyId) => KEY_INDEX_TRADER_STRATEGY_ORDERS + traderId.Value + ":" + strategyId.Value;
/// <inheritdoc />
public CommandResult AddOrder(Order order, TraderId traderId, AccountId accountId, StrategyId strategyId, PositionId positionId)
{
if (this.CachedOrders.ContainsKey(order.Id))
{
return(CommandResult.Fail($"The {order.Id} already existed in the cache (was not unique)."));
}
Debug.KeyNotIn(order.Id, this.indexOrderTrader, nameof(order.Id), nameof(this.indexOrderTrader));
Debug.KeyNotIn(order.Id, this.indexOrderAccount, nameof(order.Id), nameof(this.indexOrderAccount));
Debug.KeyNotIn(order.Id, this.indexOrderPosition, nameof(order.Id), nameof(this.indexOrderPosition));
Debug.NotIn(order.Id, this.indexOrders, nameof(order.Id), nameof(this.indexOrders));
this.indexAccounts.Add(accountId);
this.indexOrderTrader[order.Id] = traderId;
this.indexOrderAccount[order.Id] = accountId;
this.indexOrderPosition[order.Id] = positionId;
this.indexPositionTrader[positionId] = traderId;
this.indexPositionAccount[positionId] = accountId;
// PositionId -> Set[OrderId]
if (this.indexPositionOrders.TryGetValue(positionId, out var positionOrders))
{
positionOrders.Add(order.Id);
}
else
{
this.indexPositionOrders[positionId] = new HashSet <OrderId> {
order.Id
};
}
// AccountId -> Set[OrderId]
if (this.indexAccountOrders.TryGetValue(accountId, out var accountOrders))
{
accountOrders.Add(order.Id);
}
else
{
this.indexAccountOrders[accountId] = new HashSet <OrderId> {
order.Id
};
}
// AccountId -> Set[PositionId]
if (this.indexAccountPositions.TryGetValue(accountId, out var accountPositions))
{
accountPositions.Add(positionId);
}
else
{
this.indexAccountPositions[accountId] = new HashSet <PositionId> {
positionId
};
}
// TraderId -> TraderIdentifierIndex
if (this.indexTraders.TryGetValue(traderId, out var traderIndex))
{
traderIndex.AddIdentifiers(order.Id, positionId, strategyId);
}
else
{
this.indexTraders[traderId] = new TraderIdentifierIndex();
this.indexTraders[traderId].AddIdentifiers(order.Id, positionId, strategyId);
}
this.indexOrders.Add(order.Id);
this.CachedOrders[order.Id] = order;
this.Logger.LogDebug(LogId.Database, $"Added Order(Id={order.Id.Value}).");
return(CommandResult.Ok());
}
/// <inheritdoc />
public CommandResult AddBracketOrder(BracketOrder order, TraderId traderId, AccountId accountId, StrategyId strategyId, PositionId positionId)
{
var resultEntry = this.AddOrder(
order.Entry,
traderId,
accountId,
strategyId,
positionId);
if (resultEntry.IsFailure)
{
return(resultEntry);
}
var resultStopLoss = this.AddOrder(
order.StopLoss,
traderId,
accountId,
strategyId,
positionId);
if (resultStopLoss.IsFailure)
{
return(resultStopLoss);
}
if (order.TakeProfit != null)
{
var resultTakeProfit = this.AddOrder(
order.TakeProfit,
traderId,
accountId,
strategyId,
positionId);
if (resultTakeProfit.IsFailure)
{
return(resultTakeProfit);
}
}
return(CommandResult.Ok());
}
/// <summary> /// Returns the Redis key. /// </summary> /// <param name="traderId">The trader identifier.</param> /// <param name="strategyId">The strategy identifier.</param> /// <returns>The key string.</returns> internal static string IndexTraderStrategyPositionsKey(TraderId traderId, StrategyId strategyId) => KEY_INDEX_TRADER_STRATEGY_POSITIONS + traderId.Value + ":" + strategyId.Value;
