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