private Task SetCountInCacheAsync(AccountTier tier, int count)
{
return(_cache.HashSetAsync(GetCountsCacheKey(), new List <HashEntry>
{
new HashEntry(tier.ToString(), count.ToString())
}.ToArray()));
}
internal AccountTier?GetNextTier(AccountTier clientTier, string country, TierUpgradeRequest upgradeRequest)
{
AccountTier tier = clientTier;
if (upgradeRequest != null)
{
switch (upgradeRequest.Status)
{
case nameof(KycStatus.Rejected):
case nameof(KycStatus.RestrictedArea):
return(upgradeRequest.Tier);
case nameof(KycStatus.Pending):
tier = upgradeRequest.Tier;
break;
}
}
if (tier == AccountTier.ProIndividual)
{
return(null);
}
bool isHighRiskCountry = _settingsService.IsHighRiskCountry(country);
if (isHighRiskCountry)
{
return(AccountTier.ProIndividual);
}
var values = (AccountTier[])Enum.GetValues(typeof(AccountTier));
return(values[(int)tier + 1]);
}
private void CheckResult(ClientTierInfo info, AccountTier currentTier, AccountTier?nextTier = null, AccountTier?upgradeRequestTier = null, string upgradeRequestStatus = null)
{
Assert.Equal(currentTier, info.CurrentTier.Tier);
Assert.Equal(nextTier, info.NextTier?.Tier);
Assert.Equal(upgradeRequestTier, info.UpgradeRequest?.Tier);
Assert.Equal(upgradeRequestStatus, info.UpgradeRequest?.Status);
}
public async Task <int> GetCountAsync(AccountTier tier)
{
var count = await _tableStorage.GetDataAsync(TierUpgradeRequestEntity.GenerateCountPk(tier),
TierUpgradeRequestEntity.GenerateCountRk());
return(count?.Count ?? 0);
}
public async Task <TierLimitResponse> GetTierLimitAsync(string clientId, AccountTier tier)
{
var pd = await _personalDataService.GetAsync(clientId);
var limit = await _limitsService.GetClientLimitSettingsAsync(clientId, tier, pd.CountryFromPOA);
return(new TierLimitResponse {
Limit = limit?.MaxLimit ?? 0
});
}
private async Task DecrementCountAsync(AccountTier tier)
{
int count = await _repository.GetCountAsync(tier);
int value = Math.Max(0, count - 1);
await Task.WhenAll(
_repository.AddCountAsync(tier, value),
SetCountInCacheAsync(tier, value)
);
}
private async Task IncrementCountAsync(AccountTier tier)
{
int count = await _repository.GetCountAsync(tier);
count += 1;
await Task.WhenAll(
_repository.AddCountAsync(tier, count),
SetCountInCacheAsync(tier, count)
);
}
public static TierUpgradeRequestEntity CreateCount(AccountTier tier, int count)
{
return(new TierUpgradeRequestEntity
{
PartitionKey = GenerateCountPk(tier),
RowKey = GenerateCountRk(),
Tier = tier,
Count = count,
Date = DateTime.UtcNow
});
}
public async Task AddAsync(string clientId, AccountTier tier, KycStatus status, string comment = null, DateTime?date = null)
{
var item = TierUpgradeRequestEntity.Create(clientId, tier, status, comment, date);
await _tableStorage.InsertOrReplaceAsync(item);
if (status == KycStatus.Pending)
{
var indexEntity = AzureIndex.Create(PendingRequestsIndex, GetPendingRequestIndexRk(clientId, tier), item);
await _index.InsertOrMergeAsync(indexEntity);
}
}
public static TierUpgradeRequestEntity Create(string clientId, AccountTier tier, KycStatus status, string comment, DateTime?date = null)
{
return(new TierUpgradeRequestEntity
{
PartitionKey = GeneratePk(tier),
RowKey = GenerateRk(clientId),
ClientId = clientId,
Tier = tier,
KycStatus = status,
Date = date ?? DateTime.UtcNow,
Comment = comment
});
}
public Task UpdateCountsAsync(string clientId, AccountTier tier, KycStatus?oldStatus, KycStatus newStatus)
{
if (newStatus == KycStatus.Ok && oldStatus.HasValue)
{
return(DecrementCountAsync(tier));
}
if (!oldStatus.HasValue)
{
return(IncrementCountAsync(tier));
}
return(Task.CompletedTask);
}
private async Task <CurrentTier> GetCurrentTierAync(string clientId, AccountTier clientTier, string country)
{
var currentDepositAmountTask = _limitsService.GetClientDepositAmountAsync(clientId);
var maxLimitTask = _limitsService.GetClientLimitSettingsAsync(clientId, clientTier, country);
await Task.WhenAll(currentDepositAmountTask, maxLimitTask);
return(new CurrentTier
{
Tier = clientTier,
Asset = _settingsService.GetDefaultAsset(),
Current = currentDepositAmountTask.Result,
MaxLimit = maxLimitTask.Result?.MaxLimit ?? 0
});
}
public async Task AddAsync(string clientId, AccountTier tier, KycStatus status, string changer)
{
ITierUpgradeRequest currentTierRequest = await GetAsync(clientId, tier);
DateTime?requestDate = null;
if (currentTierRequest != null && status != KycStatus.Pending)
{
requestDate = currentTierRequest.Date;
await _repository.DeletePendingRequestIndexAsync(clientId, currentTierRequest.Tier);
}
await _repository.AddAsync(clientId, tier, status, date : requestDate);
await _auditLogRepository.InsertRecordAsync(clientId, new AuditLogData
{
BeforeJson = GetStatus(tier, currentTierRequest).ToJson(),
AfterJson = (currentTierRequest?.KycStatus == status ? $"{tier}:{status} (updated)" : $"{tier}:{status}").ToJson(),
CreatedTime = DateTime.UtcNow,
RecordType = AuditRecordType.TierUpgradeRequest,
Changer = changer
});
switch (status)
{
case KycStatus.Ok:
await _clientAccountClient.ClientAccount.ChangeAccountTierAsync(clientId, new AccountTierRequest { Tier = tier });
break;
case KycStatus.Rejected:
case KycStatus.RestrictedArea:
await _kycStatusService.ChangeKycStatusAsync(clientId, status, nameof(TierUpgradeService));
break;
}
if (currentTierRequest?.KycStatus != status)
{
CqrsEngine.PublishEvent(new TierUpgradeRequestChangedEvent
{
ClientId = clientId,
Tier = tier,
OldStatus = currentTierRequest?.KycStatus,
NewStatus = status
}, TierBoundedContext.Name);
}
}
public async Task <ClientTierInfo> GetClientTierInfoAsync(string clientId, AccountTier clientTier, string country)
{
var currentTierTask = GetCurrentTierAync(clientId, clientTier, country);
var upgradeRequetTask = GetUpgradeRequestAsync(clientId, country);
var questionnaireTask = _questionnaireService.GetQuestionnaireAsync(clientId);
await Task.WhenAll(currentTierTask, upgradeRequetTask, questionnaireTask);
NextTier nextTier = await GetNextTierAsync(clientId, clientTier, country, upgradeRequetTask.Result);
var result = new ClientTierInfo
{
CurrentTier = currentTierTask.Result,
NextTier = nextTier,
UpgradeRequest = upgradeRequetTask.Result,
QuestionnaireAnswered = questionnaireTask.Result.Any()
};
return(result);
}
internal async Task <NextTier> GetNextTierAsync(string clientId, AccountTier clientTier, string country, TierUpgradeRequest upgradeRequest)
{
AccountTier?nextTier = GetNextTier(clientTier, country, upgradeRequest);
if (nextTier.HasValue)
{
var nextTierLimits = await _limitsService.GetClientLimitSettingsAsync(clientId, nextTier.Value, country);
if (nextTierLimits != null)
{
return(new NextTier
{
Tier = nextTier.Value,
MaxLimit = nextTierLimits.MaxLimit ?? 0,
Documents = nextTierLimits.Documents.Select(x => x.ToString()).ToArray(),
});
}
}
return(null);
}
public LimitSettings GetLimit(CountryRisk risk, AccountTier tier)
{
return(_limitSettings.ContainsKey(risk)
? _limitSettings[risk].FirstOrDefault(x => x.Tier == tier)
: null);
}
public Task AddCountAsync(AccountTier tier, int count)
{
return(_tableStorage.InsertOrReplaceAsync(TierUpgradeRequestEntity.CreateCount(tier, count)));
}
public Task DeletePendingRequestIndexAsync(string clientId, AccountTier tier)
{
return(_index.DeleteIfExistAsync(PendingRequestsIndex, GetPendingRequestIndexRk(clientId, tier)));
}
public async Task <IReadOnlyList <ITierUpgradeRequest> > GetByTierAsync(AccountTier tier)
{
return((await _tableStorage.GetDataAsync(TierUpgradeRequestEntity.GeneratePk(tier))).ToList());
}
public async Task <ITierUpgradeRequest> GetAsync(string clientId, AccountTier tier)
{
return(await _tableStorage.GetDataAsync(TierUpgradeRequestEntity.GeneratePk(tier),
TierUpgradeRequestEntity.GenerateRk(clientId)));
}
private string GetPendingRequestIndexRk(string clientId, AccountTier tier) => $"{clientId}_{tier}";
public async Task <LimitSettings> GetClientLimitSettingsAsync(string clientId, AccountTier tier, string country)
{
if (tier == AccountTier.Beginner)
{
return(null);
}
var countryRisk = _settingsService.GetCountryRisk(country);
if (countryRisk == null && !_clientIds.Contains(clientId))
{
_log.Warning(message: $"Can't get country risk for country {country}", context: clientId);
}
LimitSettings limit = null;
if (countryRisk.HasValue)
{
limit = _settingsService.GetLimit(countryRisk.Value, tier);
if (limit == null)
{
_log.Warning(message: $"Can't get limit settings for tier {tier} and country risk {countryRisk}", context: clientId);
}
}
var individualLimit = await _limitsRepository.GetAsync(clientId);
var result = new LimitSettings
{
Tier = tier,
MaxLimit = individualLimit?.Limit ?? limit?.MaxLimit,
Documents = limit?.Documents ?? Array.Empty <DocumentType>()
};
return(result);
}
public Task <ITierUpgradeRequest> GetAsync(string clientId, AccountTier tier)
{
return(_repository.GetAsync(clientId, tier));
}
/// <summary>
/// Returns an <see cref="ImmutableList{T}"/> containing all <see cref="RewardPropertyPremiumModifierEntry"/> for the given <see cref="AccountTier"/>.
/// </summary>
public ImmutableList <RewardPropertyPremiumModifierEntry> GetRewardPropertiesForTier(AccountTier tier)
{
return(rewardPropertiesByTier.TryGetValue(tier, out ImmutableList <RewardPropertyPremiumModifierEntry> entries) ? entries : ImmutableList <RewardPropertyPremiumModifierEntry> .Empty);
}
private static string GetStatus(AccountTier tier, ITierUpgradeRequest request)
{
return(request == null ? string.Empty : $"{tier}:{request.KycStatus.ToString()}");
}
public Task <IReadOnlyList <ITierUpgradeRequest> > GetByTierAsync(AccountTier tier)
{
return(_repository.GetByTierAsync(tier));
}
public static string GeneratePk(AccountTier tier) => $"{tier}";
public static string GenerateCountPk(AccountTier tier) => $"{tier}Count";
