internal async Task <TierUpgradeRequest> GetUpgradeRequestAsync(string clientId, string country)
{
IReadOnlyList <ITierUpgradeRequest> tierUpgradeRequests = await _tierUpgradeService.GetByClientAsync(clientId);
var rejectedRequest = tierUpgradeRequests
.OrderBy(x => x.Tier)
.FirstOrDefault(x => x.KycStatus != KycStatus.Ok && x.KycStatus != KycStatus.Pending);
var lastPendingRequest = tierUpgradeRequests
.Where(x => x.KycStatus != KycStatus.Ok)
.OrderByDescending(x => x.Tier)
.FirstOrDefault();
var tier = rejectedRequest?.Tier ?? lastPendingRequest?.Tier ?? null;
double limit = 0;
if (tier != null)
{
LimitSettings limitSettings = await _limitsService.GetClientLimitSettingsAsync(clientId, tier.Value, country);
limit = limitSettings?.MaxLimit ?? 0;
}
if (rejectedRequest != null)
{
return(new TierUpgradeRequest
{
Tier = rejectedRequest.Tier,
Status = rejectedRequest.KycStatus.ToString(),
SubmitDate = rejectedRequest.Date,
Limit = limit
});
}
if (lastPendingRequest != null)
{
return(new TierUpgradeRequest
{
Tier = lastPendingRequest.Tier,
Status = lastPendingRequest.KycStatus.ToString(),
SubmitDate = lastPendingRequest.Date,
Limit = limit
});
}
return(null);
}
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "Api", Version = "v1"
});
c.OperationFilter <SwaggerHeaderParameter>();
});
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = ApiKeyAuthenticationOptions.DefaultScheme;
options.DefaultChallengeScheme = ApiKeyAuthenticationOptions.DefaultScheme;
})
.AddApiKeySupport(options => { });
var connectionString = Configuration.GetConnectionString("Default");
services.AddDbContext <UltimateRedditBotDbContext>(options =>
{
options.UseSqlServer(connectionString, e => e.MigrationsAssembly(typeof(UltimateRedditBotDbContext).Assembly.FullName));
});
using var scope = services.BuildServiceProvider().CreateScope();
var dbContext = scope.ServiceProvider.GetRequiredService <UltimateRedditBotDbContext>();
var limitSettings = new LimitSettings()
{
DefaultMaxPlaylists = Configuration.GetValue <int>(SettingKeys.DefaultMaxPlaylists),
DefaultMaxItemsInQueue = Configuration.GetValue <int>(SettingKeys.DefaultMaxItemsInQueue),
DefaultMaxSubscriptions = Configuration.GetValue <int>(SettingKeys.DefaultMaxSubscriptions),
};
services.AddSingleton(limitSettings);
services.AddCors();
//Apply last changes
dbContext.Database.Migrate();
services.AddCore();
}
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 async Task Handle(ClientDepositedEvent evt, ICommandSender commandSender)
{
var clientAccountTask = _clientAccountClient.ClientAccountInformation.GetByIdAsync(evt.ClientId);
var pdTask = _personalDataService.GetAsync(evt.ClientId);
await Task.WhenAll(clientAccountTask, pdTask);
ClientInfo clientAccount = clientAccountTask.Result;
IPersonalData pd = pdTask.Result;
if (clientAccount == null)
{
return;
}
await _limitsService.SaveDepositOperationAsync(_mapper.Map <DepositOperation>(evt));
LimitSettings currentLimitSettings = await _limitsService.GetClientLimitSettingsAsync(evt.ClientId, clientAccount.Tier, pd.CountryFromPOA);
if (currentLimitSettings?.MaxLimit == null)
{
return;
}
var checkAmountTask = _limitsService.GetClientDepositAmountAsync(evt.ClientId);
var pushSettingsTask = _clientAccountClient.ClientSettings.GetPushNotificationAsync(evt.ClientId);
await Task.WhenAll(checkAmountTask, pushSettingsTask);
var checkAmount = checkAmountTask.Result;
var pushSettings = pushSettingsTask.Result;
if (checkAmount > currentLimitSettings.MaxLimit.Value)
{
await _limitsService.SetLimitReachedAsync(evt.ClientId, checkAmount,
currentLimitSettings.MaxLimit.Value, evt.BaseAsset);
if (pushSettings.Enabled && !string.IsNullOrEmpty(clientAccount.NotificationsId))
{
await SendPushNotificationAsync(clientAccount.PartnerId, clientAccount.NotificationsId,
"PushLimitReachedTemplate", new { }, commandSender);
}
}
if (checkAmount <= currentLimitSettings.MaxLimit.Value)
{
bool needNotification = _settingsService.IsLimitReachedForNotification(checkAmount, currentLimitSettings.MaxLimit.Value);
if (!needNotification)
{
return;
}
if (pushSettings.Enabled && !string.IsNullOrEmpty(clientAccount.NotificationsId))
{
await SendPushNotificationAsync(clientAccount.PartnerId, clientAccount.NotificationsId,
"PushLimitPercentReachedTemplate", new {
CurrentAmount = checkAmount,
Limit = currentLimitSettings.MaxLimit.Value,
Percent = Math.Round(checkAmount / currentLimitSettings.MaxLimit.Value * 100),
FullName = pd.FullName,
Asset = evt.BaseAsset
}, commandSender);
}
}
}
public GuildCommandHandler(UltimateRedditBotDbContext context, IMapper mapper, LimitSettings limitSettings)
: base(context, mapper)
{
_limitSettings = limitSettings;
}
