public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var parameters = context.Parameters;
var bla = parameters["ring0Users"];
return(Task.FromResult(true));
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var settings = context.Parameters.Get <CookiePresentFilterSettings>();
bool isEnabled = _httpContextAccessor.HttpContext.Request.Cookies.ContainsKey(settings.CookieName);
return(Task.FromResult(isEnabled));
}
public async Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
if (!_httpContextAccessor.HttpContext.User.Identity.IsAuthenticated)
{
return(false);
}
using (var scope = _scopeFactory.CreateScope())
{
var featuresContext = scope.ServiceProvider.GetRequiredService <FeaturesContext>();
var userManager = scope.ServiceProvider.GetRequiredService <UserManager <IdentityUser> >();
var user = await userManager.GetUserAsync(_httpContextAccessor.HttpContext.User);
var feature = featuresContext.Features.FirstOrDefault(a => a.Name.ToLower() == context.FeatureName.ToLower());
if (user == null || feature == null)
{
return(false);
}
var userFeature = featuresContext.UserFeatures.FirstOrDefault(f => f.UserId == user.Id && f.FeatureId == feature.Id);
return(userFeature != null);
}
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var userAgent = _httpContextAccessor.HttpContext.Request.Headers["User-Agent"].ToString();
var settings = context.Parameters.Get <BrowserFilterSettings>();
return(Task.FromResult(settings.AllowedBrowsers.Any(c => userAgent.Contains(c))));
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var isEnabled = tenant.EnabledFeatureFlags
.Any(f => f.FeatureName == context.FeatureName);
return(Task.FromResult(isEnabled));
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var settings = context.Parameters.Get <IpAddressPercentageFilterSettings>();
var ipAddress = _httpContextAccessor.HttpContext.Connection.RemoteIpAddress;
int randomSeed = 0;
if (ipAddress != null)
{
var ipBytes = ipAddress.GetAddressBytes();
if (ipBytes.Length >= 3)
{
int rawIp = 0;
rawIp ^= ipBytes[ipBytes.Length - 1];
rawIp ^= ipBytes[ipBytes.Length - 2] << 8;
rawIp ^= ipBytes[ipBytes.Length - 3] << 16;
randomSeed = rawIp;
}
}
var random = new Random(randomSeed);
bool isEnabled = random.Next(100) < settings.PercentageValue;
return(Task.FromResult(isEnabled));
}
/// <inheritdoc />
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var settings = (BrowserFilterSettings)context.Parameters;
string userAgent = GetUserAgent();
if (settings.AllowedBrowsers.Any(browser => browser.Equals(SupportedBrowserId.Chrome.ToString(),
StringComparison.OrdinalIgnoreCase)) && IsChrome(userAgent))
{
return(Task.FromResult(true));
}
if (settings.AllowedBrowsers.Any(browser => browser.Equals(SupportedBrowserId.Edge.ToString(),
StringComparison.OrdinalIgnoreCase)) && IsEdge(userAgent))
{
return(Task.FromResult(true));
}
if (settings.AllowedBrowsers.Any(browser => browser.Equals(SupportedBrowserId.InternetExplorer.ToString(),
StringComparison.OrdinalIgnoreCase)) && IsInternetExplorer11(userAgent))
{
return(Task.FromResult(true));
}
if (settings.AllowedBrowsers.Any(browser => browser.Equals(SupportedBrowserId.Firefox.ToString(),
StringComparison.OrdinalIgnoreCase)) && IsFirefox(userAgent))
{
return(Task.FromResult(true));
}
return(Task.FromResult(false));
}
public Task <bool> IsOn(FeatureFilterEvaluationContext context, CancellationToken cancellationToken = default)
{
var now = this.dateTimeResolver();
var settings = context.GetSettings <DateTimeFeatureFilterSettings>();
if (settings is null)
{
throw new InvalidOperationException("Invalid settings.");
}
var isOn = true;
if (settings.From.HasValue && now < settings.From)
{
isOn = false;
}
if (settings.To.HasValue && now > settings.To)
{
isOn = false;
}
return(Task.FromResult(isOn));
}
public static async Task Main(string[] args)
{
IConfigurationRoot configuration = new ConfigurationBuilder()
.AddAzureAppConfiguration(options =>
{
//options.Connect(Environment.GetEnvironmentVariable("ConnectionString")).UseFeatureFlags();
options.Connect(_appConfigConnectionString).UseFeatureFlags();
}).Build();
IServiceCollection services = new ServiceCollection();
services.AddSingleton <IConfiguration>(configuration).AddFeatureManagement().AddFeatureFilter <ringDeploymentFilter>();
FeatureFilterEvaluationContext context = new FeatureFilterEvaluationContext();
ringDeploymentFilter ff = new ringDeploymentFilter();
using (ServiceProvider serviceProvider = services.BuildServiceProvider())
{
IFeatureManager featureManager = serviceProvider.GetRequiredService <IFeatureManager>();
var enabled = await featureManager.IsEnabledAsync("ff_RefreshWeatherData", ff);
if (enabled == true)
{
Console.WriteLine("Welcome to the beta!");
}
}
Console.WriteLine("Hello World!");
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var httpContext = _httpContextAccessor.HttpContext;
string subscriptionTypeClaim = httpContext.User.Claims.First(s => s.Type.Equals(ClaimConfig.CLAIM_SUBSCRIPTION_TYPE)).Value;
var settings = context.Parameters.Get <SubscriptionFilterSettings>();
return(Task.FromResult(settings.SubscriptionType.Equals(subscriptionTypeClaim)));
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var settings = context.Parameters.Get <GroupFilterSettings>();
var user = _httpContextAccessor.HttpContext.User;
return(Task.FromResult(settings.AllowedGroups.Intersect(user.Groups()).Any()));
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext featureFilterContext, ITenantFeatureContext appContext)
{
var settings = featureFilterContext.Parameters.Get <TenantFilterSettings>();
appContext.TenantId = settings.AllowedTenants.ToString();
return(Task.FromResult(((IList)settings.AllowedTenants).Contains(appContext.TenantId)));
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var httpContext = _httpContextAccessor.HttpContext;
string licensePlanClaim = httpContext.User.Claims.First(s => s.Type.Equals(ClaimConfig.CLAIM_LICENSE_PLAN)).Value;
var settings = context.Parameters.Get <LicensePlanFilterSettings>();
return(Task.FromResult(settings.LicensePlan.Equals(licensePlanClaim)));
}
public bool Evaluate(FeatureFilterEvaluationContext context)
{
var settings = context.Parameters.Get <ClaimsFilterSettings>();
var user = _httpContextAccesor.HttpContext.User;
return(settings.RequiredClaims
.All(claimType => user.HasClaim(claim => claim.Type == claimType)));
}
public HeadersFilterTests()
{
this.httpContextAccessorMock = new Mock <IHttpContextAccessor>();
this.target = new HeadersFilter(this.httpContextAccessorMock.Object);
this.context = new FeatureFilterEvaluationContext
{
FeatureName = FeatureName
};
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext featureFilterContext, AppContext appContext)
{
var settings = featureFilterContext.Parameters.Get <BetaFilterSettings>();
//var settings = new { ClientIds = new List<int>() };
//featureFilterContext.Parameters.Bind(settings);
return(Task.FromResult(settings.ClientIds.Contains(appContext.ClientId)));
}
public bool Evaluate(FeatureFilterEvaluationContext context)
{
var settings = context.Parameters.Get <CookieFeatureFilterSettings>();
if (_httpContextAccessor.HttpContext.Request.Cookies.TryGetValue(settings.CookieName, out var value))
{
return(value == settings.CookieValue);
}
return(false);
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext featureFilterContext, IFeatureFilterContext appContext)
{
var settings = featureFilterContext.Parameters.Get <FeatureFilterContext>();
appContext.IsEnable = settings.IsEnable;
appContext.OriginType = settings.OriginType;
appContext.NewType = settings.NewType;
return(Task.FromResult(appContext.IsEnable));
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var result =
_httpContextAccessor?.HttpContext?.User.HasClaim(
PlatformConstants.Security.Claims.PermissionClaimType,
Demo.ModuleConstants.Security.Permissions.Developer) ??
false;
return(Task.FromResult(result));
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var rd = this.ActionContextAccessor.ActionContext.RouteData;
string currentController = rd.Values["controller"].ToString() + "Controller";
string currentAction = rd.Values["action"].ToString();
string featureName = $"{currentController}.{currentAction}";
bool shouldGrantAccess = await ShouldGrantAccess(featureName : featureName);
return(shouldGrantAccess);
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var settings = context.Parameters.Get <CookieFeatureFilterSettings>();
if (_httpContextAccessor.HttpContext.Request.Cookies.TryGetValue(settings.CookieName, out var value))
{
return(Task.FromResult(value == settings.CookieValue));
}
return(Task.FromResult(false));
}
/// <summary>
/// Performs a targeting evaluation using the provided <see cref="TargetingContext"/> to determine if a feature should be enabled.
/// </summary>
/// <param name="context">The feature evaluation context.</param>
/// <param name="targetingContext">The targeting context to use during targeting evaluation.</param>
/// <exception cref="ArgumentNullException">Thrown if either <paramref name="context"/> or <paramref name="targetingContext"/> is null.</exception>
/// <returns>True if the feature is enabled, false otherwise.</returns>
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context, ITargetingContext targetingContext)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (targetingContext == null)
{
throw new ArgumentNullException(nameof(targetingContext));
}
var settings = (TargetingFilterSettings)context.Parameters;
if (!TryValidateSettings(settings, out string paramName, out string message))
{
throw new ArgumentException(message, paramName);
}
//
// Check if the user is being targeted directly
if (targetingContext.UserId != null &&
settings.Audience.Users != null &&
settings.Audience.Users.Any(user => targetingContext.UserId.Equals(user, ComparisonType)))
{
return(Task.FromResult(true));
}
//
// Check if the user is in a group that is being targeted
if (targetingContext.Groups != null &&
settings.Audience.Groups != null)
{
foreach (string group in targetingContext.Groups)
{
GroupRollout groupRollout = settings.Audience.Groups.FirstOrDefault(g => g.Name.Equals(group, ComparisonType));
if (groupRollout != null)
{
string audienceContextId = $"{targetingContext.UserId}\n{context.FeatureName}\n{group}";
if (IsTargeted(audienceContextId, groupRollout.RolloutPercentage))
{
return(Task.FromResult(true));
}
}
}
}
//
// Check if the user is being targeted by a default rollout percentage
string defaultContextId = $"{targetingContext.UserId}\n{context.FeatureName}";
return(Task.FromResult(IsTargeted(defaultContextId, settings.Audience.DefaultRolloutPercentage)));
}
/// <summary>
/// Evaluate a condition based on the appContxet representing a CountryAlpha2Code
/// </summary>
/// <param name="featureFilterContext"></param>
/// <param name="appContext"></param>
/// <returns></returns>
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext featureFilterContext, string appContext)
{
var settings = featureFilterContext.Parameters.Get <CountryAlpha2CodeFilterSettings>();
if (!settings.ExcludedCountries.Any(x => string.Equals(x, appContext, System.StringComparison.OrdinalIgnoreCase)))
{
return(Task.FromResult(settings.AllowedCountries.Any(x => string.Equals(x, appContext, System.StringComparison.OrdinalIgnoreCase))));
}
return(Task.FromResult(false));
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var value = Randomize.RandomNumber();
var isEnabled = value % 3 == 0;
if (!isEnabled)
{
_logger.LogWarning($"Feature '{Alias}' is not enabled for current value '{value}'.");
}
return(Task.FromResult(isEnabled));
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var settings = context.Parameters.Get <ProxyAllowedFilterSettings>() ?? new ProxyAllowedFilterSettings();
if (settings.ProxyingAllowed)
{
return(Task.FromResult(true));
}
return(Task.FromResult(false));
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var httpContext = _httpContextAccessor.HttpContext;
string userIdClaim = httpContext.User.Claims.First(s => s.Type.Equals(ClaimConfig.CLAIM_USER_ID)).Value;
Guid userId = new Guid(userIdClaim);
IEnumerable <Models.User> users = new List <Models.User>();
// check if country code was changed
bool hitCache = _cache.TryGetValue(MemoryCacheItems.PercentageUsers, out users);
return(Task.FromResult(hitCache && users.Any(u => u.Id.Equals(userId))));
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext featureFilterContext, RuntimeInformationContext appContext)
{
var runtimeContext = featureFilterContext.Parameters.Get <RuntimeInformationContext>();
var isEnabled = runtimeContext.Equals(appContext);
if (!isEnabled)
{
_logger.LogWarning($"Feature '{Alias}' is not enabled for current context '{appContext}'.");
}
return(Task.FromResult(isEnabled));
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var httpContext = _httpContextAccessor.HttpContext;
if (httpContext.Request.Headers.TryGetValue(GeneralConstants.DeviceExtraction, out StringValues deviceType))
{
DeviceTypeFilterSettings settings = context.Parameters.Get <DeviceTypeFilterSettings>();
return(Task.FromResult(settings.AllowedDevices.Contains(deviceType.ToString())));
}
return(Task.FromResult(false));
}
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext context)
{
var currentOSPlatform = OperatingSystemFeatureFilterSettings.GetCurrentOSPlatform();
var settings = context.Parameters.Get <OperatingSystemFeatureFilterSettings>();
var isEnabled = settings.GetFeatureOSPlatform() == currentOSPlatform;
if (!isEnabled)
{
_logger.LogWarning($"Feature '{Alias}' is not enabled for current operating system '{currentOSPlatform}'.");
}
return(Task.FromResult(isEnabled));
}
/// <summary>
///
/// </summary>
/// <param name="featureEvaluationContext"></param>
/// <param name="accountContext"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext featureEvaluationContext,
IAccountContext accountContext)
{
if (string.IsNullOrEmpty(accountContext?.AccountId))
{
throw new ArgumentNullException(nameof(accountContext));
}
var settings = (AccountFilterSettings)featureEvaluationContext.Parameters;
return(Task.FromResult(settings.AllowedAccounts.Contains(accountContext.AccountId)));
}
