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";