/// <summary>
/// Processes the tag helper context to evaluate if the feature's content should be rendered.
/// </summary>
/// <param name="context">The tag helper context.</param>
/// <param name="output">The tag helper output.</param>
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.TagName = null; // We don't want the feature to actually be a part of HTML, so we strip it
bool enabled = false;
if (!string.IsNullOrEmpty(Name))
{
IEnumerable <string> names = Name.Split(',').Select(n => n.Trim());
enabled = Requirement == RequirementType.All ?
names.All(n => _featureManager.IsEnabled(n)) :
names.Any(n => _featureManager.IsEnabled(n));
}
if (Negate)
{
enabled = !enabled;
}
if (!enabled)
{
output.SuppressOutput();
}
}
// This method is used to generate the description in the swagger UI page, according to the available features
public string GetSwaggerHomepage(IFeatureManager featureManager)
{
var description = new StringBuilder();
if (featureManager.IsEnabled(Features.Metrics))
{
description.Append(HomeGenerator.BasicHtml());
}
description.Append("<p>This template provides loads of developer friendly features that makes dotnet core ready for microservices and containers scenarios.</p>");
description.Append("<ul>");
if (featureManager.IsEnabled(Features.HttpLogger))
{
description.Append("<li><a target='_blank' href='/log?level=all'>/log</a> monitor your beautiful logs from the comfort of your browser </li>");
}
if (featureManager.IsEnabled(Features.Healthz))
{
description.Append("<li><a target='_blank' href='/healthz'>/healthz</a> url to monitor your application health status </li>");
}
if (featureManager.IsEnabled(Features.HealthUI))
{
description.Append("<li><a target='_blank' href='/healthchecks-ui'>/healthchecks-ui</a> UI to monitor your application health status </li>");
}
description.Append("</ul>");
return(description.ToString());
}
public IActionResult Index()
{
if (_featureManager.IsEnabled(nameof(ApplicationFeatureFlags.FeatureC)))
{
Debug.WriteLine("Debugging enabled, serving Index.");
}
return(View());
}
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);
}
private static AgSpotsSerialization ToAgSpot(
List <Spot> spots,
List <SalesArea> salesAreas,
IReadOnlyCollection <BreakWithProgramme> breaks,
List <Campaign> campaigns,
List <Demographic> demographics,
List <BusinessType> businessTypes,
List <Product> products,
List <Clash> clashes,
AgSpot agSpot,
IFeatureManager featureManager)
{
var agSpots = new ConcurrentBag <AgSpot>();
Dictionary <string, SalesArea> salesAreasByName = SalesArea.IndexListByName(salesAreas);
Dictionary <string, Campaign> campaignsByExternalId = Campaign.IndexListByExternalId(campaigns);
Dictionary <string, bool> businessTypesInclusionSettings = businessTypes
.ToDictionary(bt => bt.Code, bt => bt.IncludeConversionIndex);
Dictionary <string, BreakWithProgramme> breaksWithProgrammeBySalesAreaAndExternalBreakRef = BreakWithProgramme.IndexListBySalesAreaAndExternalBreakRef(breaks);
IImmutableDictionary <string, Product> productByExternalId = products.IndexListByExternalID();
IImmutableDictionary <string, Clash> clashByExternalRef = clashes.IndexListByExternalRef();
var clashRoots = ClashHelper.CalculateClashTopParents(clashByExternalRef);
var threadSafeSpotsCollection = spots.ToImmutableList();
var includeNominalPrice = featureManager.IsEnabled(nameof(ProductFeature.NominalPrice));
var includePositionInBreak = featureManager.IsEnabled(nameof(ProductFeature.PositionInBreak));
_ = Parallel.ForEach(threadSafeSpotsCollection, spot => agSpots.Add(
GetAgSpot(
spot,
threadSafeSpotsCollection,
salesAreasByName,
campaignsByExternalId,
businessTypesInclusionSettings,
breaksWithProgrammeBySalesAreaAndExternalBreakRef,
productByExternalId,
clashByExternalRef,
demographics,
agSpot.Clone(),
includeNominalPrice,
includePositionInBreak,
clashRoots
)
)
);
var serialization = new AgSpotsSerialization();
return(serialization.MapFrom(agSpots.ToList()));
}
public ScenarioCampaignLevelResultsDataHandler(AWSSettings awsSettings, ICloudStorage cloudStorage,
IScenarioCampaignResultReportCreator campaignResultReportCreator, IFeatureManager featureManager,
IAuditEventRepository auditEventRepository, IMapper mapper, IFacilityRepository facilityRepository)
{
_campaignResultReportCreator = campaignResultReportCreator;
_awsSettings = awsSettings;
_cloudStorage = cloudStorage;
_auditEventRepository = auditEventRepository;
_mapper = mapper;
_facilityRepository = facilityRepository;
_includeScenarioPerformanceMeasurementKpIs = featureManager.IsEnabled(nameof(ProductFeature.ScenarioPerformanceMeasurementKPIs));
_saveData = featureManager.IsEnabled(nameof(ProductFeature.PrePostCampaignResults));
}
/// <summary>Initializes a new instance of the <see cref="CampaignSerializerBase" /> class.</summary>
/// <param name="auditEventRepository">The audit event repository.</param>
/// <param name="featureManager">The feature manager.</param>
/// <param name="clock">The clock.</param>
/// <param name="mapper">The mapper.</param>
protected CampaignSerializerBase(
IAuditEventRepository auditEventRepository,
IFeatureManager featureManager,
IClock clock,
IMapper mapper) : base(auditEventRepository)
{
_clock = clock;
_mapper = mapper;
_includeChannelGroup =
featureManager.IsEnabled(ProductFeature.IncludeChannelGroupFileForOptimiser);
_mergeUniqueDayParts = featureManager.IsEnabled(ProductFeature.StrikeWeightDayPartsMerge);
_includeCampaignPrice = featureManager.IsEnabled(ProductFeature.NominalPrice);
}
public void Percentage()
{
string feature1 = "feature1";
Environment.SetEnvironmentVariable($"FeatureManagement:{feature1}:EnabledFor:0:Name", "Percentage");
Environment.SetEnvironmentVariable($"FeatureManagement:{feature1}:EnabledFor:0:Parameters:Value", "50");
IConfiguration config = new ConfigurationBuilder().AddEnvironmentVariables().Build();
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton(config)
.AddFeatureManagement()
.AddFeatureFilter <PercentageFilter>();
ServiceProvider provider = serviceCollection.BuildServiceProvider();
IFeatureManager featureManager = provider.GetRequiredService <IFeatureManager>();
int enabledCount = 0;
for (int i = 0; i < 10; i++)
{
if (featureManager.IsEnabled(feature1))
{
enabledCount++;
}
}
Assert.True(enabledCount > 0 && enabledCount < 10);
}
public async Task <ActionResult <IEnumerable <HighScore> > > Get(int limit = 0)
{
logger?.LogInformation("Retrieving score list with a limit of {SearchLimit}.", limit);
var scores = context.Scores
.Select(score => new HighScore()
{
Game = score.Game,
Points = score.Points,
Nickname = score.Gamer.Nickname
});
if (featureManager.IsEnabled(nameof(ApiFeatureFlags.LeaderboardListLimit)))
{
int searchLimit = limit;
// This is a demo bug, supposedly "hard" to find
do
{
searchLimit--;
}while (searchLimit != 0);
scores = scores.Take(limit);
}
return(Ok(await scores.ToListAsync().ConfigureAwait(false)));
}
public Facade(IAuthenticationSchemeRetriever authenticationSchemeRetriever, IAuthorizationResolver authorizationResolver, IClientStore clientStore, IDecorationLoader decorationLoader, IEventService events, IOptionsMonitor <ExceptionHandlingOptions> exceptionHandling, IFeatureManager featureManager, IHttpContextAccessor httpContextAccessor, IIdentityFacade identity, IOptionsMonitor <ExtendedIdentityServerOptions> identityServer, IIdentityServerInteractionService interaction, IStringLocalizerFactory localizerFactory, ILoggerFactory loggerFactory, IOptionsMonitor <RequestLocalizationOptions> requestLocalization, IServiceProvider serviceProvider)
{
this.AuthenticationSchemeRetriever = authenticationSchemeRetriever ?? throw new ArgumentNullException(nameof(authenticationSchemeRetriever));
this.AuthorizationResolver = authorizationResolver ?? throw new ArgumentNullException(nameof(authorizationResolver));
this.ClientStore = clientStore ?? throw new ArgumentNullException(nameof(clientStore));
this.DecorationLoader = decorationLoader ?? throw new ArgumentNullException(nameof(decorationLoader));
this.Events = events ?? throw new ArgumentNullException(nameof(events));
this.ExceptionHandling = exceptionHandling ?? throw new ArgumentNullException(nameof(exceptionHandling));
this.FeatureManager = featureManager ?? throw new ArgumentNullException(nameof(featureManager));
this.HttpContextAccessor = httpContextAccessor ?? throw new ArgumentNullException(nameof(httpContextAccessor));
this.Identity = identity ?? throw new ArgumentNullException(nameof(identity));
this.IdentityServer = identityServer ?? throw new ArgumentNullException(nameof(identityServer));
this.Interaction = interaction ?? throw new ArgumentNullException(nameof(interaction));
this.LocalizerFactory = localizerFactory ?? throw new ArgumentNullException(nameof(localizerFactory));
this.LoggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
this.RequestLocalization = requestLocalization ?? throw new ArgumentNullException(nameof(requestLocalization));
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (featureManager.IsEnabled(Feature.Saml))
{
this.SamlInteraction = serviceProvider.GetRequiredService <ISamlInteractionService>();
}
}
public async Task OnGetAsync()
{
Scores = new List <HighScore>();
try
{
//ILeaderboardClient proxy = RestService.For<ILeaderboardClient>(options.Value.BaseUrl);
if (featureManager.IsEnabled(nameof(AppFeatureFlags.LeaderboardListLimit)))
{
int limit;
Scores = await proxy.GetHighScores(Int32.TryParse(Request.Query["limit"], out limit)?limit : 5)
.ConfigureAwait(false);
}
else
{
Scores = await proxy.GetHighScores().ConfigureAwait(false);
}
}
catch (HttpRequestException ex)
{
logger.LogWarning(ex, "Http request failed.");
}
catch (TimeoutRejectedException ex)
{
logger.LogWarning(ex, "Timeout occurred when retrieving high score list.");
}
catch (Exception ex)
{
logger.LogError(ex, "Unknown exception occurred while retrieving high score list");
throw;
}
}
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);
}
/// <summary>
/// Returns true if the specified <see cref="ProductFeature"/> value is enabled, otherwise false.
/// </summary>
public static bool IsEnabled(this IFeatureManager featureManager, ProductFeature feature)
{
if (featureManager is null)
{
throw new ArgumentNullException(nameof(featureManager));
}
return(featureManager.IsEnabled(feature.ToString()));
}
public IEnumerable <FeatureFlag> EnabledFeatures(string actionstepOrg)
{
// Required by org key feature flag filter
HttpContext.SetCurrentOrgKey(actionstepOrg);
return(Enum.GetValues(typeof(FeatureFlag))
.OfType <FeatureFlag>()
.Where(f => _featureManager.IsEnabled(f.ToString())));
}
public IActionResult Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
var isEnabled = _featureManager.IsEnabled("nonExistentFeature");
return(new OkObjectResult($"nonExistentFetature enabled status: {isEnabled}"));
}
public IActionResult About()
{
ViewData["Message"] = "Your application description page.";
if (_featureManager.IsEnabled(nameof(MyFeatureFlags.CustomViewData)))
{
ViewData["Message"] = $"This is FANCY CONTENT you can see only if '{nameof(MyFeatureFlags.CustomViewData)}' is enabled.";
}
;
return(View());
}
public void 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(featureManager.IsEnabled(OnFeature));
Assert.False(featureManager.IsEnabled(OffFeature));
IEnumerable <IFeatureFilter> featureFilters = serviceProvider.GetRequiredService <IEnumerable <IFeatureFilter> >();
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);
};
featureManager.IsEnabled(ConditionalFeature);
Assert.True(called);
}
public DataExporter(IConfigurationDbContext configurationDatabaseContext, IFeatureManager featureManager, IIdentityFacade identityFacade, ILoggerFactory loggerFactory, IServiceProvider serviceProvider)
{
this.ConfigurationDatabaseContext = configurationDatabaseContext ?? throw new ArgumentNullException(nameof(configurationDatabaseContext));
this.FeatureManager = featureManager ?? throw new ArgumentNullException(nameof(featureManager));
this.IdentityFacade = identityFacade ?? throw new ArgumentNullException(nameof(identityFacade));
this.Logger = (loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory))).CreateLogger(this.GetType());
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (featureManager.IsEnabled(Feature.Saml))
{
this.SamlDatabaseContext = serviceProvider.GetRequiredService <ISamlConfigurationDbContext>();
}
if (featureManager.IsEnabled(Feature.WsFederation))
{
this.WsFederationDatabaseContext = serviceProvider.GetRequiredService <IWsFederationConfigurationDbContext>();
}
}
public ScenarioCampaignFailuresDataHandler(AWSSettings awsSettings,
ICloudStorage cloudStorage,
IRepositoryFactory repositoryFactory,
IFeatureManager featureManager,
IAuditEventRepository auditEventRepository)
{
_awsSettings = awsSettings;
_cloudStorage = cloudStorage;
_repositoryFactory = repositoryFactory;
_auditEventRepository = auditEventRepository;
_saveData = featureManager.IsEnabled(nameof(ProductFeature.PrePostCampaignResults));
}
public bool IsEnabled(string feature)
{
//
// First, check local cache
if (_flagCache.ContainsKey(feature))
{
return(_flagCache[feature]);
}
bool enabled = _featureManager.IsEnabled(feature);
_flagCache[feature] = enabled;
return(enabled);
}
public IFilterMetadata CreateInstance(IServiceProvider serviceProvider)
{
IFeatureManager featureManager = serviceProvider.GetRequiredService <IFeatureManagerSnapshot>();
if (featureManager.IsEnabled(FeatureName))
{
return((IFilterMetadata)ActivatorUtilities.CreateInstance(serviceProvider, typeof(T)));
}
else
{
//
// TODO check if null
return(new DisabledFeatureFilter(FeatureName));
}
}
public void TimeWindow()
{
string feature1 = "feature1";
string feature2 = "feature2";
string feature3 = "feature3";
string feature4 = "feature4";
Environment.SetEnvironmentVariable($"FeatureManagement:{feature1}:EnabledFor:0:Name", "TimeWindow");
Environment.SetEnvironmentVariable($"FeatureManagement:{feature1}:EnabledFor:0:Parameters:End", DateTimeOffset.UtcNow.AddDays(1).ToString("r"));
Environment.SetEnvironmentVariable($"FeatureManagement:{feature2}:EnabledFor:0:Name", "TimeWindow");
Environment.SetEnvironmentVariable($"FeatureManagement:{feature2}:EnabledFor:0:Parameters:End", DateTimeOffset.UtcNow.ToString("r"));
Environment.SetEnvironmentVariable($"FeatureManagement:{feature3}:EnabledFor:0:Name", "TimeWindow");
Environment.SetEnvironmentVariable($"FeatureManagement:{feature3}:EnabledFor:0:Parameters:Start", DateTimeOffset.UtcNow.ToString("r"));
Environment.SetEnvironmentVariable($"FeatureManagement:{feature4}:EnabledFor:0:Name", "TimeWindow");
Environment.SetEnvironmentVariable($"FeatureManagement:{feature4}:EnabledFor:0:Parameters:Start", DateTimeOffset.UtcNow.AddDays(1).ToString("r"));
IConfiguration config = new ConfigurationBuilder().AddEnvironmentVariables().Build();
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton(config)
.AddFeatureManagement()
.AddFeatureFilter <TimeWindowFilter>();
ServiceProvider provider = serviceCollection.BuildServiceProvider();
IFeatureManager featureManager = provider.GetRequiredService <IFeatureManager>();
Assert.True(featureManager.IsEnabled(feature1));
Assert.False(featureManager.IsEnabled(feature2));
Assert.True(featureManager.IsEnabled(feature3));
Assert.False(featureManager.IsEnabled(feature4));
}
/// <summary>
/// Conditionally creates a branch in the request pipeline that is rejoined to the main pipeline.
/// </summary>
/// <param name="app"></param>
/// <param name="featureName">The feature that is required to be enabled to take use this application branch</param>
/// <param name="configuration">Configures a branch to take</param>
/// <returns></returns>
public static IApplicationBuilder UseForFeature(this IApplicationBuilder app, string featureName, Action <IApplicationBuilder> configuration)
{
if (app == null)
{
throw new ArgumentNullException(nameof(app));
}
if (string.IsNullOrEmpty(featureName))
{
throw new ArgumentNullException(nameof(featureName));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
//
// Create and configure the branch builder right away; otherwise,
// we would end up running our branch after all the components
// that were subsequently added to the main builder.
IApplicationBuilder branchBuilder = app.New();
configuration(branchBuilder);
return(app.Use(main =>
{
// This is called only when the main application builder
// is built, not per request.
branchBuilder.Run(main);
RequestDelegate branch = branchBuilder.Build();
return async(context) =>
{
IFeatureManager fm = context.RequestServices.GetRequiredService <IFeatureManagerSnapshot>();
if (fm.IsEnabled(featureName))
{
await branch(context);
}
else
{
await main(context);
}
};
}));
}
public UISettings Get()
{
// Only user feature flags should be returned because we aren't setting
// an org key in the context
var featureFlags = Enum.GetValues(typeof(FeatureFlag))
.OfType <FeatureFlag>()
.Where(f => _featureManager.IsEnabled(f.ToString()));
return(new UISettings()
{
BuildNumber = UIDefinitions.BuildNumber,
YearWcaIncorporated = UIDefinitions.YearWcaIncorporated,
IsDevEnvironment = UIDefinitions.IsDevEnvironment,
BackToActionstepURL = _actionstepService.LaunchPadUri.AbsoluteUri,
UserFeatureFlags = featureFlags
});
}
public async Task <string> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req)
{
// Signal to refresh the configuration watched keys are modified. This will be no-op
// if the cache expiration time window is not reached.
_configRefresher.Refresh(); // Can do sync by adding await
// CONFIG (standard)
var configValue = _config[ConfigKeys.FnMessage];
// CONFIG (from KV)
var kvConfigValue = _config[ConfigKeys.AKVSourcedSecret];
// FEATURE
var featureValue = _features.IsEnabled(Features.FlipFlop);
return($"Config: {configValue} || Feature: {featureValue} || From KV: {kvConfigValue}");
}
