public FeatureSyncExportStep(IFeatureManager featureManager) { _featureManager = featureManager; Logger = NullLogger.Instance; T = NullLocalizer.Instance; }
public SyncProjectsTask( IFeatureManager featureManager, IModuleExecution moduleExecution) { _featureManager = featureManager; _moduleExecution = moduleExecution; }
public ShapePlacementParsingStrategy( IFeatureManager featureManager, IPlacementFileParser placementFileParser) { _featureManager = featureManager; _placementFileParser = placementFileParser; }
public FeaturesScriptManager(IFeatureManager featureManager, IFeatureChecker featureChecker) { _featureManager = featureManager; _featureChecker = featureChecker; AbpSession = NullAbpSession.Instance; }
public ThemeService( IOrchardServices orchardServices, IExtensionManager extensionManager, IFeatureManager featureManager, IEnumerable<IThemeSelector> themeSelectors, IVirtualPathProvider virtualPathProvider, ICacheManager cacheManager, ISiteThemeService siteThemeService) { Services = orchardServices; _extensionManager = extensionManager; _featureManager = featureManager; _themeSelectors = themeSelectors; _virtualPathProvider = virtualPathProvider; _cacheManager = cacheManager; _siteThemeService = siteThemeService; if (_featureManager.FeatureDependencyNotification == null) { _featureManager.FeatureDependencyNotification = GenerateWarning; } Logger = NullLogger.Instance; T = NullLocalizer.Instance; }
/// <summary> /// Creates a new <see cref="FeatureChecker"/> object. /// </summary> public FeatureChecker(IFeatureManager featureManager) { _featureManager = featureManager; FeatureValueStore = NullFeatureValueStore.Instance; OwSession = NullOwSession.Instance; }
public AbpUserConfigurationBuilder( IMultiTenancyConfig multiTenancyConfig, ILanguageManager languageManager, ILocalizationManager localizationManager, IFeatureManager featureManager, IFeatureChecker featureChecker, IPermissionManager permissionManager, IUserNavigationManager userNavigationManager, ISettingDefinitionManager settingDefinitionManager, ISettingManager settingManager, IAbpAntiForgeryConfiguration abpAntiForgeryConfiguration, IAbpSession abpSession, IPermissionChecker permissionChecker) { _multiTenancyConfig = multiTenancyConfig; _languageManager = languageManager; _localizationManager = localizationManager; _featureManager = featureManager; _featureChecker = featureChecker; _permissionManager = permissionManager; _userNavigationManager = userNavigationManager; _settingDefinitionManager = settingDefinitionManager; _settingManager = settingManager; _abpAntiForgeryConfiguration = abpAntiForgeryConfiguration; _abpSession = abpSession; _permissionChecker = permissionChecker; }
public AdminController( IEnumerable<IExtensionDisplayEventHandler> extensionDisplayEventHandlers, IOrchardServices services, IDataMigrationManager dataMigraitonManager, IFeatureManager featureManager, ISiteThemeService siteThemeService, IExtensionManager extensionManager, ShellDescriptor shellDescriptor, IPreviewTheme previewTheme, IThemeService themeService, IReportsCoordinator reportsCoordinator) { Services = services; _extensionDisplayEventHandler = extensionDisplayEventHandlers.FirstOrDefault(); _dataMigrationManager = dataMigraitonManager; _siteThemeService = siteThemeService; _extensionManager = extensionManager; _shellDescriptor = shellDescriptor; _featureManager = featureManager; _previewTheme = previewTheme; _themeService = themeService; _reportsCoordinator = reportsCoordinator; T = NullLocalizer.Instance; Logger = NullLogger.Instance; }
public FeatureCommands(IModuleService moduleService, INotifier notifier, IFeatureManager featureManager, ShellDescriptor shellDescriptor) { _moduleService = moduleService; _notifier = notifier; _featureManager = featureManager; _shellDescriptor = shellDescriptor; }
public AdminController( IEnumerable<IExtensionDisplayEventHandler> extensionDisplayEventHandlers, IOrchardServices services, IModuleService moduleService, IDataMigrationManager dataMigrationManager, IReportsCoordinator reportsCoordinator, IExtensionManager extensionManager, IFeatureManager featureManager, IRecipeHarvester recipeHarvester, IRecipeManager recipeManager, ShellDescriptor shellDescriptor, ShellSettings shellSettings, IShapeFactory shapeFactory) { Services = services; _extensionDisplayEventHandler = extensionDisplayEventHandlers.FirstOrDefault(); _moduleService = moduleService; _dataMigrationManager = dataMigrationManager; _reportsCoordinator = reportsCoordinator; _extensionManager = extensionManager; _featureManager = featureManager; _recipeHarvester = recipeHarvester; _recipeManager = recipeManager; _shellDescriptor = shellDescriptor; _shellSettings = shellSettings; Shape = shapeFactory; T = NullLocalizer.Instance; Logger = NullLogger.Instance; }
public ContentPickerController( IUpgradeService upgradeService, IOrchardServices orchardServices, IFeatureManager featureManager) { _upgradeService = upgradeService; _orchardServices = orchardServices; _featureManager = featureManager; }
public FeatureStep( IFeatureManager featureManager, ILoggerFactory logger, IStringLocalizer<FeatureStep> localizer) : base(logger, localizer) { _featureManager = featureManager; }
public FieldController( IContentDefinitionManager contentDefinitionManager, IOrchardServices orchardServices, IFeatureManager featureManager) { _contentDefinitionManager = contentDefinitionManager; _orchardServices = orchardServices; _featureManager = featureManager; }
public TaxonomyController( IUpgradeService upgradeService, IOrchardServices orchardServices, IFeatureManager featureManager) { _upgradeService = upgradeService; _orchardServices = orchardServices; _featureManager = featureManager; }
public FeatureHash( IFeatureManager featureManager, IMemoryCache memoryCache, ISignal signal) { _memoryCache = memoryCache; _featureManager = featureManager; _signal = signal; }
public WidgetsService( IContentManager contentManager, IFeatureManager featureManager, IExtensionManager extensionManager) { _contentManager = contentManager; _featureManager = featureManager; _extensionManager = extensionManager; }
public ShapePlacementParsingStrategy( IFeatureManager featureManager, IOrchardFileSystem fileSystem, ILogger<ShapePlacementParsingStrategy> logger) { _logger = logger; _featureManager = featureManager; _fileSystem = fileSystem; }
public AutomaticDataMigrations( IDataMigrationManager dataMigrationManager, IFeatureManager featureManager ) { _dataMigrationManager = dataMigrationManager; _featureManager = featureManager; Logger = NullLogger.Instance; }
public InstallPackageCommand( IHostPlatformDetector hostPlatformDetector, IPackageManager packageManager, IFeatureManager featureManager) { this.m_HostPlatformDetector = hostPlatformDetector; this.m_PackageManager = packageManager; _featureManager = featureManager; }
public ThemeDisableEventHandler( IFeatureManager featureManager, ISiteThemeService siteThemeService, INotifier notifier) { _featureManager = featureManager; _siteThemeService = siteThemeService; _notifier = notifier; T = NullLocalizer.Instance; }
public PreviewThemeFilter( IPreviewTheme previewTheme, IWorkContextAccessor workContextAccessor, IShapeFactory shapeFactory, IFeatureManager featureManager) { _previewTheme = previewTheme; _workContextAccessor = workContextAccessor; _shapeFactory = shapeFactory; _featureManager = featureManager; }
public RepushPackageCommand( IPackageLookup packageLookup, BinaryPackageResolve binaryPackageResolve, IPackageUrlParser packageUrlParser, IFeatureManager featureManager) { _packageLookup = packageLookup; _binaryPackageResolve = binaryPackageResolve; _packageUrlParser = packageUrlParser; _featureManager = featureManager; }
public UpgradePackageCommand( IPackageManager packageManager, IHostPlatformDetector hostPlatformDetector, IPackageNameLookup packageNameLookup, IFeatureManager featureManager) { _packageManager = packageManager; _hostPlatformDetector = hostPlatformDetector; _packageNameLookup = packageNameLookup; _featureManager = featureManager; }
public AutomaticDataMigrations( IDataMigrationManager dataMigrationManager, IFeatureManager featureManager, ShellSettings shellSettings, ILogger<AutomaticDataMigrations> logger) { _dataMigrationManager = dataMigrationManager; _featureManager = featureManager; _shellSettings = shellSettings; _logger = logger; }
public AutomaticDataMigrations( IDataMigrationManager dataMigrationManager, IFeatureManager featureManager, ShellSettings shellSettings, ILoggerFactory loggerFactory) { _dataMigrationManager = dataMigrationManager; _featureManager = featureManager; _shellSettings = shellSettings; _logger = loggerFactory.CreateLogger<AutomaticDataMigrations>(); }
public SolutionInputGenerator( IServiceInputGenerator serviceInputGenerator, IExcludedServiceAwareProjectDetector excludedServiceAwareProjectDetector, IHostPlatformDetector hostPlatformDetector, IFeatureManager featureManager) { this.m_ServiceInputGenerator = serviceInputGenerator; this.m_ExcludedServiceAwareProjectDetector = excludedServiceAwareProjectDetector; _hostPlatformDetector = hostPlatformDetector; _featureManager = featureManager; }
public TransformalizeController( IOrchardServices services, ITransformalizeService transformalize, IFileService fileService, IFeatureManager featureManager ) { _orchardServices = services; _transformalize = transformalize; _fileService = fileService; _featureManager = featureManager; T = NullLocalizer.Instance; Logger = NullLogger.Instance; }
public ModuleProfilesAdminController( IRepository<ModuleProfileRecord> repository, IFeatureManager featureManager, IModuleProfilesService moduleProfilesService, INotifier notifier) { _repository = repository; _featureManager = featureManager; _moduleProfilesService = moduleProfilesService; _notifier = notifier; T = NullLocalizer.Instance; }
public ActionDispatch( LightweightKernel lightweightKernel, IHostPlatformDetector hostPlatformDetector, IPackageManager packageManager, IModuleUtilities moduleUtilities, IFeatureManager featureManager) { this.m_LightweightKernel = lightweightKernel; this.m_HostPlatformDetector = hostPlatformDetector; this.m_PackageManager = packageManager; _moduleUtilities = moduleUtilities; _featureManager = featureManager; }
public MediaController( IOrchardServices orchardServices, IFeatureManager featureManager, IEnumerable<IMediaLibraryService> mediaLibraryServices, IMimeTypeProvider mimeTypeProvider, IContentDefinitionManager contentDefinitionManager) { _orchardServices = orchardServices; _featureManager = featureManager; _mediaLibraryServices = mediaLibraryServices; _mimeTypeProvider = mimeTypeProvider; _contentDefinitionManager = contentDefinitionManager; Logger = NullLogger.Instance; }
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next) { IFeatureManager featureManager = context.HttpContext.RequestServices.GetRequiredService <IFeatureManagerSnapshot>(); if (await featureManager.IsEnabledAsync(FeatureName).ConfigureAwait(false)) { IServiceProvider serviceProvider = context.HttpContext.RequestServices.GetRequiredService <IServiceProvider>(); IAsyncActionFilter filter = ActivatorUtilities.CreateInstance <T>(serviceProvider); await filter.OnActionExecutionAsync(context, next).ConfigureAwait(false); } else { await next().ConfigureAwait(false); } }
/// <summary> /// Add Swagger Configuration dependencies. /// </summary> public static IServiceCollection AddSwagger(this IServiceCollection services) { IFeatureManager featureManager = services .BuildServiceProvider() .GetRequiredService <IFeatureManager>(); bool isEnabled = featureManager .IsEnabledAsync(nameof(CustomFeature.Swagger)) .ConfigureAwait(false) .GetAwaiter() .GetResult(); if (isEnabled) { services .AddTransient <IConfigureOptions <SwaggerGenOptions>, ConfigureSwaggerOptions>() .AddSwaggerGen( c => { c.IncludeXmlComments(XmlCommentsFilePath); c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme { In = ParameterLocation.Header, Description = "Please insert JWT with Bearer into field", Name = "Authorization", Type = SecuritySchemeType.ApiKey }); c.AddSecurityRequirement(new OpenApiSecurityRequirement { { new OpenApiSecurityScheme { Reference = new OpenApiReference { Type = ReferenceType.SecurityScheme, Id = "Bearer" } }, new string[] { } } }); }); } return(services); }
public AutomaticDataMigrations( IDataMigrationManager dataMigrationManager, IDataMigrationInterpreter dataMigrationInterpreter, IFeatureManager featureManager, IDistributedLockService distributedLockService, ITransactionManager transactionManager, ShellSettings shellSettings) { _dataMigrationManager = dataMigrationManager; _featureManager = featureManager; _distributedLockService = distributedLockService; _shellSettings = shellSettings; _transactionManager = transactionManager; _dataMigrationInterpreter = dataMigrationInterpreter; Logger = NullLogger.Instance; }
public FeatureValueStore( ICacheManager cacheManager, IRepository <TenantFeatureSetting, long> tenantFeatureRepository, IRepository <Tenant> tenantRepository, IRepository <EditionFeatureSetting, long> editionFeatureRepository, IFeatureManager featureManager, IUnitOfWorkManager unitOfWorkManager) : base( cacheManager, tenantFeatureRepository, tenantRepository, editionFeatureRepository, featureManager, unitOfWorkManager ) { }
public IndexModel(IFeatureManager featureManager) { FeatureManager = featureManager; // only returns true during provided time window bool showBanner = FeatureManager.IsEnabled(FeatureManagement.ConstFeatureFlags.ChristmasBanner); bool showFancyFonts = FeatureManager.IsEnabled(FeatureManagement.ConstFeatureFlags.FancyFonts); var isEnabled = FeatureManager.IsEnabled(FeatureManagement.ConstFeatureFlags.Beta); // may throw! // Flags on the main FeatureFlags class are safe to use everywhere var isEnabled2 = FeatureManager.IsEnabled(FeatureManagement.ConstFeatureFlags.NewBranding); // Flags on the nested Ui class are only safe when HttpContext is available var isEnabled3 = FeatureManager.IsEnabled(FeatureManagement.ConstFeatureFlags.Ui.Beta); }
private static IFeature InsertComFeatureBase(IFeatureManager featMgr, Type macroFeatType, string[] paramNames, int[] paramTypes, string[] paramValues, int[] dimTypes, double[] dimValues, object[] selection, object[] editBodies) { if (!typeof(MacroFeatureEx).IsAssignableFrom(macroFeatType)) { throw new InvalidCastException($"{macroFeatType.FullName} must inherit {typeof(MacroFeatureEx).FullName}"); } var options = swMacroFeatureOptions_e.swMacroFeatureByDefault; var provider = ""; macroFeatType.TryGetAttribute <OptionsAttribute>(a => { options = a.Flags; provider = a.Provider; }); var baseName = MacroFeatureInfo.GetBaseName(macroFeatType); var progId = MacroFeatureInfo.GetProgId(macroFeatType); if (string.IsNullOrEmpty(progId)) { throw new NullReferenceException("Prog id for macro feature cannot be extracted"); } var icons = MacroFeatureIconInfo.GetIcons(macroFeatType, m_App.SupportsHighResIcons()); using (var selSet = new SelectionGroup(featMgr.Document.ISelectionManager)) { if (selection != null && selection.Any()) { var selRes = selSet.AddRange(selection); Debug.Assert(selRes); } var feat = featMgr.InsertMacroFeature3(baseName, progId, null, paramNames, paramTypes, paramValues, dimTypes, dimValues, editBodies, icons, (int)options) as IFeature; return(feat); } }
public async Task TargetingAccessor() { IConfiguration config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build(); var services = new ServiceCollection(); services .Configure <FeatureManagementOptions>(options => { options.IgnoreMissingFeatureFilters = true; }); var targetingContextAccessor = new OnDemandTargetingContextAccessor(); services.AddSingleton <ITargetingContextAccessor>(targetingContextAccessor); services .AddSingleton(config) .AddFeatureManagement() .AddFeatureFilter <TargetingFilter>(); ServiceProvider serviceProvider = services.BuildServiceProvider(); IFeatureManager featureManager = serviceProvider.GetRequiredService <IFeatureManager>(); string beta = Enum.GetName(typeof(Features), Features.TargetingTestFeature); // // Targeted by user id targetingContextAccessor.Current = new TargetingContext { UserId = "Jeff" }; Assert.True(await featureManager.IsEnabledAsync(beta)); // // Not targeted by user id or default rollout targetingContextAccessor.Current = new TargetingContext { UserId = "Patty" }; Assert.False(await featureManager.IsEnabledAsync(beta)); }
/// <summary> /// Add Authentication Extensions. /// </summary> public static IServiceCollection AddAuthentication( this IServiceCollection services, IConfiguration configuration) { IFeatureManager featureManager = services .BuildServiceProvider() .GetRequiredService <IFeatureManager>(); bool isEnabled = featureManager .IsEnabledAsync(nameof(CustomFeature.Authentication)) .ConfigureAwait(false) .GetAwaiter() .GetResult(); if (isEnabled) { services.AddScoped <IUserService, ExternalUserService>(); services .AddAuthentication("Bearer") .AddIdentityServerAuthentication("Bearer", options => { // set the Identity.API service as the authority on authentication/authorization options.Authority = configuration["AuthenticationModule:AuthorityUrl"]; options.ApiName = "api1"; options.RequireHttpsMetadata = false; // set the name of the API that's talking to the Identity API }); } else { services.AddScoped <IUserService, TestUserService>(); services.AddAuthentication(x => { x.DefaultAuthenticateScheme = "Test"; x.DefaultChallengeScheme = "Test"; }).AddScheme <AuthenticationSchemeOptions, TestAuthenticationHandler>( "Test", options => { }); } return(services); }
public async Task Invoke(HttpContext context, IFeatureManager featureManager) { var evaluationsResponse = new List <EvaluationResponse>(); var featureNames = context.Request.Query["featureName"]; foreach (var featureName in featureNames) { var isEnabled = await featureManager.IsEnabledAsync(featureName); evaluationsResponse.Add(new EvaluationResponse { Name = featureName, Enabled = isEnabled }); } await WriteResponse(context, evaluationsResponse); }
/// <summary> /// Determines whether the specified type is enabled using <see cref="FeatureFilterAttribute"/> attribute /// </summary> /// <param name="featureManager">Feature manager.</param> /// <param name="serviceType">Type of the service to check.</param> /// <returns> /// <c>true</c> if the specified service is enabled; otherwise, <c>false</c>. /// </returns> /// <exception cref="ArgumentNullException">featureManager</exception> public static bool IsServiceEnabled(this IFeatureManager featureManager, Type serviceType) { if (featureManager is null) { throw new ArgumentNullException(nameof(featureManager)); } var featureAttribute = serviceType.GetCustomAttribute <FeatureFilterAttribute>(true); if (featureAttribute is null) { return(true); } return(featureAttribute.RequirementType == RequirementType.All ? featureAttribute.Features.All(featureManager.IsEnabled) : featureAttribute.Features.Any(featureManager.IsEnabled)); }
public static void SetupTenant( Tenant tenant, IConfiguration configuration, ITestEnvironment testEnvironment, IFeatureManager featureManager) { var rootFolder = System.Web.Hosting.HostingEnvironment.MapPath("/"); AppContainer.ConfigureTenant(tenant.Id, builder => { _ = builder.RegisterModule(new CoreAutofacModule(rootFolder)); _ = builder.RegisterModule(new LandmarkRunServicesModule(configuration, featureManager)); _ = builder.RegisterModule( new DefaultAuditEventModule(System.Web.Hosting.HostingEnvironment.MapPath("/Logs"))); _ = builder.RegisterModule(new TenantAutofacModule(tenant, configuration, testEnvironment, featureManager)); }); }
///// <summary> ///// Constructor. ///// </summary> public TenantDatabaseController(ITenantsRepository tenantsRepository, ITenantSettingsRepository tenantSettingsRepository, ITenantSettingsFeatureManager featureManager, IFeatureManager productFeatureManager, IFeatureSettingsProvider featureSettingsProvider, ITestEnvironment testEnvironment, IConfiguration configuration, IMapper mapper) { _tenantsRepository = tenantsRepository; _tenantSettingsRepository = tenantSettingsRepository; _featureManager = featureManager; _productFeatureManager = productFeatureManager; _featureSettingsProvider = featureSettingsProvider; _testEnvironment = testEnvironment; _configuration = configuration; _mapper = mapper; }
public ModuleService( IFeatureManager featureManager, IExtensionManager extensionManager, IShellDescriptorManager shellDescriptorManager, IHtmlLocalizer <AdminMenu> htmlLocalizer, INotifier notifier) { _notifier = notifier; _featureManager = featureManager; _extensionManager = extensionManager; _shellDescriptorManager = shellDescriptorManager; //if (_featureManager.FeatureDependencyNotification == null) { // _featureManager.FeatureDependencyNotification = GenerateWarning; //} T = htmlLocalizer; }
/// <summary> /// Inserts new macro feature /// </summary> /// <typeparam name="TMacroFeature">Definition of COM macro feature</typeparam> /// <param name="featMgr">Pointer to feature manager</param> /// <returns>Newly created feature</returns> public static IFeature InsertComFeature <TMacroFeature>(this IFeatureManager featMgr) where TMacroFeature : MacroFeatureEx { if (typeof(TMacroFeature).IsAssignableToGenericType(typeof(MacroFeatureEx <>))) { var paramsType = typeof(TMacroFeature).GetArgumentsOfGenericType( typeof(MacroFeatureEx <>)).First(); var parameters = Activator.CreateInstance(paramsType); return(InsertComFeatureWithParameters(featMgr, typeof(TMacroFeature), parameters)); } else { return(InsertComFeatureBase( featMgr, typeof(TMacroFeature), null, null, null, null, null, null, null)); } }
public GetWorkOrderUseCase( IRepairsGateway repairsGateway, IAppointmentsGateway appointmentGateway, IOptions <DrsOptions> drsOptions, IFeatureManager featureManager, IDrsService drsService, IScheduleOfRatesGateway sorGateway, ILogger <GetWorkOrderUseCase> logger ) { _repairsGateway = repairsGateway; _appointmentGateway = appointmentGateway; _drsOptions = drsOptions; _featureManager = featureManager; _drsService = drsService; _sorGateway = sorGateway; _logger = logger; }
private static IFeature InsertComFeatureWithParameters( IFeatureManager featMgr, Type macroFeatType, object parameters) { string[] paramNames; int[] paramTypes; string[] paramValues; object[] selection; int[] dimTypes; double[] dimValues; IBody2[] editBodies; m_ParamsParser.Parse(parameters, out paramNames, out paramTypes, out paramValues, out selection, out dimTypes, out dimValues, out editBodies); return(InsertComFeatureBase(featMgr, macroFeatType, paramNames, paramTypes, paramValues, dimTypes, dimValues, selection, editBodies)); }
/// <summary> /// Initializes a new instance of the <see cref="AbpFeatureValueStore{TTenant, TUser}"/> class. /// </summary> public AbpFeatureValueStore( ICacheManager cacheManager, IRepository <TenantFeatureSetting, long> tenantFeatureRepository, IRepository <TTenant> tenantRepository, IRepository <EditionFeatureSetting, long> editionFeatureRepository, IFeatureManager featureManager, IUnitOfWorkManager unitOfWorkManager) { _cacheManager = cacheManager; _tenantFeatureRepository = tenantFeatureRepository; _tenantRepository = tenantRepository; _editionFeatureRepository = editionFeatureRepository; _featureManager = featureManager; _unitOfWorkManager = unitOfWorkManager; LocalizationManager = NullLocalizationManager.Instance; LocalizationSourceName = AbpZeroConsts.LocalizationSourceName; }
public AdminController( IModuleService moduleService, IExtensionManager extensionManager, IFeatureManager featureManager, IHtmlLocalizer <AdminController> localizer, IShellDescriptorManager shellDescriptorManager, IAuthorizationService authorizationService, INotifier notifier) { _moduleService = moduleService; _extensionManager = extensionManager; _featureManager = featureManager; _shellDescriptorManager = shellDescriptorManager; _authorizationService = authorizationService; _notifier = notifier; T = localizer; }
public async Task ThrowsExceptionForMissingFeatureFilter() { IConfiguration config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build(); var services = new ServiceCollection(); services .AddSingleton(config) .AddFeatureManagement(); ServiceProvider serviceProvider = services.BuildServiceProvider(); IFeatureManager featureManager = serviceProvider.GetRequiredService <IFeatureManager>(); FeatureManagementException e = await Assert.ThrowsAsync <FeatureManagementException>(async() => await featureManager.IsEnabledAsync(ConditionalFeature)); Assert.Equal(FeatureManagementError.MissingFeatureFilter, e.Error); }
public FeatureAppService( IFeatureManager featureManager, ILocalizationManager localizationManager, IIocManager iocManager, TenantManager tenantManager, RoleManager roleManager, IRepository <FeatureSetting, long> featureRepository, IAuthorizationConfiguration authorizationConfiguration, UserManager userManager) { _featureManager = featureManager; _localizationManager = localizationManager; _iocManager = iocManager; _tenantManager = tenantManager; _roleManager = roleManager; _authorizationConfiguration = authorizationConfiguration; _userManager = userManager; _featureRepository = featureRepository; }
public GenerateProjectsTask( IProjectLoader projectLoader, IProjectGenerator projectGenerator, ISolutionGenerator solutionGenerator, IJSILProvider jsilProvider, IPackageRedirector packageRedirector, IModuleExecution moduleExecution, IFeatureManager featureManager, IHostPlatformDetector hostPlatformDetector) { m_ProjectLoader = projectLoader; m_ProjectGenerator = projectGenerator; m_SolutionGenerator = solutionGenerator; m_JSILProvider = jsilProvider; m_PackageRedirector = packageRedirector; _moduleExecution = moduleExecution; _featureManager = featureManager; _hostPlatformDetector = hostPlatformDetector; }
public void OnClose(int reason) { //This function must contain code, even if it does nothing, to prevent the //.NET runtime environment from doing garbage collection at the wrong time. int IndentSize; IndentSize = System.Diagnostics.Debug.IndentSize; System.Diagnostics.Debug.WriteLine(IndentSize); if (reason == (int)swPropertyManagerPageCloseReasons_e.swPropertyManagerPageClose_Okay) { string partTemplate = iSwApp.GetUserPreferenceStringValue((int)swUserPreferenceStringValue_e.swDefaultTemplatePart); if ((partTemplate != null) && (partTemplate != "")) { swModel = (ModelDoc2)iSwApp.NewDocument(partTemplate, (int)swDwgPaperSizes_e.swDwgPaperA2size, 0.0, 0.0); swModel.InsertSketch2(true); double x = this.activePage.CubeLength / ValueConst.factor; double y = this.activePage.CubeWidth / ValueConst.factor; double z = this.activePage.CubeHeight / ValueConst.factor; swModel.SketchRectangle(0, 0, 0, x, y, 0, false); //Extrude the sketch IFeatureManager featMan = swModel.FeatureManager; Feature valuebody = featMan.FeatureExtrusion(true, false, false, (int)swEndConditions_e.swEndCondBlind, (int)swEndConditions_e.swEndCondBlind, z, 0.0, false, false, false, false, 0.0, 0.0, false, false, false, false, true, false, false); //修改特征名称为:阀块基体 valuebody.Name = "阀块基体"; } else { System.Windows.Forms.MessageBox.Show("There is no part template available. Please check your options and make sure there is a part template selected, or select a new part template."); } } }
public StorageService(IHttpContextAccessor httpContext, ILogger <StorageService> logger, IFeatureManager featureManager) { if (httpContext == null || httpContext.HttpContext == null) { _blogSlug = ""; } else { _blogSlug = httpContext.HttpContext.User.Identity.Name; } _logger = logger; _featureManager = featureManager; if (!Directory.Exists(Location)) { CreateFolder(""); } }
public Logger(IHttpContextAccessor contextAccessor, INoorTrustDbContext databaseContext, IFeatureManager featureManager) { if (contextAccessor == null) { throw new ArgumentNullException(nameof(contextAccessor), $"{nameof(contextAccessor)} is null."); } if (featureManager == null) { throw new ArgumentNullException("featureManager", "featureManager is null."); } if (databaseContext == null) { throw new ArgumentNullException("databaseContext", "databaseContext is null."); } _DatabaseContext = databaseContext; _FeatureManager = featureManager; _ContextAccessor = contextAccessor; }
public ShapeTemplateBindingStrategy( IEnumerable <IShapeTemplateHarvester> harvesters, IFeatureManager featureManager, IExtensionManager extensionManager, IShellFeaturesManager shellFeaturesManager, IEnumerable <IShapeTemplateViewEngine> shapeTemplateViewEngines, IOptions <MvcViewOptions> options, IHostingEnvironment hostingEnvironment, ILogger <DefaultShapeTableManager> logger) { _harvesters = harvesters; _featureManager = featureManager; _extensionManager = extensionManager; _shellFeaturesManager = shellFeaturesManager; _shapeTemplateViewEngines = shapeTemplateViewEngines; _viewEngine = options; _hostingEnvironment = hostingEnvironment; _logger = logger; }
public async Task ReadsConfiguration() { IConfiguration config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build(); var services = new ServiceCollection(); services .AddSingleton(config) .AddFeatureManagement() .AddFeatureFilter <TestFilter>(); ServiceProvider serviceProvider = services.BuildServiceProvider(); IFeatureManager featureManager = serviceProvider.GetRequiredService <IFeatureManager>(); Assert.True(await featureManager.IsEnabledAsync(OnFeature)); Assert.False(await featureManager.IsEnabledAsync(OffFeature)); IEnumerable <IFeatureFilterMetadata> featureFilters = serviceProvider.GetRequiredService <IEnumerable <IFeatureFilterMetadata> >(); // // Sync filter TestFilter testFeatureFilter = (TestFilter)featureFilters.First(f => f is TestFilter); bool called = false; testFeatureFilter.Callback = (evaluationContext) => { called = true; Assert.Equal("V1", evaluationContext.Parameters["P1"]); Assert.Equal(ConditionalFeature, evaluationContext.FeatureName); return(true); }; await featureManager.IsEnabledAsync(ConditionalFeature); Assert.True(called); }
public RegisterController( ICentresDataService centresDataService, IJobGroupsDataService jobGroupsDataService, IRegistrationService registrationService, ICryptoService cryptoService, IUserService userService, CentreCustomPromptHelper centreCustomPromptHelper, IFeatureManager featureManager, ISupervisorDelegateService supervisorDelegateService ) { this.centresDataService = centresDataService; this.jobGroupsDataService = jobGroupsDataService; this.registrationService = registrationService; this.cryptoService = cryptoService; this.userService = userService; this.centreCustomPromptHelper = centreCustomPromptHelper; this.featureManager = featureManager; this.supervisorDelegateService = supervisorDelegateService; }
public CreateWorkOrderUseCase( IRepairsGateway repairsGateway, IScheduleOfRatesGateway scheduleOfRatesGateway, ILogger <CreateWorkOrderUseCase> logger, ICurrentUserService currentUserService, IAuthorizationService authorizationService, IFeatureManager featureManager, INotifier notifier, IOptions <DrsOptions> drsOptions ) { _repairsGateway = repairsGateway; _scheduleOfRatesGateway = scheduleOfRatesGateway; _logger = logger; _currentUserService = currentUserService; _authorizationService = authorizationService; _featureManager = featureManager; _notifier = notifier; _drsOptions = drsOptions; }
public LocationsAdminController( ILocationsService locationService, IOrchardServices services, ISiteService siteService, IFeatureManager featureManager, IShapeFactory shapeFactory, IShippingService shippingService = null ) { _locationService = locationService; _siteService = siteService; _featureManager = featureManager; Shape = shapeFactory; _shippingService = shippingService; Services = services; T = NullLocalizer.Instance; }
public AutoBookOutputHandler(AWSSettings awsSettings, ICloudStorage cloudStorage, IRepositoryFactory repositoryFactory, IScenarioResultRepository scenarioResultRepository, IAuditEventRepository auditEventRepository, RootFolder baseLocalFolder, IPipelineAuditEventRepository pipelineAuditEventRepository, IFeatureManager featureManager, IScenarioCampaignMetricsProcessor scenarioCampaignMetricsProcessor, IKPICalculationScopeFactory kpiCalculationScopeFactory) { _awsSettings = awsSettings; _repositoryFactory = repositoryFactory; _scenarioResultRepository = scenarioResultRepository; _auditEventRepository = auditEventRepository; _cloudStorage = cloudStorage; _baseLocalFolder = baseLocalFolder; _pipelineAuditEventRepository = pipelineAuditEventRepository; _featureManager = featureManager; _scenarioCampaignMetricsProcessor = scenarioCampaignMetricsProcessor; _kpiCalculationScopeFactory = kpiCalculationScopeFactory; _includeScenarioPerformanceMeasurementKPIs = featureManager.IsEnabled(nameof(ProductFeature.ScenarioPerformanceMeasurementKPIs)); }