public CookiePolicyMiddleware( RequestDelegate next, IOptions<CookiePolicyOptions> options) { Options = options.Value; _next = next; }
public async Task Invoke(HttpContext context, ISecretNumber secretNumber, IOptions<MessageConfiguration> configuration) { await context.Response.WriteAsync(secretNumber.ComputeNumber().ToString()); await context.Response.WriteAsync(configuration.Value.Messages.Salutation); }
/// <summary> /// Initializes a new instance of the <see cref="RazorViewEngine" />. /// </summary> public RazorViewEngine( IRazorPageFactoryProvider pageFactory, IRazorPageActivator pageActivator, HtmlEncoder htmlEncoder, IOptions<RazorViewEngineOptions> optionsAccessor, ILoggerFactory loggerFactory) { _options = optionsAccessor.Value; if (_options.ViewLocationFormats.Count == 0) { throw new ArgumentException( Resources.FormatViewLocationFormatsIsRequired(nameof(RazorViewEngineOptions.ViewLocationFormats)), nameof(optionsAccessor)); } if (_options.AreaViewLocationFormats.Count == 0) { throw new ArgumentException( Resources.FormatViewLocationFormatsIsRequired(nameof(RazorViewEngineOptions.AreaViewLocationFormats)), nameof(optionsAccessor)); } _pageFactory = pageFactory; _pageActivator = pageActivator; _htmlEncoder = htmlEncoder; _logger = loggerFactory.CreateLogger<RazorViewEngine>(); ViewLookupCache = new MemoryCache(new MemoryCacheOptions { CompactOnMemoryPressure = false }); }
public RequestCultureMiddleware(RequestDelegate next, IOptions<RequestCultureOptions> options) { if (next == null) throw new ArgumentNullException(nameof(next)); if (options == null) throw new ArgumentNullException(nameof(options)); _next = next; _options = options.Value; }
public DevelopmentDefaultData(IOptions<DevelopmentSettings> options, IDataContext dataContext, UserManager<User> userManager, RoleManager<Role> roleManager) { this.settings = options.Value; this.dataContext = dataContext; this.userManager = userManager; this.roleManager = roleManager; }
public ManifestService( IOptions<AppSettings> appSettings, IUrlHelper urlHelper) { this.appSettings = appSettings; this.urlHelper = urlHelper; }
public CommonExceptionHandlerMiddleware( RequestDelegate next, ILoggerFactory loggerFactory, DiagnosticSource diagnosticSource, IOptions<ExceptionHandlerOptions> options = null ) { _next = next; if(options == null) { _options = new ExceptionHandlerOptions(); } else { _options = options.Value; } _logger = loggerFactory.CreateLogger<CommonExceptionHandlerMiddleware>(); if (_options.ExceptionHandler == null) { _options.ExceptionHandler = _next; } _clearCacheHeadersDelegate = ClearCacheHeaders; _diagnosticSource = diagnosticSource; }
public ExtensionLocator( IOptions<ExtensionHarvestingOptions> optionsAccessor, IExtensionHarvester extensionHarvester) { _optionsAccessor = optionsAccessor; _extensionHarvester = extensionHarvester; }
public RaygunAspNetMiddleware(RequestDelegate next, IOptions<RaygunSettings> settings, RaygunMiddlewareSettings middlewareSettings) { _next = next; _middlewareSettings = middlewareSettings; _settings = _middlewareSettings.ClientProvider.GetRaygunSettings(settings.Value ?? new RaygunSettings()); }
/// <summary> /// Create a new instance of <see cref="DataAnnotationsModelValidatorProvider"/>. /// </summary> /// <param name="options">The <see cref="IOptions{MvcDataAnnotationsLocalizationOptions}"/>.</param> /// <param name="stringLocalizerFactory">The <see cref="IStringLocalizerFactory"/>.</param> public DataAnnotationsModelValidatorProvider( IOptions<MvcDataAnnotationsLocalizationOptions> options, IStringLocalizerFactory stringLocalizerFactory) { _options = options; _stringLocalizerFactory = stringLocalizerFactory; }
public TwilioSMSService(IOptions<SmsSettings> smsSettings) { _smsSettings = smsSettings.Value; //TwilioClient.Init(_smsSettings.Sid, _smsSettings.Token); _restClient = new TwilioRestClient(_smsSettings.Sid, _smsSettings.Token); }
public CustomUrlHelper(IScopedInstance<ActionContext> contextAccessor, IActionSelector actionSelector, IOptions<AppOptions> appOptions) : base(contextAccessor, actionSelector) { _appOptions = appOptions; _httpContext = contextAccessor.Value.HttpContext; }
public override UnbindResult Unbind(HttpRequestData request, IOptions options) { if (request == null) { throw new ArgumentNullException(nameof(request)); } var payload = Convert.FromBase64String(request.QueryString["SAMLRequest"].First()); using (var compressed = new MemoryStream(payload)) { using (var decompressedStream = new DeflateStream(compressed, CompressionMode.Decompress, true)) { using (var deCompressed = new MemoryStream()) { decompressedStream.CopyTo(deCompressed); var xml = new XmlDocument() { PreserveWhitespace = true }; xml.LoadXml(Encoding.UTF8.GetString(deCompressed.GetBuffer())); return new UnbindResult( xml.DocumentElement, request.QueryString["RelayState"].SingleOrDefault()); } } } }
public HomeController( IBrowserConfigService browserConfigService, #if DNX451 // The FeedService is not available for .NET Core because the System.ServiceModel.Syndication.SyndicationFeed // type does not yet exist. See https://github.com/dotnet/wcf/issues/76. IFeedService feedService, #endif IManifestService manifestService, IOpenSearchService openSearchService, IRobotsService robotsService, ISitemapService sitemapService, IOptions<AppSettings> appSettings) { this.appSettings = appSettings; this.browserConfigService = browserConfigService; #if DNX451 // The FeedService is not available for .NET Core because the System.ServiceModel.Syndication.SyndicationFeed // type does not yet exist. See https://github.com/dotnet/wcf/issues/76. this.feedService = feedService; #endif this.manifestService = manifestService; this.openSearchService = openSearchService; this.robotsService = robotsService; this.sitemapService = sitemapService; }
internal RedisMessageBus(IStringMinifier stringMinifier, ILoggerFactory loggerFactory, IPerformanceCounterManager performanceCounterManager, IOptions<MessageBusOptions> optionsAccessor, IOptions<RedisScaleoutOptions> scaleoutConfigurationAccessor, IRedisConnection connection, bool connectAutomatically) : base(stringMinifier, loggerFactory, performanceCounterManager, optionsAccessor, scaleoutConfigurationAccessor) { _connectionString = scaleoutConfigurationAccessor.Options.ConnectionString; _db = scaleoutConfigurationAccessor.Options.Database; _key = scaleoutConfigurationAccessor.Options.EventKey; _connection = connection; _logger = loggerFactory.CreateLogger<RedisMessageBus>(); ReconnectDelay = TimeSpan.FromSeconds(2); if (connectAutomatically) { ThreadPool.QueueUserWorkItem(_ => { var ignore = ConnectWithRetry(); }); } }
/// <summary> /// application configuration for cloudscribe core /// here is where we will need to do some magic for mutli tenants by folder if configured for that as by default /// we would also plug in any custom OWIN middleware components here /// things that would historically be implemented as HttpModules would now be implemented as OWIN middleware components /// </summary> /// <param name="app"></param> /// <param name="config"></param> /// <returns></returns> public static IApplicationBuilder UseCloudscribeCore( this IApplicationBuilder app, IOptions<MultiTenantOptions> multiTenantOptions) { //// Add cookie-based authentication to the request pipeline. ////https://github.com/aspnet/Identity/blob/dev/src/Microsoft.AspNet.Identity/BuilderExtensions.cs //app.UseIdentity(); app.UseCloudscribeIdentity(); app.UseMultiTenantFacebookAuthentication(); app.UseMultiTenantGoogleAuthentication(); app.UseMultiTenantMicrosoftAccountAuthentication(); app.UseMultiTenantTwitterAuthentication(); //app.UseCultureReplacer(); //app.UseRequestLocalization(); return app; }
private static CommandResult ProcessResponse(IOptions options, Saml2Response samlResponse) { var principal = new ClaimsPrincipal(samlResponse.GetClaims(options)); principal = options.SPOptions.SystemIdentityModelIdentityConfiguration .ClaimsAuthenticationManager.Authenticate(null, principal); var requestState = samlResponse.GetRequestState(options); if(requestState == null && options.SPOptions.ReturnUrl == null) { throw new ConfigurationErrorsException(MissingReturnUrlMessage); } return new CommandResult() { HttpStatusCode = HttpStatusCode.SeeOther, Location = requestState?.ReturnUrl ?? options.SPOptions.ReturnUrl, Principal = principal, RelayData = requestState == null ? null : requestState.RelayData }; }
public CustomCompilationService(ApplicationPartManager partManager, IOptions<RazorViewEngineOptions> optionsAccessor, IRazorViewEngineFileProviderAccessor fileProviderAccessor, ILoggerFactory loggerFactory) : base(partManager, optionsAccessor, fileProviderAccessor, loggerFactory) { }
public AppController(IHttpContextAccessor httpContextAccessor, UserManager<MyUser> userManager, IOptions<IdentityOptions> optionsAccessor) { SignInManager = new MySignInManager(userManager as MyUserManager, httpContextAccessor, new MyClaimsPrincipleFactory()); UserManager = userManager; }
public SingleActionApplicationModelConvention(IOptions<SingleActionControllerOptions> optionsAccessor) { options = optionsAccessor.Value; if(!options.IsOptionsConfigured) { throw new Exception("SingleActionControllerOptions class not configured in Startup."); } }
public SingleActionControllerRouteBuilder(IOptions<SingleActionControllerOptions> optionsAccessor, IControllerTypeProvider controllerTypeProvider, IEnumerable<IApplicationModelProvider> applicationModelProviders, IOptions<MvcOptions> mvcOptionsAccessor) { options = optionsAccessor.Value; conventions = mvcOptionsAccessor.Value.Conventions; this.controllerTypeProvider = controllerTypeProvider; this.applicationModelProviders = applicationModelProviders.OrderBy(p => p.Order).ToArray(); }
public HttpServiceGatewayMiddleware( RequestDelegate next, ILoggerFactory loggerFactory, IHttpCommunicationClientFactory httpCommunicationClientFactory, IOptions<HttpServiceGatewayOptions> gatewayOptions) { if (next == null) throw new ArgumentNullException(nameof(next)); if (loggerFactory == null) throw new ArgumentNullException(nameof(loggerFactory)); if (httpCommunicationClientFactory == null) throw new ArgumentNullException(nameof(httpCommunicationClientFactory)); if (gatewayOptions?.Value == null) throw new ArgumentNullException(nameof(gatewayOptions)); if (gatewayOptions.Value.ServiceName == null) throw new ArgumentNullException($"{nameof(gatewayOptions)}.{nameof(gatewayOptions.Value.ServiceName)}"); // "next" is not stored because this is a terminal middleware _logger = loggerFactory.CreateLogger(HttpServiceGatewayDefaults.LoggerName); _httpCommunicationClientFactory = httpCommunicationClientFactory; _gatewayOptions = gatewayOptions.Value; }
/// <summary> /// Creates a new <see cref="SessionMiddleware"/>. /// </summary> /// <param name="next">The <see cref="RequestDelegate"/> representing the next middleware in the pipeline.</param> /// <param name="loggerFactory">The <see cref="ILoggerFactory"/> representing the factory that used to create logger instances.</param> /// <param name="sessionStore">The <see cref="ISessionStore"/> representing the session store.</param> /// <param name="options">The session configuration options.</param> public SessionMiddleware( RequestDelegate next, ILoggerFactory loggerFactory, ISessionStore sessionStore, IOptions<SessionOptions> options) { if (next == null) { throw new ArgumentNullException(nameof(next)); } if (loggerFactory == null) { throw new ArgumentNullException(nameof(loggerFactory)); } if (sessionStore == null) { throw new ArgumentNullException(nameof(sessionStore)); } if (options == null) { throw new ArgumentNullException(nameof(options)); } _next = next; _logger = loggerFactory.CreateLogger<SessionMiddleware>(); _options = options.Value; _sessionStore = sessionStore; _sessionStore.Connect(); }
public GravatarProvider( IOptions<AppSettings> appSettings , ApplicationUserManager userManager) { _appSettings = appSettings.Value; _userManager = userManager; }
public static CommandResult Run( HttpRequestData request, string returnPath, IOptions options) { if (request == null) { throw new ArgumentNullException(nameof(request)); } if (options == null) { throw new ArgumentNullException(nameof(options)); } var binding = Saml2Binding.Get(request); if (binding != null) { var unbindResult = binding.Unbind(request, options); VerifyMessageIsSigned(unbindResult, options); switch (unbindResult.Data.LocalName) { case "LogoutRequest": return HandleRequest(unbindResult, options); case "LogoutResponse": return HandleResponse(unbindResult, request); default: throw new NotImplementedException(); } } return InitiateLogout(request, returnPath, options); }
public FolderTenantNodeUrlPrefixProvider( SiteSettings currentSite, IOptions<MultiTenantOptions> multiTenantOptions) { site = currentSite; options = multiTenantOptions.Value; }
public static void Configure(IHostingEnvironment env, IOptions<AppConfig> config) { ActionsFile = env.WebRootPath + config.Value.ActionsFile; ConfigsFile= env.WebRootPath + config.Value.ConfigsFile; LoadActions(); LoadConfigs(); }
public SiteAdminController( SiteManager siteManager, GeoDataManager geoDataManager, IOptions<MultiTenantOptions> multiTenantOptions, IOptions<UIOptions> uiOptionsAccessor, IOptions<LayoutSelectorOptions> layoutSeletorOptionsAccessor, ILayoutFileListBuilder layoutListBuilder //ConfigHelper configuration //, ITriggerStartup startupTrigger ) { //if (siteResolver == null) { throw new ArgumentNullException(nameof(siteResolver)); } if (geoDataManager == null) { throw new ArgumentNullException(nameof(geoDataManager)); } //if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } //config = configuration; this.multiTenantOptions = multiTenantOptions.Value; //Site = siteResolver.Resolve(); this.siteManager = siteManager; this.geoDataManager = geoDataManager; uiOptions = uiOptionsAccessor.Value; this.layoutListBuilder = layoutListBuilder; layoutOptions = layoutSeletorOptionsAccessor.Value; //startup = startupTrigger; }
public OpenSearchService( IOptions<AppSettings> appSettings, IUrlHelper urlHelper) { this.appSettings = appSettings; this.urlHelper = urlHelper; }
public DnxProjectSystem(OmnisharpWorkspace workspace, IOmnisharpEnvironment env, IOptions<OmniSharpOptions> optionsAccessor, ILoggerFactory loggerFactory, IMetadataFileReferenceCache metadataFileReferenceCache, IApplicationLifetime lifetime, IFileSystemWatcher watcher, IEventEmitter emitter, DnxContext context) { _workspace = workspace; _env = env; _logger = loggerFactory.CreateLogger<DnxProjectSystem>(); _metadataFileReferenceCache = metadataFileReferenceCache; _options = optionsAccessor.Options; _dnxPaths = new DnxPaths(env, _options, loggerFactory); _designTimeHostManager = new DesignTimeHostManager(loggerFactory, _dnxPaths); _packagesRestoreTool = new PackagesRestoreTool(_options, loggerFactory, emitter, context, _dnxPaths); _context = context; _watcher = watcher; _emitter = emitter; _directoryEnumerator = new DirectoryEnumerator(loggerFactory); lifetime.ApplicationStopping.Register(OnShutdown); }
public CommentRepository(IOptions <Settings> settings, ILogger <CommentRepository> logger) { _context = new MongoContext(settings); _logger = logger; }
public OpenIdConnectOptionsSetup(IOptions <AzureAdB2cOptions> b2cOptions) { AzureAdB2cOptions = b2cOptions.Value; }
public FileStorageService(IOptions <ConnectionSettings> connectionSetting, IOptions <AppSettings> appSettings) { _appSettings = appSettings.Value; _connectionSetting = connectionSetting.Value; }
/// <summary> /// ctor /// </summary> /// <param name="cache"></param> /// <param name="options"></param> /// <param name="logger"></param> public ClientAccessTokenCache(IDistributedCache cache, IOptions <AccessTokenManagementOptions> options, ILogger <ClientAccessTokenCache> logger) { _cache = cache; _logger = logger; _options = options.Value; }
public static async Task <RecipesCosmosClient> InitializeRecipesCosmosInstance(IOptions <RecipesCosmosDbConfig> options, ILogger <RecipesCosmosClient> logger) { var cosmosConfig = options.Value; CosmosClientOptions cosmosClientOptions = new CosmosClientOptions { MaxRetryAttemptsOnRateLimitedRequests = 9, MaxRetryWaitTimeOnRateLimitedRequests = TimeSpan.FromSeconds(60) }; CosmosClient cosmosClient = new CosmosClient( cosmosConfig.endPointUrl, cosmosConfig.authorizationKey, cosmosClientOptions ); RecipesCosmosClient recipesCosmosClient = new RecipesCosmosClient(logger, cosmosConfig, cosmosClient); DatabaseResponse databaseResponse = await cosmosClient.CreateDatabaseIfNotExistsAsync(cosmosConfig.databaseId); ContainerProperties containerProperties = new ContainerProperties() { Id = cosmosConfig.containerId, PartitionKeyPath = $"/{cosmosConfig.partitionKey}" }; await databaseResponse.Database.CreateContainerIfNotExistsAsync(containerProperties); return(recipesCosmosClient); }
public View(IOptions <AppSettings> options) { _settings = options.Value; }
public CosignLoginResultsExtractor(IOptions <IdpSettings.IdpSettings> settings) { _cosignClientName = settings.Value.CosignClient.Name; }
public MainWindow(IGenerator generator, ICallService callService, IAgentService agentService, IConsoleService consoleService, IOptions <AppSettings> settings) { InitializeComponent(); this.generator = generator; this.callService = callService; this.consoleService = consoleService; this.agentService = agentService; this.settings = settings.Value; var allAgents = agentService.GetAllAgents(); foreach (var agent in allAgents) { AgenstList.Items.Add(agent); } Calls = new Queue <Call>(); ActiveCall = new List <Call>(); var newCalls = callService.GenerateCalls(); foreach (var call in newCalls) { Calls.Enqueue(call); } LogConsole.Items.Add(consoleService.CallInfo(Calls.Count())); Task.Factory.StartNew(() => { BeginInvokeExample(); }); }
public LikeFactory(IOptions<MySqlConfig> options) { connectionString = options.Value.ConnectionString; }
public RuntimeMultiViewCompilerProvider(IHttpContextAccessor contextAccessor, ApplicationPartManager applicationPartManager, IOptions <RazorMultiViewEngineOptions> optionsAccessor, IDictionary <string, RazorProjectEngine> razorProjectEngines, PublicCSharpCompiler csharpCompiler, ILoggerFactory loggerFactory) { this.contextAccessor = contextAccessor ?? throw new ArgumentNullException(nameof(contextAccessor)); this.options = optionsAccessor?.Value ?? throw new ArgumentNullException(nameof(optionsAccessor)); this.logger = loggerFactory.CreateLogger <RuntimeMultiViewCompiler>(); var feature = new ViewsFeature(); applicationPartManager.PopulateFeature(feature); var defaultViews = new List <CompiledViewDescriptor>(); var defaultEngine = razorProjectEngines.First(); foreach (var descriptor in feature.ViewDescriptors.Where(f => f.Item.Type.Assembly.GetName().Name.Equals(options.DefaultViewLibrary?.AssemblyName) || f.Item.Type.Assembly.GetName().Name.Equals(options.DefaultViewLibrary?.AssemblyName + ".Views", StringComparison.Ordinal))) { if (!defaultViews.Exists(v => v.RelativePath.Equals(descriptor.RelativePath, StringComparison.OrdinalIgnoreCase))) { defaultViews.Add(descriptor); } } compilers.Add("default", new RuntimeMultiViewCompiler(new Dictionary <string, RazorProjectEngine> { { defaultEngine.Key, defaultEngine.Value } }, csharpCompiler, defaultViews, logger)); // A cache list of libraries and their compiled views var libraryViewList = new Dictionary <string, List <CompiledViewDescriptor> >(); foreach (var option in options.ViewLibraryConfig) { var optionEngines = new Dictionary <string, RazorProjectEngine>(); if (compilers.ContainsKey(option.Key)) { continue; } // A list of descriptors for this option var viewDescriptors = new List <CompiledViewDescriptor>(); // Loop the requested libraries foreach (var library in option.Value) { if (razorProjectEngines.TryGetValue(library + ".Views", out var engine)) { if (!optionEngines.ContainsKey(library)) { optionEngines.Add(library + ".Views", engine); } } if (!libraryViewList.TryGetValue(library, out var liblist)) { liblist = feature.ViewDescriptors.Where(d => d.Item.Type.Assembly.GetName().Name.Equals($"{library}") || d.Item.Type.Assembly.GetName().Name.Equals($"{library}.Views")).ToList(); } foreach (var descriptor in liblist) { if (viewDescriptors.Exists(v => v.RelativePath.Equals(descriptor.RelativePath, StringComparison.OrdinalIgnoreCase))) { continue; } viewDescriptors.Add(descriptor); } } // Add any missing views from the default library foreach (var descriptor in defaultViews) { if (viewDescriptors.Exists(v => v.RelativePath.Equals(descriptor.RelativePath, StringComparison.OrdinalIgnoreCase))) { continue; } viewDescriptors.Add(descriptor); } optionEngines.Add(defaultEngine.Key, defaultEngine.Value); compilers.Add(option.Key, new RuntimeMultiViewCompiler(optionEngines, csharpCompiler, viewDescriptors, logger)); } }
public ElectSwaggerMiddleware(RequestDelegate next, IOptions <ElectSwaggerOptions> configuration) { _next = next; _options = configuration.Value; }
public ApiClient(HttpClient httpClient, IOptions <EmployerDemandApi> config) { _httpClient = httpClient; _config = config.Value; _httpClient.BaseAddress = new Uri(_config.BaseUrl); }
public UserService(IUserRepository userRepository, IOptions <AppSettings> appSettings) { _userRepository = userRepository; _appSettings = appSettings.Value; }
public SquidexService(IOptions<SquidexOptions> squidexOptions) { _squidexClientManager = new SquidexClientManager(squidexOptions.Value); _squidexOptions = squidexOptions.Value; }
public ChargerRepository(IOptions <ModbusSlaveConfiguration> modbusSlaveConfiguration) : base(modbusSlaveConfiguration) { _modbusSlaveConfiguration = modbusSlaveConfiguration.Value; }
public AlarmNotificationService(MyDBContext dbCtx, Lazy<ITemplateHelperService> templateService, ISettingService s, IEmailService mailService, ITranslationService t, IOptions<AppSettings> appSettings, ILogger<AlarmNotificationService> logger) { _dbCtx = dbCtx; _logger = logger; _appSettings = appSettings; _mailService = mailService; _t = t; _s = s; _templateService = templateService; }
public FeedingService(ISatisfactionService satisfactionService, IOptions <FeedingOptions> feedingOptions) { _satisfactionService = satisfactionService; _options = feedingOptions.Value; }
public BaseProcessor (IOptions<AppSettings> settings, ILogger logger) { _settings = settings; _logger = logger; }
public IapiRateLimiterUserIdHttpFilterService(IAPIRateLimiterUserIdStorageProvider iipRateLimiterUserIdStorageProvider, IHttpContextAccessor httpContext, IOptions <APIRateLimiterUserIdOptions> settings) { _provider = iipRateLimiterUserIdStorageProvider; _httpContext = httpContext; _settings = settings.Value; }
public JwtFactory(IOptions <JwtIssuerOptions> jwtOptions) { _jwtOptions = jwtOptions.Value; ThrowIfInvalidOptions(_jwtOptions); }
public JwtTokenService(IOptions <JwtTokenSettings> options) { _settings = options.Value; }
public ThemeProcessor(IOptions <UrlsOptions> urlOptions) { url = urlOptions.Value.BuildUrl("images/logo-white.png", false); }
public EFRepositoryGenerator(IOptions <EFRepositoryGeneratorOptions> options) { _generatorOptions = options.Value; }
public WithdrawalMethodConfigurationProvider(IOptions <PaymentServicePrepaymentOptions> options) { _options = options.Value; }
public GetGroupsHandler(IOptions<ServiceNowOptions> options, IMapper mapper, IMemoryCache cache) { _options = options.Value; _mapper = mapper; _cache = cache; }
public ConsumerRabbitManager(ILoggerFactory loggerFactory, IOptions <RabbitOptions> optionsAccs) { _options = optionsAccs.Value; this._logger = loggerFactory.CreateLogger <ConsumerRabbitManager>(); InitRabbitMQ(); }
public AuthenticationService(UserManager <User> userManager, SignInManager <User> signInManager, IJwtUser user, IOptions <JwtSettings> jwtSettings, IOptions <FacebookAuthSettings> facebookAuthSettings, IOptions <RefreshTokenSettings> refreshTokenSettings, IdentityDbContext context, IMapper mapper) { this.UserManager = userManager; this.SignInManager = signInManager; this.JwtSettings = jwtSettings.Value; this.FacebookAuthSettings = facebookAuthSettings.Value; this.RefreshTokenSettings = refreshTokenSettings.Value; this.Context = context; this.Mapper = mapper; }
public AuditTrailHubService(IAuditTrailSink sink, IOptions <AuditTrailHubOptions> options) { _sink = sink ?? throw new ArgumentNullException(nameof(sink)); _options = options.Value; }
public RoversController(IRoverRepository repository, IOptions <ServiceConfiguration> configuration) { _repository = repository; _configuration = configuration; }
public MemberRoleCount(IOptions <CommonCommandOptions> commonCommandOptions) { _commonCommandOptions = commonCommandOptions.Value; }