public async Task Publish(MarketOrderWithTrades marketOrderWithTrades)
{
if (marketOrderWithTrades == null)
{
return;
}
var clientId = await _clientAccountClient.GetClientByWalletAsync(marketOrderWithTrades.Order.ClientId);
var order = await _ordersConverter.ConvertAsync(marketOrderWithTrades.Order);
PublishOrdersToClient(clientId, new[] { order });
}
public async Task HandleMarketOrderSell()
{
AccountEntity testAccount = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
Assert.NotNull(testAccount);
BalanceDTO accountBalance1 = testAccount.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
Assert.NotNull(accountBalance1);
BalanceDTO accountBalance2 = testAccount.BalancesParsed.Where(b => b.Asset == this.TestAsset2).FirstOrDefault();
Assert.NotNull(accountBalance2);
string badMarketOrderId = Guid.NewGuid().ToString();
string marketOrderId = Guid.NewGuid().ToString();
double volume = 0.1;
bool isStraight = true;
double reservedVolume = 0.0;
//Attempt bad buy
string badMarketOrderResponse = await this.Consumer.Client.HandleMarketOrderAsync(
badMarketOrderId, this.TestAccountId1, this.TestAssetPair.Id, OrderAction.Sell, accountBalance1.Balance + 10, isStraight, reservedVolume);
Assert.NotNull(badMarketOrderResponse);
MarketOrderWithTrades badMessage = (MarketOrderWithTrades)await this.WaitForRabbitMQ <MarketOrderWithTrades>(
o => o.order.externalId == badMarketOrderId);
Assert.NotNull(badMessage);
Assert.True(badMessage.order.id == badMarketOrderResponse);
Assert.True(badMessage.order.clientId == this.TestAccountId1);
Assert.True(badMessage.order.assetPairId == this.TestAssetPair.Id);
Assert.True(badMessage.order.straight == isStraight);
Assert.True(badMessage.order.volume == (accountBalance1.Balance + 10) * -1);
Assert.True(badMessage.order.reservedLimitVolume == reservedVolume);
Assert.True(badMessage.order.status == "NotEnoughFunds");
//Attempt proper sell
string marketOrderResponse = await this.Consumer.Client.HandleMarketOrderAsync(
marketOrderId, this.TestAccountId1, this.TestAssetPair.Id, OrderAction.Sell, volume, isStraight, reservedVolume);
Assert.NotNull(marketOrderResponse);
MarketOrderWithTrades message = (MarketOrderWithTrades)await this.WaitForRabbitMQ <MarketOrderWithTrades>(
o => o.order.externalId == marketOrderId);
Assert.NotNull(message);
Assert.True(message.order.id == marketOrderResponse);
Assert.True(message.order.clientId == this.TestAccountId1);
Assert.True(message.order.assetPairId == this.TestAssetPair.Id);
Assert.True(message.order.straight == isStraight);
Assert.True(message.order.volume == volume * -1);
Assert.True(message.order.reservedLimitVolume == reservedVolume);
Assert.True(message.order.status == "Matched");
double sumOfLimitVolumes = 0.0;
double sumOfMarketVolumes = 0.0;
double currentPrice = 0.0;
foreach (var trade in message.trades)
{
Assert.True(trade.limitAsset == this.TestAsset2);
Assert.True(trade.marketAsset == this.TestAsset1);
Assert.True(trade.marketClientId == this.TestAccountId1);
if (double.TryParse(trade.limitVolume, NumberStyles.Float, CultureInfo.InvariantCulture, out double parsedLimitVolume) &&
double.TryParse(trade.marketVolume, NumberStyles.Float, CultureInfo.InvariantCulture, out double parsedMarketVolume) &&
double.TryParse(trade.price, NumberStyles.Float, CultureInfo.InvariantCulture, out double parsedPrice))
{
sumOfLimitVolumes += parsedLimitVolume;
sumOfMarketVolumes += parsedMarketVolume;
currentPrice = parsedPrice;
Assert.True(MathUtils.RoundDown(parsedLimitVolume, this.AssetPrecission) ==
MathUtils.RoundDown(parsedMarketVolume * parsedPrice, this.AssetPrecission));
}
}
Assert.True(sumOfMarketVolumes == volume);
//check MarketOrders table
MarketOrderEntity marketOrderDBRecord = (MarketOrderEntity)await this.MarketOrdersRepository.TryGetAsync(marketOrderResponse);
//Assert.NotNull(marketOrderDBRecord);
if (marketOrderDBRecord != null)
{
Assert.True(marketOrderDBRecord.AssetPairId == this.TestAssetPair.Id);
Assert.True(marketOrderDBRecord.ClientId == this.TestAccountId1);
Assert.True(marketOrderDBRecord.Price == currentPrice);
Assert.True(marketOrderDBRecord.Status == "Matched");
Assert.True(marketOrderDBRecord.Straight == true);
Assert.True(marketOrderDBRecord.Volume == volume * -1);
}
//check accoutn balance change
AccountEntity checkTestAccount = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
BalanceDTO checkAccountBalance1 = checkTestAccount.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
BalanceDTO checkAccountBalance2 = checkTestAccount.BalancesParsed.Where(b => b.Asset == this.TestAsset2).FirstOrDefault();
Assert.True(Math.Round(checkAccountBalance1.Balance - accountBalance1.Balance, this.AssetPrecission) == Math.Round(sumOfMarketVolumes * -1, this.AssetPrecission));
Assert.True(Math.Round(checkAccountBalance2.Balance - accountBalance2.Balance, this.AssetPrecission) == Math.Round(sumOfLimitVolumes, this.AssetPrecission));
}
private async Task ProcessMessageAsync(MarketOrderWithTrades orders)
{
_ordersPublisher.Publish(orders);
}
