Esempio n. 1
0
 public WebItemManager(IContainer container, IConfiguration configuration, IOptionsMonitor <ILog> options)
 {
     Container     = container;
     Configuration = configuration;
     log           = options.Get("ASC.Web");
     disableItem   = (Configuration["web:disabled-items"] ?? "").Split(",").ToList();
     LoadItems();
 }
Esempio n. 2
0
        private CallInvoker CreateInvoker(EntryKey key)
        {
            var(name, type) = (key.Name, key.Type);
            var scope    = _scopeFactory.CreateScope();
            var services = scope.ServiceProvider;

            try
            {
                var httpClientFactoryOptions = _httpClientFactoryOptionsMonitor.Get(name);
                if (httpClientFactoryOptions.HttpClientActions.Count > 0)
                {
                    throw new InvalidOperationException($"The ConfigureHttpClient method is not supported when creating gRPC clients. Unable to create client with name '{name}'.");
                }

                var clientFactoryOptions = _grpcClientFactoryOptionsMonitor.Get(name);
                var httpHandler          = _messageHandlerFactory.CreateHandler(name); if (httpHandler == null)
                {
                    throw new ArgumentNullException(nameof(httpHandler));
                }

                var channelOptions = new GrpcChannelOptions();
                channelOptions.HttpHandler     = httpHandler;
                channelOptions.LoggerFactory   = _loggerFactory;
                channelOptions.ServiceProvider = services;

                if (clientFactoryOptions.ChannelOptionsActions.Count > 0)
                {
                    foreach (var applyOptions in clientFactoryOptions.ChannelOptionsActions)
                    {
                        applyOptions(channelOptions);
                    }
                }

                var address = clientFactoryOptions.Address;
                if (address == null)
                {
                    throw new InvalidOperationException($@"Could not resolve the address for gRPC client '{name}'. Set an address when registering the client: services.AddGrpcClient<{type.Name}>(o => o.Address = new Uri(""https://localhost:5001""))");
                }

                var channel = GrpcChannel.ForAddress(address, channelOptions);

                var httpClientCallInvoker = channel.CreateCallInvoker();

                var resolvedCallInvoker = GrpcClientFactoryOptions.BuildInterceptors(
                    httpClientCallInvoker,
                    services,
                    clientFactoryOptions,
                    InterceptorScope.Channel);

                return(resolvedCallInvoker);
            }
            catch
            {
                // If something fails while creating the handler, dispose the services.
                scope?.Dispose();
                throw;
            }
        }
        public async Task <ProductsApiResult> GetProducts()
        {
            const string cacheKey = "Products";

            if (_cache.TryGetValue <ProductsApiResult>(cacheKey, out var forecast))
            {
                return(forecast);
            }

            const string path = "api/products";

            try
            {
                var request = new HttpRequestMessage(HttpMethod.Get, path);
                request.Headers.Add("ApiKey", _productsApiConfig.Get(ExternalServicesConfig.ProductsApi)
                                    .ApiKey);

                var response = await _httpClient.SendAsync(request);

                if (!response.IsSuccessStatusCode)
                {
                    return(null);
                }

                var content = await response.Content.ReadAsAsync <ProductsApiResult>();

                if (content != null)
                {
                    var cacheOptions = new MemoryCacheEntryOptions
                    {
                        AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(_productsApiConfig.Get(ExternalServicesConfig.ProductsApi).MinsToCache)
                    };

                    _cache.Set(cacheKey, content, cacheOptions);
                }

                return(content);
            }
            catch (HttpRequestException e)
            {
                _logger.LogError(e, "Failed to get products data from API");
            }

            return(null);
        }
Esempio n. 4
0
        public DaprClient CreateClient(string name)
        {
            if (name == null)
            {
                throw new ArgumentNullException(nameof(name));
            }

            var client = _daprClients.GetOrAdd(name, _daprClientFactory).Value;

            var options = _optionsMonitor.Get(name);

            for (int i = 0; i < options.DaprClientActions.Count; i++)
            {
                options.DaprClientActions[i](client);
            }

            return(client);
        }
Esempio n. 5
0
        internal static TOptions GetOptions <TOptions>(this IOptionsMonitor <TOptions> optionsMonitor,
                                                       string name, Action <TOptions>?configureOptions)
            where TOptions : class, new()
        {
            var options = optionsMonitor?.Get(name) ?? new TOptions();

            configureOptions?.Invoke(options);
            return(options);
        }
        protected static CosmosCollectionConfiguration GetCosmosCollectionConfiguration(
            IOptionsMonitor <CosmosCollectionConfiguration> namedCosmosCollectionConfigurationAccessor,
            string collectionConfigurationName)
        {
            EnsureArg.IsNotNull(namedCosmosCollectionConfigurationAccessor, nameof(namedCosmosCollectionConfigurationAccessor));
            EnsureArg.IsNotNullOrWhiteSpace(collectionConfigurationName, nameof(collectionConfigurationName));

            return(namedCosmosCollectionConfigurationAccessor.Get(collectionConfigurationName));
        }
    public virtual string GetAuthCookieNameOrNull()
    {
        if (_abpAntiForgeryOptions.AuthCookieSchemaName == null)
        {
            return(null);
        }

        return(_namedOptionsAccessor.Get(_abpAntiForgeryOptions.AuthCookieSchemaName)?.Cookie?.Name);
    }
 public CrossModuleTransferUtility(IOptionsMonitor <ILog> option, IDataStore source, IDataStore destination)
 {
     Log                = option.Get("ASC.CrossModuleTransferUtility");
     Option             = option;
     this.source        = source ?? throw new ArgumentNullException("source");
     this.destination   = destination ?? throw new ArgumentNullException("destination");
     maxChunkUploadSize = 10 * 1024 * 1024;
     chunksize          = 5 * 1024 * 1024;
 }
Esempio n. 9
0
 public Worker(
     IServiceProvider serviceProvider,
     IOptionsMonitor <ILog> options,
     Common.Utils.ConfigurationExtension configurationExtension)
 {
     this.serviceProvider   = serviceProvider;
     this.thumbnailSettings = ThumbnailSettings.GetInstance(configurationExtension);
     logger = options.Get("ASC.Files.ThumbnailBuilder");
 }
 public async Task InvokeAsync(HttpContext context)
 {
     if (context.Request.Path.Value.ToLower() == "/refresh_auth_config")
     {
         var op = _optionsMonitor.Get("Bearer");
         op.ConfigurationManager.RequestRefresh();
     }
     await _next.Invoke(context);
 }
Esempio n. 11
0
        /// <inheritdoc/>
        public async Task <HttpResponseMessage> CallWebApiForUserAsync(
            string serviceName,
            string?authenticationScheme = null,
            Action <DownstreamWebApiOptions>?calledDownstreamWebApiOptionsOverride = null,
            ClaimsPrincipal?user  = null,
            StringContent?content = null)
        {
            DownstreamWebApiOptions effectiveOptions = MergeOptions(serviceName, calledDownstreamWebApiOptionsOverride);

            if (string.IsNullOrEmpty(effectiveOptions.Scopes))
            {
                throw new ArgumentException(IDWebErrorMessage.ScopesNotConfiguredInConfigurationOrViaDelegate);
            }

            MicrosoftIdentityOptions microsoftIdentityOptions = _microsoftIdentityOptionsMonitor
                                                                .Get(_tokenAcquisition.GetEffectiveAuthenticationScheme(authenticationScheme));

            string apiUrl = effectiveOptions.GetApiUrl();

            CreateProofOfPossessionConfiguration(effectiveOptions, apiUrl);

            string?userflow;

            if (microsoftIdentityOptions.IsB2C && string.IsNullOrEmpty(effectiveOptions.UserFlow))
            {
                userflow = microsoftIdentityOptions.DefaultUserFlow;
            }
            else
            {
                userflow = effectiveOptions.UserFlow;
            }

            AuthenticationResult authResult = await _tokenAcquisition.GetAuthenticationResultForUserAsync(
                effectiveOptions.GetScopes(),
                authenticationScheme,
                effectiveOptions.Tenant,
                userflow,
                user,
                effectiveOptions.TokenAcquisitionOptions)
                                              .ConfigureAwait(false);

            using (HttpRequestMessage httpRequestMessage = new HttpRequestMessage(
                       effectiveOptions.HttpMethod,
                       apiUrl))
            {
                if (content != null)
                {
                    httpRequestMessage.Content = content;
                }

                httpRequestMessage.Headers.Add(
                    Constants.Authorization,
                    authResult.CreateAuthorizationHeader());
                effectiveOptions.CustomizeHttpRequestMessage?.Invoke(httpRequestMessage);
                return(await _httpClient.SendAsync(httpRequestMessage).ConfigureAwait(false));
            }
        }
Esempio n. 12
0
        public BranchClient(IOptionsMonitor <BranchConfig> options, string name)
        {
            var opts        = options.Get(name);
            var httpOptions = new HttpOptions();

            httpOptions.Headers.Add("Authorization", $"bearer {opts.Key}");

            Client = new JsonClient(opts.Url, httpOptions);
        }
Esempio n. 13
0
        public IActionResult SignIn( )
        {
            var scheme  = AzureADB2CDefaults.AuthenticationScheme; // 本来はここでいろんなIDaaSの種類が選べるということ?
            var options = _options.Get(scheme);

            var redirectUrl = Url.Content("~/Home/Index");
            var properties  = new AuthenticationProperties {
                RedirectUri = redirectUrl
            };

            properties.Items[AzureADB2CDefaults.PolicyKey] = options.SignUpSignInPolicyId;

            return(Challenge(
                       new AuthenticationProperties {
                RedirectUri = redirectUrl
            },
                       scheme));
        }
Esempio n. 14
0
        /// <summary>
        /// By default, build url for Aspnet hosting url. Url building based on UrlOptions configure in appsettings
        /// </summary>
        /// <param name="webApiPath"></param>
        /// <returns></returns>
        public Uri BuildConfirmationUrl(string userId, string token)
        {
            var        builder = new UriBuilder();
            UrlOptions urlOptions;

            if (SpaHostUrl)
            {
                urlOptions = urlSettings.Get("Angular-AccountConfirmationUrl");
            }
            else
            {
                urlOptions = urlSettings.Get("Aspnet-AccountConfirmationUrl");
            }

            BuildBaseAddress(builder, urlOptions);
            builder.Query = $"userID={userId}&token={token}";
            return(uri = builder.Uri);
        }
        public TClient CreateClient(string name)
        {
            if (!_clientRegistrations.TryGetValue(name, out ClientRegistration <TClient, TOptions> registration))
            {
                throw new InvalidOperationException($"Unable to find client registration with type '{typeof(TClient).Name}' and name '{name}'.");
            }

            return(registration.GetClient(_monitor.Get(name), _clientsOptions.Get(name).CredentialFactory(_serviceProvider)));
        }
Esempio n. 16
0
 /// <summary>
 /// Initializes a new instance of the <see cref="TorahQuoteJob"/> class.
 /// </summary>
 /// <param name="options"></param>
 /// <param name="service"></param>
 /// <param name="torahVerses"></param>
 public TorahQuoteJob(
     IOptionsMonitor <TorahQuoteJobOptions> options,
     TorahService service,
     TorahVerses torahVerses)
 {
     _options     = options.Get(Name);
     _service     = service ?? throw new ArgumentNullException(nameof(service));
     _torahVerses = torahVerses ?? throw new ArgumentNullException(nameof(torahVerses));
 }
Esempio n. 17
0
 public RackspaceCloudStorage(
     TenantManager tenantManager,
     PathUtils pathUtils,
     EmailValidationKeyProvider emailValidationKeyProvider,
     IOptionsMonitor <ILog> options)
     : base(tenantManager, pathUtils, emailValidationKeyProvider, options)
 {
     _logger = options.Get("ASC.Data.Storage.Rackspace.RackspaceCloudStorage");
 }
Esempio n. 18
0
 public GoogleDriveStorage(
     ConsumerFactory consumerFactory,
     FileUtility fileUtility,
     IOptionsMonitor <ILog> monitor)
 {
     ConsumerFactory = consumerFactory;
     FileUtility     = fileUtility;
     Log             = monitor.Get("ASC.Files");
 }
Esempio n. 19
0
        public HttpClientFactoryOptions Get(string name)
        {
            string client = _handlerRegistry.GetClientNameFromKey(name);

            _logger.LogDebug($"{nameof(ClientHandlerResolutionDecorator)} - Resolving options for {client} based on key lookup for {name}");
            var options = _optionsMonitor.Get(client);

            return(options);
        }
Esempio n. 20
0
 public GlobalNotify(ICacheNotify <AscCacheItem> notify, IOptionsMonitor <ILog> options, CoreBaseSettings coreBaseSettings)
 {
     Notify = notify;
     Logger = options.Get("ASC.Files");
     if (coreBaseSettings.Standalone)
     {
         ClearCache();
     }
 }
        public BundleDefaultsOptions GetDefaults(string bundleType)
        {
            if (bundleType == null)
            {
                throw new ArgumentNullException(nameof(bundleType));
            }

            return(_defaultsOptions.Get(bundleType));
        }
Esempio n. 22
0
 public BnaHandler(
     IHttpClientFactory httpClientFactory,
     HttpClientPoliciesSettings bnaClientPoliciesSettings,
     IOptionsMonitor <CurrencySettings> bnaSettings,
     ISlackHooksService slackHooksService,
     ILogger <CurrencyHandler> logger) : base(httpClientFactory, bnaClientPoliciesSettings,
                                              bnaSettings.Get("BnaService"), slackHooksService, logger)
 {
 }
        public AppWorkFlowWithOptionsMonitor(IOptionsMonitor <AppSetting1> appSettingOption,
                                             IOptionsMonitor <Player1> playerOption)
        {
            this._player     = playerOption.Get("Player");
            this._appSetting = appSettingOption?.CurrentValue;

            Console.WriteLine($"AppSetting.Player.AppId = {this._appSetting.Player.AppId}");
            Console.WriteLine($"Player.AppId = {this._player.AppId}");
        }
Esempio n. 24
0
 public FilesMessageService(
     IOptionsMonitor <ILog> options,
     MessageTarget messageTarget,
     MessageService messageService)
 {
     log            = options.Get("ASC.Messaging");
     MessageTarget  = messageTarget;
     MessageService = messageService;
 }
Esempio n. 25
0
 public SettingsController(
     CommonMethods commonMethods,
     CoreSettings coreSettings,
     IOptionsMonitor <ILog> option)
 {
     CommonMethods = commonMethods;
     CoreSettings  = coreSettings;
     Log           = option.Get("ASC.ApiSystem");
 }
Esempio n. 26
0
        public WeatherApiClient(HttpClient httpClient, IOptionsMonitor <ExternalServicesConfig> options, ILogger <WeatherApiClient> logger)
        {
            var externalServiceConfig = options.Get(ExternalServicesConfig.WeatherApi);

            httpClient.BaseAddress = new Uri(externalServiceConfig.Url);

            _httpClient = httpClient;
            _logger     = logger;
        }
Esempio n. 27
0
 public OrganisationLogoManager(WebImageSupplier webImageSupplier,
                                Global global,
                                IOptionsMonitor <ILog> logger,
                                DaoFactory daoFactory)
 {
     _webImageSupplier = webImageSupplier;
     _global           = global;
     _logger           = logger.Get("ASC.CRM");
     _daoFactory       = daoFactory;
 }
        public HttpClient CreateClient(string name)
        {
            if (name == null)
            {
                throw new ArgumentNullException(nameof(name));
            }

            var handler = _cache.GetOrAdd(name, _valueFactory);
            var client  = new HttpClient(handler.Value, disposeHandler: false);

            var options = _optionsMonitor.Get(name);

            for (var i = 0; i < options.HttpClientActions.Count; i++)
            {
                options.HttpClientActions[i](client);
            }

            return(client);
        }
 public AccountDomainService(ILogger <AccountDomainService> logger,
                             IDailyTaskApi dailyTaskApi,
                             IOptionsMonitor <BiliBiliCookieOptions> cookie,
                             IOptionsMonitor <Dictionary <string, int> > dicOptions)
 {
     _logger       = logger;
     _dailyTaskApi = dailyTaskApi;
     _cookie       = cookie.CurrentValue;
     _expDic       = dicOptions.Get(Constants.OptionsNames.ExpDictionaryName);
 }
Esempio n. 30
0
 public TariffController(
     CommonMethods commonMethods,
     IOptionsSnapshot <HostedSolution> hostedSolutionOptions,
     IOptionsMonitor <ILog> option
     )
 {
     CommonMethods  = commonMethods;
     HostedSolution = hostedSolutionOptions.Value;
     Log            = option.Get("ASC.ApiSystem");
 }