public RedisFactory(IOptionsMonitor <RedisOptions> optionsMonitor)
{
_optionsMonitor = optionsMonitor;
optionsMonitor.OnChange((_, name) => _connectionMultiplexers.TryRemove(name, out var _));
}
/// <summary>
/// Initializes a new instance of the <see cref="CorrelationIdContextProvider"/> class.
/// </summary>
/// <param name="httpContextAccessor">The http context accessor used to retreive the correlation id.</param>
/// <param name="options">Options containing the name of the correlation id header.</param>
public CorrelationIdContextProvider(IHttpContextAccessor httpContextAccessor,
IOptionsMonitor <CorrelationIdContextProviderOptions> options = null)
: this(httpContextAccessor?.HttpContext?.GetCorrelationIdAccessor(options?.CurrentValue.CorrelationIdHeader ?? CorrelationId))
{
}
public CustomFormatter(IOptionsMonitor <CustomOptions> options)
: base("custom")
{
ReloadLoggerOptions(options.CurrentValue);
_optionsReloadToken = options.OnChange(ReloadLoggerOptions);
}
public DefaultDapperFactory(IServiceProvider services, IOptionsMonitor <DapperFactoryOptions> optionsMonitor)
{
_services = services ?? throw new ArgumentNullException(nameof(services));
_optionsMonitor = optionsMonitor ?? throw new ArgumentNullException(nameof(optionsMonitor));
}
public ApiAuthHandler(IOptionsMonitor <ApiAuthOptions> options, ILoggerFactory logger, UrlEncoder encoder,
ISystemClock clock, ApiClientFactory factory)
: base(options, logger, encoder, clock)
{
Factory = factory;
}
public SingleLineConsoleLoggerProvider(IOptionsMonitor <SingleLineConsoleLoggerOptions> options)
{
_options = options;
_optionsReloadToken = _options.OnChange(ReloadOptions);
_sink = new SingleLineConsoleLoggerSink(_options.CurrentValue);
}
public ConfigurationOptionsMonitorService(IOptionsMonitor <Settings> optionsMonitor)
{
_optionsMonitor = optionsMonitor;
}
public BasicAuthenticationHandler(IApiSignInManager apiSignInManager, IUserManager userManager, IOptionsMonitor <BasicAuthenticationOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock)
: base(options, logger, encoder, clock)
{
_apiSignInManager = apiSignInManager;
_userManager = userManager;
}
public MongoPatchbotGameStore(IMongoConnection databaseConnection, IOptionsMonitor <DatabaseOptions> databaseOptions, IHostApplicationLifetime hostLifetime, ILogger <MongoPatchbotGameStore> log, IEntityCache <string, PatchbotGame> patchbotGameCache, IOptionsMonitor <CachingOptions> cachingOptions)
: base(databaseConnection, databaseOptions, hostLifetime, log)
{
this._patchbotGameCache = patchbotGameCache;
this._log = log;
this._cachingOptions = cachingOptions;
base.MongoConnection.ClientChanged += OnClientChanged;
OnClientChanged(base.MongoConnection.Client);
}
public QQHandler(IOptionsMonitor <QQOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock)
: base(options, logger, encoder, clock)
{
}
public ChiyaProxyHttp2HandlerBuilder(IServiceProvider services, IOptionsMonitor <ProxyOptions> options, ILogger <ChiyaProxyHttp2HandlerBuilder> logger)
{
_services = services;
_options = options;
_logger = logger;
}
public async Task <IActionResult> Create(CourseCreateInputModel inputModel, [FromServices] IAuthorizationService authorizationService, [FromServices] IEmailClient emailClient, [FromServices] IOptionsMonitor <UsersOptions> usersOptions)
{
if (ModelState.IsValid)
{
try
{
CourseDetailViewModel course = await courseService.CreateCourseAsync(inputModel);
// Per non inserire logica nel controller, potremmo spostare questo blocco all'interno del metodo CreateCourseAsync del servizio applicativo
// ...ma attenzione a non creare riferimenti circolari! Se il course service dipende da IAuthorizationService
// ...e viceversa l'authorization handler dipende dal course service, allora la dependency injection non riuscirà a risolvere nessuno dei due servizi, dandoci un errore
AuthorizationResult result = await authorizationService.AuthorizeAsync(User, nameof(Policy.CourseLimit));
if (!result.Succeeded)
{
await emailClient.SendEmailAsync(usersOptions.CurrentValue.NotificationEmailRecipient, "Avviso superamento soglia", $"Il docente {User.Identity.Name} ha creato molti corsi: verifica che riesca a gestirli tutti.");
}
TempData["ConfirmationMessage"] = "Ok! Il tuo corso è stato creato, ora perché non inserisci anche gli altri dati?";
return(RedirectToAction(nameof(Edit), new { id = course.Id }));
}
catch (CourseTitleUnavailableException)
{
ModelState.AddModelError(nameof(CourseDetailViewModel.Title), "Questo titolo già esiste");
}
}
ViewData["Title"] = "Nuovo corso";
return(View(inputModel));
}
public SystemTokenAuthenticationHandler(IOptionsMonitor <Opts> options, ILoggerFactory logger,
UrlEncoder encoder, ISystemClock clock, IDatabase db) : base(options,
logger, encoder, clock)
{
_db = db;
}
/// <summary>
///
/// </summary>
/// <param name="options"></param>
/// <param name="logger"></param>
public SmtpClientService(IOptionsMonitor <EmailStmpOption> options, ILogger <SmtpClientService> logger)
{
emailConfig = options.CurrentValue.EmailSetting;
_logger = logger;
}
public TwitterHandler2(IOptionsMonitor <TwitterOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock)
: base(options, logger, encoder, clock)
{
}
public AttachmentService(IAttachmentRepository repository, IAttachmentOwnerRepository ownerRepository, IOptionsMonitor <ModuleCommonOptions> moduleCommonOptionsMonitor, IMediaTypeRepository mediaTypeRepository, IMapper mapper, CommonDbContext dbContext)
{
_repository = repository;
_ownerRepository = ownerRepository;
_moduleCommonOptions = moduleCommonOptionsMonitor.CurrentValue;
_mediaTypeRepository = mediaTypeRepository;
_mapper = mapper;
_dbContext = dbContext;
}
public BalanceNoteRepository(IOptionsMonitor <DbSettings> options) : base(options)
{
}
public HeaderAuthenticationHandler(IOptionsMonitor <HeaderAuthenticationOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock) : base(options, logger, encoder, clock)
{
}
public ConsoleLoggerProvider(IOptionsMonitor <BatchingLoggerOptions> options) : base(options)
{
}
public ApiKeyAuthenticationHandler(IOptionsMonitor <ApiKeyAuthenticationOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock, IServiceProvider serviceProvider)
: base(options, logger, encoder, clock)
{
ServiceProvider = serviceProvider;
}
public IndexModel(IAccountContext account, IOptionsMonitor <AppConfig> appConfig) : base(appConfig)
{
_account = account;
}
public CountryApiClient(HttpClient client, IOptionsMonitor <AppSettingsOptions> appSettings)
{
_client = client ?? throw new ArgumentNullException(nameof(client));
_appSettings = appSettings ?? throw new ArgumentNullException(nameof(appSettings));
}
public FileVersionScrubService(IServiceScopeFactory serviceScopeFactory, IOptionsMonitor <FileVersionScrubOptions> fileVersionScrubOptions, ILogger <FileVersionScrubService> logger)
{
_serviceScopeFactory = serviceScopeFactory;
_fileVersionScrubOptions = fileVersionScrubOptions;
_logger = logger;
}
public TenantStatusFilter(IOptionsMonitor <ILog> options, TenantManager tenantManager)
{
log = options.CurrentValue;
TenantManager = tenantManager;
}
public HelloService(IHttpMessageHandlerFactory factory, ILogger <HelloService> logger, IOptionsMonitor <HelloServiceOptions> options)
{
_logger = logger;
_client = new Hello_PortTypeClient();
_client.Endpoint.EndpointBehaviors.Add(new HttpMessageHandlerBehavior(factory, ServiceName));
_client.Endpoint.Address = new EndpointAddress(options.CurrentValue.EndpointAddress);
_client.Endpoint.Binding.CloseTimeout = TimeSpan.FromSeconds(options.CurrentValue.TimeoutSeconds);
_client.Endpoint.Binding.OpenTimeout = TimeSpan.FromSeconds(options.CurrentValue.TimeoutSeconds);
_client.Endpoint.Binding.ReceiveTimeout = TimeSpan.FromSeconds(options.CurrentValue.TimeoutSeconds);
_client.Endpoint.Binding.SendTimeout = TimeSpan.FromSeconds(options.CurrentValue.TimeoutSeconds);
}
public UsersController(IAddRepresentationCommandHandler addRepresentationCommandHandler, IDeleteRepresentationCommandHandler deleteRepresentationCommandHandler, IReplaceRepresentationCommandHandler replaceRepresentationCommandHandler, IPatchRepresentationCommandHandler patchRepresentationCommandHandler, ISCIMRepresentationQueryRepository scimRepresentationQueryRepository, ISCIMSchemaQueryRepository scimSchemaQueryRepository, IAttributeReferenceEnricher attributeReferenceEnricher, IOptionsMonitor <SCIMHostOptions> options, ILogger <UsersController> logger) : base(SCIMConstants.SCIMEndpoints.User, addRepresentationCommandHandler, deleteRepresentationCommandHandler, replaceRepresentationCommandHandler, patchRepresentationCommandHandler, scimRepresentationQueryRepository, scimSchemaQueryRepository, attributeReferenceEnricher, options, logger)
{
}
public void EmptyCtor_Should_ThrowException(
IOptionsMonitor <AppSettings> settings)
{
Assert.Throws <ArgumentNullException>(() => new EventCanceledIntegrationEventHandler(null, settings));
}
public BasicAuthenticationHandler(IOptionsMonitor <AuthenticationSchemeOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock) : base(options, logger, encoder, clock)
{
}
public TwilioSignatureValidator(IOptionsMonitor <TwilioSettings> settingsMonitor)
{
_settingsMonitor = settingsMonitor;
}
/// <summary>
/// Initializes a new instance of the <see cref="LinkTagHelper"/> class.
/// </summary>
public LinkTagHelper(IWebHostEnvironment env, IMemoryCache cache, IAssetPipeline pipeline, IOptionsMonitor <WebOptimizerOptions> options)
: base(env, cache, pipeline, options)
{
}
