private static void RegisterServiceBusConfig(
            ContainerBuilder containerBuilder,
            IConfigurationHelper configHelper)
        {
            var serviceBusOptions =
                configHelper.GetSectionValues <ServiceBusOptions>("ServiceBusSettings");

            containerBuilder.RegisterInstance(serviceBusOptions).As <ServiceBusOptions>().SingleInstance();

            var topicConfig = new ServiceBusTopicConfig(
                serviceBusOptions.ServiceBusConnectionString,
                serviceBusOptions.TopicName,
                serviceBusOptions.SubscriptionName,
                Environment.ProcessorCount,
                TimeSpan.FromMinutes(30));

            containerBuilder.Register(c =>
            {
                var topicSubscriptionSevice =
                    new TopicSubscriptionSevice <JobContextDto>(
                        topicConfig,
                        c.Resolve <IJsonSerializationService>(),
                        c.Resolve <ILogger>());
                return(topicSubscriptionSevice);
            }).As <ITopicSubscriptionService <JobContextDto> >();

            containerBuilder.Register(c =>
            {
                var topicPublishSevice =
                    new TopicPublishService <JobContextDto>(
                        topicConfig,
                        c.Resolve <IJsonSerializationService>());
                return(topicPublishSevice);
            }).As <ITopicPublishService <JobContextDto> >();

            containerBuilder.Register(c =>
            {
                var config = new QueueConfiguration(
                    serviceBusOptions.ServiceBusConnectionString,
                    serviceBusOptions.AuditQueueName,
                    1);

                return(new QueuePublishService <AuditingDto>(
                           config,
                           c.Resolve <IJsonSerializationService>()));
            }).As <IQueuePublishService <AuditingDto> >();

            containerBuilder.Register(c =>
            {
                var config = new QueueConfiguration(
                    serviceBusOptions.ServiceBusConnectionString,
                    serviceBusOptions.JobStatusQueueName,
                    1);

                return(new QueuePublishService <JobStatusDto>(
                           config,
                           c.Resolve <IJsonSerializationService>()));
            }).As <IQueuePublishService <JobStatusDto> >();
        }
        public static ContainerBuilder BuildContainer(IConfigurationHelper configHelper)
        {
            var containerBuilder = new ContainerBuilder();

            var topicAndTaskOptions = configHelper.GetSectionValues <TopicAndTaskSectionOptions>("TopicAndTaskSection");

            containerBuilder.RegisterInstance(topicAndTaskOptions).As <ITopicAndTaskSectionOptions>().SingleInstance();

            var larsConfiguration = configHelper.GetSectionValues <LarsConfiguration>("LarsSection");

            containerBuilder.RegisterInstance(larsConfiguration).As <LarsConfiguration>().SingleInstance();

            var dasCommitmentsConfiguration = configHelper.GetSectionValues <DasCommitmentsConfiguration>("DasCommitmentsSection");

            containerBuilder.RegisterInstance(dasCommitmentsConfiguration).As <DasCommitmentsConfiguration>().SingleInstance();

            var orgConfiguration = configHelper.GetSectionValues <OrgConfiguration>("OrgSection");

            containerBuilder.RegisterInstance(orgConfiguration).As <OrgConfiguration>().SingleInstance();

            var easConfiguration = configHelper.GetSectionValues <EasConfiguration>("EasSection");

            containerBuilder.RegisterInstance(easConfiguration).As <EasConfiguration>().SingleInstance();

            var ilrValidationErrorsConfiguration = configHelper.GetSectionValues <IlrValidationErrorsConfiguration>("IlrValidationErrorsSection");

            containerBuilder.RegisterInstance(ilrValidationErrorsConfiguration).As <IlrValidationErrorsConfiguration>().SingleInstance();

            var dataStoreConfiguration = configHelper.GetSectionValues <DataStoreConfiguration>("DataStoreSection");

            containerBuilder.RegisterInstance(dataStoreConfiguration).As <DataStoreConfiguration>().SingleInstance();

            var largeEmployeeConfiguration = configHelper.GetSectionValues <LargeEmployerConfiguration>("LargeEmployerSection");

            containerBuilder.RegisterInstance(largeEmployeeConfiguration).As <LargeEmployerConfiguration>().SingleInstance();

            var dasPaymentsConfiguration = configHelper.GetSectionValues <DASPaymentsConfiguration>("DASPaymentsSection");

            containerBuilder.RegisterInstance(dasPaymentsConfiguration).As <DASPaymentsConfiguration>().SingleInstance();

            var postcodeConfiguration = configHelper.GetSectionValues <PostcodeConfiguration>("PostcodeSection");

            containerBuilder.RegisterInstance(postcodeConfiguration).As <PostcodeConfiguration>().SingleInstance();

            var collectionsManagementConfiguration =
                configHelper.GetSectionValues <CollectionsManagementConfiguration>("CollectionsManagementSection");

            containerBuilder.RegisterInstance(collectionsManagementConfiguration)
            .As <CollectionsManagementConfiguration>().SingleInstance();

            // register azure blob storage service
            var azureBlobStorageOptions = configHelper.GetSectionValues <AzureStorageOptions>("AzureStorageSection");

            containerBuilder.RegisterInstance(azureBlobStorageOptions).As <IAzureStorageOptions>();
            containerBuilder.Register(c =>
                                      new AzureStorageKeyValuePersistenceConfig(
                                          azureBlobStorageOptions.AzureBlobConnectionString,
                                          azureBlobStorageOptions.AzureBlobContainerName))
            .As <IAzureStorageKeyValuePersistenceServiceConfig>().SingleInstance();

            containerBuilder.RegisterType <AzureStorageKeyValuePersistenceService>()
            .As <IKeyValuePersistenceService>()
            .As <IStreamableKeyValuePersistenceService>()
            .InstancePerLifetimeScope();

            // register serialization
            containerBuilder.RegisterType <JsonSerializationService>()
            .As <IJsonSerializationService>();
            containerBuilder.RegisterType <XmlSerializationService>()
            .As <IXmlSerializationService>();

            // get ServiceBus, Azurestorage config values and register container
            var serviceBusOptions =
                configHelper.GetSectionValues <ServiceBusOptions>("ServiceBusSettings");

            containerBuilder.RegisterInstance(serviceBusOptions).As <ServiceBusOptions>().SingleInstance();

            // Version info
            var versionInfo = configHelper.GetSectionValues <VersionInfo>("VersionSection");

            containerBuilder.RegisterInstance(versionInfo).As <IVersionInfo>().SingleInstance();

            // register logger
            var loggerOptions =
                configHelper.GetSectionValues <LoggerOptions>("LoggerSection");

            containerBuilder.RegisterInstance(loggerOptions).As <LoggerOptions>().SingleInstance();
            containerBuilder.RegisterModule <LoggerModule>();

            // auditing
            var auditPublishConfig = new ServiceBusQueueConfig(
                serviceBusOptions.ServiceBusConnectionString,
                serviceBusOptions.AuditQueueName,
                Environment.ProcessorCount);

            containerBuilder.Register(c => new QueuePublishService <AuditingDto>(
                                          auditPublishConfig,
                                          c.Resolve <IJsonSerializationService>()))
            .As <IQueuePublishService <AuditingDto> >();

            // get job status queue config values and register container
            var jobStatusQueueOptions =
                configHelper.GetSectionValues <JobStatusQueueOptions>("JobStatusSection");

            containerBuilder.RegisterInstance(jobStatusQueueOptions).As <JobStatusQueueOptions>().SingleInstance();

            // Job Status Update Service
            var jobStatusPublishConfig = new JobStatusQueueConfig(
                jobStatusQueueOptions.JobStatusConnectionString,
                jobStatusQueueOptions.JobStatusQueueName,
                Environment.ProcessorCount);

            containerBuilder.Register(c => new QueuePublishService <JobStatusDto>(
                                          jobStatusPublishConfig,
                                          c.Resolve <IJsonSerializationService>()))
            .As <IQueuePublishService <JobStatusDto> >();

            // register Job Context services
            var topicConfig = new ServiceBusTopicConfig(
                serviceBusOptions.ServiceBusConnectionString,
                serviceBusOptions.TopicName,
                serviceBusOptions.ReportingSubscriptionName,
                Environment.ProcessorCount);

            containerBuilder.Register(c =>
            {
                var topicSubscriptionService =
                    new TopicSubscriptionSevice <JobContextDto>(
                        topicConfig,
                        c.Resolve <IJsonSerializationService>(),
                        c.Resolve <ILogger>());
                return(topicSubscriptionService);
            }).As <ITopicSubscriptionService <JobContextDto> >();

            containerBuilder.Register(c =>
            {
                var topicPublishService =
                    new TopicPublishService <JobContextDto>(
                        topicConfig,
                        c.Resolve <IJsonSerializationService>());
                return(topicPublishService);
            }).As <ITopicPublishService <JobContextDto> >();

            // register message mapper
            containerBuilder.RegisterType <DefaultJobContextMessageMapper <JobContextMessage> >().As <IMapper <JobContextMessage, JobContextMessage> >();

            // register MessageHandler
            containerBuilder.RegisterType <MessageHandler>().As <IMessageHandler <JobContextMessage> >().InstancePerLifetimeScope();

            containerBuilder.RegisterType <EntryPoint>().WithAttributeFiltering().InstancePerLifetimeScope();

            containerBuilder.RegisterType <JobContextManager <JobContextMessage> >().As <IJobContextManager <JobContextMessage> >()
            .InstancePerLifetimeScope();

            containerBuilder.RegisterType <JobContextMessage>().As <IJobContextMessage>()
            .InstancePerLifetimeScope();

            containerBuilder.Register(context =>
            {
                CollectionsManagementConfiguration settings = context.Resolve <CollectionsManagementConfiguration>();
                DbContextOptionsBuilder optionsBuilder      = new DbContextOptionsBuilder();
                optionsBuilder.UseSqlServer(
                    settings.CollectionsManagementConnectionString,
                    options => options.EnableRetryOnFailure(3, TimeSpan.FromSeconds(3), new List <int>()));
                return(optionsBuilder.Options);
            })
            .As <DbContextOptions>()
            .InstancePerLifetimeScope();

            containerBuilder.RegisterType <ILR1819_DataStoreEntitiesValid>().As <IIlr1819ValidContext>();
            containerBuilder.Register(context =>
            {
                var optionsBuilder = new DbContextOptionsBuilder <ILR1819_DataStoreEntitiesValid>();
                optionsBuilder.UseSqlServer(
                    dataStoreConfiguration.ILRDataStoreValidConnectionString,
                    options => options.EnableRetryOnFailure(3, TimeSpan.FromSeconds(3), new List <int>()));

                return(optionsBuilder.Options);
            })
            .As <DbContextOptions <ILR1819_DataStoreEntitiesValid> >()
            .SingleInstance();

            containerBuilder.RegisterType <ILR1819_DataStoreEntities>().As <IIlr1819RulebaseContext>();
            containerBuilder.Register(context =>
            {
                var optionsBuilder = new DbContextOptionsBuilder <ILR1819_DataStoreEntities>();
                optionsBuilder.UseSqlServer(
                    dataStoreConfiguration.ILRDataStoreConnectionString,
                    options => options.EnableRetryOnFailure(3, TimeSpan.FromSeconds(3), new List <int>()));

                return(optionsBuilder.Options);
            })
            .As <DbContextOptions <ILR1819_DataStoreEntities> >()
            .SingleInstance();

            containerBuilder.RegisterType <DASPaymentsContext>().As <IDASPaymentsContext>();
            containerBuilder.Register(context =>
            {
                var optionsBuilder = new DbContextOptionsBuilder <DASPaymentsContext>();
                optionsBuilder.UseSqlServer(
                    dasPaymentsConfiguration.DASPaymentsConnectionString,
                    options => options.EnableRetryOnFailure(3, TimeSpan.FromSeconds(3), new List <int>()));

                return(optionsBuilder.Options);
            })
            .As <DbContextOptions <DASPaymentsContext> >()
            .SingleInstance();

            containerBuilder.RegisterType <DateTimeProvider.DateTimeProvider>().As <IDateTimeProvider>().InstancePerLifetimeScope();

            RegisterReports(containerBuilder);
            RegisterServices(containerBuilder);
            RegisterBuilders(containerBuilder);
            RegisterRules(containerBuilder);
            RegisterCommands(containerBuilder);

            return(containerBuilder);
        }