private async Task UpdateAssetPairAsync(object obj)
{
var assetPairs = (await StateManager.GetStateAsync <IEnumerable <AssetPair> >("AssetPairs")).ToList();
var pendingOrders = await _pendingOrderRepository.GetAllAsync(null);
var rnd = new Random();
var assetId = rnd.Next(assetPairs.Count);
var assetPair = assetPairs[assetId];
AssetPairQuote updatedQuote;
if (pendingOrders != null)
{
var orders = pendingOrders as IList <PendingOrder> ?? pendingOrders.ToList();
var assetPairIds = orders.Select(p => p.AssetPairId).Distinct().ToList();
assetPairIds.Add(assetPair.Id);
assetId = rnd.Next(assetPairIds.Count);
var pendingOrder = orders.First(p => p.AssetPairId.Equals(assetPairIds[assetId]));
var assetPairQuote = new AssetPairQuote
{
AssetPairId = pendingOrder.AssetPairId
};
if (pendingOrder.OrderAction == OrderAction.Buy)
{
assetPairQuote.Bid = pendingOrder.DefinedPrice - rnd.NextDouble();
assetPairQuote.Ask = assetPairQuote.Bid + rnd.NextDouble();
}
else
{
assetPairQuote.Ask = pendingOrder.DefinedPrice + rnd.NextDouble();
assetPairQuote.Bid = assetPairQuote.Bid - rnd.NextDouble();
}
await _assetPairQuoteRepository.UpdateAsync(assetPairQuote);
updatedQuote = await _assetPairQuoteRepository.GetByIdAsync(assetPairQuote.AssetPairId);
}
else
{
updatedQuote = await _assetPairQuoteRepository.UpdateAsync(assetPair);
}
await _matchingEngineEventSubscriber.AssetPairPriceUpdatedAsync(updatedQuote);
if (pendingOrders != null)
{
await UpdatePendingOrdersAsync(updatedQuote);
}
}
public Task UpdateAsync(AssetPairQuote assetPairQuote)
{
var order = _orders.FirstOrDefault(o => o.AssetPairId == assetPairQuote.AssetPairId);
if (order == null)
{
throw new InvalidOperationException();
}
order = assetPairQuote;
order.DateTime = DateTime.UtcNow;
return(TaskEx.Empty);
}
private async Task UpdatePendingOrdersAsync(AssetPairQuote updatedQuote)
{
var pendingOrders =
(await _pendingOrderRepository.FindByAssetPairIdAsync(updatedQuote.AssetPairId)).ToList();
foreach (var pendingOrder in pendingOrders)
{
if (((pendingOrder.OrderAction == OrderAction.Buy) && (pendingOrder.DefinedPrice >= updatedQuote.Bid)) ||
((pendingOrder.OrderAction == OrderAction.Sell) && (pendingOrder.DefinedPrice <= updatedQuote.Ask)))
{
var currentQuote = await _assetPairQuoteRepository.GetByIdAsync(updatedQuote.AssetPairId);
if (currentQuote == null)
{
throw new InvalidOperationException();
}
var orderInfo = new MarketOrder
{
ClientId = pendingOrder.ClientId,
AssetPairId = pendingOrder.AssetPairId,
Volume = pendingOrder.Volume,
Id = Guid.NewGuid().ToString(),
CreatedAt = currentQuote.DateTime
};
orderInfo.Price = orderInfo.OrderAction == OrderAction.Buy ? currentQuote.Ask : currentQuote.Bid;
await
_marketOrderRepository.AddAsync(orderInfo);
await _pendingOrderRepository.DeleteAsync(pendingOrder.ClientId, pendingOrder.Id);
await _matchingEngineEventSubscriber.ActiveOrdersUpdatedAsync(pendingOrder.ClientId);
}
}
}
private OrderCalculator MockOrderCalculator()
{
var assetPairQuoteRepository = Substitute.For <IAssetPairQuoteRepository>();
var gbpUsd = new AssetPairQuote
{
AssetPairId = "GBPUSD",
Ask = 1.5555
};
var usdChf = new AssetPairQuote
{
AssetPairId = "USDCHF",
Ask = 1.2222
};
var usdJpy = new AssetPairQuote
{
AssetPairId = "USDJPY",
Ask = 1.3333
};
assetPairQuoteRepository.GetByIdAsync(gbpUsd.AssetPairId).Returns(gbpUsd);
assetPairQuoteRepository.GetByIdAsync(usdChf.AssetPairId).Returns(usdChf);
assetPairQuoteRepository.GetByIdAsync(usdJpy.AssetPairId).Returns(usdJpy);
var dictionaryProxy = Substitute.For <IDictionaryProxy>();
dictionaryProxy.GetAssetPairAsync("USD", "JPY").Returns(new AssetPair {
Id = "USDJPY"
});
dictionaryProxy.GetAssetPairAsync("GBP", "USD").Returns(new AssetPair {
Id = "GBPUSD"
});
var calculator = new OrderCalculator(assetPairQuoteRepository, dictionaryProxy);
return(calculator);
}
public Task AddAllAsync(IEnumerable <AssetPair> assetPairs)
{
var assetPairQuotes = new List <AssetPairQuote>();
foreach (var assetPair in assetPairs)
{
var ask = _rnd.NextDouble() * (3 - 0.1) + 0.1;
var bid = ask - _rnd.NextDouble();
var assetPairQuote = new AssetPairQuote
{
AssetPairId = assetPair.Id,
Ask = ask,
Bid = bid,
DateTime = DateTime.UtcNow
};
assetPairQuotes.Add(assetPairQuote);
}
_orders = assetPairQuotes;
return(TaskEx.Empty);
}
public async Task AssetPairPriceUpdatedAsync(AssetPairQuote assetPair)
{
var message = new BrokeredMessage(assetPair);
await SendMessageAsync(MatchingEngineTopics.AssetPairPriceUpdated, message);
}
public Task AddAsync(AssetPairQuote entity)
{
throw new NotImplementedException();
}
