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