public async Task <IActionResult> GetBalances()
{
var result = new List <WalletBalancesModel>();
var walletsTask = _clientAccountService.Wallets.GetClientWalletsFilteredAsync(_requestContext.ClientId, owner: OwnerType.Spot);
var clientKeysTask = _hftInternalService.Keys.GetKeys(_requestContext.ClientId);
var availableAssetsTask = _assetsHelper.GetSetOfAssetsAvailableToClientAsync(_requestContext.ClientId, _requestContext.PartnerId);
await Task.WhenAll(walletsTask, clientKeysTask, availableAssetsTask);
var wallets = walletsTask.Result;
var clientKeys = clientKeysTask.Result;
var availableAssets = availableAssetsTask.Result;
foreach (var wallet in wallets)
{
var walletBalances = await _balancesClient.GetClientBalances(wallet.Type == WalletType.Trading?_requestContext.ClientId : wallet.Id);
var balancesToShow = walletBalances?
.Where(x => availableAssets.Contains(x.AssetId) && x.Balance > 0)
.Select(ClientBalanceResponseModel.Create);
result.Add(new WalletBalancesModel
{
Id = wallet.Id,
Type = wallet.Type.ToString(),
Name = wallet.Name,
Description = wallet.Description,
Balances = balancesToShow ?? new ClientBalanceResponseModel[0],
ApiKey = clientKeys.FirstOrDefault(x => x.WalletId == wallet.Id)?.ApiKey
});
}
return(Ok(result));
}
public async Task <IActionResult> GetBalances()
{
var result = new List <WalletBalancesModel>();
var wallets = await _clientAccountService.GetWalletsByClientIdAsync(_requestContext.ClientId);
var clientKeys = await _hftInternalService.GetKeysAsync(_requestContext.ClientId);
foreach (var wallet in wallets)
{
var balances = await _balancesClient.GetClientBalances(wallet.Type == TradingWalletType?_requestContext.ClientId : wallet.Id);
result.Add(new WalletBalancesModel
{
Id = wallet.Id,
Type = wallet.Type,
Name = wallet.Name,
Description = wallet.Description,
Balances = balances?.Select(ClientBalanceResponseModel.Create) ?? new ClientBalanceResponseModel[0],
ApiKey = clientKeys.FirstOrDefault(x => x.Wallet == wallet.Id)?.Key
});
}
return(Ok(result));
}
public async Task UpdateAsync()
{
string walletId = _settingsService.GetWalletId();
if (string.IsNullOrEmpty(walletId))
{
return;
}
try
{
IEnumerable <ClientBalanceResponseModel> response =
await _balancesClient.GetClientBalances(walletId);
Balance[] balances = response
.Select(o => new Balance(ExchangeNames.Lykke, o.AssetId, o.Balance, o.Reserved))
.ToArray();
_cache.Set(balances);
_traceWriter.Balances(balances);
}
catch (Exception exception)
{
_log.ErrorWithDetails(exception, "An error occurred while getting balances from Lykke exchange.");
}
}
public async Task <IReadOnlyList <PrimaryMarketBalance> > GetBalancesAsync()
{
var balances = await _balancesClient.GetClientBalances(_walletId);
return(balances
.Select(x => new PrimaryMarketBalance
{
AssetId = x.AssetId,
Balance = x.Balance,
Reserved = x.Reserved
})
.Where(x => x.Balance != 0 || x.Reserved != 0)
.ToArray());
}
public async Task <GetWalletsResponse> GetWallets()
{
var responce = new GetWalletsResponse();
var clientId = this.ClientId();
var balaces = (await _balancesClient.GetClientBalances(clientId)).ToDictionary(e => e.AssetId, e => e);
responce.Wallets = _settings.BalanceAssets.Select(e => new WalletBalanceModel()
{
Asset = e,
Balance = balaces.ContainsKey(e) ? balaces[e].Balance : 0,
Reserved = balaces.ContainsKey(e) ? balaces[e].Reserved : 0
}).ToList();
return(responce);
}
/// <summary>
/// Request money transfer referral link - reserved for version 2
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
//[HttpPost("giftCoinLinks")] - for v2
//[SwaggerOperation("RequestGiftCoinsReferralLink")]
//[ProducesResponseType(typeof(ErrorResponseModel), (int)HttpStatusCode.BadRequest)]
//[ProducesResponseType(typeof(ErrorResponseModel), (int)HttpStatusCode.NotFound)]
//[ProducesResponseType(typeof(RequestRefLinkResponse), (int)HttpStatusCode.Created)]
private async Task <IActionResult> RequestGiftCoinsReferralLink([FromBody] GiftCoinsReferralLinkRequest request)
{
if (request == null)
{
return(await LogAndReturnBadRequest("", ControllerContext, Phrases.InvalidRequest));
}
if (request.Amount <= 0)
{
return(await LogAndReturnBadRequest(request, ControllerContext, Phrases.InvalidAmount));
}
if (String.IsNullOrEmpty(request.SenderClientId))
{
return(await LogAndReturnBadRequest(request, ControllerContext, Phrases.InvalidSenderClientId));
}
var asset = (await _assets.GetDictionaryAsync()).Values.FirstOrDefault(v => v.Id == request.Asset);
if (String.IsNullOrEmpty(request.Asset) || asset == null)
{
return(await LogAndReturnBadRequest(request, ControllerContext, Phrases.InvalidAsset));
}
var clientBalances = await _balancesClient.GetClientBalances(request.SenderClientId);
if (clientBalances == null)
{
return(await LogAndReturnNotFound(request, ControllerContext, $"Cant get clientBalance of asset {asset.Name} for client id {request.SenderClientId}."));
}
var balance = clientBalances.FirstOrDefault(x => x.AssetId == asset.Id)?.Balance;
if (!balance.HasValue || balance.Value < request.Amount)
{
return(await LogAndReturnBadRequest(request, ControllerContext, Phrases.InvalidTreesAmount));
}
var referralLink = await _referralLinksService.CreateGiftCoinsLink(request);
await LogInfo(request, ControllerContext, referralLink.ToJson());
return(Created(uri: $"api/referralLinks/{referralLink.Id}", value: new RequestRefLinkResponse {
RefLinkId = referralLink.Id, RefLinkUrl = referralLink.Url
}));
}
private async Task <IList <BalanceIssueDto> > FindBalancesWithIssues()
{
var balanceIssues = new List <BalanceIssueDto>();
var balanceWarnings = await _balanceWarningRepository.GetBalancesWarnings();
var balancesWallets = balanceWarnings.Select(x => x.ClientId).Distinct()
.ToDictionary(x => x, x => _balancesClient.GetClientBalances(x));
var tasks = balancesWallets.Values.Cast <Task>().ToList();
await Task.WhenAll(tasks);
var balances = new Dictionary <string, ClientBalanceResponseModel>();
foreach (var balanceWallet in balancesWallets)
{
foreach (var balance in balanceWallet.Value.Result)
{
balances[GetBalanceDictionaryKey(balanceWallet.Key, balance.AssetId)] = balance;
}
}
foreach (var balanceWarning in balanceWarnings)
{
var key = GetBalanceDictionaryKey(balanceWarning.ClientId, balanceWarning.AssetId);
var isBalanceFound = balances.TryGetValue(key, out var balance);
if (isBalanceFound && balance.Balance < balanceWarning.MinBalance ||
!isBalanceFound && balanceWarning.MinBalance > 0)
{
balanceIssues.Add(new BalanceIssueDto
{
ClientId = balanceWarning.ClientId,
AssetId = balanceWarning.AssetId,
Name = balanceWarning.Name,
AssetName = balanceWarning.AssetName,
Balance = balance?.Balance ?? 0,
MinBalance = balanceWarning.MinBalance
});
}
}
return(balanceIssues);
}
public async Task <IReadOnlyList <Balance> > GetAsync()
{
try
{
var balance = await _balancesClient.GetClientBalances(await _settingsService.GetWalletIdAsync());
return(balance.Select(x => new Balance
{
AssetId = x.AssetId,
Available = x.Balance,
Reserved = x.Reserved
}).ToArray());
}
catch (Exception e)
{
throw new FailedOperationException("Failed to retrieve balances.", e);
}
}
public async Task UpdateBalancesAsync()
{
string walletId = _settingsService.GetWalletId();
if (string.IsNullOrEmpty(walletId))
{
return;
}
try
{
IEnumerable <ClientBalanceResponseModel> exchangeBalances =
await _balancesClient.GetClientBalances(walletId);
IDictionary <string, AssetLink> assetMap = (await _assetLinkService.GetAllAsync())
.ToDictionary(o => o.ExternalAssetId, o => o);
IReadOnlyCollection <Balance> balances = exchangeBalances
.Select(exchangeBalance =>
{
string assetId = assetMap.TryGetValue(exchangeBalance.AssetId, out AssetLink assetLink)
? assetLink.AssetId
: exchangeBalance.AssetId;
return(new Balance(assetId, exchangeBalance.Balance, exchangeBalance.Reserved));
})
.ToArray();
LogChangedBalances(balances);
_cache.Set(balances);
}
catch (Exception exception)
{
_log.Error(exception, "An error occurred while getting balances from Lykke exchange.");
}
}
public async Task <IActionResult> GetBalances()
{
var clientId = User.GetUserId();
var balances = await _balancesClient.GetClientBalances(clientId);
var walletBalances = balances?.Select(x => new BalanceModel
{
AssetId = x.AssetId,
Balance = x.Balance,
Reserved = x.Reserved
}) ?? Enumerable.Empty <BalanceModel>();
foreach (var wallet in walletBalances)
{
var asset = _assetsReadModel.TryGetIfEnabled(wallet.AssetId);
if (asset != null)
{
wallet.Balance = wallet.Balance.TruncateDecimalPlaces(asset.Accuracy);
wallet.Reserved = wallet.Reserved.TruncateDecimalPlaces(asset.Accuracy);
}
}
return(Ok(walletBalances));
}
