public override async Task <AssetsDictionaryResponse> AssetsDictionary(Empty request, ServerCallContext context)
{
var result = new AssetsDictionaryResponse();
var categories = await _assetsService.AssetCategoryGetAllAsync();
string clientId = context.GetClientId();
string partnerId = context.GetParnerId();
var assets = await _assetsHelper.GetAssetsAvailableToClientAsync(clientId, partnerId, true);
result.Body = new AssetsDictionaryResponse.Types.Body();
result.Body.Categories.AddRange(_mapper.Map <List <AssetCategory> >(categories));
result.Body.Assets.AddRange(_mapper.Map <List <Asset> >(assets));
var popularAssetPairs = await _assetsHelper.GetPopularPairsAsync(assets.Select(x => x.Id).ToList());
foreach (var asset in result.Body.Assets)
{
if (popularAssetPairs.ContainsKey(asset.Id))
{
asset.PopularPairs.AddRange(popularAssetPairs[asset.Id]);
}
}
return(result);
}
public override async Task <BalancesResponse> GetBalances(Empty request, ServerCallContext context)
{
var clientId = context.GetClientId();
var balances = await _balancesClient.GetClientBalances(clientId);
var res = new BalancesResponse {
Body = new BalancesResponse.Types.Body()
};
res.Body.Balances.AddRange(_mapper.Map <List <Balance> >(balances));
return(res);
}
public override async Task <EmptyResponse> RegisterPushNotifications(RegisterPushRequest request, ServerCallContext context)
{
var result = new EmptyResponse();
var clientId = context.GetClientId();
var clientInfo = await _clientAccountClient.ClientAccountInformation.GetByIdAsync(clientId);
var sessionId = context.GetLykkeSessionId();
await _pushNotificationsClient.FcmTokens.RegisterAsync(new FcmTokenModel
{
NotificationId = clientInfo.NotificationsId,
ClientId = clientId,
SessionId = sessionId,
FcmToken = request.FcmToken
});
return(result);
}
public override async Task <FundsResponse> GetFunds(FundsRequest request, ServerCallContext context)
{
var result = new FundsResponse();
var token = context.GetBearerToken();
var wallets = await _clientAccountClient.Wallets.GetClientWalletsFilteredAsync(context.GetClientId(), WalletType.Trading);
var walletId = wallets.FirstOrDefault()?.Id;
var response = await _walletApiV2Client.GetFundsByWalletIdAsync(
walletId, null, request.AssetId, request.Take, request.Skip,
request.OptionalFromDateCase == FundsRequest.OptionalFromDateOneofCase.None?(DateTimeOffset?)null : request.From.ToDateTimeOffset(),
request.OptionalToDateCase == FundsRequest.OptionalToDateOneofCase.None?(DateTimeOffset?)null : request.To.ToDateTimeOffset(),
token);
if (response != null)
{
result.Body = new FundsResponse.Types.Body();
result.Body.Funds.AddRange(_mapper.Map <List <FundsResponse.Types.FundsModel> >(response));
}
return(result);
}
public override async Task <AssetTradesResponse> GetAssetTrades(AssetTradesRequest request, ServerCallContext context)
{
var result = new AssetTradesResponse();
var token = context.GetBearerToken();
var wallets = await _clientAccountClient.Wallets.GetClientWalletsFilteredAsync(context.GetClientId(), WalletType.Trading);
var walletId = wallets.FirstOrDefault()?.Id;
var response = await _walletApiV2Client.GetByWalletIdAsync(
walletId, new List <string> {
}, request.AssetId, null, request.Take, request.Skip,
token);
var assetPairs = await _assetsService.AssetPairGetAllAsync();
if (response != null)
{
foreach (var group in response.GroupBy(x => x.Id))
{
var pair = group.ToList();
if (pair.Count == 0 || pair.Count != 2)
{
continue;
}
string assetPairId = pair[0].AssetPair;
var assetPair = assetPairs.FirstOrDefault(x => x.Id == assetPairId);
if (assetPair == null)
{
continue;
}
var assetTrade = new AssetTradesResponse.Types.AssetTradeModel
{
Id = pair[0].Id,
AssetPairId = assetPairId,
BaseAssetId = assetPair.BaseAssetId,
QuoteAssetId = assetPair.QuotingAssetId,
Price = pair[0].Price?.ToString() ?? string.Empty,
Timestamp = Timestamp.FromDateTime(pair[0].DateTime.UtcDateTime)
};
foreach (var item in pair)
{
if (item.Asset == assetPair.BaseAssetId)
{
assetTrade.BaseVolume = item.Amount.ToString(CultureInfo.InvariantCulture);
}
else
{
assetTrade.QuoteVolume = item.Amount.ToString(CultureInfo.InvariantCulture);
}
}
result.Body = new AssetTradesResponse.Types.Body();
result.Body.Trades.Add(assetTrade);
}
}
return(result);
}
public override async Task <CancelOrderResponse> CancelAllOrders(CancelOrdersRequest request, ServerCallContext context)
{
MeResponseModel response;
if (!string.IsNullOrEmpty(request.AssetPairId))
{
var result = await _validationService.ValidateAssetPairAsync(request.AssetPairId);
if (result != null)
{
var res = new CancelOrderResponse
{
Error = new ErrorResponseBody {
Code = ErrorCode.InvalidField, Message = result.Message
}
};
res.Error.Fields.Add(result.FieldName, result.Message);
}
bool?isBuy;
if (request.OptionalSideCase == CancelOrdersRequest.OptionalSideOneofCase.None)
{
isBuy = null;
}
else
{
switch (request.Side)
{
case Side.Buy:
isBuy = true;
break;
case Side.Sell:
isBuy = false;
break;
default:
isBuy = null;
break;
}
}
var model = new LimitOrderMassCancelModel
{
Id = Guid.NewGuid().ToString(),
AssetPairId = request.AssetPairId,
ClientId = context.GetClientId(),
IsBuy = isBuy
};
response = await _matchingEngineClient.MassCancelLimitOrdersAsync(model);
}
else
{
var orders = await GetOrders(new LimitOrdersRequest(), context);
if (orders.Body?.Orders.Any() ?? false)
{
var orderIds = orders.Body.Orders.Select(x => x.Id).ToList();
response = await _matchingEngineClient.CancelLimitOrdersAsync(orderIds);
}
else
{
response = new MeResponseModel {
Status = MeStatusCodes.Ok
};
}
}
if (response == null)
{
return(new CancelOrderResponse
{
Error = new ErrorResponseBody {
Code = ErrorCode.Runtime, Message = ErrorMessages.MeNotAvailable
}
});
}
if (response.Status == MeStatusCodes.Ok)
{
return new CancelOrderResponse
{
Body = new CancelOrderResponse.Types.Body
{
Payload = true
}
}
}
;
return(new CancelOrderResponse
{
Error = new ErrorResponseBody {
Code = ErrorCode.Runtime, Message = response.Message ?? response.Status.ToString()
}
});
}
