public CreateOrChangeOrderDefault(OrderState orderState, SymbolInfo symbol, CreateOrChangeOrder origOrder)
{
binary.action = OrderAction.Cancel;
OrderState = orderState;
binary.lastModifyTime = Factory.Parallel.UtcNow;
binary.symbol = symbol;
binary.side = default(OrderSide);
binary.type = default(OrderType);
binary.price = 0D;
binary.size = 0;
binary.logicalOrderId = 0;
binary.logicalSerialNumber = 0L;
binary.tag = null;
binary.reference = null;
binary.brokerOrder = CreateBrokerOrderId();
binary.utcCreateTime = Factory.Parallel.UtcNow;
if (origOrder == null)
{
throw new NullReferenceException("original order cannot be null for a cancel order.");
}
binary.originalOrder = origOrder;
binary.replacedBy = null;
binary.orderFlags = origOrder.OrderFlags;
instanceId = ++nextInstanceId;
}
private void ProcessChangeOrder(CreateOrChangeOrder order)
{
SendExecutionReport(order, "E", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow);
SendPositionUpdate(order.Symbol, ProviderSimulator.GetPosition(order.Symbol));
SendExecutionReport(order, "5", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow);
SendPositionUpdate(order.Symbol, ProviderSimulator.GetPosition(order.Symbol));
}
private CreateOrChangeOrder RemoveOrderInternal(long clientOrderId)
{
if (clientOrderId == 0)
{
return(null);
}
CreateOrChangeOrder order = null;
if (ordersByBrokerId.TryGetValue(clientOrderId, out order))
{
var result = ordersByBrokerId.Remove(clientOrderId);
if (result && trace)
{
log.Trace("Removed order by broker id " + clientOrderId + ": " + order);
}
CreateOrChangeOrder orderBySerial;
if (ordersBySerial.TryGetValue(order.LogicalSerialNumber, out orderBySerial))
{
if (orderBySerial.BrokerOrder.Equals(clientOrderId))
{
var result2 = ordersBySerial.Remove(order.LogicalSerialNumber);
if (result2 && trace)
{
log.Trace("Removed order by logical serial " + order.LogicalSerialNumber + ": " + orderBySerial);
}
}
}
ordersBySequence.Remove(order.Sequence);
return(order);
}
return(null);
}
public void SelectBySymbolTest()
{
using (var store = Factory.Utility.PhyscalOrderStore("OrderStoreTest"))
{
var symbolInfo = Factory.Symbol.LookupSymbol("EUR/USD");
var clientId = 010101010101L;
var logicalSerial = 100000335;
var order = Factory.Utility.PhysicalOrder(OrderAction.Create, OrderState.Active, symbolInfo, OrderSide.Sell,
OrderType.BuyLimit, OrderFlags.None,
124.34, 1234, 14, logicalSerial, clientId, null, TimeStamp.UtcNow);
store.SetOrder(order);
order = Factory.Utility.PhysicalOrder(OrderAction.Create, OrderState.Active, symbolInfo, OrderSide.Sell, OrderType.BuyLimit, OrderFlags.None,
124.34, 1234, 14, logicalSerial + 1, clientId, null, TimeStamp.UtcNow);
store.SetOrder(order);
var list = store.GetOrders((o) => o.Symbol.Symbol == "EUR/USD");
var enumerator = list.GetEnumerator();
var count = 0;
CreateOrChangeOrder firstItem = null;
if (enumerator.MoveNext())
{
count++;
firstItem = enumerator.Current;
}
Assert.AreEqual(1, count);
Assert.AreEqual(order.BrokerOrder, firstItem.BrokerOrder);
Assert.AreEqual(logicalSerial + 1, firstItem.LogicalSerialNumber);
}
}
private void AssureNode(CreateOrChangeOrder order)
{
if (order.Reference == null)
{
order.Reference = nodePool.Create(order);
}
}
protected override void ResendOrder(CreateOrChangeOrder order)
{
if (order.Action == OrderAction.Cancel)
{
if (debug)
{
log.Debug("Resending cancel order: " + order);
}
//if (SyncTicks.Enabled && !IsRecovered)
//{
// TryAddPhysicalOrder(order);
//}
SendCancelOrder(order, true);
}
else
{
if (debug)
{
log.Debug("Resending order: " + order);
}
//if (SyncTicks.Enabled && !IsRecovered)
//{
// TryAddPhysicalOrder(order);
//}
OnCreateOrChangeBrokerOrder(order, true);
}
}
public bool OnCancelBrokerOrder(CreateOrChangeOrder order)
{
if (debug)
{
log.Debug("OnCancelBrokerOrder( " + order.OriginalOrder.BrokerOrder + ")");
}
var origOrder = CancelBrokerOrder(order.OriginalOrder.BrokerOrder);
if (origOrder == null)
{
if (debug)
{
log.Debug("PhysicalOrder too late to change. Already filled or canceled, ignoring.");
}
var message = "No such order";
if (onRejectOrder != null)
{
SendReject(order, true, message);
}
else
{
throw new ApplicationException(message + " while handling order: " + order);
}
return(true);
}
origOrder.ReplacedBy = order;
if (confirmOrders != null)
{
confirmOrders.ConfirmCancel(order.BrokerOrder, true);
}
UpdateCounts();
return(true);
}
private IEnumerable <CreateOrChangeOrder> OrderReferences(CreateOrChangeOrder order)
{
if (order.ReplacedBy != null)
{
if (AddUniqueOrder(order.ReplacedBy))
{
yield return(order.ReplacedBy);
foreach (var sub in OrderReferences(order.ReplacedBy))
{
if (AddUniqueOrder(sub))
{
yield return(sub);
}
}
}
}
if (order.OriginalOrder != null)
{
if (AddUniqueOrder(order.OriginalOrder))
{
yield return(order.OriginalOrder);
foreach (var sub in OrderReferences(order.OriginalOrder))
{
if (AddUniqueOrder(sub))
{
yield return(sub);
}
}
}
}
}
public bool TryGetOrderById(long orderId, out CreateOrChangeOrder createOrChangeOrder)
{
LogOpenOrders();
lock (orderMapLocker)
{
return(orderMap.TryGetValue(orderId, out createOrChangeOrder));
}
}
public bool AddCreateOrder(CreateOrChangeOrder order)
{
var result = !HasCreateOrder(order);
if (!result)
{
createOrderQueue.AddLast(order);
}
return(result);
}
private void ProcessCancelOrder(CreateOrChangeOrder cancelOrder)
{
var origOrder = cancelOrder.OriginalOrder;
var randomOrder = random.Next(0, 10) < 5 ? cancelOrder : origOrder;
SendExecutionReport(randomOrder, "6", 0.0, 0, 0, 0, (int)origOrder.Size, TimeStamp.UtcNow);
SendPositionUpdate(cancelOrder.Symbol, ProviderSimulator.GetPosition(cancelOrder.Symbol));
SendExecutionReport(randomOrder, "4", 0.0, 0, 0, 0, (int)origOrder.Size, TimeStamp.UtcNow);
SendPositionUpdate(cancelOrder.Symbol, ProviderSimulator.GetPosition(cancelOrder.Symbol));
}
public bool TryGetOrderBySequence(int sequence, out CreateOrChangeOrder order)
{
AssertAtomic();
if (sequence == 0)
{
order = null;
return(false);
}
return(ordersBySequence.TryGetValue(sequence, out order));
}
public bool TryGetOrderById(long brokerOrder, out CreateOrChangeOrder order)
{
AssertAtomic();
if (brokerOrder == null)
{
order = null;
return(false);
}
return(ordersByBrokerId.TryGetValue(brokerOrder, out order));
}
private bool CreateBrokerOrder(CreateOrChangeOrder order)
{
#if VERIFYSIDE
if (!VerifySide(order))
{
return(false);
}
#endif
lock (orderMapLocker)
{
try
{
orderMap.Add(order.BrokerOrder, order);
if (trace)
{
log.Trace("Added order " + order.BrokerOrder);
}
}
catch (ArgumentException)
{
throw new ApplicationException("A broker order id of " + order.BrokerOrder + " was already added.");
}
}
TriggerOperation operation = default(TriggerOperation);
switch (order.Type)
{
case OrderType.BuyMarket:
case OrderType.SellMarket:
break;
case OrderType.BuyStop:
case OrderType.SellLimit:
operation = TriggerOperation.GreaterOrEqual;
break;
case OrderType.BuyLimit:
case OrderType.SellStop:
operation = TriggerOperation.LessOrEqual;
break;
case OrderType.StopLoss:
default:
throw new ArgumentOutOfRangeException();
}
if (triggers != null)
{
var triggerId = triggers.AddTrigger(order.LogicalSerialNumber, TriggerData.Price, operation, order.Price, TriggerCallback);
serialTriggerMap[order.LogicalSerialNumber] = triggerId;
}
SortAdjust(order);
IsChanged = true;
OrderChanged();
return(true);
}
private bool VerifyBuySide(CreateOrChangeOrder order)
{
var result = true;
if (order.Side != OrderSide.Buy)
{
OrderSideWrongReject(order);
result = false;
}
return(result);
}
private void SendReject(CreateOrChangeOrder order, bool removeOriginal, string message)
{
var wrapper = new RejectWrapper
{
Order = order,
RemoveOriginal = removeOriginal,
Message = message
};
rejectQueue.Enqueue(wrapper);
}
private bool AddUniqueOrder(CreateOrChangeOrder order)
{
AssertAtomic();
int id;
if (!unique.TryGetValue(order, out id))
{
unique.Add(order, ++uniqueId);
return(true);
}
return(false);
}
public void TryProcessAdustments(CreateOrChangeOrder order)
{
SimulateSymbol symbolSyncTicks;
using (symbolHandlersLocker.Using())
{
symbolHandlers.TryGetValue(order.Symbol.BinaryIdentifier, out symbolSyncTicks);
}
if (symbolSyncTicks != null)
{
symbolSyncTicks.TryProcessAdjustments();
}
}
public void CancelOrder(CreateOrChangeOrder order)
{
SimulateSymbol symbolSyncTicks;
using (symbolHandlersLocker.Using())
{
symbolHandlers.TryGetValue(order.Symbol.BinaryIdentifier, out symbolSyncTicks);
}
if (symbolSyncTicks != null)
{
symbolSyncTicks.CancelOrder(order);
}
}
private void OnProcessOrder(CreateOrChangeOrder order, Tick tick)
{
if (tick.UtcTime < order.UtcCreateTime)
{
//if (trace) log.Trace
log.Info("Skipping check of " + order.Type + " on tick UTC time " + tick.UtcTime + "." + order.UtcCreateTime.Microsecond + " because earlier than order create UTC time " + order.UtcCreateTime + "." + order.UtcCreateTime.Microsecond);
return;
}
if (tick.UtcTime > order.LastReadTime)
{
order.LastReadTime = tick.UtcTime;
fillLogic.TryFillOrder(order, tick);
}
}
public bool HasCreateOrder(CreateOrChangeOrder order)
{
foreach (var queueOrder in GetActiveOrders(order.Symbol))
{
if (queueOrder.Action == OrderAction.Create && order.LogicalSerialNumber == queueOrder.LogicalSerialNumber)
{
if (debug)
{
log.Debug("Create ignored because order was already on create order queue: " + queueOrder);
}
return(true);
}
}
return(false);
}
private bool HasCreateOrder(CreateOrChangeOrder order)
{
for (var current = CreateOrderQueue.First; current != null; current = current.Next)
{
var queueOrder = current.Value;
if (order.LogicalSerialNumber == queueOrder.LogicalSerialNumber)
{
if (debug)
{
log.Debug("Create ignored because order was already on create order queue: " + queueOrder);
}
return(true);
}
}
return(false);
}
private void ProcessCreateOrder(CreateOrChangeOrder order)
{
SendExecutionReport(order, "A", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow);
SendPositionUpdate(order.Symbol, ProviderSimulator.GetPosition(order.Symbol));
if (order.Symbol.FixSimulationType == FIXSimulationType.BrokerHeldStopOrder &&
(order.Type == OrderType.BuyStop || order.Type == OrderType.StopLoss))
{
SendExecutionReport(order, "A", "D", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow);
SendPositionUpdate(order.Symbol, ProviderSimulator.GetPosition(order.Symbol));
}
else
{
SendExecutionReport(order, "0", 0.0, 0, 0, 0, (int)order.Size, TimeStamp.UtcNow);
SendPositionUpdate(order.Symbol, ProviderSimulator.GetPosition(order.Symbol));
}
}
private void Adjust(ActiveList <CreateOrChangeOrder> list, CreateOrChangeOrder order)
{
AssureNode(order);
var addedOne = false;
var node = (ActiveListNode <CreateOrChangeOrder>)order.Reference;
if (node.List == null)
{
list.AddLast(node);
}
else if (!node.List.Equals(list))
{
node.List.Remove(node);
list.AddLast(node);
}
}
public void PurgeOriginalOrder(CreateOrChangeOrder order)
{
if (order.OriginalOrder == null)
{
return;
}
var clientOrderId = order.OriginalOrder.BrokerOrder;
if (trace)
{
log.Trace("PurgeOriginalOrder( " + clientOrderId + ")");
}
AssertAtomic();
RemoveOrderInternal(order.OriginalOrder.BrokerOrder);
order.OriginalOrder = null;
}
public bool OnChangeBrokerOrder(CreateOrChangeOrder createOrChangeOrder)
{
if (!IsRecovered)
{
return(false);
}
if (debug)
{
log.Debug("OnChangeBrokerOrder( " + createOrChangeOrder + ". Connection " + ConnectionStatus + ", IsOrderServerOnline " + isOrderServerOnline);
}
if (createOrChangeOrder.Action != OrderAction.Change)
{
throw new InvalidOperationException("Expected action Change but was " + createOrChangeOrder.Action);
}
OnCreateOrChangeBrokerOrder(createOrChangeOrder, false);
return(true);
}
public override void OnRejectOrder(CreateOrChangeOrder order, string error)
{
var mbtMsg = (FIXMessage4_2)FixFactory.Create();
mbtMsg.SetAccount("33006566");
mbtMsg.SetClientOrderId(order.BrokerOrder.ToString());
mbtMsg.SetOrderStatus("8");
mbtMsg.SetText(error);
mbtMsg.SetSymbol(order.Symbol.Symbol);
mbtMsg.SetTransactTime(TimeStamp.UtcNow);
mbtMsg.AddHeader("8");
if (trace)
{
log.Trace("Sending reject order: " + mbtMsg);
}
SendMessage(mbtMsg);
}
public void SetOrder(CreateOrChangeOrder order)
{
AssertAtomic();
if (trace)
{
log.Trace("Assigning order " + order.BrokerOrder + " with " + order.LogicalSerialNumber);
}
ordersByBrokerId[order.BrokerOrder] = order;
if (order.Sequence != 0)
{
ordersBySequence[order.Sequence] = order;
}
if (order.LogicalSerialNumber != 0)
{
ordersBySerial[order.LogicalSerialNumber] = order;
if (order.Action == OrderAction.Cancel && order.OriginalOrder == null)
{
throw new ApplicationException("CancelOrder w/o any original order setting: " + order);
}
}
}
private void OrderSideWrongReject(CreateOrChangeOrder order)
{
var message = "Sorry, improper setting of a " + order.Side + " order when position is " + actualPosition;
lock (orderMapLocker)
{
orderMap.Remove(order.BrokerOrder);
}
if (onRejectOrder != null)
{
if (debug)
{
log.Debug("Rejecting order because position is " + actualPosition + " but order side was " + order.Side + ": " + order);
}
SendReject(order, true, message);
}
else
{
throw new ApplicationException(message + " while handling order: " + order);
}
}
public override void OnPhysicalFill(PhysicalFill fill, CreateOrChangeOrder order)
{
if (order.Symbol.FixSimulationType == FIXSimulationType.BrokerHeldStopOrder &&
(order.Type == OrderType.BuyStop || order.Type == OrderType.SellStop))
{
order.Type = order.Type == OrderType.BuyStop ? OrderType.BuyMarket : OrderType.SellMarket;
var marketOrder = Factory.Utility.PhysicalOrder(order.Action, order.OrderState,
order.Symbol, order.Side, order.Type, OrderFlags.None, 0,
order.Size, order.LogicalOrderId,
order.LogicalSerialNumber,
order.BrokerOrder, null, TimeStamp.UtcNow);
SendExecutionReport(marketOrder, "0", 0.0, 0, 0, 0, (int)marketOrder.Size, TimeStamp.UtcNow);
}
if (debug)
{
log.Debug("Converting physical fill to FIX: " + fill);
}
SendPositionUpdate(order.Symbol, ProviderSimulator.GetPosition(order.Symbol));
var orderStatus = fill.CumulativeSize == fill.TotalSize ? "2" : "1";
SendExecutionReport(order, orderStatus, "F", fill.Price, fill.TotalSize, fill.CumulativeSize, fill.Size, fill.RemainingSize, fill.UtcTime);
}
