private async Task HandleOrderStatus(LimitOrderMessage message)
{
foreach (var order in message.Orders.Where(x => x.Order.ClientId == Config.ClientId))
{
if (order.Order.Status == OrderStatus.Cancelled)
{
await LykkeLog.WriteInfoAsync(nameof(LykkeExchange), nameof(HandleOrderStatus), order.ToString(),
"Order canceled. Calling ExecutedTradeHandlers");
await _tradeHandler.Handle(new ExecutionReport(new Instrument(Name, order.Order.AssetPairId),
DateTime.UtcNow,
order.Order.Price ?? 0,
Math.Abs(order.Order.Volume),
order.Order.Volume < 0 ? TradeType.Sell : TradeType.Buy,
order.Order.ExternalId,
OrderExecutionStatus.Cancelled));
}
else if (order.Order.Status == OrderStatus.Matched && order.Trades.Any())
{
await LykkeLog.WriteInfoAsync(nameof(LykkeExchange), nameof(HandleOrderStatus), order.ToString(),
"Order executed. Calling ExecutedTradeHandlers");
await _tradeHandler.Handle(new ExecutionReport(new Instrument(Name, order.Order.AssetPairId),
order.Trades.Last().Timestamp,
order.Order.Price ?? order.Trades.Last().Price ?? 0,
Math.Abs(order.Order.Volume - order.Order.RemainingVolume),
order.Order.Volume < 0 ? TradeType.Sell : TradeType.Buy,
order.Order.ExternalId,
OrderExecutionStatus.Fill));
}
}
}
private void HandleLimitOrderList(LimitOrderMessage message)
{
//Only update the List<LimitOrder> field in this class
//If a LimitOrderMessage is sent during runtime
if (!message.IsStartup)
{
_myLimitOrders = message.LimitOrders;
}
}
private async Task ProcessLimitOrder(LimitOrderMessage ordersUpdateMessage)
{
await ordersUpdateMessage.Orders.ParallelForEachAsync(async order =>
{
if (Guid.TryParse(order.Order.ExternalId, out Guid orderId))
{
var sessionIds = _sessionRepository.GetSessionIds(order.Order.ClientId);
if (sessionIds.Length == 0)
{
return;
}
var notifyResponse = new LimitOrderUpdateEvent
{
Order = new Order
{
Id = orderId,
Status = order.Order.Status,
AssetPairId = order.Order.AssetPairId,
Volume = order.Order.Volume,
Price = order.Order.Price,
RemainingVolume = order.Order.RemainingVolume,
LastMatchTime = order.Order.LastMatchTime
},
Trades = order.Trades.Select(x => new Trade
{
Asset = x.Asset,
Volume = x.Volume,
Price = x.Price,
Timestamp = x.Timestamp,
OppositeAsset = x.OppositeAsset,
OppositeVolume = x.OppositeVolume
}).ToArray()
};
_subject.OnNext(new WampEvent
{
Options = new PublishOptions
{
Eligible = sessionIds
},
Arguments = new object[] { notifyResponse }
});
}
}).ConfigureAwait(false);
}
private void HandleLimitOrderMessage(LimitOrderMessage message)
{
LimitOrderList = new ObservableCollection <LimitOrder>(message.LimitOrders);
}
private async Task ProcessMessageAsync(LimitOrderMessage message)
{
foreach (var messageOrder in message.Orders)
{
if (!_settings.TrustedClientIds.Contains(messageOrder.Order.ClientId))
{
continue;
}
if (messageOrder.Order.Status == OrderStatus.InOrderBook)
{
var order = new OrderEntity()
{
ClientId = messageOrder.Order.ClientId,
OrderId = messageOrder.Order.ExternalId,
CreatedTime = DateTime.UtcNow,
AvgExecutionPrice = 0,
ExecutedAmount = 0,
Instrument = messageOrder.Order.AssetPairId,
OriginalAmount = Math.Abs(messageOrder.Order.Volume),
Price = messageOrder.Order.Price ?? 0,
TradeType = messageOrder.Order.Volume > 0 ? "Buy" : "Sell",
RemainingAmount = Math.Abs(messageOrder.Order.Volume),
Status = "Active",
CountExecute = 0,
SumExecutePrice = 0
};
await _orderRepository.AddOrReplace(order);
}
if (messageOrder.Order.Status == OrderStatus.Matched ||
messageOrder.Order.Status == OrderStatus.Processing)
{
var order = await _orderRepository.GetOrder(messageOrder.Order.ClientId, messageOrder.Order.ExternalId);
if (order == null)
{
order = new OrderEntity()
{
ClientId = messageOrder.Order.ClientId,
OrderId = messageOrder.Order.ExternalId,
CreatedTime = DateTime.UtcNow,
AvgExecutionPrice = 0,
ExecutedAmount = 0,
Instrument = messageOrder.Order.AssetPairId,
OriginalAmount = Math.Abs(messageOrder.Order.Volume),
Price = messageOrder.Order.Price ?? 0,
TradeType = messageOrder.Order.Volume > 0 ? "Buy" : "Sell",
RemainingAmount = Math.Abs(messageOrder.Order.Volume),
Status = "Active",
CountExecute = 0,
SumExecutePrice = 0
};
await _orderRepository.AddOrReplace(order);
}
;
foreach (var trade in messageOrder.Trades)
{
var volume = messageOrder.Order.Volume < 0 ? trade.Volume : trade.OppositeVolume;
order.RemainingAmount -= Math.Abs(volume);
order.SumExecutePrice += trade.Price ?? 0;
order.CountExecute++;
order.AvgExecutionPrice = order.SumExecutePrice / order.CountExecute;
order.ExecutedAmount += Math.Abs(volume);
if (messageOrder.Order.Status == OrderStatus.Matched)
{
order.Status = "Fill";
}
}
await _orderRepository.AddOrReplace(order);
}
if (messageOrder.Order.Status == OrderStatus.Cancelled)
{
var order = await _orderRepository.GetOrder(messageOrder.Order.ClientId, messageOrder.Order.ExternalId);
if (order == null)
{
continue;
}
order.Status = "Canceled";
await _orderRepository.AddOrReplace(order);
}
}
}
private void CreateLimitOrders(LimitOrderMessage message)
{
_limitOrderList = message.LimitOrders;
}
