internal void CanSerializeAndDeserialize_SubmitBracketOrderCommands_WithNoTakeProfit()
{
// Arrange
var entry = new StubOrderBuilder().BuildMarketOrder();
var stopLoss = new StubOrderBuilder().BuildStopMarketOrder();
var bracketOrder = new BracketOrder(entry, stopLoss);
var command = new SubmitBracketOrder(
new TraderId("TESTER", "000"),
new AccountId("FXCM", "028999999", "SIMULATED"),
new StrategyId("EMACross", "001"),
new PositionId("P-123456"),
bracketOrder,
Guid.NewGuid(),
StubZonedDateTime.UnixEpoch());
// Act
var packed = this.serializer.Serialize(command);
var unpacked = (SubmitBracketOrder)this.serializer.Deserialize(packed);
// Assert
Assert.Equal(command, unpacked);
Assert.Equal(bracketOrder, unpacked.BracketOrder);
this.Output.WriteLine(Convert.ToBase64String(packed));
this.Output.WriteLine(Encoding.UTF8.GetString(packed));
}
/// <summary>
/// Initializes a new instance of the <see cref="SubmitBracketOrder"/> 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="bracketOrder">The bracket order to submit.</param>
/// <param name="commandId">The command identifier.</param>
/// <param name="commandTimestamp">The command timestamp.</param>
public SubmitBracketOrder(
TraderId traderId,
AccountId accountId,
StrategyId strategyId,
PositionId positionId,
BracketOrder bracketOrder,
Guid commandId,
ZonedDateTime commandTimestamp)
: base(
CommandType,
commandId,
commandTimestamp)
{
this.TraderId = traderId;
this.AccountId = accountId;
this.StrategyId = strategyId;
this.PositionId = positionId;
this.BracketOrder = bracketOrder;
}
/// <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());
}
/// <inheritdoc />
public void NewOrderList(BracketOrder bracketOrder)
{
if (bracketOrder.TakeProfit != null)
{
var message = NewOrderListEntryFactory.CreateWithStopLossAndTakeProfit(
bracketOrder.Symbol.Code,
this.accountId.AccountNumber,
bracketOrder,
this.TimeNow());
this.SendFixMessage(message);
}
else
{
var message = NewOrderListEntryFactory.CreateWithStopLoss(
bracketOrder.Symbol.Code,
this.accountId.AccountNumber,
bracketOrder,
this.TimeNow());
this.SendFixMessage(message);
}
}
/// <summary>
/// Creates and returns a new <see cref="NewOrderList"/> FIX message with contingency orders.
/// </summary>
/// <param name="symbolCode">The brokers symbol.</param>
/// <param name="accountNumber">The account number.</param>
/// <param name="bracketOrder">The bracket order.</param>
/// <param name="timeNow">The time now.</param>
/// <returns>The FIX message.</returns>
public static NewOrderList CreateWithStopLoss(
string symbolCode,
AccountNumber accountNumber,
BracketOrder bracketOrder,
ZonedDateTime timeNow)
{
Debug.NotEmptyOrWhiteSpace(symbolCode, nameof(symbolCode));
Debug.NotDefault(timeNow, nameof(timeNow));
var message = new NewOrderList();
message.SetField(new ListID(timeNow.TickOfDay.ToString()));
message.SetField(new TotNoOrders(2));
message.SetField(new ContingencyType(101));
message.SetField(new NoOrders(2));
message.SetField(new BidType(3));
message.SetField(new TransactTime(timeNow.ToDateTimeUtc()));
// Order 1
var entry = bracketOrder.Entry;
var order1 = new NewOrderList.NoOrdersGroup();
order1.SetField(new ClOrdID(entry.Id.Value));
order1.SetField(new ListSeqNo(0));
order1.SetField(new ClOrdLinkID("1"));
order1.SetField(new Account(accountNumber.Value));
order1.SetField(new Symbol(symbolCode));
order1.SetField(FxcmMessageHelper.GetFixOrderSide(entry.OrderSide));
order1.SetField(FxcmMessageHelper.GetFixOrderType(entry.OrderType));
order1.SetField(FxcmMessageHelper.GetFixTimeInForce(entry.TimeInForce));
order1.SetField(new OrderQty(entry.Quantity.Value));
// Add price
if (entry.Price?.Value != null)
{
switch (entry.OrderType)
{
case OrderType.Limit:
order1.SetField(new Price(entry.Price.Value));
break;
case OrderType.Stop:
order1.SetField(new StopPx(entry.Price.Value));
break;
case OrderType.StopLimit:
order1.SetField(new StopPx(entry.Price.Value));
break;
case OrderType.Market:
case OrderType.Undefined:
goto default;
default:
throw ExceptionFactory.InvalidSwitchArgument(entry.OrderType, nameof(entry.OrderType));
}
}
// Optional tags
if (entry.ExpireTime.HasValue)
{
var expireTime = FxcmMessageHelper.ToExpireTimeFormat(entry.ExpireTime.Value);
order1.SetField(new StringField(126, expireTime));
}
// Order 2 -----------------------------------------------------------------------------
var stopLoss = bracketOrder.StopLoss;
var order2 = new NewOrderList.NoOrdersGroup();
order2.SetField(new ClOrdID(stopLoss.Id.Value));
order2.SetField(new ListSeqNo(1));
order2.SetField(new ClOrdLinkID("2"));
order2.SetField(new Account(accountNumber.Value));
order2.SetField(new Symbol(symbolCode));
order2.SetField(FxcmMessageHelper.GetFixOrderSide(stopLoss.OrderSide));
order2.SetField(new OrdType(OrdType.STOP));
order2.SetField(FxcmMessageHelper.GetFixTimeInForce(stopLoss.TimeInForce));
order2.SetField(new OrderQty(stopLoss.Quantity.Value));
// Stop-loss orders should always have a stop price
if (stopLoss.Price?.Value != null)
{
order2.SetField(new StopPx(stopLoss.Price.Value));
}
message.AddGroup(order1);
message.AddGroup(order2);
return(message);
}
/// <inheritdoc/>
public void SubmitOrder(BracketOrder bracketOrder)
{
this.CalledMethods.Add(nameof(this.SubmitOrder));
this.ReceivedObjects.Add(bracketOrder);
}
/// <inheritdoc />
public void SubmitOrder(BracketOrder bracketOrder)
{
this.fixClient.NewOrderList(bracketOrder);
}
/// <inheritdoc />
public void NewOrderList(BracketOrder bracketOrder)
{
this.FixMessageRouter.NewOrderList(bracketOrder);
}
