Beispiel #1
0
 public BlogController(IBlogFactory factory, IHttpContextAccessor accessor, BlogSeed seed, IOptionsFactory <PostRelated> related)
 {
     _factory       = factory;
     this._accessor = accessor;
     this._seed     = seed;
     this._related  = related;
 }
 public AbpWeChatMiniProgramOptionsManager(
     ISettingProvider settingProvider,
     IOptionsFactory <AbpWeChatMiniProgramOptions> factory)
     : base(factory)
 {
     SettingProvider = settingProvider;
 }
Beispiel #3
0
 public ODataApiExplorerOptionsAdapter(
     IOptions <ODataApiVersioningOptions> options,
     IOptionsFactory <ODataApiExplorerOptions> factory)
 {
     this.options = options;
     this.factory = factory;
 }
 public AbpWeChatOfficialOptionsManager(
     ISettingProvider settingProvider,
     IOptionsFactory <AbpWeChatOfficialOptions> factory)
     : base(factory)
 {
     SettingProvider = settingProvider;
 }
        public SiteCookieAuthenticationOptions(
            IOptionsFactory<CookieAuthenticationOptions> factory, 
            IEnumerable<IOptionsChangeTokenSource<CookieAuthenticationOptions>> sources, 
            IOptionsMonitorCache<CookieAuthenticationOptions> cache,
            IOptions<MultiTenantOptions> multiTenantOptionsAccessor,
            IPostConfigureOptions<CookieAuthenticationOptions> cookieOptionsInitializer,
            IHttpContextAccessor httpContextAccessor,
            ILogger<SiteCookieAuthenticationOptions> logger
            )
        {
            _multiTenantOptions = multiTenantOptionsAccessor.Value;
            _cookieOptionsInitializer = cookieOptionsInitializer;
            _httpContextAccessor = httpContextAccessor;
            _log = logger;

            _factory = factory;
            _sources = sources;
            _cache = cache;

            foreach (var source in _sources)
            {
                ChangeToken.OnChange<string>(
                    () => source.GetChangeToken(),
                    (name) => InvokeChanged(name),
                    source.Name);
            }
        }
Beispiel #6
0
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="factory">The factory to use to create options.</param>
        /// <param name="sources">The sources used to listen for changes to the options instance.</param>
        /// <param name="cache">The cache used to store options.</param>
        public OptionsMonitor(IOptionsFactory<TOptions> factory, IEnumerable<IOptionsChangeTokenSource<TOptions>> sources, IOptionsMonitorCache<TOptions> cache)
        {
            _factory = factory;
            _cache = cache;

            void RegisterSource(IOptionsChangeTokenSource<TOptions> source)
            {
                IDisposable registration = ChangeToken.OnChange(
                          () => source.GetChangeToken(),
                          (name) => InvokeChanged(name),
                          source.Name);

                _registrations.Add(registration);
            }

            // The default DI container uses arrays under the covers. Take advantage of this knowledge
            // by checking for an array and enumerate over that, so we don't need to allocate an enumerator.
            if (sources is IOptionsChangeTokenSource<TOptions>[] sourcesArray)
            {
                foreach (IOptionsChangeTokenSource<TOptions> source in sourcesArray)
                {
                    RegisterSource(source);
                }
            }
            else
            {
                foreach (IOptionsChangeTokenSource<TOptions> source in sources)
                {
                    RegisterSource(source);
                }
            }
        }
 public AbpRequestLocalizationOptionsManager(
     IOptionsFactory <RequestLocalizationOptions> factory,
     IAbpRequestLocalizationOptionsProvider abpRequestLocalizationOptionsProvider)
     : base(factory)
 {
     _abpRequestLocalizationOptionsProvider = abpRequestLocalizationOptionsProvider;
 }
Beispiel #8
0
 public BaseDbContextManager(IOptionsFactory <T> factory, IConfiguration configuration) : base(factory)
 {
     Pairs         = new Dictionary <string, T>();
     AsyncList     = new List <T>();
     Factory       = factory;
     Configuration = configuration;
 }
Beispiel #9
0
        public SiteGoogleOptions(
            IOptionsFactory <GoogleOptions> factory,
            IEnumerable <IOptionsChangeTokenSource <GoogleOptions> > sources,
            IOptionsMonitorCache <GoogleOptions> cache,
            IOptions <MultiTenantOptions> multiTenantOptionsAccessor,
            IPostConfigureOptions <GoogleOptions> optionsInitializer,
            IDataProtectionProvider dataProtection,
            IHttpContextAccessor httpContextAccessor,
            ILogger <SiteGoogleOptions> logger
            )
        {
            _multiTenantOptions  = multiTenantOptionsAccessor.Value;
            _httpContextAccessor = httpContextAccessor;
            _log = logger;
            _optionsInitializer = optionsInitializer;
            _dp = dataProtection;

            _factory = factory;
            _sources = sources;
            _cache   = cache;

            foreach (var source in _sources)
            {
                ChangeToken.OnChange <string>(
                    () => source.GetChangeToken(),
                    (name) => InvokeChanged(name),
                    source.Name);
            }
        }
 public JwtBearerOptionsProvider(
     IOptionsFactory <JwtBearerOptions> optionsFactory,
     TenantProvider tenantProvider)
 {
     _cache          = new ConcurrentDictionary <(string, string), Lazy <JwtBearerOptions> >();
     _optionsFactory = optionsFactory;
     _tenantProvider = tenantProvider;
 }
 public MultitenantOptionsMonitor(IOptionsFactory <TOptions> factory, IEnumerable <IOptionsChangeTokenSource <TOptions> > sources, IOptionsMonitorCache <TOptions> cache, IHttpContextAccessor httpContextAccessor)
 {
     _factory             = factory;
     _sources             = sources;
     _optionsCache        = cache;
     _httpContextAccessor = httpContextAccessor;
     _cache.TryAdd("root", new Lazy <IOptionsMonitor <TOptions> >(() => new OptionsMonitor <TOptions>(_factory, _sources, new OptionsCache <TOptions>())));
 }
Beispiel #12
0
 /// <summary>
 /// Ctor
 /// </summary>
 /// <param name="optionsCache">Options</param>
 /// <param name="optionsFactory">Factory for options</param>
 /// <param name="requestStateStore">Storage for request state</param>
 public Saml2Handler(
     IOptionsMonitorCache <Saml2Options> optionsCache,
     IOptionsFactory <Saml2Options> optionsFactory,
     IRequestStateStore requestStateStore)
 {
     this.optionsFactory    = optionsFactory;
     this.requestStateStore = requestStateStore;
     this.optionsCache      = optionsCache;
 }
 public OptionsMetadataValidator(
     OptionsMetadata optionsMetadata,
     IOptionsFactory <TOptions> optionsFactory,
     ValueParserSelector valueParserSelector)
 {
     _optionsMetadata     = optionsMetadata;
     _optionsFactory      = optionsFactory;
     _valueParserSelector = valueParserSelector;
 }
Beispiel #14
0
 public CodeGeneratorFactory(
     IOptionsFactory optionsFactory          = null,
     IProcessLauncher processLauncher        = null,
     IOpenApiDocumentFactory documentFactory = null)
 {
     this.optionsFactory  = optionsFactory ?? new OptionsFactory();
     this.processLauncher = processLauncher ?? new ProcessLauncher();
     this.documentFactory = documentFactory ?? new OpenApiDocumentFactory();
 }
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="authOptions"></param>
 /// <param name="optionsFactory"></param>
 /// <param name="optionsMonitorCache"></param>
 public DynamicAuthOptionsBuilder(
     IOptions <AuthenticationOptions> authOptions,
     IOptionsFactory <TOptions> optionsFactory,
     IOptionsMonitorCache <TOptions> optionsMonitorCache)
 {
     _optionsFactory      = optionsFactory;
     _optionsMonitorCache = optionsMonitorCache;
     AuthOptions          = authOptions.Value;
 }
        public HomeController(ILogger <HomeController> logger, IOptionsFactory <CookieAuthenticationOptions> fact, IOptionsMonitor <AppSettings> appSettings, ITenant tenant)
        {
            var options = appSettings.CurrentValue;



            _logger = logger;
            _fact   = fact;
        }
Beispiel #17
0
 public MyOptionsMonitor(
     //  TenantContext<Tenant> tenantContext,
     IOptionsFactory <OAuthOptions> optionsFactory,
     IMemoryCache cache)
 {
     //   _tenantContext = tenantContext;
     _optionsFactory = optionsFactory;
     _cache          = cache;
 }
Beispiel #18
0
 public StorageQueue(
     IOptionsMonitor <TOptions> storageQueueOptionsMonitor,
     IOptionsFactory <StorageAccountOptions> storageAccountOptionsFactory,
     ILogger <StorageQueue <TOptions> > logger)
 {
     _storageQueueOptionsMonitor   = storageQueueOptionsMonitor ?? throw new ArgumentNullException(nameof(storageQueueOptionsMonitor));
     _storageAccountOptionsFactory = storageAccountOptionsFactory ?? throw new ArgumentNullException(nameof(storageAccountOptionsFactory));
     _logger = logger ?? throw new ArgumentNullException(nameof(logger));
 }
Beispiel #19
0
 /// <summary>
 /// Initializes a new instance of the <see cref="StorageBlob{TOptions}"/> class.
 /// </summary>
 /// <param name="storageBlobOptionsMonitor"></param>
 /// <param name="storageAccountOptionsFactory"></param>
 /// <param name="logger"></param>
 public StorageBlob(
     IOptionsMonitor <TOptions> storageBlobOptionsMonitor,
     IOptionsFactory <StorageAccountOptions> storageAccountOptionsFactory,
     ILogger <StorageBlob <TOptions> > logger)
 {
     _storageBlobOptionsMonitor    = storageBlobOptionsMonitor;
     _storageAccountOptionsFactory = storageAccountOptionsFactory;
     _logger = logger ?? throw new ArgumentNullException(nameof(logger));
 }
 public InstanceManager(IOptionsFactory <ScriptApplicationHostOptions> optionsFactory, HttpClient client, IScriptWebHostEnvironment webHostEnvironment,
                        IEnvironment environment, ILogger <InstanceManager> logger)
 {
     _client             = client ?? throw new ArgumentNullException(nameof(client));
     _webHostEnvironment = webHostEnvironment ?? throw new ArgumentNullException(nameof(webHostEnvironment));
     _logger             = logger ?? throw new ArgumentNullException(nameof(logger));
     _environment        = environment ?? throw new ArgumentNullException(nameof(environment));
     _optionsFactory     = optionsFactory ?? throw new ArgumentNullException(nameof(optionsFactory));
 }
 public TenantBasedMicrosoftAccountOptions(
     IOptionsFactory <MicrosoftAccountOptions> factory,
     IEnumerable <IOptionsChangeTokenSource <MicrosoftAccountOptions> > sources,
     IOptionsMonitorCache <MicrosoftAccountOptions> cache,
     ISettingManager settingManager
     ) : base(factory, sources, cache)
 {
     AbpSession      = NullAbpSession.Instance;
     _settingManager = settingManager;
 }
Beispiel #22
0
 public ReadOnlyPluginOptions(ILifetimeScope scope, IOptionsFactory <TOptions> factory)
 {
     if (!scope.TryResolveNamed(PLUGIN_NAME, typeof(string), out var registeredPluginName) ||
         !(registeredPluginName is string pluginName))
     {
         throw new NullReferenceException("Component not configure with UseConfigurationModel");
     }
     this.PluginName = pluginName;
     this.Factory    = factory;
 }
        protected TenantBasedSocialLoginOptionsBase(
            IOptionsFactory <TOptions> factory,
            IEnumerable <IOptionsChangeTokenSource <TOptions> > sources,
            IOptionsMonitorCache <TOptions> cache
            ) : base(factory, sources, cache)
        {
            AbpSession = NullAbpSession.Instance;

            _factory = factory;
            _cache   = cache;
        }
Beispiel #24
0
 public CodeGeneratorFactory(
     IOptionsFactory optionsFactory          = null,
     IProcessLauncher processLauncher        = null,
     IOpenApiDocumentFactory documentFactory = null,
     IRemoteLogger remoteLogger = null)
 {
     this.optionsFactory  = optionsFactory ?? new OptionsFactory();
     this.processLauncher = processLauncher ?? new ProcessLauncher();
     this.documentFactory = documentFactory ?? new OpenApiDocumentFactory();
     this.remoteLogger    = remoteLogger ?? Logger.Instance;
 }
 public TenantBasedWsFederationOptions(
     IOptionsFactory <WsFederationOptions> factory,
     IEnumerable <IOptionsChangeTokenSource <WsFederationOptions> > sources,
     IOptionsMonitorCache <WsFederationOptions> cache,
     ISettingManager settingManager,
     IAppConfigurationAccessor configurationAccessor
     ) : base(factory, sources, cache)
 {
     AbpSession      = NullAbpSession.Instance;
     _settingManager = settingManager;
 }
        protected DapperDbContext(IOptionsFactory <DapperDbContextOptions> optionsAccessors)
        //protected DapperDbContext(IEnumerable<IOptions<DapperDbContextOptions>> optionsAccessors)
        {
            //SqlMapperExtensions.GetDatabaseType = DataSource.GetDatabaseType;
            SqlMapperExtensions.GetDatabaseType = conn => "MySqlConnection";
            SqlMapperExtensions.TableNameMapper = (name) => name.Name;
            _options = optionsAccessors.Create(DataSourceOptions.ToString());
            //_options = optionsAccessors.FirstOrDefault(p=>p.Configure).Value;
            _connection = CreateConnection(_options.Configuration);

            _connection.Open();
        }
Beispiel #27
0
 public InstanceManager(IOptionsFactory <ScriptApplicationHostOptions> optionsFactory, HttpClient client, IScriptWebHostEnvironment webHostEnvironment,
                        IEnvironment environment, ILogger <InstanceManager> logger, IMetricsLogger metricsLogger, IMeshServiceClient meshServiceClient, IRunFromPackageHandler runFromPackageHandler)
 {
     _client                = client ?? throw new ArgumentNullException(nameof(client));
     _webHostEnvironment    = webHostEnvironment ?? throw new ArgumentNullException(nameof(webHostEnvironment));
     _logger                = logger ?? throw new ArgumentNullException(nameof(logger));
     _metricsLogger         = metricsLogger;
     _meshServiceClient     = meshServiceClient;
     _runFromPackageHandler = runFromPackageHandler ?? throw new ArgumentNullException(nameof(runFromPackageHandler));
     _environment           = environment ?? throw new ArgumentNullException(nameof(environment));
     _optionsFactory        = optionsFactory ?? throw new ArgumentNullException(nameof(optionsFactory));
 }
Beispiel #28
0
 public MempoolMonitoringService(
     IOptionsFactory <BatBotOptions> batBotOptionsFactory,
     MessagingService messagingService,
     BackoffService backoffService,
     TransactionProcessorService transactionProcessorService,
     EthereumService ethereumService)
 {
     _batBotOptions               = batBotOptionsFactory.Create(Options.DefaultName);
     _messagingService            = messagingService;
     _backoffService              = backoffService;
     _transactionProcessorService = transactionProcessorService;
     _ethereumService             = ethereumService;
 }
 public SiteCookieAuthenticationOptions(
     IOptionsFactory <CookieAuthenticationOptions> factory,
     IEnumerable <IOptionsChangeTokenSource <CookieAuthenticationOptions> > sources,
     IOptionsMonitorCache <CookieAuthenticationOptions> cache,
     IPostConfigureOptions <CookieAuthenticationOptions> cookieOptionsInitializer,
     IHttpContextAccessor httpContextAccessor,
     ILogger <SiteCookieAuthenticationOptions> logger
     )
 {
     _cookieOptionsInitializer = cookieOptionsInitializer;
     _httpContextAccessor      = httpContextAccessor;
     _log = logger;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="ModelCreationEngine{TInput, TResult, TOptions}"/> class.
 /// </summary>
 /// <param name="modelBuilders"></param>
 /// <param name="sourceLoaderOptionsFactory"></param>
 /// <param name="engineOptionsMonitor"></param>
 /// <param name="modelLoaderOptionsFactory"></param>
 /// <param name="logger"></param>
 public ModelCreationEngine(
     IEnumerable <IModelDefinitionBuilder <TInput, TResult> > modelBuilders,
     IOptionsFactory <SourceLoaderOptions <TInput> > sourceLoaderOptionsFactory,
     IOptionsMonitor <TOptions> engineOptionsMonitor,
     IOptionsFactory <ModelLoaderOptions> modelLoaderOptionsFactory,
     ILogger <ModelCreationEngine <TInput, TResult, TOptions> > logger)
 {
     _modelBuilders = modelBuilders ?? throw new ArgumentNullException(nameof(modelBuilders));
     _sourceLoaderOptionsFactory = sourceLoaderOptionsFactory ?? throw new ArgumentNullException(nameof(sourceLoaderOptionsFactory));
     _engineOptionsMonitor       = engineOptionsMonitor;
     _modelLoaderOptionsFactory  = modelLoaderOptionsFactory ?? throw new ArgumentNullException(nameof(modelLoaderOptionsFactory));
     _logger = logger ?? throw new ArgumentNullException(nameof(logger));
 }
Beispiel #31
0
 public PinManager(IStorageManager storageManager, IOptionsFactory optionsFactory)
 {
     _storageManager = storageManager;
     _optionsFactory = optionsFactory;
 }