/// <summary>
/// Registers <see cref="IEmailSender"/> that point to Azure queue
/// </summary>
/// <param name="container"></param>
/// <param name="connectionString">Queue connection string</param>
/// <param name="queueName">Queue name</param>
public static void RegisterEmailSenderViaAzureQueueMessageProducer(this ContainerBuilder container, IReloadingManager <string> connectionString, string queueName = "emailsqueue")
{
var messageProducer = new EmailMessageQueueProducer(AzureQueueExt.Create(connectionString, queueName));
var emailSender = new EmailSender(messageProducer);
container.RegisterInstance <IEmailSender>(emailSender);
}
public static IServiceProvider BindAndBuild(IConfigurationRoot configuration)
{
var collection = new ServiceCollection();
collection.AddTransient <Job>();
collection.AddTransient <Func <string, IQueueExt> >(x => queueName => AzureQueueExt.Create(new FakeReloadingManager(configuration.GetConnectionString("azure")), queueName));
collection.AddSingleton <IBlobStorage>(AzureBlobStorage.Create(new FakeReloadingManager(configuration.GetConnectionString("azure"))));
var mongoClient = new MongoClient(configuration.GetConnectionString("mongo"));
collection.AddSingleton <ISpentOutputRepository>(new SpentOutputRepository(new MongoStorage <OutputEntity>(mongoClient, "SpentOutputs")));
collection.AddSingleton <IBroadcastedOutputRepository>(
new BroadcastedOutputRepository(new MongoStorage <BroadcastedOutputEntity>(mongoClient, "BroadcastedOutputs")));
collection.AddSingleton <IBroadcastedTransactionRepository>(
new BroadcastedTransactionRepository(new MongoStorage <BroadcastedTransactionEntity>(mongoClient, "BroadcastedTransactions")));
collection.AddSingleton <IPaidFeesTaskWriter, PaidFeesTaskWriter>();
collection.AddSingleton <IPaidFeesRepository>(
new PaidFeesRepository(new MongoStorage <PaidFeesEntity>(mongoClient, "PaidFees")));
collection.AddSingleton <ITransactionSignRequestRepository>(
new TransactionSignRequestRepository(new MongoStorage <TransactionSignRequestEntity>(mongoClient, "SignRequests")));
collection.AddSingleton <IConfiguration>(configuration);
return(collection.BuildServiceProvider());
}
private void RegistermSmsServices(ContainerBuilder builder)
{
var smsQueue = new AzureQueueExt(_settings.Db.ClientPersonalInfoConnString, "smsqueue");
var smsQueueReader = new QueueReader(smsQueue, "SmsQueueReader", 3000, _log);
builder.Register <IQueueReader>(x => smsQueueReader).SingleInstance();
builder.RegisterType <TemplateGenerator>().As <ITemplateGenerator>();
builder.RegisterType <SmsTextGenerator>().As <ISmsTextGenerator>().SingleInstance();
if (_settings.Sms.UseMocks)
{
builder.RegisterType <SmsMockSender>().As <ISmsSender>().SingleInstance();
builder.RegisterType <AlternativeSmsMockSender>().As <IAlternativeSmsSender>().SingleInstance();
}
else
{
builder.RegisterInstance(_settings.Sms.Nexmo)
.SingleInstance();
builder.RegisterType <NexmoSmsSender>().As <ISmsSender>().SingleInstance();
builder.RegisterInstance(_settings.Sms.Twilio)
.SingleInstance();
builder.RegisterType <TwilioSmsSender>().As <IAlternativeSmsSender>().SingleInstance();
}
}
private void RegisterEmailServices(ContainerBuilder builder)
{
var emailsQueue = new AzureQueueExt(_settings.Db.ClientPersonalInfoConnString, "emailsqueue");
var internalEmailQueueReader = new QueueReader(emailsQueue, "InternalEmailQueueReader", 3000, _log);
var blockChainEmailQueue = new AzureQueueExt(_settings.Db.BitCoinQueueConnectionString, "emailsqueue");
var blockChainEmailQueueReader = new QueueReader(blockChainEmailQueue, "BlockchainEmailQueueReader", 3000, _log);
var sharedEmailQueue = new AzureQueueExt(_settings.Db.SharedStorageConnString, "emailsqueue");
var sharedEmailQueueReader = new QueueReader(sharedEmailQueue, "SharedEmailQueueReader", 3000, _log);
builder.Register <IEnumerable <IQueueReader> >(x => new List <IQueueReader>
{
internalEmailQueueReader,
blockChainEmailQueueReader,
sharedEmailQueueReader
})
.SingleInstance();
builder.RegisterType <EmailGenerator>()
.As <IEmailGenerator>()
.SingleInstance()
.WithParameters(new []
{
TypedParameter.From(_settings.Email),
TypedParameter.From(_settings.Blockchain),
TypedParameter.From(_settings.WalletApi)
});
builder.RegisterType <HttpRequestClient>();
builder.RegisterType <RemoteTemplateGenerator>()
.As <IRemoteTemplateGenerator>()
.SingleInstance()
.WithParameter(TypedParameter.From(_settings.Email.EmailTemplatesHost));
builder.RegisterType <SwiftCredentialsService>().As <ISwiftCredentialsService>().SingleInstance();
SmtpClient ClientFactory()
{
var client = new SmtpClient
{
Timeout = 10000
};
client.Connect(_settings.Email.SmtpHost, _settings.Email.SmtpPort);
client.Authenticate(new NetworkCredential(_settings.Email.SmtpLogin, _settings.Email.SmtpPwd));
return(client);
}
var from = new MailboxAddress(_settings.Email.EmailFromDisplayName, _settings.Email.EmailFrom);
if (_settings.Email.UseMocks)
{
builder.RegisterType <SmtpMailSenderMock>().SingleInstance();
builder.Register(x => new SmtpMailSender(_log, ClientFactory, from, x.Resolve <IBroadcastMailsRepository>()));
builder.RegisterType <MockAndRealMailSender>().As <ISmtpEmailSender>().SingleInstance();
}
else
{
builder.Register <ISmtpEmailSender>(x => new SmtpMailSender(_log, ClientFactory, from, x.Resolve <IBroadcastMailsRepository>()));
}
}
public async Task AzureQueue_CheckParallelInsert()
{
var queue = new AzureQueueExt(_azureStorageConnectionString, _queueName);
Parallel.For(1, 11, i =>
{
queue.PutRawMessageAsync(i.ToString()).Wait();
});
Assert.AreEqual(10, await _testQueue.Count() ?? 0);
}
public static ITransactionMonitoringTaskRepository Create(
IReloadingManager <string> connectionString)
{
var queue = AzureQueueExt.Create
(
connectionStringManager: connectionString,
queueName: "transaction-monitoring-tasks",
maxExecutionTimeout: TimeSpan.FromDays(7)
);
return(new TransactionMonitoringTaskRepository(queue));
}
public static IServiceProvider BindAndBuild(IConfigurationRoot configuration)
{
var collection = new ServiceCollection();
collection.AddTransient <ReenqueueJob>();
collection.AddTransient <Func <string, IQueueExt> >(x => queueName => AzureQueueExt.Create(new FakeReloadingManager(configuration.GetConnectionString("job")), queueName));
collection.AddSingleton <IConfiguration>(configuration);
return(collection.BuildServiceProvider());
}
public static IBalanceObservationTaskRepository Create(
IReloadingManager <string> connectionString)
{
var queue = AzureQueueExt.Create
(
connectionStringManager: connectionString,
queueName: "balance-observation-tasks",
maxExecutionTimeout: TimeSpan.FromDays(7)
);
return(new BalanceObservationTaskRepository(queue));
}
public GlobalExceptionFilter(ILog log, IReloadingManager <BaseSettings> settings)
{
_log = log;
if (!string.IsNullOrEmpty(settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString))
{
_slackMessageQueue = AzureQueueExt.Create(settings.ConnectionString(x => x.SlackNotifications.AzureQueue.ConnectionString), "slack-notifications");
}
else
{
_slackMessageQueue = new QueueExtInMemory();
}
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType <HealthService>()
.As <IHealthService>()
.SingleInstance();
builder.Register(ctx => AzureQueueExt.Create(_settingsManager.ConnectionString(x => x.Db.AzureQueueConnString), "solar-transit")).As <IQueueExt>().SingleInstance();
RegisterPeriodicalHandlers(builder);
RegisterMongoDb(builder);
builder.Populate(_services);
}
public static void RegisterAzureQueues(this IServiceCollection Services,
IReloadingManager <BaseSettings> settings,
IReloadingManager <SlackNotificationSettings> slackNotificationManager)
{
var dataReloadingManager = settings.ConnectionString(x => x.Db.DataConnString);
var slackReloadManager = slackNotificationManager.ConnectionString(x => x.AzureQueue.ConnectionString);
var queueName = slackNotificationManager.CurrentValue.AzureQueue.QueueName;
Services.AddTransient <IQueueFactory, QueueFactory>();
Services.AddTransient <Func <string, IQueueExt> >(provider =>
{
return(x =>
{
switch (x)
{
case Constants.TransferContractUserAssignmentQueueName:
return AzureQueueExt.Create(dataReloadingManager, Constants.StoragePrefix + x);
case Constants.EthereumContractQueue:
return AzureQueueExt.Create(dataReloadingManager, Constants.StoragePrefix + x);
case Constants.SlackNotifierQueue:
return AzureQueueExt.Create(slackReloadManager, Constants.StoragePrefix + queueName);
case Constants.EthereumOutQueue:
return AzureQueueExt.Create(dataReloadingManager, Constants.StoragePrefix + x); //remove
case Constants.ContractTransferQueue:
return AzureQueueExt.Create(dataReloadingManager, Constants.StoragePrefix + x);
case Constants.TransactionMonitoringQueue:
return AzureQueueExt.Create(dataReloadingManager, Constants.StoragePrefix + x);
case Constants.CoinTransactionQueue:
return AzureQueueExt.Create(dataReloadingManager, Constants.StoragePrefix + x);
case Constants.UserContractManualQueue:
return AzureQueueExt.Create(dataReloadingManager, Constants.StoragePrefix + x);
default:
throw new Exception("Queue is not registered");
}
});
});
}
private static void RegisterQueues(this ContainerBuilder builder,
IReloadingManager <AppSettings> generalSettings,
ILog log)
{
builder.RegisterInstance(new AssetDefinitionParseBlockCommandProducer(AzureQueueExt.Create(generalSettings.ConnectionString(x => x.BcnExploler.Db.AssetsConnString), QueueNames.AssetDefinitionScanner.ParseBlock)))
.As <IAssetDefinitionParseBlockCommandProducer>();
builder.RegisterInstance(new AssetDefinitionCommandProducer(AzureQueueExt.Create(generalSettings.ConnectionString(x => x.BcnExploler.Db.AssetsConnString), QueueNames.AssetDefinitionScanner.RetrieveAsset)))
.As <IAssetDefinitionCommandProducer>();
builder.RegisterInstance(new AssetImageCommandProducer(AzureQueueExt.Create(generalSettings.ConnectionString(x => x.BcnExploler.Db.AssetsConnString), QueueNames.AssetDefinitionScanner.UpsertImages)))
.As <IAssetImageCommandProducer>();
builder.RegisterInstance(new AssetCoinholdersIndexesCommandProducer(AzureQueueExt.Create(generalSettings.ConnectionString(x => x.BcnExploler.Db.AssetsConnString), QueueNames.AssetIndexer.UpdateIndex)))
.As <IAssetCoinholdersIndexesCommandProducer>();
}
public static void RegisterAzureQueues(this ContainerBuilder builder,
IReloadingManager <string> dataReloadingManager,
IReloadingManager <SlackNotificationSettings> slackNotificationManager)
{
var slackReloadManager = slackNotificationManager.ConnectionString(x => x.AzureQueue.ConnectionString);
var queueName = slackNotificationManager.CurrentValue.AzureQueue.QueueName;
Func <string, IQueueExt> oldQueueResolver = (queueNameArg) =>
{
switch (queueNameArg)
{
case Constants.TransferContractUserAssignmentQueueName:
return(AzureQueueExt.Create(dataReloadingManager, Constants.StoragePrefix + queueNameArg));
case Constants.EthereumContractQueue:
return(AzureQueueExt.Create(dataReloadingManager, Constants.StoragePrefix + queueNameArg));
case Constants.SlackNotifierQueue:
return(AzureQueueExt.Create(slackReloadManager, Constants.StoragePrefix + queueName));
case Constants.EthereumOutQueue:
return(AzureQueueExt.Create(dataReloadingManager, Constants.StoragePrefix + queueNameArg)); //remove
case Constants.ContractTransferQueue:
return(AzureQueueExt.Create(dataReloadingManager, Constants.StoragePrefix + queueNameArg));
case Constants.TransactionMonitoringQueue:
return(AzureQueueExt.Create(dataReloadingManager, Constants.StoragePrefix + queueNameArg));
case Constants.CoinTransactionQueue:
return(AzureQueueExt.Create(dataReloadingManager, Constants.StoragePrefix + queueNameArg));
case Constants.UserContractManualQueue:
return(AzureQueueExt.Create(dataReloadingManager, Constants.StoragePrefix + queueNameArg));
default:
throw new Exception("Queue is not registered");
}
};
builder.RegisterType <QueueFactory>()
.As <IQueueFactory>().SingleInstance();
builder.RegisterInstance <Func <string, IQueueExt> >(oldQueueResolver);
}
private static void BindQueue(this ContainerBuilder ioc, IReloadingManager <GeneralSettings> settings)
{
var dataReloadingManager = settings.Nested(p => p.BcnReports.Db.DataConnString);
ioc.RegisterType <SlackNotificationsProducer>()
.As <ISlackNotificationsProducer>();
ioc.RegisterType <SlackNotificationsProducer>()
.As <IPoisionQueueNotifier>();
ioc.Register(p => new AddressReportCommandProducer(AzureQueueExt.Create(dataReloadingManager, QueueNames.AddressTransactionsReport)))
.As <IAddressReportCommandProducer>();
ioc.Register(p => new AssetReportCommandProducer(AzureQueueExt.Create(dataReloadingManager, QueueNames.AssetTransactionsReport)))
.As <IAssetReportCommandProducer>();
ioc.Register(p => new BlockReportCommandProducer(AzureQueueExt.Create(dataReloadingManager, QueueNames.BlockTransactionsReport)))
.As <IBlockReportCommandProducer>();
}
public static IServiceProvider BindAndBuild(IConfigurationRoot configuration)
{
var mongoClient = new MongoClient(configuration.GetConnectionString("mongo"));
var collection = new ServiceCollection();
collection.AddTransient <EnqueueFeesJob>();
collection.AddSingleton <Func <string, IQueueExt> >(x => AzureQueueExt.Create(new FakeReloadingManager(configuration.GetConnectionString("default")), x));
collection.AddSingleton <IPregeneratedOutputsQueueFactory, PregeneratedOutputsQueueFactory>();
collection.AddSingleton <IAssetRepository>(new AssetRepository(AzureTableStorage <AssetEntity> .Create(new FakeReloadingManager(configuration.GetConnectionString("dicts")), "Dictionaries", log: null)));
collection.AddSingleton <ISpentOutputRepository>(
new SpentOutputRepository(new MongoStorage <OutputEntity>(mongoClient, "SpentOutputs")));
collection.AddSingleton <IWalletAddressRepository>(
new WalletAddressRepository(new MongoStorage <WalletAddressEntity>(mongoClient, "Wallets")));
collection.AddSingleton <ISegwitPrivateWalletRepository>(
new SegwitPrivateWalletRepository(new MongoStorage <SegwitPrivateWalletEntity>(mongoClient, "SegwitWallets")));
collection.AddSingleton <IBroadcastedOutputRepository>(
new BroadcastedOutputRepository(new MongoStorage <BroadcastedOutputEntity>(mongoClient, "BroadcastedOutputs")));
collection.AddSingleton <IInternalSpentOutputRepository>(
new InternalSpentOutputRepository(new MongoStorage <InternalSpentOutput>(mongoClient, "InternalSpentOutputs")));
var network = (NetworkType)configuration.GetValue <int>("BitcoinConfig:Network");
var rpcConnectionParams = new RpcConnectionParams(new BaseSettings()
{
NetworkType = network
});
collection.AddSingleton(rpcConnectionParams);
collection.AddSingleton <Func <QBitNinjaClient> >(x =>
{
return(() => new QBitNinjaClient(configuration.GetValue <string>("BitcoinConfig:QBitNinjaBaseUrl"), rpcConnectionParams.Network));
});
collection.AddSingleton <IConfiguration>(configuration);
collection.AddTransient <IQBitNinjaApiCaller, QBitNinjaApiCaller>();
collection.AddTransient <IBitcoinOutputsService, BitcoinOutputsService>();
return(collection.BuildServiceProvider());
}
private static void BindQueue(this ContainerBuilder ioc, IReloadingManager <DbSettings> settings)
{
ioc.RegisterInstance <Func <string, IQueueExt> >(queueName =>
{
switch (queueName)
{
case Constants.EmailNotifierQueue:
return(AzureQueueExt.Create(settings.ConnectionString(x => x.SharedConnString), queueName));
default:
return(AzureQueueExt.Create(settings.ConnectionString(x => x.DataConnString), queueName));
}
});
ioc.RegisterType <PregeneratedOutputsQueueFactory>().As <IPregeneratedOutputsQueueFactory>().SingleInstance();
ioc.RegisterType <TransactionQueueWriter>().As <ITransactionQueueWriter>().SingleInstance();
ioc.RegisterType <TransactionMonitoringWriter>().As <ITransactionMonitoringWriter>().SingleInstance();
ioc.RegisterType <FeeReserveMonitoringWriter>().As <IFeeReserveMonitoringWriter>().SingleInstance();
ioc.RegisterType <ReturnOutputsMessageWriter>().As <IReturnOutputsMessageWriter>().SingleInstance();
ioc.RegisterType <SpendCommitmentMonitoringWriter>().As <ISpendCommitmentMonitoringWriter>().SingleInstance();
ioc.RegisterType <PaidFeesTaskWriter>().As <IPaidFeesTaskWriter>().SingleInstance();
ioc.RegisterType <CommitmentClosingTaskWriter>().As <ICommitmentClosingTaskWriter>().SingleInstance();
}
public IQueueReader Create(string connection, string queueName, TimeSpan queueTimeout)
{
return(new AzureQueueReader(AzureQueueExt.Create(_connectionPool.GetConnection(connection), queueName, queueTimeout)));
}
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 void BindRepositories(ContainerBuilder builder)
{
builder.RegisterInstance <IPostponedCashInRepository>(
new PostponedCashInRepository(
AzureTableStorage <PostponedCashInRecord> .Create(
_settingsManager.ConnectionString(i => i.TxDetectorJob.Db.BitCoinQueueConnectionString), "PostponedBtcCashIns", _log)));
builder.RegisterInstance <IConfirmedTransactionsRepository>(
new ConfirmedTransactionsRepository(
AzureTableStorage <ConfirmedTransactionRecord> .Create(
_settingsManager.ConnectionString(i => i.TxDetectorJob.Db.BitCoinQueueConnectionString), "ConfirmedTransactions", _log)));
builder.RegisterInstance <IBitcoinCashinRepository>(
new BitcoinCashinRepository(
AzureTableStorage <BitcoinCashinEntity> .Create(
_settingsManager.ConnectionString(i => i.TxDetectorJob.Db.BitCoinQueueConnectionString), "BitcoinCashin", _log)));
builder.RegisterInstance <IBalanceChangeTransactionsRepository>(
new BalanceChangeTransactionsRepository(
AzureTableStorage <BalanceChangeTransactionEntity> .Create(
_settingsManager.ConnectionString(i => i.TxDetectorJob.Db.BitCoinQueueConnectionString), "BalanceChangeTransactions", _log)));
builder.RegisterInstance <ILastProcessedBlockRepository>(
new LastProcessedBlockRepository(
AzureTableStorage <LastProcessedBlockEntity> .Create(
_settingsManager.ConnectionString(i => i.TxDetectorJob.Db.BitCoinQueueConnectionString), "LastProcessedBlocks", _log)));
builder.RegisterInstance <IInternalOperationsRepository>(
new InternalOperationsRepository(
AzureTableStorage <InternalOperationEntity> .Create(
_settingsManager.ConnectionString(i => i.TxDetectorJob.Db.BitCoinQueueConnectionString), "InternalOperations", _log)));
builder.RegisterInstance <IWalletCredentialsRepository>(
new WalletCredentialsRepository(
AzureTableStorage <WalletCredentialsEntity> .Create(
_settingsManager.ConnectionString(i => i.TxDetectorJob.Db.ClientPersonalInfoConnString), "WalletCredentials", _log)));
builder.RegisterInstance <IBcnClientCredentialsRepository>(
new BcnClientCredentialsRepository(
AzureTableStorage <BcnCredentialsRecordEntity> .Create(_settingsManager.ConnectionString(i => i.TxDetectorJob.Db.ClientPersonalInfoConnString),
"BcnClientCredentials", _log)));
builder.RegisterInstance <IAppGlobalSettingsRepositry>(
new AppGlobalSettingsRepository(
AzureTableStorage <AppGlobalSettingsEntity> .Create(
_settingsManager.ConnectionString(i => i.TxDetectorJob.Db.ClientPersonalInfoConnString), "Setup", _log)));
builder.RegisterInstance <IEmailCommandProducer>(
new EmailCommandProducer(
AzureQueueExt.Create(
_settingsManager.ConnectionString(i => i.TxDetectorJob.Db.ClientPersonalInfoConnString), "emailsqueue")));
builder.RegisterInstance <IPaymentTransactionEventsLog>(
new PaymentTransactionEventsLog(
AzureTableStorage <PaymentTransactionLogEventEntity> .Create(
_settingsManager.ConnectionString(i => i.TxDetectorJob.Db.LogsConnString), "PaymentsLog", _log)));
builder.RegisterInstance <IPaymentTransactionsRepository>(
new PaymentTransactionsRepository(
AzureTableStorage <PaymentTransactionEntity> .Create(
_settingsManager.ConnectionString(i => i.TxDetectorJob.Db.ClientPersonalInfoConnString), "PaymentTransactions", _log),
AzureTableStorage <AzureMultiIndex> .Create(
_settingsManager.ConnectionString(i => i.TxDetectorJob.Db.ClientPersonalInfoConnString), "PaymentTransactions", _log)));
}
public void TestInit()
{
_testQueue = new AzureQueueExt(_azureStorageConnectionString, _queueName);
}
protected override void Load(ContainerBuilder builder)
{
builder.Register <ISmsCommandProducer>(y =>
new SmsCommandProducer(AzureQueueExt.Create(
_smsNotificationsSettings.ConnectionString(x => x.AzureQueue.ConnectionString),
_smsNotificationsSettings.CurrentValue.AzureQueue.QueueName)));
builder.RegisterType <VerificationCodesFactory>().AsImplementedInterfaces().SingleInstance();
builder.RegisterType <RandomValueGenerator>().AsImplementedInterfaces().SingleInstance();
builder.RegisterType <DateTimeProvider>().AsImplementedInterfaces().SingleInstance();
builder.Register(x =>
AzureTableStorage <SmsVerificationCodeEntity> .Create(_personalDataConnString,
TableNameSmsVerificationCodes, x.Resolve <ILogFactory>()
)).AsImplementedInterfaces().SingleInstance();
builder.Register(x =>
AzureTableStorage <SmsVerificationPriorityCodeEntity> .Create(_personalDataConnString,
TableNameSmsVerificationPriorityCodes, x.Resolve <ILogFactory>())).AsImplementedInterfaces().SingleInstance();
builder.RegisterType <SmsVerificationCodeRepository>().AsImplementedInterfaces().SingleInstance();
builder.Register(x =>
AzureTableStorage <EmailVerificationCodeEntity> .Create(_personalDataConnString,
TableNameEmailVerificationCodes, x.Resolve <ILogFactory>())).AsImplementedInterfaces().SingleInstance();
builder.Register(x =>
AzureTableStorage <EmailVerificationPriorityCodeEntity> .Create(_personalDataConnString,
TableNameEmailVerificationPriorityCodes, x.Resolve <ILogFactory>())).AsImplementedInterfaces().SingleInstance();
builder.RegisterType <EmailVerificationCodeRepository>().AsImplementedInterfaces().SingleInstance();
builder.Register <ICallTimeLimitsRepository>(y =>
new CallTimeLimitsRepository(
AzureTableStorage <ApiCallHistoryRecord> .Create(_logsConnString, TableNameApiCalls, y.Resolve <ILogFactory>())));
if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("EncryptionKey")))
{
builder
.Register(x =>
{
var manager = new EncryptedStorageManager(AzureTableStorage <EncryptionInitModel> .Create(
_google2faConnString,
TableNameGoogle2Fa,
x.Resolve <ILogFactory>()));
if (!manager.TrySetKey(Environment.GetEnvironmentVariable("EncryptionKey"), out string error))
{
var exception = new InvalidOperationException("EncryptionKey is not set");
x.Resolve <ILogFactory>().CreateLog(this).WriteFatalError("SetEncryptionKey", error, exception);
throw exception;
}
return(manager);
})
.As <EncryptedStorageManager>()
.AutoActivate();
builder
.Register(
x => EncryptedTableStorageDecorator <Google2FaSecretEntity> .Create(
AzureTableStorage <Google2FaSecretEntity> .Create(
_google2faConnString,
TableNameGoogle2Fa,
x.Resolve <ILogFactory>()),
x.Resolve <EncryptedStorageManager>().Serializer))
.As <INoSQLTableStorage <Google2FaSecretEntity> >()
.SingleInstance();
}
else
{
builder
.Register(
x => {
if (x.Resolve <IHostingEnvironment>().IsProduction())
{
throw new Exception("Need to set EncryptionKey in Production environment");
}
return(AzureTableStorage <Google2FaSecretEntity> .Create(
_google2faConnString,
TableNameGoogle2Fa,
x.Resolve <ILogFactory>()));
})
.As <INoSQLTableStorage <Google2FaSecretEntity> >()
.AutoActivate()
.SingleInstance();
}
builder
.RegisterType <Google2FaRepository>()
.As <IGoogle2FaRepository>()
.SingleInstance();
}
public EmailRepository(IReloadingManager <string> connectionStringManager, ILog log)
{
_tableStorage = AzureTableStorage <EmailEntity> .Create(connectionStringManager, "Emails", log);
_queueExt = AzureQueueExt.Create(connectionStringManager, Constants.EmailQueue);
}
private void BindQueue(ContainerBuilder builder)
{
builder.RegisterInstance(new PaidFeeQueueWriter(
AzureQueueExt.Create(_settings.ConnectionString(x => x.AffiliateService.Db.AzureConnString),
Constants.PaidFeeQueueName))).As <IPaidFeeQueueWriter>();
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddMvc()
.AddJsonOptions(options =>
{
options.SerializerSettings.ContractResolver = new DefaultContractResolver();
});
services.AddSwaggerGen(options =>
{
options.DefaultLykkeConfiguration("v1", "SlackNotifications Job API");
});
var builder = new ContainerBuilder();
var settingsManager = Configuration.LoadSettings <AppSettings>();
Log = CreateLogWithSlack(services, settingsManager);
builder.RegisterInstance(Log).As <ILog>().SingleInstance();
var settings = settingsManager.CurrentValue;
builder.RegisterInstance(settings.SlackNotificationsJobSettings).SingleInstance();
builder.RegisterType <SlackNotifcationsConsumer>();
if (!string.IsNullOrEmpty(settings.SlackNotificationsJobSettings.ForwardMonitorMessagesQueueConnString))
{
builder.RegisterInstance <IMsgForwarder>(new MsgForwarder(AzureQueueExt.Create(
settingsManager.ConnectionString(x => x.SlackNotificationsJobSettings.ForwardMonitorMessagesQueueConnString),
"slack-notifications-monitor"))).SingleInstance();
}
else
{
builder.RegisterInstance <IMsgForwarder>(new MsgForwarderStub()).SingleInstance();
}
builder.RegisterType <NotificationFilter>().As <INotificationFilter>().SingleInstance();
builder
.RegisterType <SrvSlackNotifications>()
.WithParameter(TypedParameter.From(settings.SlackIntegration))
.WithParameter(TypedParameter.From(settings))
.As <ISlackNotificationSender>();
builder
.Register(c => MessagesRepository.Create(settingsManager.Nested(s => s.SlackNotificationsJobSettings.FullMessagesConnString)))
.As <IMessagesRepository>();
builder.AddTriggers(pool =>
{
pool.AddDefaultConnection(settingsManager.ConnectionString(x => x.SlackNotificationsJobSettings.SharedStorageConnString));
});
builder.RegisterType <UnmuteHandler>()
.As <IStartable>()
.AutoActivate()
.SingleInstance();
builder.Populate(services);
ApplicationContainer = builder.Build();
var serviceProvider = new AutofacServiceProvider(ApplicationContainer);
_triggerHost = new TriggerHost(serviceProvider);
_triggerHost.ProvideAssembly(typeof(SlackNotifcationsConsumer).Assembly);
return(serviceProvider);
}
public IQueueExt Build(string queueName = "default-queue-name")
{
return(AzureQueueExt.Create(_settings.ConnectionString(x => x.Db.DataConnString), Constants.StoragePrefix + queueName));
}
private void BindRepositories(ContainerBuilder builder)
{
builder.Register <ITransactionsRepository>(ctx =>
new TransactionsRepository(
AzureTableStorage <BitCoinTransactionEntity> .Create(
_dbSettingsManager.ConnectionString(x => x.BitCoinQueueConnectionString),
"BitCoinTransactions", ctx.Resolve <ILogFactory>())))
.SingleInstance();
builder.Register <IWalletCredentialsRepository>(ctx =>
new WalletCredentialsRepository(
AzureTableStorage <WalletCredentialsEntity> .Create(
_dbSettingsManager.ConnectionString(x => x.ClientPersonalInfoConnString),
"WalletCredentials", ctx.Resolve <ILogFactory>())))
.SingleInstance();
builder.Register <IBcnClientCredentialsRepository>(ctx =>
new BcnClientCredentialsRepository(
AzureTableStorage <BcnCredentialsRecordEntity> .Create(
_dbSettingsManager.ConnectionString(x => x.ClientPersonalInfoConnString),
"BcnClientCredentials", ctx.Resolve <ILogFactory>())))
.SingleInstance();
builder.Register <IClientCacheRepository>(ctx =>
new ClientCacheRepository(
AzureTableStorage <ClientCacheEntity> .Create(
_dbSettingsManager.ConnectionString(x => x.ClientPersonalInfoConnString),
"ClientCache", ctx.Resolve <ILogFactory>())))
.SingleInstance();
builder.Register <IEthereumTransactionRequestRepository>(ctx =>
new EthereumTransactionRequestRepository(
AzureTableStorage <EthereumTransactionReqEntity> .Create(
_dbSettingsManager.ConnectionString(x => x.BitCoinQueueConnectionString),
"EthereumTxRequest", ctx.Resolve <ILogFactory>())))
.SingleInstance();
builder.Register <IBitcoinCashinRepository>(ctx =>
new BitcoinCashinRepository(
AzureTableStorage <BitcoinCashinEntity> .Create(
_dbSettingsManager.ConnectionString(x => x.BitCoinQueueConnectionString),
"BitcoinCashin", ctx.Resolve <ILogFactory>())))
.SingleInstance();
builder.Register <IMarketOrdersRepository>(ctx =>
new MarketOrdersRepository(AzureTableStorage <MarketOrderEntity> .Create(
_dbSettingsManager.ConnectionString(x => x.HMarketOrdersConnString),
"MarketOrders", ctx.Resolve <ILogFactory>())))
.SingleInstance();
builder.Register <ILimitOrdersRepository>(ctx =>
new LimitOrdersRepository(AzureTableStorage <LimitOrderEntity> .Create(
_dbSettingsManager.ConnectionString(x => x.HMarketOrdersConnString),
"LimitOrders", ctx.Resolve <ILogFactory>())))
.SingleInstance();
builder.RegisterInstance <IEmailCommandProducer>(
new EmailCommandProducer(AzureQueueExt.Create(
_dbSettingsManager.ConnectionString(x => x.ClientPersonalInfoConnString),
"emailsqueue")));
builder.Register <IOffchainRequestRepository>(ctx =>
new OffchainRequestRepository(
AzureTableStorage <OffchainRequestEntity> .Create(
_dbSettingsManager.ConnectionString(x => x.OffchainConnString),
"OffchainRequests", ctx.Resolve <ILogFactory>())))
.SingleInstance();
builder.Register <IOffchainTransferRepository>(ctx =>
new OffchainTransferRepository(
AzureTableStorage <OffchainTransferEntity> .Create(
_dbSettingsManager.ConnectionString(x => x.OffchainConnString),
"OffchainTransfers", ctx.Resolve <ILogFactory>())))
.SingleInstance();
builder.Register <IPaymentTransactionsRepository>(ctx =>
new PaymentTransactionsRepository(
AzureTableStorage <PaymentTransactionEntity> .Create(
_dbSettingsManager.ConnectionString(x => x.ClientPersonalInfoConnString),
"PaymentTransactions", ctx.Resolve <ILogFactory>()),
AzureTableStorage <AzureMultiIndex> .Create(
_dbSettingsManager.ConnectionString(x => x.ClientPersonalInfoConnString),
"PaymentTransactions", ctx.Resolve <ILogFactory>())))
.SingleInstance();
builder.RegisterInstance(
new BitcoinTransactionContextBlobStorage(AzureBlobStorage.Create(
_dbSettingsManager.ConnectionString(x => x.BitCoinQueueConnectionString))))
.As <IBitcoinTransactionContextBlobStorage>();
builder.Register <IEthererumPendingActionsRepository>(ctx =>
new EthererumPendingActionsRepository(
AzureTableStorage <EthererumPendingActionEntity> .Create(
_dbSettingsManager.ConnectionString(x => x.BitCoinQueueConnectionString),
"EthererumPendingActions", ctx.Resolve <ILogFactory>())))
.SingleInstance();
builder.Register <IClientCommentsRepository>(ctx =>
new ClientCommentsRepository(AzureTableStorage <ClientCommentEntity> .Create(
_dbSettingsManager.ConnectionString(x => x.ClientPersonalInfoConnString),
"ClientComments", ctx.Resolve <ILogFactory>())))
.SingleInstance();
builder.Register(ctx =>
EthereumCashinAggregateRepository.Create(
_dbSettingsManager.ConnectionString(x => x.BitCoinQueueConnectionString),
ctx.Resolve <ILogFactory>()))
.As <IEthereumCashinAggregateRepository>()
.SingleInstance();
}
