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