private async Task <FeatureBitTableDefinition> GetExistingFeatureBit(IFeatureBitDefinition definition)
{
var tableDefinition = definition.ToTableDefinition(_table.Name);
var tableResult = await _table.ExecuteAsync(TableOperation.Retrieve <FeatureBitTableDefinition>(tableDefinition.PartitionKey, tableDefinition.RowKey));
return((FeatureBitTableDefinition)tableResult.Result);
}
private static bool EvaluateEnvironmentBasedFeatureState(IFeatureBitDefinition bitDef)
{
bool featureState;
var env = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT").ToUpperInvariant();
featureState = !bitDef.ExcludedEnvironments.ToUpperInvariant().Contains(env);
return(featureState);
}
private static bool EvaluateEnvironmentBasedFeatureState(IFeatureBitDefinition bitDef)
{
bool featureState;
var env = SystemContext.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")?.ToUpperInvariant();
var environmentAry = bitDef.ExcludedEnvironments.ToUpperInvariant().Split(',');
featureState = !environmentAry.Contains(env);
return(featureState);
}
public async Task RemoveAsync(IFeatureBitDefinition definition)
{
var existing = await GetExistingFeatureBit(definition);
if (existing != null)
{
await _table.ExecuteAsync(TableOperation.Delete(existing));
}
}
/// <summary>
/// <see cref="IFeatureBitDefinition.Update"/>
/// </summary>
public void Update(IFeatureBitDefinition newEntity)
{
AllowedUsers = newEntity.AllowedUsers;
LastModifiedByUser = newEntity.LastModifiedByUser;
ExcludedEnvironments = newEntity.ExcludedEnvironments;
LastModifiedDateTime = newEntity.LastModifiedDateTime;
MinimumAllowedPermissionLevel = newEntity.MinimumAllowedPermissionLevel;
OnOff = newEntity.OnOff;
}
public async Task RemoveAsync(IFeatureBitDefinition definitionToRemove)
{
var toRemove = await GetByNameAsync(definitionToRemove.Name);
if (toRemove != null)
{
DbContext.Remove(toRemove);
await DbContext.SaveChangesAsync();
}
}
/// <summary>
/// Indacicates if a given feature is enabled or not.
/// </summary>
/// <param name="feature">Feature </param>
/// <returns>Returns the boolean value of the feature status.</returns>
public bool IsEnabled(IFeatureBitDefinition feature)
{
if (feature != null)
{
return(EvaluateBitValue(feature));
}
else
{
throw new ArgumentNullException(nameof(feature));
}
}
public async Task ItCanGetASpecificIFeatureBitDefinitionByName()
{
// Arrange
AddThreeDefinitions();
// Act
IFeatureBitDefinition result = (await _it.GetByNameAsync("item2"));
// Assert
result.MinimumAllowedPermissionLevel.Should().Be(10);
}
public async Task UpdateAsync(IFeatureBitDefinition definition)
{
var existing = await GetExistingFeatureBit(definition);
if (existing == null)
{
throw new DataException($"Could not update. Feature bit with name '{definition.Name}' does not exist");
}
existing.Update(definition);
var replaceOp = TableOperation.Replace(existing);
await _table.ExecuteAsync(replaceOp);
}
public async Task <IFeatureBitDefinition> AddAsync(IFeatureBitDefinition definition)
{
if (await GetExistingFeatureBit(definition) != null)
{
throw new DataException($"Cannot add. Feature bit with name '{definition.Name}' already exists.");
}
definition.Id = await GetNextId();
var insertOp = TableOperation.Insert(definition.ToTableDefinition(_table.Name));
var result = await _table.ExecuteAsync(insertOp);
return((IFeatureBitDefinition)result.Result);
}
public async Task <IFeatureBitDefinition> AddAsync(IFeatureBitDefinition definition)
{
FeatureBitEfDefinition newEntity = definition.ToEfDefinition();
ValidateDefinition(newEntity);
await MakeSureAFeatureBitWithThatNameDoesNotExist(newEntity);
var entity = await DbContext.FeatureBitDefinitions.AddAsync(newEntity);
await DbContext.SaveChangesAsync();
return(entity.Entity);
}
private static bool EvaluateBitValue(IFeatureBitDefinition bitDef)
{
bool result;
if (bitDef.ExcludedEnvironments?.Length > 0)
{
result = EvaluateEnvironmentBasedFeatureState(bitDef);
}
else
{
result = bitDef.IsOnOff;
}
return(result);
}
public static FeatureBitEfDefinition ToEfDefinition(this IFeatureBitDefinition definition)
{
return(new FeatureBitEfDefinition
{
Name = definition.Name,
ExcludedEnvironments = definition.ExcludedEnvironments,
ExactAllowedPermissionLevel = definition.ExactAllowedPermissionLevel,
AllowedUsers = definition.AllowedUsers,
CreatedByUser = definition.CreatedByUser,
CreatedDateTime = definition.CreatedDateTime,
OnOff = definition.OnOff,
Id = definition.Id,
LastModifiedByUser = definition.LastModifiedByUser,
LastModifiedDateTime = definition.LastModifiedDateTime,
MinimumAllowedPermissionLevel = definition.MinimumAllowedPermissionLevel
});
}
private static bool EvaluateEnvironmentBasedFeatureState(IFeatureBitDefinition bitDef)
{
bool featureState;
var env = SystemContext.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")?.ToUpperInvariant();
var excludedEnvironmentAry = GetEnvironmentList(bitDef.ExcludedEnvironments);
var includedEnvironmentAry = GetEnvironmentList(bitDef.IncludedEnvironments);
if (includedEnvironmentAry.Any())
{
featureState = includedEnvironmentAry.Contains(env);
}
else
{
featureState = !excludedEnvironmentAry.Contains(env);
}
return(featureState);
}
public async Task ItCanAddIFeatureBitDefinitions()
{
// Arrange
var item1 = new FeatureBitEfDefinition {
Name = "item1", CreatedByUser = "******", LastModifiedByUser = "******"
};
// Act
IFeatureBitDefinition result = await _it.AddAsync(item1);
// Assert
result.Name.Should().Be("item1");
result.Id.Should().NotBe(0);
using (var context = new FeatureBitsEfDbContext(_options))
{
context.FeatureBitDefinitions.Should().Contain(f => f.Name == "item1");
}
}
private object[] GetDataRow(IFeatureBitDefinition featureBitDefinition)
{
var cells = new List <object>
{
featureBitDefinition.Id,
featureBitDefinition.Name
};
if (_options.Long)
{
cells.Add(featureBitDefinition.OnOff);
cells.Add(featureBitDefinition.ExcludedEnvironments);
cells.Add(featureBitDefinition.MinimumAllowedPermissionLevel);
cells.Add(featureBitDefinition.ExactAllowedPermissionLevel ?? -1);
cells.Add(featureBitDefinition.AllowedUsers);
}
return(cells.ToArray());
}
public async Task UpdateAsync(IFeatureBitDefinition definition)
{
try
{
DbContext.Update(definition);
await DbContext.SaveChangesAsync();
} catch (DbUpdateConcurrencyException ex)
{
if (ex.Entries.Count == 1 && ex.Entries[0].IsKeySet == false)
{
DbContext.Add(definition);
await DbContext.SaveChangesAsync();
}
else
{
throw ex;
}
}
}
/// <summary>
/// Determine if a feature should be enabled or disabled
/// </summary>
/// <param name="feature">Feature to be checked</param>
/// <param name="currentPermissionLevel">The permission level of the current user</param>
/// <typeparam name="T">An enumeration or an integer</typeparam>
/// <returns>True if the feature is enabled.</returns>
public bool IsEnabled <T>(T feature, int currentPermissionLevel) where T : struct, IConvertible
{
Type tType = typeof(T);
if (!(tType.IsEnum || tType == typeof(int)))
{
throw new ArgumentException("T must be an enumerated type");
}
IFeatureBitDefinition bitDef = Definitions.FirstOrDefault(x => x.Id == feature.ToInt32(new FeatureBitFormatProvider()));
if (bitDef != null)
{
return(EvaluateBitValue(bitDef, currentPermissionLevel));
}
string featureString = tType.IsEnum ? Enum.GetName(tType, feature) : feature.ToString(CultureInfo.InvariantCulture);
throw new KeyNotFoundException($"Unable to find Feature {featureString}");
}
public static FeatureBitTableDefinition ToTableDefinition(this IFeatureBitDefinition definition, string tableName)
{
return(new FeatureBitTableDefinition
{
Name = definition.Name,
PartitionKey = tableName,
RowKey = definition.Name,
ExcludedEnvironments = definition.ExcludedEnvironments,
ExactAllowedPermissionLevel = definition.ExactAllowedPermissionLevel,
AllowedUsers = definition.AllowedUsers,
IncludedEnvironments = definition.IncludedEnvironments,
CreatedByUser = definition.CreatedByUser,
CreatedDateTime = definition.CreatedDateTime,
OnOff = definition.OnOff,
Id = definition.Id,
LastModifiedByUser = definition.LastModifiedByUser,
LastModifiedDateTime = definition.LastModifiedDateTime,
MinimumAllowedPermissionLevel = definition.MinimumAllowedPermissionLevel
});
}
private static bool EvaluateBitValue(IFeatureBitDefinition bitDef, int currentUsersPermissionLevel)
{
bool result;
if (bitDef.ExcludedEnvironments?.Length > 0 || bitDef.IncludedEnvironments?.Length > 0)
{
result = EvaluateEnvironmentBasedFeatureState(bitDef);
}
else if (currentUsersPermissionLevel > 0 && bitDef.ExactAllowedPermissionLevel > 0)
{
result = bitDef.ExactAllowedPermissionLevel == currentUsersPermissionLevel;
}
else if (bitDef.MinimumAllowedPermissionLevel > 0)
{
result = CheckMinimumPermission(bitDef, currentUsersPermissionLevel);
}
else
{
result = bitDef.OnOff;
}
return(result);
}
public async Task <int> RunAsync()
{
int returnValue = 0;
try
{
IFeatureBitDefinition newBit = BuildBit();
await _repo.AddAsync(newBit);
SystemContext.ConsoleWriteLine("Feature bit added.");
}
catch (DataException e)
{
returnValue = await HandleFeatureBitAlreadyExists(e);
}
catch (Exception e)
{
returnValue = 1;
SystemContext.ConsoleErrorWriteLine(e.ToString());
}
return(returnValue);
}
public async Task UpdateAsync(IFeatureBitDefinition definition)
{
DbContext.Update(definition);
await DbContext.SaveChangesAsync();
}
private static FeatureBitEvaluator SetupFeatureBitEvaluator(IFeatureBitDefinition bitDefinition)
{
return(SetupFeatureBitEvaluator(new List <IFeatureBitDefinition> {
bitDefinition
}));
}
private static bool CheckMinimumPermission(IFeatureBitDefinition bitDef, int currentUsersPermissionLevel) => currentUsersPermissionLevel >= bitDef.MinimumAllowedPermissionLevel;
