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;
}
