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