public override async Task <LimitOrdersResponse> GetOrders(LimitOrdersRequest request, ServerCallContext context)
{
var session = SessionFromContext(context);
var assetId = request.OptionalAssetPairIdCase == LimitOrdersRequest.OptionalAssetPairIdOneofCase.AssetPairId
? request.AssetPairId
: string.Empty;
var orders = await _clientWalletService.GetClientOrdersAsync(session.TenantId, session.ClientId, assetId);
var response = new LimitOrdersResponse()
{
Result = new LimitOrdersResponse.Types.OrdersPayload()
{
Orders =
{
orders.Select(o => new LimitOrderModel()
{
Id = o.ExternalId,
DateTime = Timestamp.FromDateTime(DateTime.SpecifyKind(o.CreatedAt, DateTimeKind.Utc)),
Asset = string.Empty,
Price = o.Price,
Volume = o.Volume.Replace("-", ""),
RemainingVolume = o.RemainingVolume,
AssetPair = o.AssetPairId,
RemainingOtherVolume = o.RemainingVolume,
TotalCost = (decimal.Parse(o.Price) * decimal.Parse(o.Volume)).ToString(CultureInfo.InvariantCulture),
OrderType = o.Side.ToString()
})
}
}
};
return(response);
}
public override async Task <LimitOrdersResponse> GetOrders(LimitOrdersRequest request, ServerCallContext context)
{
var token = context.GetBearerToken();
var response = await _walletApiV1Client.OffchainLimitListAsync(request.AssetPairId, token);
var result = new LimitOrdersResponse();
if (response.Result != null)
{
result.Body = new LimitOrdersResponse.Types.Body();
result.Body.Orders.AddRange(_mapper.Map <List <LimitOrderModel> >(response.Result.Orders));
}
if (response.Error != null)
{
result.Error = response.Error.ToApiError();
}
return(result);
}
public async Task LimitOrderBuy() // and CancelLimitOrder
{
AccountEntity testAccount = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
Assert.NotNull(testAccount);
BalanceDTO accountBalance = testAccount.BalancesParsed.Where(b => b.Asset == this.TestAsset2).FirstOrDefault();
Assert.NotNull(accountBalance);
string limitOrderID = Guid.NewGuid().ToString();
string badLimitOrderID = Guid.NewGuid().ToString();
double amount = 0.01;
double price = Helpers.Random.NextDouble() / 100;
//Attempt bad buy
MeResponseModel badOrderResponse = await this.Consumer.Client.PlaceLimitOrderAsync(
badLimitOrderID, this.TestAccountId1, this.TestAssetPair.Id, OrderAction.Buy, accountBalance.Balance + 10, 2);
Assert.False(badOrderResponse.Status == MeStatusCodes.Ok);
LimitOrdersResponse badMessage = (LimitOrdersResponse)await this.WaitForRabbitMQ <LimitOrdersResponse>(
o => o.orders.Any(m => m.order.externalId == badLimitOrderID && m.order.status == "NotEnoughFunds"));
Assert.NotNull(badMessage);
LimitOrders badSubMessage = badMessage.orders.Where(m => m.order.externalId == badLimitOrderID && m.order.status == "NotEnoughFunds").FirstOrDefault();
Assert.NotNull(badSubMessage);
Assert.True(badSubMessage.order.clientId == this.TestAccountId1);
Assert.True(badSubMessage.order.assetPairId == this.TestAssetPair.Id);
Assert.True(badSubMessage.order.volume == accountBalance.Balance + 10);
//Assert.True(badSubMessage.order.price == price);
//Attempt buy stored in order book
MeResponseModel LimitOrderResponse = await this.Consumer.Client.PlaceLimitOrderAsync(
limitOrderID, this.TestAccountId1, this.TestAssetPair.Id, OrderAction.Buy, amount, price);
Assert.True(LimitOrderResponse.Status == MeStatusCodes.Ok);
AccountEntity checkTestAccount = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
BalanceDTO checkAccountBalance = checkTestAccount.BalancesParsed.Where(b => b.Asset == this.TestAsset2).FirstOrDefault();
Assert.True(Math.Round(checkAccountBalance.Reserved, this.AssetPrecission) == Math.Round(accountBalance.Reserved + amount, this.AssetPrecission));
LimitOrdersResponse message = (LimitOrdersResponse)await this.WaitForRabbitMQ <LimitOrdersResponse>(
o => o.orders.Any(m => m.order.externalId == limitOrderID && m.order.status == "InOrderBook"));
Assert.NotNull(message);
LimitOrders subMessage = message.orders.Where(m => m.order.externalId == limitOrderID && m.order.status == "InOrderBook").FirstOrDefault();
Assert.NotNull(subMessage);
Assert.True(subMessage.order.clientId == this.TestAccountId1);
Assert.True(subMessage.order.assetPairId == this.TestAssetPair.Id);
Assert.True(subMessage.order.volume == amount);
Assert.True(subMessage.order.price == price);
//Cancel proper buy
MeResponseModel LimitOrderCancelResponse = await this.Consumer.Client.CancelLimitOrderAsync(limitOrderID);
Assert.True(LimitOrderCancelResponse.Status == MeStatusCodes.Ok);
checkTestAccount = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
checkAccountBalance = checkTestAccount.BalancesParsed.Where(b => b.Asset == this.TestAsset2).FirstOrDefault();
Assert.True(checkAccountBalance.Reserved == accountBalance.Reserved);
LimitOrdersResponse cancelMessage = (LimitOrdersResponse)await this.WaitForRabbitMQ <LimitOrdersResponse>(
o => o.orders.Any(m => m.order.externalId == limitOrderID && m.order.status == "Cancelled"));
Assert.NotNull(cancelMessage);
LimitOrders cancelSubMessage = cancelMessage.orders.Where(m => m.order.externalId == limitOrderID && m.order.status == "Cancelled").FirstOrDefault();
Assert.NotNull(cancelSubMessage);
Assert.True(cancelSubMessage.order.clientId == this.TestAccountId1);
Assert.True(cancelSubMessage.order.assetPairId == this.TestAssetPair.Id);
Assert.True(cancelSubMessage.order.volume == amount);
Assert.True(cancelSubMessage.order.price == price);
}
public async Task LimitOrderSell() // and CancelLimitOrder
{
AccountEntity testAccount = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
Assert.NotNull(testAccount);
BalanceDTO accountBalance = testAccount.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
Assert.NotNull(accountBalance);
string limitOrderID = Guid.NewGuid().ToString();
string badLimitOrderID = Guid.NewGuid().ToString();
double amount = 0.2;
double price = Helpers.Random.Next(100, 999);
double matchedPrice = Helpers.Random.NextDouble();
//Attempt bad sell
MeResponseModel badOrderResponse = await this.Consumer.Client.PlaceLimitOrderAsync(
badLimitOrderID, this.TestAccountId1, this.TestAssetPair.Id, OrderAction.Sell, accountBalance.Balance + 10, price);
Assert.False(badOrderResponse.Status == MeStatusCodes.Ok);
LimitOrdersResponse badMessage = (LimitOrdersResponse)await this.WaitForRabbitMQ <LimitOrdersResponse>(
o => o.orders.Any(m => m.order.externalId == badLimitOrderID && m.order.status == "NotEnoughFunds"));
Assert.NotNull(badMessage);
LimitOrders badSubMessage = badMessage.orders.Where(m => m.order.externalId == badLimitOrderID && m.order.status == "NotEnoughFunds").FirstOrDefault();
Assert.NotNull(badSubMessage);
Assert.True(badSubMessage.order.clientId == this.TestAccountId1);
Assert.True(badSubMessage.order.assetPairId == this.TestAssetPair.Id);
Assert.True(badSubMessage.order.volume == (accountBalance.Balance + 10) * -1);
Assert.True(badSubMessage.order.price == price);
//Attempt sell stored in order book
MeResponseModel LimitOrderResponse = await this.Consumer.Client.PlaceLimitOrderAsync(
limitOrderID, this.TestAccountId1, this.TestAssetPair.Id, OrderAction.Sell, amount, price);
Assert.True(LimitOrderResponse.Status == MeStatusCodes.Ok);
AccountEntity checkTestAccount = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
BalanceDTO checkAccountBalance = checkTestAccount.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
Assert.True(Math.Round(checkAccountBalance.Reserved, this.AssetPrecission) == Math.Round(accountBalance.Reserved + amount, this.AssetPrecission));
LimitOrdersResponse message = (LimitOrdersResponse)await this.WaitForRabbitMQ <LimitOrdersResponse>(
o => o.orders.Any(m => m.order.externalId == limitOrderID && m.order.status == "InOrderBook"));
Assert.NotNull(message);
LimitOrders subMessage = message.orders.Where(m => m.order.externalId == limitOrderID && m.order.status == "InOrderBook").FirstOrDefault();
Assert.NotNull(subMessage);
Assert.True(subMessage.order.clientId == this.TestAccountId1);
Assert.True(subMessage.order.assetPairId == this.TestAssetPair.Id);
Assert.True(subMessage.order.volume == amount * -1);
Assert.True(subMessage.order.price == price);
//LimitOrderEntity limitOrderFromDB = (LimitOrderEntity)await fixture.LimitOrdersRepository.TryGetAsync("Active_" + fixture.TestAccountId1, subMessage.order.id);
//Assert.NotNull(limitOrderFromDB);
//Assert.True(limitOrderFromDB.AssetPairId == fixture.TestAssetPair.Id);
//Assert.True(limitOrderFromDB.Price == subMessage.order.price);
//Assert.True(limitOrderFromDB.Status == subMessage.order.status);
//Assert.True(limitOrderFromDB.Volume == amount);
//Assert.True(limitOrderFromDB.RemainingVolume == subMessage.order.remainingVolume);
//Assert.True(limitOrderFromDB.Straight == );
//Assert.True(limitOrderFromDB.MatchingId == subMessage.order.);
//Cancel the proper sell
MeResponseModel LimitOrderCancelResponse = await this.Consumer.Client.CancelLimitOrderAsync(limitOrderID);
Assert.True(LimitOrderCancelResponse.Status == MeStatusCodes.Ok);
checkTestAccount = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
checkAccountBalance = checkTestAccount.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
Assert.True(checkAccountBalance.Reserved == accountBalance.Reserved);
LimitOrdersResponse cancelMessage = (LimitOrdersResponse)await this.WaitForRabbitMQ <LimitOrdersResponse>(
o => o.orders.Any(m => m.order.externalId == limitOrderID && m.order.status == "Cancelled"));
Assert.NotNull(cancelMessage);
LimitOrders cancelSubMessage = cancelMessage.orders.Where(m => m.order.externalId == limitOrderID && m.order.status == "Cancelled").FirstOrDefault();
Assert.NotNull(cancelSubMessage);
Assert.True(cancelSubMessage.order.clientId == this.TestAccountId1);
Assert.True(cancelSubMessage.order.assetPairId == this.TestAssetPair.Id);
Assert.True(cancelSubMessage.order.volume == amount * -1);
Assert.True(cancelSubMessage.order.price == price);
}
