void IFeatureEventHandler.Installing(IFeatureInfo feature)
{
}
public void TryAdd(Type type, IFeatureInfo feature)
{
dummyVar0 = this._features.TryAdd(type, feature);
return;
}
Task IFeatureEventHandler.DisablingAsync(IFeatureInfo feature)
{
return(Task.CompletedTask);
}
public virtual void Built(IFeatureInfo featureInfo)
{
}
public Task <FeatureEntry> LoadFeatureAsync(IFeatureInfo feature)
{
return(Task.FromResult((FeatureEntry) new NonCompiledFeatureEntry(feature)));
}
Task IFeatureEventHandler.UninstalledAsync(IFeatureInfo feature) => Task.CompletedTask;
private int GetPriority(IFeatureInfo feature)
{
return(_extensionPriorityStrategies.Sum(s => s.GetPriority(feature)));
}
public ShapeAlterationBuilder From(IFeatureInfo feature)
{
_feature = feature;
return(this);
}
public void NotifyFeatureStart(IFeatureInfo feature)
{
_notifier.NotifyFeatureStart(feature);
}
void IFeatureEventHandler.Uninstalled(IFeatureInfo feature)
{
}
public async Task AddDefaultRolesForFeatureAsync(IFeatureInfo feature)
{
// when another module is being enabled, locate matching permission providers
var providersForEnabledModule = _permissionProviders
.Where(x => _typeFeatureProvider.GetFeatureForDependency(x.GetType()).Id == feature.Id);
if (Logger.IsEnabled(LogLevel.Debug))
{
if (providersForEnabledModule.Any())
{
Logger.LogDebug($"Configuring default roles for module {feature.Id}");
}
else
{
Logger.LogDebug($"No default roles for module {feature.Id}");
}
}
foreach (var permissionProvider in providersForEnabledModule)
{
// get and iterate stereotypical groups of permissions
var stereotypes = permissionProvider.GetDefaultStereotypes();
foreach (var stereotype in stereotypes)
{
// turn those stereotypes into roles
var role = await _roleManager.FindByNameAsync(stereotype.Name);
if (role == null)
{
if (Logger.IsEnabled(LogLevel.Information))
{
Logger.LogInformation($"Defining new role {stereotype.Name} for permission stereotype");
}
role = new Role {
RoleName = stereotype.Name
};
await _roleManager.CreateAsync(role);
}
// and merge the stereotypical permissions into that role
var stereotypePermissionNames = (stereotype.Permissions ?? Enumerable.Empty <Permission>()).Select(x => x.Name);
var currentPermissionNames = role.RoleClaims.Where(x => x.ClaimType == Permission.ClaimType).Select(x => x.ClaimValue);
var distinctPermissionNames = currentPermissionNames
.Union(stereotypePermissionNames)
.Distinct();
// update role if set of permissions has increased
var additionalPermissionNames = distinctPermissionNames.Except(currentPermissionNames);
if (additionalPermissionNames.Any())
{
foreach (var permissionName in additionalPermissionNames)
{
if (Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogInformation("Default role {0} granted permission {1}", stereotype.Name, permissionName);
}
await _roleManager.AddClaimAsync(role, new Claim(Permission.ClaimType, permissionName));
}
}
}
}
}
void IFeatureEventHandler.Disabled(IFeatureInfo feature)
{
}
void IFeatureEventHandler.Enabling(IFeatureInfo feature)
{
}
void IFeatureEventHandler.Installed(IFeatureInfo feature)
{
AddDefaultRolesForFeatureAsync(feature).Wait();
}
Task IFeatureEventHandler.EnabledAsync(IFeatureInfo feature) => SetMediaTokenSettingsAsync(feature);
public int GetPriority(IFeatureInfo feature)
{
return(feature.Priority);
}
Task IFeatureEventHandler.DisabledAsync(IFeatureInfo feature) => Task.CompletedTask;
/// <summary>
/// Initializes a new instance of the <see cref="FoundFeatureInfo"/> class.
/// </summary>
/// <param name="commandHandlerInfo">The FTP command handler information.</param>
/// <param name="featureInfo">The feature information.</param>
public FoundFeatureInfo(IFtpCommandHandlerInformation commandHandlerInfo, IFeatureInfo featureInfo)
{
IsCommandHandler = true;
_commandHandlerInfo = commandHandlerInfo;
FeatureInfo = featureInfo;
}
private bool HasDependency(IFeatureInfo f1, IFeatureInfo f2)
{
return(_extensionDependencyStrategies.Any(s => s.HasDependency(f1, f2)));
}
/// <summary>
/// Initializes a new instance of the <see cref="FoundFeatureInfo"/> class.
/// </summary>
/// <param name="extensionInfo">The FTP command handler extension information.</param>
/// <param name="featureInfo">The feature information.</param>
public FoundFeatureInfo(IFtpCommandHandlerExtensionInformation extensionInfo, IFeatureInfo featureInfo)
{
IsExtension = true;
_extensionInfo = extensionInfo;
FeatureInfo = featureInfo;
}
public bool HasDependency(IFeatureInfo observer, IFeatureInfo subject)
{
return(observer.Dependencies.Contains(subject.Id));
}
/// <summary>
/// Initializes a new instance of the <see cref="FoundFeatureInfo"/> class.
/// </summary>
/// <param name="authMechanism">The authentication mechanism.</param>
/// <param name="featureInfo">The feature information.</param>
public FoundFeatureInfo(IAuthenticationMechanism authMechanism, IFeatureInfo featureInfo)
{
IsAuthenticationMechanism = true;
_authenticationMechanism = authMechanism;
FeatureInfo = featureInfo;
}
/// <summary>
/// Disables a feature.
/// </summary>
/// <param name="featureId">The ID of the feature to be enabled.</param>
/// <param name="force">Boolean parameter indicating if the feature should enable it's dependencies if required or fail otherwise.</param>
/// <returns>An enumeration of the disabled features.</returns>
private IEnumerable <IFeatureInfo> GetFeaturesToDisable(ShellDescriptor shellDescriptor, IFeatureInfo featureInfo, bool force)
{
var enabledFeatures = _extensionManager.GetEnabledFeatures(shellDescriptor).ToArray();
var affectedFeatures = _extensionManager
.GetDependentFeatures(featureInfo.Id, enabledFeatures)
.ToList();
if (affectedFeatures.Count > 1 && !force)
{
if (_logger.IsEnabled(LogLevel.Warning))
{
_logger.LogWarning("Additional features need to be disabled.");
}
if (FeatureDependencyNotification != null)
{
FeatureDependencyNotification("If {0} is disabled, then you'll also need to disable {1}.", featureInfo, affectedFeatures.Where(f => f.Id != featureInfo.Id));
}
}
return(affectedFeatures);
}
/// <summary>
/// Disables a feature.
/// </summary>
/// <param name="featureId">The ID of the feature to be enabled.</param>
/// <param name="force">Boolean parameter indicating if the feature should enable it's dependencies if required or fail otherwise.</param>
/// <returns>An enumeration of the disabled features.</returns>
private async Task <IEnumerable <IFeatureInfo> > DisableFeatureAsync(ShellDescriptor shellDescriptor, IFeatureInfo featureInfo, bool force)
{
IEnumerable <string> affectedFeatures =
await GetDependentFeaturesAsync(shellDescriptor, featureInfo.Id);
var featuresToDisable = _extensionManager
.GetExtensions()
.Features
.Where(x => affectedFeatures.Contains(x.Id))
.ToList();
if (featuresToDisable.Count > 1 && !force)
{
if (_logger.IsEnabled(LogLevel.Warning))
{
_logger.LogWarning("Additional features need to be disabled.");
}
if (FeatureDependencyNotification != null)
{
FeatureDependencyNotification("If {0} is disabled, then you'll also need to disable {1}.", featureInfo, featuresToDisable.Where(f => f.Id != featureInfo.Id));
}
}
return(featuresToDisable);
}
public bool DependencyOn(IFeatureInfo feature)
{
return(false);
}
public ShapeTable GetShapeTable(string themeId)
{
var cacheKey = $"ShapeTable:{themeId}";
ShapeTable shapeTable;
if (!_memoryCache.TryGetValue(cacheKey, out shapeTable))
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("Start building shape table");
}
IList <IReadOnlyList <ShapeAlteration> > alterationSets = new List <IReadOnlyList <ShapeAlteration> >();
foreach (var bindingStrategy in _bindingStrategies)
{
IFeatureInfo strategyDefaultFeature =
_typeFeatureProvider.GetFeatureForDependency(bindingStrategy.GetType());
var builder = new ShapeTableBuilder(strategyDefaultFeature);
bindingStrategy.Discover(builder);
var builtAlterations = builder.BuildAlterations().ToReadOnlyCollection();
if (builtAlterations.Any())
{
alterationSets.Add(builtAlterations);
}
}
var alterations = alterationSets
.SelectMany(shapeAlterations => shapeAlterations)
.Where(alteration => IsModuleOrRequestedTheme(alteration, themeId))
.OrderByDependenciesAndPriorities(AlterationHasDependency, GetPriority)
.ToList();
var descriptors = alterations.GroupBy(alteration => alteration.ShapeType, StringComparer.OrdinalIgnoreCase)
.Select(group => group.Aggregate(
new ShapeDescriptor {
ShapeType = group.Key
},
(descriptor, alteration) =>
{
alteration.Alter(descriptor);
return(descriptor);
})).ToList();
foreach (var descriptor in descriptors)
{
foreach (var alteration in alterations.Where(a => a.ShapeType == descriptor.ShapeType).ToList())
{
var local = new ShapeDescriptor {
ShapeType = descriptor.ShapeType
};
alteration.Alter(local);
descriptor.BindingSources.Add(local.BindingSource);
}
}
shapeTable = new ShapeTable
{
Descriptors = descriptors.ToDictionary(sd => sd.ShapeType, StringComparer.OrdinalIgnoreCase),
Bindings = descriptors.SelectMany(sd => sd.Bindings).ToDictionary(kv => kv.Key, kv => kv.Value, StringComparer.OrdinalIgnoreCase),
};
//await _eventBus.NotifyAsync<IShapeTableEventHandler>(x => x.ShapeTableCreated(result));
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("Done building shape table");
}
_memoryCache.Set(cacheKey, shapeTable, new MemoryCacheEntryOptions {
Priority = CacheItemPriority.NeverRemove
});
}
return(shapeTable);
}
Task IFeatureEventHandler.InstalledAsync(IFeatureInfo feature)
{
return(Task.CompletedTask);
}
Task IFeatureEventHandler.EnablingAsync(IFeatureInfo feature) => Task.CompletedTask;
Task IFeatureEventHandler.UninstallingAsync(IFeatureInfo feature)
{
return(Task.CompletedTask);
}
public ShapeTable GetShapeTable(string themeId)
{
var cacheKey = $"ShapeTable:{themeId}";
ShapeTable shapeTable;
if (!_memoryCache.TryGetValue(cacheKey, out shapeTable))
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("Start building shape table");
}
var excludedFeatures = _shapeDescriptors.Count == 0 ? new List <string>() :
_shapeDescriptors.Select(kv => kv.Value.Feature.Id).Distinct().ToList();
foreach (var bindingStrategy in _bindingStrategies)
{
IFeatureInfo strategyFeature = _typeFeatureProvider.GetFeatureForDependency(bindingStrategy.GetType());
if (!(bindingStrategy is IShapeTableHarvester) && excludedFeatures.Contains(strategyFeature.Id))
{
continue;
}
var builder = new ShapeTableBuilder(strategyFeature, excludedFeatures);
bindingStrategy.Discover(builder);
var builtAlterations = builder.BuildAlterations();
BuildDescriptors(bindingStrategy, builtAlterations);
}
var enabledAndOrderedFeatureIds = _shellFeaturesManager
.GetEnabledFeaturesAsync()
.GetAwaiter()
.GetResult()
.Select(f => f.Id)
.ToList();
// let the application acting as a super theme for shapes rendering.
if (enabledAndOrderedFeatureIds.Remove(_hostingEnvironment.ApplicationName))
{
enabledAndOrderedFeatureIds.Add(_hostingEnvironment.ApplicationName);
}
var descriptors = _shapeDescriptors
.Where(sd => enabledAndOrderedFeatureIds.Contains(sd.Value.Feature.Id))
.Where(sd => IsModuleOrRequestedTheme(sd.Value.Feature, themeId))
.OrderBy(sd => enabledAndOrderedFeatureIds.IndexOf(sd.Value.Feature.Id))
.GroupBy(sd => sd.Value.ShapeType, StringComparer.OrdinalIgnoreCase)
.Select(group => new ShapeDescriptorIndex
(
shapeType: group.Key,
alterationKeys: group.Select(kv => kv.Key),
descriptors: _shapeDescriptors
));
shapeTable = new ShapeTable
{
Descriptors = descriptors.Cast <ShapeDescriptor>().ToDictionary(sd => sd.ShapeType, StringComparer.OrdinalIgnoreCase),
Bindings = descriptors.SelectMany(sd => sd.Bindings).ToDictionary(kv => kv.Key, kv => kv.Value, StringComparer.OrdinalIgnoreCase)
};
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("Done building shape table");
}
_memoryCache.Set(cacheKey, shapeTable, new MemoryCacheEntryOptions {
Priority = CacheItemPriority.NeverRemove
});
}
return(shapeTable);
}