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(); }