public void RegisterMenus(TreeNode <MenuItem> rootNode, string menuName)
{
Guard.NotNull(rootNode, nameof(rootNode));
Guard.NotEmpty(menuName, nameof(menuName));
var providers = _requestCache.Get("sm.menu.providers.{0}".FormatInvariant(menuName), () =>
{
var allInstances = _requestCache.Get("sm.menu.allproviders", () =>
{
var instances = new List <IMenuProvider>();
var providerTypes = _typeScanner.FindTypes <IMenuProvider>(ignoreInactiveModules: true);
foreach (var type in providerTypes)
{
try
{
var provider = EngineContext.Current.Scope.ResolveUnregistered(type) as IMenuProvider;
instances.Add(provider);
}
catch { }
}
return(instances);
});
return(allInstances.Where(x => x.MenuName.EqualsNoCase(menuName)).OrderBy(x => x.Ordinal).ToList());
});
providers.Each(x => x.BuildMenu(rootNode));
}
private IApplicationInitializer[] GetInitializers()
{
try
{
var initializerTypes = _typeScanner.FindTypes <IApplicationInitializer>(ignoreInactiveModules: true);
return(initializerTypes
.Select(x => _scope.ResolveUnregistered(x) as IApplicationInitializer)
.OrderBy(x => x.Order)
.ToArray());
}
catch (Exception ex)
{
_logger.Error(ex, "Error while resolving application initializers.");
throw;
}
}
public async Task InitializeAsync(HttpContext httpContext)
{
var removeUnusedPermissions = true;
var providers = new List <IPermissionProvider>();
// TODO: (core) PluginManager.PluginChangeDetected is still required in InstallPermissionsInitializer?
if (/*PluginManager.PluginChangeDetected ||*/ DbMigrationManager.Instance.GetAppliedMigrations().Any() || !await _db.PermissionRecords.AnyAsync())
{
// INFO: even if no module has changed: directly after a DB migration this code block MUST run. It seems awkward
// that pending migrations exist when binaries has not changed. But after a manual DB reset for a migration rerun
// nobody touches the binaries usually.
// Core permission provider and all module providers.
var types = _typeScanner.FindTypes <IPermissionProvider>(ignoreInactiveModules: true).ToList();
foreach (var type in types)
{
if (Activator.CreateInstance(type) is IPermissionProvider provider)
{
providers.Add(provider);
}
else
{
removeUnusedPermissions = false;
Logger.Warn($"Cannot create instance of IPermissionProvider {type.Name.NaIfEmpty()}.");
}
}
}
else
{
// Always check core permission provider.
providers.Add(new StandardPermissionProvider());
// Keep unused permissions in database (has no negative effects) as long as at least one module changed.
removeUnusedPermissions = false;
}
await _permissionService.InstallPermissionsAsync(providers.ToArray(), removeUnusedPermissions);
}
protected virtual IEnumerable <(Type SeederType, Type ContextType)> DiscoverDataSeeders()
{
var seederTypes = _typeScanner.FindTypes(typeof(IDataSeeder <>), ignoreInactiveModules: true);
foreach (var seederType in seederTypes)
{
if (!seederType.HasDefaultConstructor())
{
// Skip data seeders that are not constructible.
continue;
}
if (typeof(Migration).IsAssignableFrom(seederType))
{
// Skip data seeders that are bound to specific migrations.
continue;
}
if (seederType.IsSubClass(typeof(IDataSeeder <>), out var intf))
{
yield return(seederType, intf.GetGenericArguments()[0]);
}
}
}
/// <summary>
/// Find all types that are subclasses of <typeparamref name="T"/> in all passed <paramref name="assemblies"/>.
/// </summary>
/// <param name="baseType">The base type to check for.</param>
/// <param name="concreteTypesOnly">Whether abstract types should be skipped.</param>
/// <param name="assemblies">Assemblies to scan.</param>
/// <returns>Matching types</returns>
public static IEnumerable <Type> FindTypes <T>(this ITypeScanner scanner, IEnumerable <Assembly> assemblies, bool concreteTypesOnly = true)
{
return(scanner.FindTypes(typeof(T), assemblies, concreteTypesOnly));
}
/// <summary>
/// Find all types that are subclasses of <typeparamref name="T"/> in all known assemblies.
/// </summary>
/// <typeparam name="T">The base type to check for</typeparam>
/// <param name="concreteTypesOnly">Whether abstract types should be skipped.</param>
/// <param name="ignoreInactiveModules">Speciifies whether inactive module's assemblies should be ignored.</param>
/// <returns>Matching types</returns>
public static IEnumerable <Type> FindTypes <T>(this ITypeScanner scanner, bool concreteTypesOnly = true, bool ignoreInactiveModules = false)
{
return(scanner.FindTypes(typeof(T), concreteTypesOnly, ignoreInactiveModules));
}
