public OperationsService(ITransfersRepository transfersRepository,
IBonusCashInsRepository bonusCashInsRepository,
ICampaignClient campaignClient,
IPrivateBlockchainFacadeClient privateBlockchainFacadeClient,
ICustomerTierRepository customerTierRepository,
IMemoryCache memoryCache,
TimeSpan customerWalletsCacheExpirationPeriod,
IPartnersPaymentsRepository partnersPaymentsRepository,
IReferralStakesRepository referralStakesRepository,
IPartnerManagementClient partnerManagementClient,
ILinkedWalletTransfersRepository linkedWalletTransfersRepository,
IFeeCollectedOperationsRepository feeCollectedOperationsRepository,
ILinkWalletOperationsRepository linkWalletOperationsRepository,
IVoucherPurchasePaymentsRepository voucherPurchasePaymentsRepository,
string tokenSymbol,
ILogFactory logFactory)
{
_transfersRepository = transfersRepository;
_bonusCashInsRepository = bonusCashInsRepository;
_campaignClient = campaignClient;
_privateBlockchainFacadeClient = privateBlockchainFacadeClient;
_customerTierRepository = customerTierRepository;
_customerWalletsCacheExpirationPeriod = customerWalletsCacheExpirationPeriod;
_tokenSymbol = tokenSymbol;
_partnersPaymentsRepository = partnersPaymentsRepository;
_partnerManagementClient = partnerManagementClient;
_referralStakesRepository = referralStakesRepository;
_linkedWalletTransfersRepository = linkedWalletTransfersRepository;
_feeCollectedOperationsRepository = feeCollectedOperationsRepository;
_linkWalletOperationsRepository = linkWalletOperationsRepository;
_voucherPurchasePaymentsRepository = voucherPurchasePaymentsRepository;
_customerWalletsCache = new OnDemandDataCache <string>(memoryCache);
_log = logFactory.CreateLog(this);
}
public CachedVolatilityController(IVolatilityController volatilityController,
IPayVolatilityServiceClientCacheSettings settings)
{
_volatilityController = volatilityController;
_settings = settings;
_memoryCache = new OnDemandDataCache <IEnumerable <VolatilityModel> >();
}
public MerchantService(
IMemoryCache memoryCache,
CacheExpirationPeriodsSettings cacheExpirationPeriods,
IPayMerchantClient payMerchantClient)
{
_cacheExpirationPeriods = cacheExpirationPeriods;
_payMerchantClient = payMerchantClient;
_merchantNamesCache = new OnDemandDataCache <string>(memoryCache);
}
private void RegisterServices(ContainerBuilder builder)
{
var settings = _appSettings.CurrentValue.LimitationsSettings;
builder.RegisterType <StartupManager>()
.As <IStartupManager>()
.SingleInstance();
builder.RegisterType <CurrencyConverter>()
.As <ICurrencyConverter>()
.SingleInstance()
.WithParameter(TypedParameter.From(settings.ConvertibleAssets))
.WithParameter(TypedParameter.From(settings.BaseAsset));
builder.RegisterType <AntiFraudCollector>()
.As <IAntiFraudCollector>()
.SingleInstance()
.WithParameter(TypedParameter.From(settings.RedisInstanceName));
builder.RegisterType <CashOperationsCollector>()
.As <ICashOperationsCollector>()
.SingleInstance()
.WithParameter(TypedParameter.From(settings.RedisInstanceName));
builder.RegisterType <CashTransfersCollector>()
.As <ICashTransfersCollector>()
.SingleInstance()
.WithParameter(TypedParameter.From(settings.RedisInstanceName));
builder.RegisterType <LimitationChecker>()
.As <ILimitationCheck>()
.SingleInstance()
.WithParameter(TypedParameter.From(settings.Limits))
.WithParameter(TypedParameter.From(settings.AttemptRetainInMinutes));
builder.Register(ctx =>
{
var assetService = ctx.Resolve <IAssetsService>();
var assetsCache = new OnDemandDataCache <Asset>();
var assets = assetService.AssetGetAll();
foreach (var asset in assets)
{
assetsCache.Set(asset.Id, new Asset
{
Id = asset.Id,
LowVolumeAmount = asset.LowVolumeAmount,
Accuracy = asset.Accuracy,
CashoutMinimalAmount = asset.CashoutMinimalAmount
});
}
return(assetsCache);
}).SingleInstance();
}
public AssetService(
IPayInternalClient payInternalClient,
IPayInvoiceClient payInvoiceClient,
ILykkeAssetsResolver lykkeAssetsResolver,
IMemoryCache memoryCache,
ILogFactory logFactory)
{
_payInternalClient = payInternalClient;
_payInvoiceClient = payInvoiceClient;
_lykkeAssetsResolver = lykkeAssetsResolver;
_assetsNetworkCache = new OnDemandDataCache <Dictionary <string, BlockchainType> >(memoryCache);
_assetBlockchainTypeCache = new OnDemandDataCache <Tuple <BlockchainType> >(memoryCache);
_log = logFactory.CreateLog(this);
}
public IataService(
IIataApiClient iataApiClient,
CacheExpirationPeriodsSettings cacheExpirationPeriodsSettings,
IataSettings iataSettings,
IMemoryCache memoryCache,
ILogFactory logFactory)
{
_iataApiClient = iataApiClient;
_cacheExpirationPeriodsSettings = cacheExpirationPeriodsSettings;
_iataSettings = iataSettings;
_iataBillingCategories = new OnDemandDataCache <IReadOnlyList <string> >(memoryCache);
_invoiceIataSpecificDataCache = new OnDemandDataCache <InvoiceIataSpecificData>(memoryCache);
_log = logFactory.CreateLog(this);
}
public MerchantService(
IPayInternalClient payInternalClient,
IPayInvoiceClient payInvoiceClient,
IMemoryCache memoryCache,
MerchantSettings merchantSettings,
CacheExpirationPeriodsSettings cacheExpirationPeriods,
IPayMerchantClient payMerchantClient)
{
_payInternalClient = payInternalClient;
_payInvoiceClient = payInvoiceClient;
_merchantSettings = merchantSettings;
_merchantNamesCache = new OnDemandDataCache <string>(memoryCache);
_merchantLogoUrlsCache = new OnDemandDataCache <string>(memoryCache);
_cacheExpirationPeriods = cacheExpirationPeriods;
_payMerchantClient = payMerchantClient;
}
public LimitationChecker(
ICashOperationsCollector cashOperationsCollector,
ICashTransfersCollector cashTransfersCollector,
ICurrencyConverter currencyConverter,
IAntiFraudCollector antiFraudCollector,
ILimitOperationsApi limitOperationsApi,
List <CashOperationLimitation> limits,
int attemptRetainInMinutes,
ISwiftTransferLimitationsRepository swiftTransferLimitationsRepository,
ILimitSettingsRepository limitSettingsRepository,
ICallTimeLimitsRepository callTimeLimitsRepository,
OnDemandDataCache <Asset> assets,
ILogFactory logFactory)
{
_cashOperationsCollector = cashOperationsCollector;
_cashTransfersCollector = cashTransfersCollector;
_currencyConverter = currencyConverter;
_antiFraudCollector = antiFraudCollector;
_limitOperationsApi = limitOperationsApi;
_attemptRetainInMinutes = attemptRetainInMinutes > 0 ? attemptRetainInMinutes : 1;
_swiftTransferLimitationsRepository = swiftTransferLimitationsRepository;
_limitSettingsRepository = limitSettingsRepository;
_callTimeLimitsRepository = callTimeLimitsRepository;
_assets = assets;
_log = logFactory.CreateLog(this);
if (limits == null)
{
_limits = new List <CashOperationLimitation>(0);
}
else
{
_limits = new List <CashOperationLimitation>(limits.Count);
foreach (var limit in limits)
{
if (!limit.IsValid())
{
_log.Warning("Invalid limit in settings: " + limit.ToJson());
continue;
}
_limits.Add(limit);
}
}
}
public InvoiceService(
IMerchantService merchantService,
IAssetService assetService,
IPayInvoiceClient payInvoiceClient,
IPayInternalClient payInternalClient,
IRateCalculatorClient rateCalculatorClient,
ILykkeAssetsResolver lykkeAssetsResolver,
IMemoryCache memoryCache,
CacheExpirationPeriodsSettings cacheExpirationPeriods,
ILogFactory logFactory,
IPayMerchantClient payMerchantClient)
{
_merchantService = merchantService;
_assetService = assetService;
_payInvoiceClient = payInvoiceClient;
_payInternalClient = payInternalClient;
_rateCalculatorClient = rateCalculatorClient;
_lykkeAssetsResolver = lykkeAssetsResolver;
_cacheExpirationPeriods = cacheExpirationPeriods;
_payMerchantClient = payMerchantClient;
_ratesCache = new OnDemandDataCache <Tuple <double> >(memoryCache);
_employeeFullNameCache = new OnDemandDataCache <string>(memoryCache);
_log = logFactory.CreateLog(this);
}
public SqlRepositoryHelper(IMemoryCache memoryCache, ILogFactory logFactory)
{
_resourcesCache = new OnDemandDataCache <string>(memoryCache);
_log = logFactory.CreateLog(this);
_assembly = Assembly.GetExecutingAssembly();
}
public AssetsProjection(OnDemandDataCache <Asset> assetsCache)
{
_assetsCache = assetsCache;
}
