private void OnNewOrder(OrderRecord order)
{
var iceberg =
_atOrderRepository.IcebergOrders.FirstOrDefault(io => io.ClOrdID == order.ClOrdID);
if (iceberg != null)
{
iceberg.ActivatedMarketOrderAccepted(order.OrderID);
OnOrderUpdated(iceberg);
}
}
private void OnNewOrder(OrderRecord order)
{
var iceberg =
_atOrderRepository.IcebergOrders.FirstOrDefault(io => io.ClOrdID == order.ClOrdID);
if (iceberg != null)
{
iceberg.ActivatedMarketOrderAccepted(order.OrderID);
OnOrderUpdated(iceberg);
}
}
private void OnOrderTotalFill(OrderRecord order)
{
var iceberg =
_atOrderRepository.IcebergOrders.FirstOrDefault(io => io.ClOrdID == order.ClOrdID);
if (iceberg != null)
{
iceberg.OnTotalFill();
OnOrderUpdated(iceberg);
}
}
private void OnOrderCanceled(OrderRecord order)
{
var iceberg =
_atOrderRepository.IcebergOrders.FirstOrDefault(io => io.ClOrdID == order.ClOrdID);
if (iceberg != null)
{
iceberg.MarketOrderCanceled();
OnOrderUpdated(iceberg);
}
}
public bool CreateOrder(OrderRecord o)
{
var msg =
_fixMessageGenerator.CreateNewOrderSingleMessage(o.Symbol,
o.Side,
o.ClOrdID,
TradingAccount.None,
o.Price,
o.Quantity,
o.OrdType,
_execIDGenerator.CreateExecID());
return _app.Send(msg);
}
private void OnOrderPartialFill(OrderRecord order)
{
var iceberg =
_atOrderRepository.IcebergOrders.FirstOrDefault(io => io.ClOrdID == order.ClOrdID);
if (iceberg != null)
{
// This is predicated on the ClOrdID of an order not changing
var filledQty = iceberg.CurrentQuantity - order.Quantity;
iceberg.OnPartialFill(filledQty);
OnOrderUpdated(iceberg);
}
}
private static void AddOrUpdateImpl(
List<OrderRecord> orders,
OrderRecord order,
UpdateLastUpdateTime updateLastUpdateTime)
{
var removed = RemoveOrderImpl(orders, order);
Debug.Assert(!(updateLastUpdateTime == UpdateLastUpdateTime.No && removed == null));
if (updateLastUpdateTime == UpdateLastUpdateTime.No && removed != null)
{
order.LastUpdateTime = removed.LastUpdateTime;
}
orders.Add(order);
}
public void RemoveOrder(OrderRecord order)
{
if (order.Side == MarketSide.Bid)
{
lock (_bidsLock)
{
RemoveOrderImpl(_bids, order);
_bids.Sort();
}
}
else
{
lock (_asksLock)
{
RemoveOrderImpl(_asks, order);
_asks.Sort();
}
}
}
private void OnOrderExecutionEvent(OrderStatus status, OrderRecord order)
{
switch (status)
{
case OrderStatus.New:
OnNewOrder(order);
break;
case OrderStatus.Filled:
OnOrderTotalFill(order);
break;
case OrderStatus.PartiallyFilled:
OnOrderPartialFill(order);
break;
case OrderStatus.Canceled:
OnOrderCanceled(order);
break;
// TODO Handle OrderStatus.Suspended
}
}
private void AddOrUpdateOrder(
OrderRecord order,
UpdateLastUpdateTime updateLastUpdateTime)
{
if (order.Side == MarketSide.Bid)
{
lock (_bidsLock)
{
AddOrUpdateImpl(_bids, order, updateLastUpdateTime);
_bids.Sort();
}
}
else
{
lock (_asksLock)
{
AddOrUpdateImpl(_asks, order, updateLastUpdateTime);
_asks.Sort();
}
}
}
public void SubmitNewOrder(OrderRecord o)
{
_serverFacade.CreateOrder(o);
}
private void UpdateOrder(OrderRecord order)
{
GetOrCreateStack(order).AddOrUpdateOrder(order);
UpdateOrderStackRows();
}
private void Trade(OrderStackRow osr, MarketSide side)
{
if (osr == null) throw new ArgumentNullException("osr");
// The server currently does not support click trading, so we fake
// it here by adding a matching order to the other side of the market.
// If the server supported ImmediateOrCancel then we'd use that.
var isBid = side == MarketSide.Bid;
var matchingOrderDetails = new OrderRecord
{
ClOrdID = _clOrdIDGenerator.CreateClOrdID(),
LastUpdateTime = DateTime.UtcNow,
OrderID = string.Empty, // Set by server
OrdType = OrderType.Limit,
Price = decimal.Parse(isBid ? osr.BidPrice : osr.AskPrice),
Quantity = decimal.Parse(isBid ? osr.BidQty : osr.AskQty),
Side = isBid ? MarketSide.Ask : MarketSide.Bid,
Symbol = osr.Symbol,
Status = OrderStatus.New
};
_serverFacade.CreateOrder(matchingOrderDetails);
}
public bool UpdateOrder(OrderRecord oldOrderDetails, OrderRecord newOrderDetails)
{
// TODO This should use an ordercancelreplace
var fakeCancelClOrdID = oldOrderDetails.ClOrdID + "_Cancel";
var cancel = _fixMessageGenerator.CreateOrderCancelMessage(oldOrderDetails.Symbol,
oldOrderDetails.ClOrdID,
fakeCancelClOrdID,
oldOrderDetails.Side,
oldOrderDetails.OrderID);
if (!_app.Send(cancel))
return false;
var add = _fixMessageGenerator.CreateNewOrderSingleMessage(newOrderDetails.Symbol,
newOrderDetails.Side,
newOrderDetails.ClOrdID,
TradingAccount.None,
newOrderDetails.Price,
newOrderDetails.Quantity,
OrderType.Limit,
_execIDGenerator.CreateExecID());
return _app.Send(add);
}
private static void CompareOrderRecords(OrderRecord e,
OrderRecord a,
OptionalComparisons compFlags =
OptionalComparisons.None)
{
Assert.AreEqual(e.OrdType, a.OrdType, "OrdType is different");
Assert.AreEqual(e.Price, a.Price, "Price is different");
Assert.AreEqual(e.Quantity, a.Quantity, "Quantity is different");
Assert.AreEqual(e.Side, a.Side, "Side is different");
Assert.AreEqual(e.Symbol, a.Symbol, "Symbol is different");
if ((compFlags & OptionalComparisons.LastUpdated) == OptionalComparisons.LastUpdated)
Assert.AreEqual(e.LastUpdateTime, a.LastUpdateTime, "LastUpdateTime is different");
if ((compFlags & OptionalComparisons.OrderID) == OptionalComparisons.OrderID)
Assert.AreEqual(e.OrderID, a.OrderID, "OrderID is different");
if ((compFlags & OptionalComparisons.OrderStatus) == OptionalComparisons.OrderStatus)
Assert.AreEqual(e.Status, a.Status, "Status is different");
}
private void OnOrderPartialFill(OrderRecord order)
{
var iceberg =
_atOrderRepository.IcebergOrders.FirstOrDefault(io => io.ClOrdID == order.ClOrdID);
if (iceberg != null)
{
// This is predicated on the ClOrdID of an order not changing
var filledQty = iceberg.CurrentQuantity - order.Quantity;
iceberg.OnPartialFill(filledQty);
OnOrderUpdated(iceberg);
}
}
private static OrderRecord RemoveOrderImpl(List<OrderRecord> orders, OrderRecord order)
{
var existing = orders.FirstOrDefault(o => o.ClOrdID == order.ClOrdID);
if (existing != null)
{
orders.Remove(existing);
}
return existing;
}
public void AddOrUpdateOrder(OrderRecord order)
{
AddOrUpdateOrder(order, UpdateLastUpdateTime.Yes);
}
public void AddUpdate(OrderRecord old, OrderRecord updated)
{
OldRecords.Add(old);
NewRecords.Add(updated);
}
public void OnPartialFillOrder(OrderRecord order)
{
AddOrUpdateOrder(order, UpdateLastUpdateTime.No);
}
private OrderStack GetOrCreateStack(OrderRecord order)
{
var symbol = order.Symbol;
lock (_marketLock)
{
return _market.GetOrCreate(symbol);
}
}
private void HandleOrderExecutionEvent(OrderStatus status, OrderRecord order)
{
if (order == null) throw new ArgumentNullException("order");
// TODO We need to handle suspended -> active
switch (status)
{
case OrderStatus.Canceled:
case OrderStatus.Filled:
case OrderStatus.Traded:
RemoveOrder(order);
break;
case OrderStatus.PartiallyFilled:
OnPartialFill(order);
break;
case OrderStatus.Suspended:
UpdateOrder(order);
break;
case OrderStatus.New:
AddOrUpdateOrder(order);
break;
case OrderStatus.Rejected:
OrderRejected(order);
break;
}
}
private void OnPartialFill(OrderRecord order)
{
GetOrCreateStack(order).OnPartialFillOrder(order);
UpdateOrderStackRows();
}
private void OnOrderExecutionEvent(OrderStatus status, OrderRecord order)
{
switch (status)
{
case OrderStatus.New:
OnNewOrder(order);
break;
case OrderStatus.Filled:
OnOrderTotalFill(order);
break;
case OrderStatus.PartiallyFilled:
OnOrderPartialFill(order);
break;
case OrderStatus.Canceled:
OnOrderCanceled(order);
break;
// TODO Handle OrderStatus.Suspended
}
}
private void OrderRejected(OrderRecord order)
{
_messageSink.Error(() =>
{
var reason = order.RejectReason;
if (string.IsNullOrWhiteSpace(reason))
{
// TODO There is a lack of ability to send free-text error messages via FIX
// Therefore if the reason is not filled in here we guess at the likely cause
reason = "Unkown. Possibly order would have led to a crossed market";
}
return "Unable to add order: " + reason;
});
}
private void OnOrderTotalFill(OrderRecord order)
{
var iceberg =
_atOrderRepository.IcebergOrders.FirstOrDefault(io => io.ClOrdID == order.ClOrdID);
if (iceberg != null)
{
iceberg.OnTotalFill();
OnOrderUpdated(iceberg);
}
}
private void RemoveOrder(OrderRecord order)
{
GetOrCreateStack(order).RemoveOrder(order);
UpdateOrderStackRows();
}
private void OnOrderCanceled(OrderRecord order)
{
var iceberg =
_atOrderRepository.IcebergOrders.FirstOrDefault(io => io.ClOrdID == order.ClOrdID);
if (iceberg != null)
{
iceberg.MarketOrderCanceled();
OnOrderUpdated(iceberg);
}
}
private void HandleExecutionReport(ExecutionReport msg)
{
if (msg == null) throw new ArgumentNullException("msg");
var order = new OrderRecord(msg);
var status = TranslateFixFields.Translate(msg.OrdStatus);
var e = OrderExecutionEvent;
if (e != null)
e(status, order);
}
