private void RegisterRepositories(ContainerBuilder builder)
{
const string payauthTableName = "PayAuthSignature";
const string employeeCredentialsTableName = "EmployeeCredentials";
const string resetPasswordAccessTokenTableName = "ResetPasswordAccessToken";
builder.Register(c =>
new PayAuthRepository(AzureTableStorage <PayAuthEntity> .Create(
_settings.ConnectionString(x => x.Db.DataConnString), payauthTableName,
c.Resolve <ILogFactory>())))
.As <IPayAuthRepository>()
.SingleInstance();
builder.Register(c => new EmployeeCredentialsRepository(
AzureTableStorage <EmployeeCredentialsEntity> .Create(
_settings.ConnectionString(x => x.Db.DataConnString),
employeeCredentialsTableName, c.Resolve <ILogFactory>())))
.As <IEmployeeCredentialsRepository>()
.SingleInstance();
builder.Register(c => new ResetPasswordAccessTokenRepository(
AzureTableStorage <ResetPasswordAccessTokenEntity> .Create(
_settings.ConnectionString(x => x.Db.DataConnString), resetPasswordAccessTokenTableName,
c.Resolve <ILogFactory>()),
AzureTableStorage <AzureIndex> .Create(_settings.ConnectionString(x => x.Db.DataConnString),
resetPasswordAccessTokenTableName, c.Resolve <ILogFactory>())))
.As <IResetPasswordAccessTokenRepository>()
.SingleInstance();
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(y => AzureTableStorage <PaymentTransactionEntity> .Create(
_settings.ConnectionString(x => x.Db.ClientPersonalInfoConnString), "PaymentTransactions", _log))
.As(typeof(INoSQLTableStorage <PaymentTransactionEntity>));
builder.Register(y => AzureTableStorage <AzureMultiIndex> .Create(
_settings.ConnectionString(x => x.Db.ClientPersonalInfoConnString), "PaymentTransactions", _log))
.As(typeof(INoSQLTableStorage <AzureMultiIndex>));
builder.Register(y => AzureTableStorage <PaymentTransactionEventLogEntity> .Create(
_settings.ConnectionString(x => x.Db.LogsConnString), "PaymentsLog", _log))
.As(typeof(INoSQLTableStorage <PaymentTransactionEventLogEntity>));
builder.Register(y => AzureTableStorage <IdentityEntity> .Create(
_settings.ConnectionString(x => x.Db.ClientPersonalInfoConnString), "Setup", _log))
.As(typeof(INoSQLTableStorage <IdentityEntity>));
builder.Register(y => AzureTableStorage <AppGlobalSettingsEntity>
.Create(_settings.ConnectionString(x => x.Db.GlobalSettingsConnString), "Setup", _log))
.As(typeof(INoSQLTableStorage <AppGlobalSettingsEntity>));
builder.RegisterAssemblyTypes(typeof(IRepository).Assembly)
.Where(t => typeof(IRepository).IsAssignableFrom(t))
.AsImplementedInterfaces()
.InstancePerLifetimeScope();
base.Load(builder);
}
private void RegisterServices(ContainerBuilder builder)
{
builder
.Register(ctx =>
new BlobUploader(
AzureBlobStorage.Create(
_settingsManager.ConnectionString(x => x.HistoryExportBuilderJob.Db.DataConnString))))
.As <IFileUploader>()
.SingleInstance();
builder
.Register(ctx =>
new IdMappingsRepository(
AzureTableStorage <IdMappingEntity> .Create(
_settingsManager.ConnectionString(x => x.HistoryExportBuilderJob.Db.DataConnString),
IdMappingsRepository.TableName,
ctx.Resolve <ILogFactory>())))
.As <IFileMapper>()
.SingleInstance();
builder
.Register(ctx =>
new ExpiryEntryRepository(
AzureTableStorage <ExpiryEntryEntity> .Create(
_settingsManager.ConnectionString(x => x.HistoryExportBuilderJob.Db.DataConnString),
ExpiryEntryRepository.TableName,
ctx.Resolve <ILogFactory>())))
.As <IExpiryWatcher>()
.SingleInstance();
builder
.RegisterType <CsvMaker>()
.As <IFileMaker>()
.SingleInstance();
}
private static void RegisterRepo(this ContainerBuilder builder,
IReloadingManager <AppSettings> generalSettings,
ILog log)
{
builder.Register(p =>
new AssetDefinitionRepository(AzureTableStorage <AssetDefinitionDefinitionEntity>
.Create(generalSettings.ConnectionString(x => x.BcnExploler.Db.AssetsConnString),
"AssetDefinitions",
log))).As <IAssetDefinitionRepository>();
builder.Register(p =>
new AssetDefinitionParsedBlockRepository(AzureTableStorage <AssetDefinitionParsedBlockEntity>
.Create(generalSettings.ConnectionString(x => x.BcnExploler.Db.AssetsConnString),
"AssetParsedBlocks",
log))).As <IAssetDefinitionParsedBlockRepository>();
builder.Register(p =>
new AssetImageRepository(AzureTableStorage <AssetImageEntity>
.Create(generalSettings.ConnectionString(x => x.BcnExploler.Db.AssetsConnString),
"AssetImages",
log))).As <IAssetImageRepository>();
builder.Register(p =>
new AssetScoreRepository(AzureTableStorage <AssetScoreEntity>
.Create(generalSettings.ConnectionString(x => x.BcnExploler.Db.AssetsConnString),
"AssetScores",
log))).As <IAssetScoreRepository>();
builder.Register(p =>
new AssetCoinholdersIndexRepository(AzureTableStorage <AssetCoinholdersIndexEntity>
.Create(generalSettings.ConnectionString(x => x.BcnExploler.Db.AssetsConnString),
"AssetCoinholdersIndexes",
log))).As <IAssetCoinholdersIndexRepository>();
}
protected override void Load(ContainerBuilder builder)
{
const string merchantsTableName = "Merchants";
const string merchantGroupsTableName = "MerchantGroups";
const string merchantVolatilitySettingsTableName = "MerchantVolatilitySettings";
builder.Register(c => new MerchantRepository(
AzureTableStorage <MerchantEntity> .Create(
_appSettings.ConnectionString(x => x.PayMerchantService.Db.MerchantConnString),
merchantsTableName, c.Resolve <ILogFactory>()),
AzureTableStorage <AzureIndex> .Create(
_appSettings.ConnectionString(x => x.PayMerchantService.Db.MerchantConnString),
merchantsTableName, c.Resolve <ILogFactory>())))
.As <IMerchantRepository>()
.SingleInstance();
builder.Register(c => new MerchantGroupRepository(
AzureTableStorage <MerchantGroupEntity> .Create(
_appSettings.ConnectionString(x => x.PayMerchantService.Db.MerchantConnString),
merchantGroupsTableName, c.Resolve <ILogFactory>()),
AzureTableStorage <AzureIndex> .Create(
_appSettings.ConnectionString(x => x.PayMerchantService.Db.MerchantConnString),
merchantGroupsTableName, c.Resolve <ILogFactory>())))
.As <IMerchantGroupRepository>()
.SingleInstance();
builder.Register(c => new VolatilitySettingsRepository(
AzureTableStorage <VolatilitySettingsEntity> .Create(
_appSettings.ConnectionString(x => x.PayMerchantService.Db.MerchantConnString),
merchantVolatilitySettingsTableName, c.Resolve <ILogFactory>())))
.As <IVolatilitySettingsRepository>()
.SingleInstance();
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterInstance(_log)
.As <ILog>()
.SingleInstance();
builder.RegisterType <HealthService>()
.As <IHealthService>()
.SingleInstance();
builder.RegisterType <StartupManager>()
.As <IStartupManager>();
builder.RegisterType <ShutdownManager>()
.As <IShutdownManager>();
builder.RegisterType <InputValidator>()
.As <IInputValidator>()
.SingleInstance()
.WithParameter(TypedParameter.From(_settings.CurrentValue.MaxPayloadSizeBytes));
builder.Register(ctx => new ClientDictionaryBlob(
AzureBlobStorage.Create(
_settings.ConnectionString(x => x.Db.DataConnString)),
new ClientKeysToBlobKeys(
AzureTableStorage <ClientKeysToBlobKeyEntity> .Create(
_settings.ConnectionString(x => x.Db.DataConnString),
ClientKeysToBlobKeys.TableName,
_log))))
.As <IClientDictionary>()
.SingleInstance();
builder.Populate(_services);
}
private void RegisterRepositories(ContainerBuilder builder)
{
builder.Register(container => new ChatPublisherSettingsRepository(
AzureTableStorage <ChatPublisherSettingsEntity>
.Create(_appSettings.ConnectionString(x => x.TelegramReporterService.Db.DataConnString),
"ChatPublisherSettings", container.Resolve <ILogFactory>())))
.As <IChatPublisherSettingsRepository>()
.SingleInstance();
builder.Register(container => new BalanceWarningRepository(
AzureTableStorage <BalanceWarningEntity>
.Create(_appSettings.ConnectionString(x => x.TelegramReporterService.Db.DataConnString),
"BalancesWarnings", container.Resolve <ILogFactory>())))
.As <IBalanceWarningRepository>()
.SingleInstance();
builder.Register(container => new ExternalBalanceWarningRepository(
AzureTableStorage <ExternalBalanceWarningEntity>
.Create(_appSettings.ConnectionString(x => x.TelegramReporterService.Db.DataConnString),
"ExternalBalancesWarnings", container.Resolve <ILogFactory>())))
.As <IExternalBalanceWarningRepository>()
.SingleInstance();
builder.Register(container => new ChannelRepository(
AzureTableStorage <ReportChannelEntity>
.Create(_appSettings.ConnectionString(x => x.TelegramReporterService.Db.DataConnString),
"ReportChannelSettings", container.Resolve <ILogFactory>())))
.As <IChannelRepository>()
.SingleInstance();
}
public static void BindAzureRepositories(this ContainerBuilder container, IReloadingManager <AppSettings> settings, ILog log)
{
container.RegisterInstance <IWalletCredentialsRepository>(
new WalletCredentialsRepository(AzureTableStorage <WalletCredentialsEntity> .Create(settings.ConnectionString(n => n.ReferralLinksService.Db.ClientPersonalInfoConnString), "WalletCredentials", log)));
container.RegisterInstance <IOffchainTransferRepository>(
new OffchainTransferRepository(AzureTableStorage <OffchainTransferEntity> .Create(settings.ConnectionString(n => n.ReferralLinksService.Db.OffchainConnString), "OffchainTransfers", log)));
container.RegisterInstance <IClientSettingsRepository>(
new ClientSettingsRepository(AzureTableStorage <ClientSettingsEntity> .Create(settings.ConnectionString(n => n.ReferralLinksService.Db.ClientPersonalInfoConnString), "TraderSettings", log)));
container.RegisterInstance <IOffchainEncryptedKeysRepository>(
new OffchainEncryptedKeyRepository(
AzureTableStorage <OffchainEncryptedKeyEntity> .Create(settings.ConnectionString(x => x.ReferralLinksService.Db.OffchainConnString), "OffchainEncryptedKeys", log)));
container.RegisterInstance <IOffchainRequestRepository>(
new OffchainRequestRepository(
AzureTableStorage <OffchainRequestEntity> .Create(settings.ConnectionString(x => x.ReferralLinksService.Db.OffchainConnString), "OffchainRequests", log)));
container.RegisterInstance <IReferralLinkRepository>(
new ReferralLinkRepository(AzureTableStorage <ReferralLinkEntity> .Create(settings.ConnectionString(n => n.ReferralLinksService.Db.ReferralLinksConnString), "ReferralLinks", log)));
container.RegisterInstance <IReferralLinkClaimsRepository>(
new ReferralLinkClaimsRepository(AzureTableStorage <ReferralLinkClaimEntity> .Create(settings.ConnectionString(n => n.ReferralLinksService.Db.ReferralLinksConnString), "ReferralLinkClaims", log)));
container.RegisterInstance <IOffchainFinalizeCommandProducer>(new OffchainFinalizeCommandProducer(AzureQueueExt.Create(settings.ConnectionString(x => x.ReferralLinksService.Db.BitCoinQueueConnectionString), "offchain-finalization")));
}
private static async Task <IEnumerable <(IBalanceReader balanceReader, string address)> > GetPrivateWalletAddresses(string clientId,
ILogFactory logFactory,
IReloadingManager <ToolSettings> settings,
IEnumerable <IBalanceReader> balanceReaders)
{
if (string.IsNullOrEmpty(settings.CurrentValue.Db.ClientPersonalInfoConnString))
{
throw new ArgumentNullException(nameof(ToolSettings.Db.ClientPersonalInfoConnString));
}
var privateWalletsRepo = new PrivateWalletsRepository(
AzureTableStorage <PrivateWalletEntity> .Create(
settings.ConnectionString(x => x.Db.ClientPersonalInfoConnString),
"PrivateWallets", logFactory));
var walletCredentialsRepo = new WalletCredentialsRepository(
AzureTableStorage <WalletCredentialsEntity> .Create(
settings.ConnectionString(x => x.Db.ClientPersonalInfoConnString),
"WalletCredentials", logFactory));
var wallets = (await privateWalletsRepo.GetAllPrivateWallets(clientId,
await walletCredentialsRepo.GetAsync(clientId))).ToList();
var result = new List <(IBalanceReader balanceReader, string address)>();
foreach (var balanceReader in balanceReaders)
{
var addr = wallets.SelectMany(balanceReader.GetAddresses);
result.AddRange(addr.Select(p => (balanceReader, p)));
}
return(result);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType <HealthService>()
.As <IHealthService>()
.SingleInstance();
builder.RegisterType <StartupManager>()
.As <IStartupManager>();
builder.RegisterType <ShutdownManager>()
.As <IShutdownManager>();
builder.RegisterType <CallbackService>()
.As <ICallbackService>()
.SingleInstance();
builder.Register(c => new PaymentCallbackRepository(
AzureTableStorage <PaymentCallbackEntity> .Create(
_settings.ConnectionString(x => x.Db.DataConnString),
"PaymentCallbacks", c.Resolve <ILogFactory>())))
.As <IPaymentCallbackRepository>()
.SingleInstance();
builder.RegisterType <PaymentRequestSubscriber>()
.AsSelf()
.As <IStartable>()
.As <IStopable>()
.AutoActivate()
.SingleInstance()
.WithParameter(TypedParameter.From(_settings.CurrentValue.Rabbit));
RegisterInvoiceConfirmation(builder);
builder.Populate(_services);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterInstance(_log)
.As <ILog>()
.SingleInstance();
builder.RegisterType <TweetsManager>()
.As <ITweetsManager>();
builder.RegisterInstance <ITweetsCashRepository>(
new TweetsCashRepository(
AzureTableStorage <TweetCash> .Create(_settings.ConnectionString(x => x.Db.RepoConnectionString), "TweetsCash",
_log)));
builder.RegisterInstance <ITwitterAppAccountRepository>(
new TwitterAppAccountRepository(
AzureTableStorage <TwitterAppAccount> .Create(_settings.ConnectionString(x => x.Db.RepoConnectionString), "TwitterAppAccount",
_log)));
builder.RegisterType <HealthService>()
.As <IHealthService>()
.SingleInstance();
builder.RegisterInstance(_settings.CurrentValue.TwitterSettings);
builder.Populate(_services);
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(ctx =>
new LimitsRepository(AzureTableStorage <LimitEntity> .Create(
_appSettings.ConnectionString(x => x.TierService.Db.DataConnString),
"IndividualLimits", ctx.Resolve <ILogFactory>()))
).As <ILimitsRepository>().SingleInstance();
builder.Register(ctx =>
new LimitsReachedRepository(AzureTableStorage <LimitReachedEntity> .Create(
_appSettings.ConnectionString(x => x.TierService.Db.DataConnString),
"LimitsReached", ctx.Resolve <ILogFactory>()))
).As <ILimitsReachedRepository>().SingleInstance();
builder.Register(ctx =>
new TierUpgradeRequestsRepository(AzureTableStorage <TierUpgradeRequestEntity> .Create(
_appSettings.ConnectionString(x => x.TierService.Db.DataConnString),
"TierUpgradeRequests", ctx.Resolve <ILogFactory>()),
AzureTableStorage <AzureIndex> .Create(
_appSettings.ConnectionString(x => x.TierService.Db.DataConnString),
"TierUpgradeRequests", ctx.Resolve <ILogFactory>()))
).As <ITierUpgradeRequestsRepository>().SingleInstance();
builder.Register(ctx =>
new AuditLogRepository(AzureTableStorage <AuditLogDataEntity> .Create(
_appSettings.ConnectionString(x => x.TierService.Db.ClientPersonalInfoConnString),
"AuditLogs", ctx.Resolve <ILogFactory>()))
).As <IAuditLogRepository>().SingleInstance();
builder.Register(ctx =>
new ClientDepositsRepository(AzureTableStorage <DepositOperationEntity> .Create(
_appSettings.ConnectionString(x => x.TierService.Db.DataConnString),
"ClientDeposits", ctx.Resolve <ILogFactory>()))
).As <IClientDepositsRepository>().SingleInstance();
builder.Register(ctx =>
new QuestionsRepository(AzureTableStorage <QuestionEntity> .Create(
_appSettings.ConnectionString(x => x.TierService.Db.DataConnString),
"Questions", ctx.Resolve <ILogFactory>()))
).As <IQuestionsRepository>().SingleInstance();
builder.Register(ctx =>
new AnswersRepository(AzureTableStorage <AnswerEntity> .Create(
_appSettings.ConnectionString(x => x.TierService.Db.DataConnString),
"Answers", ctx.Resolve <ILogFactory>()))
).As <IAnswersRepository>().SingleInstance();
builder.Register(ctx =>
new UserChoicesRepository(AzureTableStorage <UserChoiceEntity> .Create(
_appSettings.ConnectionString(x => x.TierService.Db.DataConnString),
"QuestionnaireChoices", ctx.Resolve <ILogFactory>()))
).As <IUserChoicesRepository>().SingleInstance();
builder.Register(ctx =>
new QuestionsRankRepository(AzureTableStorage <QuestionRankEntity> .Create(
_appSettings.ConnectionString(x => x.TierService.Db.DataConnString),
"QuestionnaireRanks", ctx.Resolve <ILogFactory>()))
).As <IQuestionsRankRepository>().SingleInstance();
}
private static void RegisterAzureRepositories(ContainerBuilder container, IReloadingManager <DbSettings> dbSettings, ILog log)
{
container.RegisterInstance <IMarketDataRepository>(
new MarketDataRepository(
AzureTableStorage <MarketDataEntity> .Create(dbSettings.ConnectionString(s => s.DataConnString), "MarketsData", log)));
container.RegisterInstance <ITradesCommonRepository>(
new TradesCommonRepository(
AzureTableStorage <TradeCommonEntity> .Create(dbSettings.ConnectionString(s => s.DataConnString), "TradesCommon", log)));
}
protected override void Load(ContainerBuilder builder)
{
// Do not register entire settings in container, pass necessary settings to services which requires them
var mapperProvider = new MapperProvider();
IMapper mapper = mapperProvider.GetMapper();
builder.RegisterInstance(mapper).As <IMapper>();
builder.RegisterAssetsClient(_appSettings.CurrentValue.AssetService);
builder.RegisterType <CachedAssetsService>()
.As <ICachedAssetsService>()
.SingleInstance()
.WithParameter("assetPairsSettings", _appSettings.CurrentValue.PayVolatilityService.AssetPairs);;
builder.Register(c =>
new CandlesRepository(AzureTableStorage <CandleEntity> .Create(
_appSettings.ConnectionString(x => x.PayVolatilityService.Db.DataConnString),
_appSettings.CurrentValue.PayVolatilityService.Db.CandlesTableName,
c.Resolve <ILogFactory>())))
.As <ICandlesRepository>()
.SingleInstance();
builder.Register(c =>
new VolatilityRepository(AzureTableStorage <VolatilityEntity> .Create(
_appSettings.ConnectionString(x => x.PayVolatilityService.Db.DataConnString),
_appSettings.CurrentValue.PayVolatilityService.Db.VolatilityTableName,
c.Resolve <ILogFactory>())))
.As <IVolatilityRepository>()
.SingleInstance();
builder.RegisterType <TickPricesSubscriber>()
.As <IStartable>()
.As <IStopable>()
.AutoActivate()
.SingleInstance()
.WithParameter("settings", _appSettings.CurrentValue.PayVolatilityService.TickPricesSubscriber)
.WithParameter("assetPairsSettings", _appSettings.CurrentValue.PayVolatilityService.AssetPairs);
builder.RegisterType <VolatilityCalculator>()
.As <IStartable>()
.As <IStopable>()
.AutoActivate()
.SingleInstance()
.WithParameter("assetPairsSettings", _appSettings.CurrentValue.PayVolatilityService.AssetPairs);
builder.RegisterType <VolatilityService>()
.As <IVolatilityService>()
.SingleInstance();
builder.RegisterInstance(_appSettings.CurrentValue.PayVolatilityService.VolatilityService)
.AsSelf()
.SingleInstance();
}
protected override void Load(
ContainerBuilder builder)
{
builder
.UseAITelemetryConsumer()
.UseRootstock
(
_appSettings.ConnectionString(x => x.Job.Db.DataConnString),
_appSettings.Nested(x => x.Job.ConfirmationLevel),
_appSettings.ConnectionString(x => x.Job.GasPriceRange),
_appSettings.CurrentValue.Job.IsMainNet
);
}
private void RegisterRepositories(ContainerBuilder builder)
{
builder.Register(ctx => AzureBlobStorage.Create(_appSettings.ConnectionString(s => s.LimitationsSettings.BlobStorageConnectionString))).SingleInstance();
builder.Register(ctx => AzureTableStorage <SwiftTransferLimitationEntity> .Create(_appSettings.ConnectionString(s => s.LimitationsSettings.LimitationSettingsConnectionString), "SwiftTransferLimitations", ctx.Resolve <ILogFactory>())).SingleInstance();
builder.Register(ctx => AzureTableStorage <ApiCallHistoryRecord> .Create(_appSettings.ConnectionString(x => x.LimitationsSettings.Log.ConnectionString), "ApiSuccessfulCalls", ctx.Resolve <ILogFactory>())).SingleInstance();
builder.Register(ctx => AzureTableStorage <AppGlobalSettingsEntity> .Create(_appSettings.ConnectionString(x => x.LimitationsSettings.GlobalSettingsConnString), "Setup", ctx.Resolve <ILogFactory>())).SingleInstance();
builder.RegisterType <CashOperationsStateRepository>().As <ICashOperationsRepository>().SingleInstance();
builder.RegisterType <CashTransfersStateRepository>().As <ICashTransfersRepository>().SingleInstance();
builder.RegisterType <SwiftTransferLimitationsRepository>().As <ISwiftTransferLimitationsRepository>().SingleInstance();
builder.RegisterType <CallTimeLimitsRepository>().As <ICallTimeLimitsRepository>().SingleInstance();
builder.RegisterType <LimitSettingsRepository>().As <ILimitSettingsRepository>().SingleInstance();
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(c =>
BlockchainSettingsRepository.CreateRepository(_settings.ConnectionString(x => x.BlockchainSettingsService.Db.DataConnectionString),
c.Resolve <ILogFactory>()))
.As <IBlockchainSettingsRepository>()
.SingleInstance();
builder.Register(c =>
BlockchainExplorersRepository.CreateRepository(_settings.ConnectionString(x => x.BlockchainSettingsService.Db.DataConnectionString),
c.Resolve <ILogFactory>()))
.As <IBlockchainExplorersRepository>()
.SingleInstance();
}
private void RegisterRepositories(ContainerBuilder builder)
{
builder.RegisterInstance <ICashOperationsRepository>(
new CashOperationsRepository(
AzureTableStorage <CashInOutOperationEntity> .Create(_settings.ConnectionString(x => x.OperationsCacheJob.Db.CashOperationsConnString), "OperationsCash", _log),
AzureTableStorage <AzureIndex> .Create(_settings.ConnectionString(x => x.OperationsCacheJob.Db.CashOperationsConnString), "OperationsCash", _log)));
builder.RegisterInstance <IClientTradesRepository>(
new ClientTradesRepository(
AzureTableStorage <ClientTradeEntity> .Create(_settings.ConnectionString(x => x.OperationsCacheJob.Db.ClientTradesConnString), "Trades", _log)));
builder.RegisterInstance <ITransferEventsRepository>(
new TransferEventsRepository(
AzureTableStorage <TransferEventEntity> .Create(_settings.ConnectionString(x => x.OperationsCacheJob.Db.TransferConnString), "Transfers", _log),
AzureTableStorage <AzureIndex> .Create(_settings.ConnectionString(x => x.OperationsCacheJob.Db.TransferConnString), "Transfers", _log)));
builder.RegisterInstance <ICashOutAttemptRepository>(
new CashOutAttemptRepository(
AzureTableStorage <CashOutAttemptEntity> .Create(_settings.ConnectionString(x => x.OperationsCacheJob.Db.CashOutAttemptConnString), "CashOutAttempt", _log)));
builder.RegisterInstance <ILimitTradeEventsRepository>(
new LimitTradeEventsRepository(
AzureTableStorage <LimitTradeEventEntity> .Create(_settings.ConnectionString(x => x.OperationsCacheJob.Db.LimitTradesConnString), "LimitTradeEvents", _log)));
builder.RegisterInstance <IWalletCredentialsRepository>(
new WalletCredentialsRepository(
AzureTableStorage <WalletCredentialsEntity> .Create(_settings.ConnectionString(x => x.OperationsCacheJob.Db.ClientPersonalInfoConnString),
"WalletCredentials", _log)));
builder.RegisterInstance <IMarketOrdersRepository>(
new MarketOrdersRepository(AzureTableStorage <MarketOrderEntity> .Create(_settings.ConnectionString(x => x.OperationsCacheJob.Db.MarketOrdersConnString),
"MarketOrders", _log)));
}
protected override void Load(ContainerBuilder builder)
{
// Do not register entire settings in container, pass necessary settings to services which requires them
var mapperProvider = new MapperProvider();
IMapper mapper = mapperProvider.GetMapper();
builder.RegisterInstance(mapper).As <IMapper>();
builder.Register(c =>
new HistoryOperationRepository(
AzureTableStorage <HistoryOperationEntity> .Create(
_appSettings.ConnectionString(x => x.PayHistoryService.Db.DataConnString),
_appSettings.CurrentValue.PayHistoryService.Db.OrderedOperationsTableName,
c.Resolve <ILogFactory>()),
AzureTableStorage <AzureIndex> .Create(
_appSettings.ConnectionString(x => x.PayHistoryService.Db.DataConnString),
_appSettings.CurrentValue.PayHistoryService.Db.OrderedOperationsTableName,
c.Resolve <ILogFactory>()),
AzureTableStorage <AzureIndex> .Create(
_appSettings.ConnectionString(x => x.PayHistoryService.Db.DataConnString),
_appSettings.CurrentValue.PayHistoryService.Db.OrderedOperationsTableName,
c.Resolve <ILogFactory>())))
.As <IHistoryOperationRepository>()
.SingleInstance();
builder.Register(c =>
new MigrationToNewIndexes(
AzureTableStorage <OldHistoryOperationEntity> .Create(
_appSettings.ConnectionString(x => x.PayHistoryService.Db.DataConnString),
_appSettings.CurrentValue.PayHistoryService.Db.OperationsTableName,
c.Resolve <ILogFactory>()),
c.Resolve <IHistoryOperationRepository>(),
c.Resolve <ILogFactory>()))
.As <IStartable>()
.AutoActivate()
.SingleInstance();
builder.RegisterType <HistoryOperationService>()
.As <IHistoryOperationService>()
.SingleInstance();
builder.RegisterType <HistoryOperationSubscruber>()
.As <IStartable>()
.As <IStopable>()
.AutoActivate()
.SingleInstance()
.WithParameter("settings", _appSettings.CurrentValue.PayHistoryService.Rabbit);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterInstance(_log);
builder.RegisterInstance(_settings);
builder.RegisterInstance(new RpcConnectionParams(_settings));
builder.BindCommonServices();
builder.BindAzure(_dbSettingsManager, _log);
builder.BindMongo(_dbSettingsManager.ConnectionString(x => x.MongoDataConnString).CurrentValue);
builder.AddTriggers(pool =>
{
pool.AddDefaultConnection(_dbSettingsManager.ConnectionString(x => x.DataConnString));
});
}
private void RegisterRepositories(ContainerBuilder builder)
{
builder.RegisterInstance <IWithdrawLimitsRepository>(
new WithdrawLimitsRepository(
AzureTableStorage <WithdrawLimitRecord> .Create(_settings.ConnectionString(x => x.Db.ClientPersonalInfoConnString), "WithdrawLimits", _log),
_settings.CurrentValue.DefaultWithdrawalLimit));
builder.RegisterInstance <ICashoutAttemptRepository>(
new CashoutAttemptRepository(
AzureTableStorage <CashoutAttemptEntity> .Create(_settings.ConnectionString(x => x.Db.BalancesInfoConnString), "CashOutAttempt", _log)));
builder.RegisterInstance <ICashoutRequestLogRepository>(
new CashoutRequestLogRepository(
AzureTableStorage <CashoutRequestLogRecord> .Create(_settings.ConnectionString(x => x.Db.BalancesInfoConnString), "CashOutAttemptLog", _log)));
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterInstance(_log)
.As <ILog>()
.SingleInstance();
builder.RegisterType <HealthService>()
.As <IHealthService>()
.SingleInstance();
builder.RegisterType <StartupManager>()
.As <IStartupManager>()
.SingleInstance();
builder.RegisterType <ShutdownManager>()
.As <IShutdownManager>()
.SingleInstance();
builder.Register(c => new RedisCache(new RedisCacheOptions
{
Configuration = _settings.CurrentValue.CacheSettings.RedisConfiguration,
InstanceName = $"{_settings.CurrentValue.CacheSettings.InstanceName}:"
}))
.As <IDistributedCache>()
.SingleInstance();
builder.RegisterType <GaUserService>()
.As <IGaUserService>()
.SingleInstance();
builder.RegisterType <GaTrackerService>()
.As <IGaTrackerService>()
.WithParameter(TypedParameter.From(_settings.CurrentValue.TrackAssets))
.WithParameter(TypedParameter.From(_settings.CurrentValue.GaSettings))
.WithParameter(TypedParameter.From(_settings.CurrentValue.IsLive))
.WithParameter(TypedParameter.From(_settings.CurrentValue.TransactionAssetId))
.SingleInstance();
builder.RegisterInstance(
new GaUserRepository(AzureTableStorage <GaUserEntity> .Create(_settings.ConnectionString(x => x.Db.DataConnString), "TrackerUsers", _log))
).As <IGaUserRepository>().SingleInstance();
builder.RegisterInstance(
new GaTrafficRepository(AzureTableStorage <GaTrafficEntity> .Create(_settings.ConnectionString(x => x.Db.DataConnString), "GaUsersTraffic", _log))
).As <IGaTrafficRepository>().SingleInstance();
builder.RegisterRateCalculatorClient(_allSettings.CurrentValue.RateCalculatorServiceClient.ServiceUrl, _log);
}
protected override void Load(ContainerBuilder builder)
{
// TODO: Do not register entire settings in container, pass necessary settings to services which requires them
// ex:
// builder.RegisterType<QuotesPublisher>()
// .As<IQuotesPublisher>()
// .WithParameter(TypedParameter.From(_settings.CurrentValue.QuotesPublication))
builder.RegisterInstance(_log)
.As<ILog>()
.SingleInstance();
builder.RegisterType<HealthService>()
.As<IHealthService>()
.SingleInstance();
builder.RegisterType<StartupManager>()
.As<IStartupManager>();
builder.RegisterType<ShutdownManager>()
.As<IShutdownManager>();
// TODO: Add your dependencies here
builder.RegisterEmailSenderViaAzureQueueMessageProducer(_settings.ConnectionString(x => x.Db.ClientReminderConnString));
builder.RegisterInstance<IKycDocumentsServiceV2>(new KycDocumentsServiceV2Client(_appSettings.CurrentValue.KycServiceClient, _log)).SingleInstance();
builder.RegisterInstance<IPersonalDataService>(new PersonalDataService(_appSettings.CurrentValue.PersonalDataServiceClient, _log)).SingleInstance();
builder.RegisterInstance<IClientAccountClient>(new ClientAccountClient(_appSettings.CurrentValue.ClientAccountServiceClient.ServiceUrl)).SingleInstance();
builder.AddTriggers(
pool =>
{
pool.AddDefaultConnection(_settings.CurrentValue.Db.ClientReminderConnString);
});
builder.RegisterType<ClientReminderTimerDrivenEntryPoint>()
.As<IStartable>();
builder.RegisterInstance<IClientReminderRepository>(
new ClientReminderRepository(
AzureTableStorage<ClientReminderEntity>.Create(_settings.ConnectionString(x => x.Db.ClientReminderConnString), "KycRemindersNewClient", _log)));
builder.RegisterType<ClientReminderService>()
.As<IClientReminderService>();
builder.Populate(_services);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterInstance(_log)
.As <ILog>()
.SingleInstance();
builder.RegisterType <HealthService>()
.As <IHealthService>()
.SingleInstance();
builder.RegisterType <StartupManager>()
.As <IStartupManager>();
builder.RegisterType <ShutdownManager>()
.As <IShutdownManager>();
builder.RegisterIcoCommonClient(_settings.CommonServiceUrl, _log);
builder.RegisterType <SettingsRepository>()
.As <ISettingsRepository>()
.WithParameter(TypedParameter.From(_dbSettingsManager.ConnectionString(x => x.DataConnString)))
.WithParameter(TypedParameter.From(_settings.InstanceId));
builder.RegisterType <BlockchainReader>()
.As <IBlockchainReader>()
.WithParameter(TypedParameter.From(_settings.Tracking.BtcUrl));
builder.RegisterType <TransactionTrackingService>()
.As <ITransactionTrackingService>()
.WithParameter(TypedParameter.From(_settings.Tracking));
RegisterPeriodicalHandlers(builder);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType <HealthService>()
.As <IHealthService>()
.SingleInstance();
builder.RegisterType <StartupManager>()
.As <IStartupManager>();
builder.RegisterType <ShutdownManager>()
.As <IShutdownManager>();
builder.RegisterType <KeyStoreService>()
.As <IKeysStoreService>()
.SingleInstance();
builder.RegisterType <SignService>()
.As <ISignService>()
.SingleInstance();
builder.RegisterType <CallbackStubService>()
.As <ICallbackStubService>()
.SingleInstance();
builder.Register(c => new CallbackDataRepository(
AzureTableStorage <CallbackDataEntity> .Create(_settings.ConnectionString(x => x.Db.DataConnString),
"CallbackData", c.Resolve <ILogFactory>())))
.As <ICallbackDataRepository>()
.SingleInstance();
builder.Populate(_services);
}
protected override void Load(
ContainerBuilder builder)
{
var logFactory = LogFactory.Create().AddConsole();
builder
.RegisterInstance(logFactory)
.As <ILogFactory>();
builder
.RegisterType <MeLogReader>()
.WithParameter(TypedParameter.From(_meLogsFolderPath))
.SingleInstance()
.AsSelf();
builder
.Register(ctx => BalanceUpdateRepository.Create(
_neoGasDistributorSettings.ConnectionString(x => x.NeoGasDistributor.Db.DataConnString),
ctx.Resolve <ILogFactory>()
))
.As <IBalanceUpdateRepository>()
.SingleInstance();
builder
.Register(ctx => new BalanceUpdateImporter
(
_neoGasDistributorSettings.CurrentValue.NeoGasDistributor.NeoAssetId,
ctx.Resolve <IBalanceUpdateRepository>(),
ctx.Resolve <ILogFactory>(),
ctx.Resolve <MeLogReader>()
));
}
protected override void Load(ContainerBuilder builder)
{
var reloadingDbManager = _settings.ConnectionString(x => x.AlgoApi.Db.TableStorageConnectionString);
builder.Register(c => new GenericRepository <WalletEntity, IWallet>(
AzureTableStorage <WalletEntity> .Create(reloadingDbManager, "Wallets", _log), "Wallet"))
.As <IDictionaryRepository <IWallet> >();
builder.Register(c => new GenericRepository <AccountEntity, IAccount>(
AzureTableStorage <AccountEntity> .Create(reloadingDbManager, "Accounts", _log), "ClientBalance"))
.As <IDictionaryRepository <IAccount> >();
builder.Register(c => new GenericRepository <OperationsEntity, IOperations>(
AzureTableStorage <OperationsEntity> .Create(reloadingDbManager, "Operations", _log), "Operations"))
.As <IDictionaryRepository <IOperations> >();
builder.Register(c => new GenericRepository <OperationDetailsEntity, IOperationDetails>(
AzureTableStorage <OperationDetailsEntity> .Create(reloadingDbManager, "OperationDetailsInformation", _log)))
.As <IDictionaryRepository <IOperationDetails> >();
builder.Register(c => new GenericRepository <PersonalDataEntity, IPersonalData>(
AzureTableStorage <PersonalDataEntity> .Create(reloadingDbManager, "PersonalData", _log), "PD"))
.As <IDictionaryRepository <IPersonalData> >();
builder.Register(c => new GenericRepository <TradersEntity, ITrader>(
AzureTableStorage <TradersEntity> .Create(reloadingDbManager, "Traders", _log)))
.As <IDictionaryRepository <ITrader> >();
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterInstance(_log)
.As <ILog>()
.SingleInstance();
builder.RegisterType <HealthService>()
.As <IHealthService>()
.SingleInstance();
builder.RegisterType <StartupManager>()
.As <IStartupManager>();
builder.RegisterType <ShutdownManager>()
.As <IShutdownManager>();
var proxyUserRepository = new ChainalysisProxyUserRepository(
AzureTableStorage <ProxyUser> .Create(_dbSettings.ConnectionString(x => x.DataConnString),
"ProxyUser", _log));
builder.RegisterInstance <IChainalysisProxyUserRepository>(proxyUserRepository).SingleInstance();
var riskApiClient = new ChainalysisMockClient(_settings.Nested(x => x.Services.CainalisysUrl).CurrentValue);
var chaialysisProxyService = new ChainalysisProxyService(proxyUserRepository, riskApiClient, _settings.Nested(x => x.Services).CurrentValue);
builder.RegisterInstance <IChainalysisProxyService>(chaialysisProxyService)
.SingleInstance();
builder.Populate(_services);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType <TotalBalancesService>()
.WithParameter(TypedParameter.From($"{_appSettings.CurrentValue.BalancesService.BalanceCache.Instance}:total"))
.As <ITotalBalancesService>();
builder.RegisterType <CachedWalletsRepository>()
.WithParameter(TypedParameter.From(_appSettings.CurrentValue.BalancesService.BalanceCache.Expiration))
.WithParameter(TypedParameter.From($"{_appSettings.CurrentValue.BalancesService.BalanceCache.Instance}:balances"))
.As <ICachedWalletsRepository>();
builder.Register(ctx =>
new WalletsRepository(AzureTableStorage <WalletEntity> .Create(
_dbSettings.ConnectionString(x => x.BalancesConnString), "Balances", ctx.Resolve <ILogFactory>()))
).As <IWalletsRepository>().SingleInstance();
builder.RegisterType <BalanceUpdateRabbitSubscriber>()
.As <IStartable>()
.AutoActivate()
.SingleInstance()
.WithParameter(TypedParameter.From(_appSettings.CurrentValue.BalancesService.MatchingEngineRabbit));
builder.RegisterType <ClientAuthenticatedRabbitSubscriber>()
.As <IStartable>()
.AutoActivate()
.SingleInstance()
.WithParameter(TypedParameter.From(_appSettings.CurrentValue.BalancesService.AuthRabbit));
}
protected override void Load(ContainerBuilder builder)
{
var settings = _appSettings.CurrentValue.BitstampAdapterService;
builder.RegisterInstance(settings).AsSelf();
builder.RegisterType <OrderbookPublishingService>()
.As <IHostedService>()
.AsSelf()
.WithParameter(new TypedParameter(typeof(OrderbookSettings), settings.Orderbooks))
.WithParameter(new TypedParameter(typeof(RabbitMqSettings), settings.RabbitMq))
.WithParameter(new TypedParameter(typeof(InstrumentSettings), settings.Instruments))
.SingleInstance();
builder.Register(ctx =>
AzureTableStorage <LimitOrderEntity> .Create(
_appSettings.ConnectionString(x => x.BitstampAdapterService.Db.OrdersConnString),
"BitstampLimitOrders",
ctx.Resolve <ILogFactory>()))
.As <INoSQLTableStorage <LimitOrderEntity> >()
.SingleInstance();
builder.RegisterType <LimitOrderRepository>()
.SingleInstance()
.AsSelf();
builder.RegisterType <HttpClientFactory>()
.SingleInstance()
.AsSelf();
}
