internal void ForwardChildOrderEvents(BfChildOrderEvent coe)
{
OrderCache?.RegisterChildOrderEvent(coe);
var tx = _childOrderTransactions.GetOrAdd(coe.ChildOrderAcceptanceId, key => new BfxChildTransactionPlaceHolder());
if (tx is BfxChildTransactionPlaceHolder placeHolder)
{
Log.Info($"Child transaction place holder found or placed. {coe.ChildOrderAcceptanceId} {coe.EventType}");
placeHolder.ChildOrderEvents.Add(coe);
return;
}
if (!(tx is BfxChildTransaction txChild))
{
throw new ApplicationException();
}
if (txChild.Parent != null)
{
txChild.Parent.OnChildOrderEvent(coe);
}
else
{
txChild.OnChildOrderEvent(coe);
}
}
public int Update(BfChildOrderEvent coe)
{
var childOrderIndex = Array.FindIndex(_childOrders, e => e.AcceptanceId == coe.ChildOrderAcceptanceId);
_childOrders[childOrderIndex].Update(coe);
return(childOrderIndex);
}
public void Update(BfChildOrderEvent coe)
{
OrderId = coe.ChildOrderId;
AcceptanceId = coe.ChildOrderAcceptanceId; // When child of parent
switch (coe.EventType)
{
case BfOrderEventType.Order:
State = BfOrderState.Active;
OrderPrice = coe.Price;
OrderDate = coe.EventDate;
ExpireDate = coe.ExpireDate;
break;
case BfOrderEventType.OrderFailed:
State = BfOrderState.Rejected;
FailedReason = coe.OrderFailedReason;
CloseDate = coe.EventDate;
break;
case BfOrderEventType.Cancel:
State = BfOrderState.Canceled;
CloseDate = coe.EventDate;
break;
case BfOrderEventType.CancelFailed:
State = BfOrderState.Rejected;
CloseDate = coe.EventDate;
FailedReason = "Cancel Failed";
break;
case BfOrderEventType.Execution:
if (!ExecutedSize.HasValue)
{
ExecutedSize = coe.Size;
}
else
{
ExecutedSize += coe.Size;
}
if (ExecutedSize >= OrderSize)
{
State = BfOrderState.Completed;
CloseDate = coe.EventDate;
}
else
{
State = BfOrderState.Active;
}
break;
case BfOrderEventType.Expire:
State = BfOrderState.Expired;
CloseDate = coe.EventDate;
break;
default:
throw new ArgumentException($"{coe.EventType} is not expected.");
}
}
public BfxExecution(BfChildOrderEvent coe)
{
Id = coe.ExecutionId;
Time = coe.EventDate;
Price = coe.Price;
Size = coe.Size;
Commission = coe.Commission;
SfdCollectedAmount = coe.SwapForDifference;
OrderId = coe.ChildOrderId;
}
public BfxPositionsElement(BfChildOrderEvent ev, decimal size)
{
ChildOrderAcceptanceId = ev.ChildOrderAcceptanceId;
ExecutionIndex = ev.ExecutionId;
Open = ev.EventDate;
Price = ev.Price;
CurrentSize = OpenSize = ev.Side == BfTradeSide.Buy ? size : -size;
_commission = ev.Commission;
_sfd = ev.SwapForDifference;
}
public void Update(BfChildOrderEvent coe)
{
if (!string.IsNullOrEmpty(coe.ChildOrderAcceptanceId))
{
AcceptanceId = coe.ChildOrderAcceptanceId;
}
if (!string.IsNullOrEmpty(coe.ChildOrderId))
{
OrderId = coe.ChildOrderId;
}
LastUpdatedTime = coe.EventDate;
switch (coe.EventType)
{
case BfOrderEventType.Order:
OrderDate = coe.EventDate; // Is it same value to real ordered date ?
ExpireDate = coe.ExpireDate;
ChangeState(BfxOrderState.Ordered);
break;
case BfOrderEventType.OrderFailed:
ChangeState(BfxOrderState.OrderFailed);
break;
case BfOrderEventType.Cancel:
ChangeState(BfxOrderState.Canceled);
break;
case BfOrderEventType.CancelFailed:
if (State != BfxOrderState.Outstanding) // Sometimes recived before ordered which under canceled OCO
{
ChangeState(BfxOrderState.CancelFailed);
}
break;
case BfOrderEventType.Execution:
_executions.Add(new BfxExecution(coe));
ExecutedSize = _executions.Sum(e => e.Size);
ExecutedPrice = Math.Round(_executions.Sum(e => e.Price * e.Size) / ExecutedSize.Value, ProductCode.GetPriceDecimals(), MidpointRounding.ToEven);
ChangeState(OrderSize > ExecutedSize ? BfxOrderState.PartiallyExecuted : BfxOrderState.Executed);
break;
case BfOrderEventType.Expire:
ChangeState(BfxOrderState.Expired);
break;
case BfOrderEventType.Unknown:
case BfOrderEventType.Trigger: // Parent order only
case BfOrderEventType.Complete: // Parent order only
throw new NotSupportedException();
}
}
// Call from BfxMarket
public override void OnChildOrderEvent(BfChildOrderEvent coe)
{
if (coe.ChildOrderAcceptanceId != _order.AcceptanceId)
{
throw new ArgumentException();
}
_order.Update(coe);
switch (coe.EventType)
{
case BfOrderEventType.Order: // Order registered
ChangeState(BfxTransactionState.Idle);
NotifyEvent(BfxTransactionEventType.Ordered, coe);
break;
case BfOrderEventType.OrderFailed:
ChangeState(BfxTransactionState.Idle);
NotifyEvent(BfxTransactionEventType.OrderFailed, coe);
break;
case BfOrderEventType.Cancel:
ChangeState(BfxTransactionState.Idle);
NotifyEvent(BfxTransactionEventType.Canceled, coe);
break;
case BfOrderEventType.CancelFailed:
ChangeState(BfxTransactionState.Idle);
NotifyEvent(BfxTransactionEventType.CancelFailed, coe);
break;
case BfOrderEventType.Execution:
NotifyEvent(Order.State == BfxOrderState.PartiallyExecuted ? BfxTransactionEventType.PartiallyExecuted : BfxTransactionEventType.Executed, coe);
break;
case BfOrderEventType.Expire:
NotifyEvent(BfxTransactionEventType.Expired, coe);
break;
case BfOrderEventType.Unknown:
case BfOrderEventType.Complete:
case BfOrderEventType.Trigger: // Not happened when Simple Order ?
throw new NotSupportedException();
}
}
public BfxPosition[] Update(BfChildOrderEvent ev)
{
var executedSize = ev.Side == BfTradeSide.Buy ? ev.Size : -ev.Size;
if (_q.Count == 0 || Math.Sign(_q.Peek().OpenSize) == Math.Sign(executedSize))
{
var pos = new BfxPositionsElement(ev);
_q.Enqueue(pos);
return(new BfxPosition[] { new BfxPosition(this, pos) });
}
// Process to another side
var closeSize = executedSize;
var closedPos = new List <BfxPositionsElement>();
while (Math.Abs(closeSize) > 0m && _q.Count > 0)
{
var pos = _q.Peek();
if (Math.Abs(closeSize) >= Math.Abs(pos.CurrentSize))
{
closeSize += pos.CurrentSize;
closedPos.Add(_q.Dequeue());
continue;
}
if (Math.Abs(closeSize) < Math.Abs(pos.CurrentSize))
{
closedPos.Add(pos.Split(closeSize));
closeSize = 0;
break;
}
}
var result = new List <BfxPosition>();
closedPos.ForEach(e => result.Add(new BfxPosition(this, e, ev)));
if (closeSize > 0m)
{
var pos = new BfxPositionsElement(ev, Math.Abs(closeSize));
_q.Enqueue(pos);
result.Add(new BfxPosition(this, pos));
}
return(result.ToArray());
}
public DbPrivateExecution(BfProductCode productCode, BfChildOrderEvent coe)
{
ProductCode = productCode;
ExecutionId = coe.ExecutionId;
Side = coe.Side;
Price = coe.Price;
Size = coe.Size;
if (coe.Side == BfTradeSide.Sell)
{
Amount = (coe.Price * coe.Size).Truncate(productCode.GetPriceDecimals());
}
else
{
Amount = (coe.Price * coe.Size).Ceiling(productCode.GetPriceDecimals());
}
ChildOrderId = coe.ChildOrderId;
ChildOrderAcceptanceId = coe.ChildOrderAcceptanceId;
Commission = coe.Commission;
ExecutedTime = coe.EventDate;
SwapForDifference = coe.SwapForDifference;
}
public override void OnChildOrderEvent(BfChildOrderEvent coe)
{
var childOrderIndex = _order.Update(coe);
var childOrder = Order.Children[childOrderIndex];
switch (coe.EventType)
{
case BfOrderEventType.Order:
NotifyChildOrderEvent(BfxTransactionEventType.Ordered, childOrderIndex, coe);
break;
case BfOrderEventType.OrderFailed:
NotifyChildOrderEvent(BfxTransactionEventType.OrderFailed, childOrderIndex, coe);
break;
case BfOrderEventType.Cancel:
NotifyChildOrderEvent(BfxTransactionEventType.Canceled, childOrderIndex, coe);
break;
case BfOrderEventType.CancelFailed:
break;
case BfOrderEventType.Execution:
NotifyChildOrderEvent(childOrder.State == BfxOrderState.PartiallyExecuted ? BfxTransactionEventType.PartiallyExecuted : BfxTransactionEventType.Executed, childOrderIndex, coe);
break;
case BfOrderEventType.Expire:
NotifyChildOrderEvent(BfxTransactionEventType.Expired, childOrderIndex, coe);
break;
case BfOrderEventType.Unknown:
case BfOrderEventType.Complete:
case BfOrderEventType.Trigger:
throw new NotSupportedException();
}
}
static void OnChildOrderEvent(BfChildOrderEvent coe)
{
switch (coe.EventType)
{
}
}
public abstract void OnChildOrderEvent(BfChildOrderEvent coe);
protected void NotifyEvent(BfxTransactionEventType oet, BfChildOrderEvent coe) => NotifyEvent(oet, coe.EventDate, coe);
protected void NotifyChildOrderEvent(BfxTransactionEventType oet, int childOrderIndex, BfChildOrderEvent coe)
{
if (Order.Children.Length == 1)
{
Market.InvokeOrderTransactionEvent(this, new BfxOrderTransactionEventArgs(Order.Children[0])
{
EventType = oet,
State = State,
Time = coe.EventDate,
Parameter = coe,
});
}
else
{
Market.InvokeOrderTransactionEvent(this, new BfxOrderTransactionEventArgs(Order)
{
EventType = BfxTransactionEventType.ChildOrderEvent,
State = State,
Time = coe.EventDate,
Parameter = coe,
ChildEventType = oet,
ChildOrderIndex = childOrderIndex,
});
}
}
public BfxPositionsElement(BfChildOrderEvent ev)
: this(ev, ev.Size)
{
}
void IBfOrderSource.RegisterChildOrderEvent(BfChildOrderEvent coe)
{
}
