public static ApplicationConfiguration UseConsoleHost(this ApplicationConfiguration application)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            return(application.Extensibility(extensibility =>
            {
                extensibility.Register(() => new ConsoleHostConfiguration(application));
            }));
        }
        internal RedisConfiguration(ApplicationConfiguration application)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            Application = application;

            _client = new RedisClientConfiguration(this);
            Application.Extensibility(extensibility => extensibility.Register(() => _client));
        }
        internal AzureConfiguration(ApplicationConfiguration application)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            Application = application.Extensibility(extensibility =>
            {
                _blobStorage = extensibility.Register(() => new AzureBlobStorageConfiguration(application));
                _serviceBus  = extensibility.Register(() => new AzureServiceBusConfiguration(application));
            });
        }
Example #4
0
        internal LoggingConfiguration(ApplicationConfiguration application)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            Application = application;

            _eventLogger = new EventLoggerConfiguration(this);

            Application.Extensibility(extensibility => extensibility.Register(() => _eventLogger));
        }
        public static ApplicationConfiguration UseElasticsearch(this ApplicationConfiguration application, Action <ElasticsearchConfiguration> elasticsearch = null)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            return(application.Extensibility(extensibility =>
            {
                ElasticsearchConfiguration configuration = extensibility.Register(() => new ElasticsearchConfiguration(application));

                elasticsearch?.Invoke(configuration);
            }));
        }
        public static ApplicationConfiguration UseSendGrid(this ApplicationConfiguration application, Action <SendGridConfiguration> SendGrid = null)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            return(application.Extensibility(extensibility =>
            {
                SendGridConfiguration configuration = extensibility.Register(() => new SendGridConfiguration(application));

                SendGrid?.Invoke(configuration);
            }));
        }
Example #7
0
        public static ApplicationConfiguration UseSlack(this ApplicationConfiguration application, Action <SlackConfiguration> slack = null)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            return(application.Extensibility(extensibility =>
            {
                SlackConfiguration configuration = extensibility.Register(() => new SlackConfiguration(application));

                slack?.Invoke(configuration);
            }));
        }
        public static ApplicationConfiguration UsePerfion(this ApplicationConfiguration application, Action <PerfionConfiguration> perfion = null)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            return(application.Extensibility(extensibility =>
            {
                PerfionConfiguration configuration = extensibility.Register(() => new PerfionConfiguration(application));

                perfion?.Invoke(configuration);
            }));
        }
        public static ApplicationConfiguration UseRedis(this ApplicationConfiguration application, Action <RedisConfiguration> redis = null)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            return(application.Extensibility(extensibility =>
            {
                RedisConfiguration configuration = extensibility.Register(() => new RedisConfiguration(application));

                redis?.Invoke(configuration);
            }));
        }
Example #10
0
        public static ApplicationConfiguration UseGlobase(this ApplicationConfiguration application, Action <GlobaseConfiguration> globase = null)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            return(application.Extensibility(extensibility =>
            {
                GlobaseConfiguration configuration = extensibility.Register(() => new GlobaseConfiguration(application));

                globase?.Invoke(configuration);
            }));
        }
        public static ApplicationConfiguration UseWebApi(this ApplicationConfiguration application, Action <WebApiConfiguration> webApi = null)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            return(application.Extensibility(extensibility =>
            {
                var configuration = extensibility.Register(() => new WebApiConfiguration(application));

                webApi?.Invoke(configuration);
            }));
        }
        public static ApplicationConfiguration UseLiteServer(this ApplicationConfiguration application, Action <LiteServerConfiguration> server = null)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            return(application.Extensibility(extensibility =>
            {
                var configuration = extensibility.Register(() => new LiteServerConfiguration(application));

                server?.Invoke(configuration);
            }));
        }
Example #13
0
        public static ApplicationConfiguration UseUCommerce(this ApplicationConfiguration application, Action <UCommerceConfiguration> uCommerce = null)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            return(application.Extensibility(extensibility =>
            {
                UCommerceConfiguration configuration = extensibility.Register(() => new UCommerceConfiguration(application));

                uCommerce?.Invoke(configuration);
            }));
        }
Example #14
0
        internal DatabaseConfiguration(ApplicationConfiguration application)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            _integrationDb = new IntegrationDatabaseConfiguration(this);
            _connections   = new Dictionary <Type, IWindsorInstaller>();

            Application = application
                          .Extensibility(extensibility => extensibility
                                         .Register(() => _integrationDb));
        }
Example #15
0
        public static ApplicationConfiguration UseMandrill(this ApplicationConfiguration application, Action <MandrillConfiguration> mandrill = null)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            return(application.Extensibility(extensibility =>
            {
                MandrillConfiguration configuration = extensibility.Register(() => new MandrillConfiguration(application));

                mandrill?.Invoke(configuration);
            }));
        }
Example #16
0
        internal ServicesConfiguration(ApplicationConfiguration application)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }

            _interceptors = new ServicesInterceptorsConfiguration(this);
            _advanced     = new ServicesAdvancedConfiguration(this);
            _conventions  = new ServicesConventionsConfiguration(this);

            Application = application
                          // NOTE: Interceptors has to go first.
                          .Extensibility(extensibility => extensibility.Register(() => _interceptors))
                          // NOTE: Advanced has to go second as they take precedence over the conventional registrations.
                          .Extensibility(extensibility => extensibility.Register(() => _advanced))
                          .Extensibility(extensibility => extensibility.Register(() => _conventions));
        }
        public static ApplicationConfiguration UseMongoDb(this ApplicationConfiguration application, Action <MongoDbConfiguration> mongoDb)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }
            if (mongoDb == null)
            {
                throw new ArgumentNullException(nameof(mongoDb));
            }

            return(application.Extensibility(extensibility =>
            {
                MongoDbConfiguration configuration = extensibility.Register(() => new MongoDbConfiguration(application));

                mongoDb(configuration);
            }));
        }
        public static ApplicationConfiguration UseHangfire(this ApplicationConfiguration application, Action <HangfireConfiguration> hangfire)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }
            if (hangfire == null)
            {
                throw new ArgumentNullException(nameof(hangfire));
            }

            return(application.Extensibility(extensibility =>
            {
                var configuration = extensibility.Register(() => new HangfireConfiguration(application));

                hangfire(configuration);
            }));
        }
        public static ApplicationConfiguration UseSerilog(this ApplicationConfiguration application, Action <SerilogConfiguration> serilog)
        {
            if (application == null)
            {
                throw new ArgumentNullException(nameof(application));
            }
            if (serilog == null)
            {
                throw new ArgumentNullException(nameof(serilog));
            }

            return(application.Extensibility(extensibility =>
            {
                SerilogConfiguration configuration =
                    extensibility.Register(() => new SerilogConfiguration(application));

                serilog(configuration);
            }));
        }