public Task <bool> EvaluateAsync(FeatureFilterEvaluationContext evaluationContext, object context)
{
if (_evaluateFunc == null)
{
return(Task.FromResult(false));
}
return(_evaluateFunc(_filter, evaluationContext, context));
}
private async Task <bool> IsEnabledAsync <TContext>(string feature, TContext appContext, bool useAppContext)
{
foreach (ISessionManager sessionManager in _sessionManagers)
{
bool?readSessionResult = await sessionManager.GetAsync(feature).ConfigureAwait(false);
if (readSessionResult.HasValue)
{
return(readSessionResult.Value);
}
}
bool enabled = false;
FeatureSettings settings = await _settingsProvider.GetFeatureSettingsAsync(feature).ConfigureAwait(false);
if (settings != null)
{
//
// Check if feature is always on
// If it is, result is true, goto: cache
if (settings.EnabledFor.Any(featureFilter => string.Equals(featureFilter.Name, "AlwaysOn", StringComparison.OrdinalIgnoreCase)))
{
enabled = true;
}
else
{
//
// For all enabling filters listed in the feature's state calculate if they return true
// If any executed filters return true, return true
foreach (FeatureFilterSettings featureFilterSettings in settings.EnabledFor)
{
IFeatureFilterMetadata filter = GetFeatureFilterMetadata(featureFilterSettings.Name);
if (filter == null)
{
string errorMessage = $"The feature filter '{featureFilterSettings.Name}' specified for feature '{feature}' was not found.";
if (!_options.IgnoreMissingFeatureFilters)
{
throw new FeatureManagementException(FeatureManagementError.MissingFeatureFilter, errorMessage);
}
else
{
_logger.LogWarning(errorMessage);
}
continue;
}
var context = new FeatureFilterEvaluationContext()
{
FeatureName = feature,
Parameters = featureFilterSettings.Parameters
};
//
// IContextualFeatureFilter
if (useAppContext)
{
ContextualFeatureFilterEvaluator contextualFilter = GetContextualFeatureFilter(featureFilterSettings.Name, typeof(TContext));
if (contextualFilter != null && await contextualFilter.EvaluateAsync(context, appContext).ConfigureAwait(false))
{
enabled = true;
break;
}
}
//
// IFeatureFilter
if (filter is IFeatureFilter featureFilter && await featureFilter.EvaluateAsync(context).ConfigureAwait(false))
{
enabled = true;
break;
}
}
}
}
foreach (ISessionManager sessionManager in _sessionManagers)
{
await sessionManager.SetAsync(feature, enabled).ConfigureAwait(false);
}
return(enabled);
}
public bool IsEnabled(string feature)
{
foreach (ISessionManager sessionManager in _sessionManagers)
{
if (sessionManager.TryGet(feature, out bool cachedEnabled))
{
return(cachedEnabled);
}
}
bool enabled = false;
IFeatureSettings settings = _settingsProvider.TryGetFeatureSettings(feature);
if (settings != null)
{
//
// Check if feature is always on
// If it is, result is true, goto: cache
if (settings.EnabledFor.Any(featureFilter => string.Equals(featureFilter.Name, "AlwaysOn", StringComparison.OrdinalIgnoreCase)))
{
enabled = true;
}
else
{
//
// For all enabling filters listed in the feature's state calculate if they return true
// If any executed filters return true, return true
foreach (IFeatureFilterSettings featureFilterSettings in settings.EnabledFor)
{
IFeatureFilter filter = GetFeatureFilter(featureFilterSettings.Name);
if (filter == null)
{
_logger.LogWarning($"Feature filter '{featureFilterSettings.Name}' specified for feature '{feature}' was not found.");
continue;
}
var context = new FeatureFilterEvaluationContext()
{
FeatureName = feature,
Parameters = featureFilterSettings.Parameters
};
if (filter.Evaluate(context))
{
enabled = true;
break;
}
}
}
}
foreach (ISessionManager sessionManager in _sessionManagers)
{
sessionManager.Set(feature, enabled);
}
return(enabled);
}