/// <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
};
}
}
void IUnlockPosition.OnUnlockPosition(PositionId positionId)
{
if (id == positionId)
{
Data?.SetColor(parameters.Unlocked);
}
}
public RADecl GetPosition(PositionId positionId)
{
RADecl result = null;
_positions.TryGetValue(positionId, out result);
return(result);
}
public void AddPosition(PositionId positionId, double rightAscension, double declination)
{
_positions[positionId] = new RADecl()
{
RA = rightAscension, Declination = declination
};
}
public void CreateCardFromPool(CardHand cardHand, PositionId positionId)
{
var poolPosition = uiPool.GetPosition(positionId);
var poolWorldPosition = poolPosition.transform.position;
CreateUiCard(cardHand, poolWorldPosition);
}
/// <summary>
/// Reads the stream.
/// </summary>
/// <param name="stream">Stream.</param>
protected override void ReadStream(Stream stream)
{
if (stream == null)
{
resultCallback(new List <PositionTurn> ()
{
}, new Exception("No turn received"));
return;
}
string fileName = PositionId.ToString() + ".html";
StreamReader reader = new StreamReader(stream);
string content = reader.ReadToEnd().Replace("url(", "url(" + Phoenix.Application.BASE_URL);
List <PositionTurn> list = new List <PositionTurn> ()
{
new PositionTurn {
Id = PositionId,
Content = content
}
};
Application.DocumentFolder.WriteFile(fileName, content);
resultCallback(list, null);
}
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));
}
public T GetAndRemoveCardAt(PositionId id)
{
var card = GetCardAt(id);
RemoveCardAt(id);
return(card);
}
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));
}
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));
}
public void RevealCard(SeatType seatType, PositionId positionId)
{
if (!Game.IsGameStarted)
{
return;
}
var pool = Game.Pool;
var isPositionLocked = pool.IsPositionLocked(positionId);
if (isPositionLocked)
{
return;
}
var data = Game.Library.GetRandomData();
var cardPool = new CardPool(data);
var inventory = GetInventory(seatType);
var actionPoints = Parameters.Amounts.ActionPointsConsume;
var hasEnoughActionPoints = inventory.GetAmount(Inventory.ActionPointItem) >= actionPoints;
if (!hasEnoughActionPoints)
{
return;
}
inventory.RemoveItem(Inventory.ActionPointItem, actionPoints);
pool.AddCardAt(cardPool, positionId);
OnRevealCard(seatType, cardPool, positionId);
}
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));
}
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 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 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 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());
}
private string FormatPos(PositionId positionId)
{
var pos = _state.GetPosition(positionId);
if (pos == null)
return "";
return string.Format("RA = {0}, Dec = {1}", Utils.FormatRA(pos.RA), Utils.FormatDegrees(pos.Declination));
}
public Position_zu_Bon_hinzufuegen(BonId bon, PositionId position, ArtikelId artikel, int menge, decimal betrag)
{
Bon = bon;
Artikel = artikel;
Menge = menge;
Betrag = betrag;
Position = position;
}
void IPickCard.OnPickCard(SeatType id, CardHand cardHand, PositionId positionId)
{
if (!IsMyEvent(id))
{
return;
}
Registry.CreateCardFromPool(cardHand, positionId);
}
public bool Equals(SalaryCategory other)
{
return(other != null &&
base.Equals(other) &&
Id.Equals(other.Id) &&
YearsRange == other.YearsRange &&
PositionId.Equals(other.PositionId) &&
Salary == other.Salary);
}
public void ReturnCardToPosition(PlayerId id, PositionId positionId)
{
if (SelectedCard == null)
{
return;
}
GameData.CurrentGameInstance.ReturnCardToPosition(this.id, SelectedCard, positionId);
SelectedCard = null;
}
/// <inheritdoc />
public override AccountId?GetAccountId(PositionId positionId)
{
if (this.indexPositionAccount.TryGetValue(positionId, out var accountId))
{
return(accountId);
}
this.Logger.LogWarning($"Cannot find AccountId for {positionId} in the database.");
return(null);
}
/// <inheritdoc />
public override TraderId?GetTraderId(PositionId positionId)
{
if (this.indexPositionTrader.TryGetValue(positionId, out var traderId))
{
return(traderId);
}
this.Logger.LogWarning(LogId.Database, $"Cannot find TraderId for {positionId}.");
return(null);
}
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);
}
private string FormatPos2(PositionId align, PositionId gotoId)
{
var alignPos = _state.GetPosition(align);
var gotoPos = _state.GetPosition(gotoId);
if (alignPos == null || gotoPos == null)
return "";
var offset = alignPos - gotoPos;
return string.Format("RA (deg) = {0}, Dec = {1}", Utils.FormatDegrees(offset.RA * 15), Utils.FormatDegrees(offset.Declination));
}
internal void GetAccountIdWithPositionId_WhenNoAccountExists_ReturnsNull()
{
// Arrange
var positionId = new PositionId("P-123456");
// Act
var result = this.database.GetAccountId(positionId);
// Assert
Assert.Null(result);
}
public void RemoveCard(PositionId positionId)
{
var position = GetPosition(positionId);
if (!position.HasData)
{
return;
}
position.Clear();
}
public UiPoolPosition GetPosition(PositionId positionId)
{
foreach (var i in PoolCardPositions)
{
if (i.Id == positionId)
{
return(i);
}
}
return(null);
}
internal void GetPosition_WhenNoPositionExists_ReturnsNull()
{
// Arrange
var positionId = new PositionId("P-123456");
// Act
var result = this.database.GetPosition(positionId);
// Assert
Assert.Null(result);
}
void SetPosition(PositionId i, Vector3 position)
{
if (!_positions.ContainsKey(i))
{
_positions.Add(i, position);
}
else
{
_positions[i] = position.WithZ(LayerZ);
}
}
public void AddPosition(PositionId positionId, double rightAscension, double declination)
{
_positions[positionId] = new RADecl() {RA = rightAscension, Declination = declination};
}
public RADecl GetPosition(PositionId positionId)
{
RADecl result = null;
_positions.TryGetValue(positionId, out result);
return result;
}
