Revised the feature system.

modules/cms-kit/host/Volo.CmsKit.Host.Shared/FeatureConfigurer.cs

@@ -6,7 +6,7 @@ namespace Volo.CmsKit
     {
         public static void Configure()
         {
-            GlobalFeatureManager.Instance.Modules().CmsKit().EnableAll();
+            GlobalFeatureManager.Instance.Modules.CmsKit().EnableAll();
         }
     }
 }

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/Abp/GlobalFeatures/GlobalFeature.cs

@@ -1,36 +0,0 @@
-using JetBrains.Annotations;
-
-namespace Volo.Abp.GlobalFeatures
-{
-    public class GlobalFeature
-    {
-        public GlobalFeatureManagerModuleConfigurator ModuleConfigurator { get; }
-
-        public string Name { get; }
-
-        public bool IsEnabled => ModuleConfigurator.ModulesConfigurator.FeatureManager.IsEnabled(Name);
-
-        public GlobalFeature(
-            [NotNull] GlobalFeatureManagerModuleConfigurator moduleConfigurator,
-            [NotNull] string name)
-        {
-            ModuleConfigurator = Check.NotNull(moduleConfigurator, nameof(moduleConfigurator));
-            Name = Check.NotNullOrWhiteSpace(name, nameof(name));
-        }
-
-        public virtual void Enable()
-        {
-            ModuleConfigurator.ModulesConfigurator.FeatureManager.Enable(Name);
-        }
-
-        public virtual void Disable()
-        {
-            ModuleConfigurator.ModulesConfigurator.FeatureManager.Disable(Name);
-        }
-
-        public virtual void SetEnabled(bool isEnabled)
-        {
-            ModuleConfigurator.ModulesConfigurator.FeatureManager.SetEnabled(Name, isEnabled);
-        }
-    }
-}

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/Abp/GlobalFeatures/GlobalFeatureConfigurator.cs

@@ -0,0 +1,45 @@
+using JetBrains.Annotations;
+
+namespace Volo.Abp.GlobalFeatures
+{
+    public class GlobalFeature
+    {
+        [NotNull]
+        public GlobalModuleFeatures Module { get; }
+
+        [NotNull]
+        public GlobalFeatureManager FeatureManager { get; }
+
+        public string FeatureName { get; }
+
+        public bool IsEnabled
+        {
+            get => FeatureManager.IsEnabled(FeatureName);
+            set => FeatureManager.SetEnabled(FeatureName, value);
+        }
+
+        public GlobalFeature(
+            [NotNull] GlobalModuleFeatures module,
+            [NotNull] string name)
+        {
+            Module = Check.NotNull(module, nameof(module));
+            FeatureName = Check.NotNullOrWhiteSpace(name, nameof(name));
+            FeatureManager = Module.FeatureManager;
+        }
+
+        public virtual void Enable()
+        {
+            FeatureManager.Enable(FeatureName);
+        }
+
+        public virtual void Disable()
+        {
+            FeatureManager.Disable(FeatureName);
+        }
+
+        public virtual void SetEnabled(bool isEnabled)
+        {
+
+        }
+    }
+}

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/Abp/GlobalFeatures/GlobalFeatureConfiguratorDictionary.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace Volo.Abp.GlobalFeatures
+{
+    public class GlobalFeatureConfiguratorDictionary : Dictionary<string, GlobalFeature>
+    {
+
+    }
+}

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/Abp/GlobalFeatures/GlobalFeatureManager.cs

@@ -4,19 +4,46 @@ using JetBrains.Annotations;
 
 namespace Volo.Abp.GlobalFeatures
 {
-    public class GlobalFeatureManager //TODO: Move to the ABP Framework..? //rename?
+    public class GlobalFeatureManager
     {
         public static GlobalFeatureManager Instance { get; protected set; } = new GlobalFeatureManager();
 
         [NotNull]
-        public ConcurrentDictionary<object, object> Configuration { get; }
+        public Dictionary<object, object> Configuration { get; }
+
+        public GlobalFeatureManagerModuleDictionary Modules { get; }
 
         protected HashSet<string> EnabledFeatures { get; }
 
         private GlobalFeatureManager()
         {
             EnabledFeatures = new HashSet<string>();
-            Configuration = new ConcurrentDictionary<object, object>();
+            Configuration = new Dictionary<object, object>();
+            Modules = new GlobalFeatureManagerModuleDictionary(this);
+        }
+
+        public virtual bool IsEnabled<TFeature>()
+            where TFeature : GlobalFeature
+        {
+            return IsEnabled(GlobalFeatureNameAttribute.GetName<TFeature>());
+        }
+
+        public virtual void SetEnabled<TFeature>(bool isEnabled)
+            where TFeature : GlobalFeature
+        {
+            SetEnabled(GlobalFeatureNameAttribute.GetName<TFeature>(), isEnabled);
+        }
+
+        public virtual void Enable<TFeature>()
+            where TFeature : GlobalFeature
+        {
+            Enable(GlobalFeatureNameAttribute.GetName<TFeature>());
+        }
+
+        public virtual void Disable<TFeature>()
+            where TFeature : GlobalFeature
+        {
+            Disable(GlobalFeatureNameAttribute.GetName<TFeature>());
         }
 
         public virtual bool IsEnabled(string featureName)
@@ -46,7 +73,7 @@ namespace Volo.Abp.GlobalFeatures
             EnabledFeatures.Remove(featureName);
         }
 
-        public virtual IEnumerable<string> GetEnabledFeatures()
+        public virtual IEnumerable<string> GetEnabledFeatureNames()
         {
             return EnabledFeatures;
         }

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/Abp/GlobalFeatures/GlobalFeatureManagerCmsKitConfigurator.cs

@@ -1,12 +0,0 @@
-namespace Volo.Abp.GlobalFeatures
-{
-    public class GlobalFeatureManagerCmsKitConfigurator : GlobalFeatureManagerModuleConfigurator
-    {
-        public GlobalFeatureManagerCmsKitConfigurator(GlobalFeatureManagerModulesConfigurator modulesConfigurator)
-            : base(modulesConfigurator)
-        {
-            this.Reactions();
-            this.Comments();
-        }
-    }
-}

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/Abp/GlobalFeatures/GlobalFeatureManagerCmsKitConfiguratorExtensions.cs

@@ -1,52 +0,0 @@
-using System;
-using JetBrains.Annotations;
-
-namespace Volo.Abp.GlobalFeatures
-{
-    public static class GlobalFeatureManagerCmsKitConfiguratorExtensions
-    {
-        public static GlobalFeature Reactions(
-            [NotNull] this GlobalFeatureManagerCmsKitConfigurator cmsKitConfigurator)
-        {
-            Check.NotNull(cmsKitConfigurator, nameof(cmsKitConfigurator));
-
-            return cmsKitConfigurator
-                    .Features
-                    .GetOrAdd("Reactions", _ => new GlobalFeature(cmsKitConfigurator, "CmsKit:Reactions"))
-                as GlobalFeature;
-        }
-
-        public static GlobalFeatureManagerCmsKitConfigurator Reactions(
-            [NotNull] this GlobalFeatureManagerCmsKitConfigurator cmsKitConfigurator,
-            [NotNull] Action<GlobalFeature> configureAction)
-        {
-            Check.NotNull(cmsKitConfigurator, nameof(cmsKitConfigurator));
-
-            configureAction(cmsKitConfigurator.Reactions());
-
-            return cmsKitConfigurator;
-        }
-
-        public static GlobalFeature Comments(
-            [NotNull] this GlobalFeatureManagerCmsKitConfigurator cmsKitConfigurator)
-        {
-            Check.NotNull(cmsKitConfigurator, nameof(cmsKitConfigurator));
-
-            return cmsKitConfigurator
-                    .Features
-                    .GetOrAdd("Comments", _ => new GlobalFeature(cmsKitConfigurator, "CmsKit:Comments"))
-                as GlobalFeature;
-        }
-
-        public static GlobalFeatureManagerCmsKitConfigurator Comments(
-            [NotNull] this GlobalFeatureManagerCmsKitConfigurator cmsKitConfigurator,
-            [NotNull] Action<GlobalFeature> configureAction)
-        {
-            Check.NotNull(cmsKitConfigurator, nameof(cmsKitConfigurator));
-
-            configureAction(cmsKitConfigurator.Comments());
-
-            return cmsKitConfigurator;
-        }
-    }
-}

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/Abp/GlobalFeatures/GlobalFeatureManagerExtensions.cs

@@ -1,18 +0,0 @@
-using JetBrains.Annotations;
-
-namespace Volo.Abp.GlobalFeatures
-{
-    public static class GlobalFeatureManagerExtensions
-    {
-        public static GlobalFeatureManagerModulesConfigurator Modules(
-            [NotNull] this GlobalFeatureManager featureManager)
-        {
-            Check.NotNull(featureManager, nameof(featureManager));
-
-            return featureManager
-                    .Configuration
-                    .GetOrAdd("_Modules", _ => new GlobalFeatureManagerModulesConfigurator(featureManager))
-                as GlobalFeatureManagerModulesConfigurator;
-        }
-    }
-}

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/Abp/GlobalFeatures/GlobalFeatureManagerModuleConfigurator.cs

@@ -1,25 +1,25 @@
-using System.Collections.Concurrent;
-using JetBrains.Annotations;
+using JetBrains.Annotations;
 
 namespace Volo.Abp.GlobalFeatures
 {
-    public abstract class GlobalFeatureManagerModuleConfigurator
+    public abstract class GlobalModuleFeatures
     {
         [NotNull]
-        public GlobalFeatureManagerModulesConfigurator ModulesConfigurator { get; }
+        public GlobalFeatureConfiguratorDictionary AllFeatures { get; }
 
         [NotNull]
-        public ConcurrentDictionary<string, GlobalFeature> Features { get; }
+        public GlobalFeatureManager FeatureManager { get; }
 
-        protected GlobalFeatureManagerModuleConfigurator(GlobalFeatureManagerModulesConfigurator modulesConfigurator)
+        protected GlobalModuleFeatures(
+            GlobalFeatureManager featureManager)
         {
-            ModulesConfigurator = Check.NotNull(modulesConfigurator, nameof(modulesConfigurator));
-            Features = new ConcurrentDictionary<string, GlobalFeature>();
+            AllFeatures = new GlobalFeatureConfiguratorDictionary();
+            FeatureManager = featureManager;
         }
 
         public virtual void EnableAll()
         {
-            foreach (var feature in Features.Values)
+            foreach (var feature in AllFeatures.Values)
             {
                 feature.Enable();
             }
@@ -27,10 +27,31 @@ namespace Volo.Abp.GlobalFeatures
 
         public virtual void DisableAll()
         {
-            foreach (var feature in Features.Values)
+            foreach (var feature in AllFeatures.Values)
             {
                 feature.Disable();
             }
         }
+
+        protected void AddFeature(string featureName)
+        {
+            AddFeature(new GlobalFeature(this, featureName));
+        }
+
+        protected void AddFeature(GlobalFeature feature)
+        {
+            AllFeatures[feature.FeatureName] = feature;
+        }
+
+        protected GlobalFeature GetFeature(string featureName)
+        {
+            return AllFeatures[featureName];
+        }
+
+        protected TFeature GetFeature<TFeature>(string featureName)
+            where TFeature : GlobalFeature
+        {
+            return (TFeature) AllFeatures[featureName];
+        }
     }
 }

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/Abp/GlobalFeatures/GlobalFeatureManagerModuleConfiguratorCmsKitExtensions.cs

@@ -1,30 +1,31 @@
 using System;
+using System.Collections.Generic;
 using JetBrains.Annotations;
+using Volo.CmsKit.GlobalFeatures;
 
 namespace Volo.Abp.GlobalFeatures
 {
     public static class GlobalFeatureManagerModuleConfiguratorCmsKitExtensions
     {
-        public static GlobalFeatureManagerCmsKitConfigurator CmsKit(
-            [NotNull] this GlobalFeatureManagerModulesConfigurator modulesConfigurator)
+        public static GlobalCmsKitFeatures CmsKit(
+            [NotNull] this GlobalFeatureManagerModuleDictionary modules)
         {
-            Check.NotNull(modulesConfigurator, nameof(modulesConfigurator));
+            Check.NotNull(modules, nameof(modules));
 
-            return modulesConfigurator
-                    .Modules
-                    .GetOrAdd("CmsKit", _ => new GlobalFeatureManagerCmsKitConfigurator(modulesConfigurator))
-                as GlobalFeatureManagerCmsKitConfigurator;
+            return modules
+                    .GetOrAdd(GlobalCmsKitFeatures.ModuleName, _ => new GlobalCmsKitFeatures(modules.FeatureManager))
+                as GlobalCmsKitFeatures;
         }
 
-        public static GlobalFeatureManagerModulesConfigurator CmsKit(
-            [NotNull] this GlobalFeatureManagerModulesConfigurator modulesConfigurator,
-            [NotNull] Action<GlobalFeatureManagerCmsKitConfigurator> configureAction)
+        public static GlobalFeatureManagerModuleDictionary CmsKit(
+            [NotNull] this GlobalFeatureManagerModuleDictionary modules,
+            [NotNull] Action<GlobalCmsKitFeatures> configureAction)
         {
             Check.NotNull(configureAction, nameof(configureAction));
 
-            configureAction(modulesConfigurator.CmsKit());
+            configureAction(modules.CmsKit());
 
-            return modulesConfigurator;
+            return modules;
         }
     }
 }

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/Abp/GlobalFeatures/GlobalFeatureManagerModulesConfigurator.cs

@@ -1,19 +1,16 @@
-using System.Collections.Concurrent;
+using System.Collections.Generic;
 using JetBrains.Annotations;
 
 namespace Volo.Abp.GlobalFeatures
 {
-    public class GlobalFeatureManagerModulesConfigurator //TODO: Change to GlobalFeatureManagerModuleDictionary and inherit from ConcurrentDictionary
+    public class GlobalFeatureManagerModuleDictionary : Dictionary<string, GlobalModuleFeatures>
     {
         public GlobalFeatureManager FeatureManager { get; }
 
-        [NotNull]
-        public ConcurrentDictionary<string, GlobalFeatureManagerModuleConfigurator> Modules { get; }
-
-        public GlobalFeatureManagerModulesConfigurator([NotNull] GlobalFeatureManager featureManager)
+        public GlobalFeatureManagerModuleDictionary(
+            [NotNull] GlobalFeatureManager featureManager)
         {
             FeatureManager = Check.NotNull(featureManager, nameof(featureManager));
-            Modules = new ConcurrentDictionary<string, GlobalFeatureManagerModuleConfigurator>();
         }
     }
 }

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/Abp/GlobalFeatures/GlobalFeatureNameAttribute.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using JetBrains.Annotations;
+
+namespace Volo.Abp.GlobalFeatures
+{
+    [AttributeUsage(AttributeTargets.Class)]
+    public class GlobalFeatureNameAttribute : Attribute
+    {
+        public string Name { get; }
+
+        public GlobalFeatureNameAttribute([NotNull] string name)
+        {
+            Name = Check.NotNullOrWhiteSpace(name, nameof(name));
+        }
+
+        public static string GetName<TFeature>()
+            where TFeature : GlobalFeature
+        {
+            return GetName(typeof(TFeature));
+        }
+
+        public static string GetName(Type type)
+        {
+            var attribute = type
+                .GetCustomAttributes<GlobalFeatureNameAttribute>()
+                .FirstOrDefault();
+
+            if (attribute == null)
+            {
+                throw new AbpException($"{type.AssemblyQualifiedName} should define the {typeof(GlobalFeatureNameAttribute).FullName} atttribute!");
+            }
+
+            return attribute
+                .As<GlobalFeatureNameAttribute>()
+                .Name;
+        }
+    }
+}

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/CmsKit/CmsKitDomainSharedModule.cs

@@ -16,16 +16,14 @@ namespace Volo.CmsKit
     {
         public override void ConfigureServices(ServiceConfigurationContext context)
         {
-            GlobalFeatureManager.Instance.Modules().CmsKit().EnableAll();
-            GlobalFeatureManager.Instance.Modules().CmsKit().DisableAll();
-            GlobalFeatureManager.Instance.Modules().CmsKit().Reactions().Enable();
-            GlobalFeatureManager.Instance.Modules().CmsKit(cmsKit =>
+            GlobalFeatureManager.Instance.Modules.CmsKit().EnableAll();
+            GlobalFeatureManager.Instance.Modules.CmsKit().DisableAll();
+            GlobalFeatureManager.Instance.Modules.CmsKit().Reactions.Enable();
+            GlobalFeatureManager.Instance.Modules.CmsKit().Reactions.Enable();
+            GlobalFeatureManager.Instance.Modules.CmsKit(cmsKit =>
             {
-                cmsKit.Reactions().Disable();
-                cmsKit.Reactions(reactions =>
-                {
-                    reactions.Enable();
-                });
+                cmsKit.Reactions.Disable();
+                cmsKit.Comments.Enable();
             });
 
             GlobalFeatureManager.Instance.IsEnabled("asd");

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/CmsKit/GlobalFeatures/CommentsFeature.cs

@@ -0,0 +1,17 @@
+using JetBrains.Annotations;
+using Volo.Abp.GlobalFeatures;
+
+namespace Volo.CmsKit.GlobalFeatures
+{
+    [GlobalFeatureName(Name)]
+    public class CommentsFeature : GlobalFeature
+    {
+        public const string Name = "CmsKit.Comments";
+
+        public CommentsFeature(
+            [NotNull] GlobalCmsKitFeatures cmsKit
+        ) : base(cmsKit, Name)
+        {
+        }
+    }
+}

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/CmsKit/GlobalFeatures/GlobalFeatureManagerCmsKitConfigurator.cs

@@ -0,0 +1,20 @@
+using Volo.Abp.GlobalFeatures;
+
+namespace Volo.CmsKit.GlobalFeatures
+{
+    public class GlobalCmsKitFeatures : GlobalModuleFeatures
+    {
+        public const string ModuleName = "CmsKit";
+
+        public ReactionsFeature Reactions => GetFeature<ReactionsFeature>(ReactionsFeature.Name);
+
+        public CommentsFeature Comments => GetFeature<CommentsFeature>(CommentsFeature.Name);
+
+        public GlobalCmsKitFeatures(GlobalFeatureManager featureManager)
+            : base(featureManager)
+        {
+            AddFeature(new ReactionsFeature(this));
+            AddFeature(new CommentsFeature(this));
+        }
+    }
+}

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/CmsKit/GlobalFeatures/ReactionsFeature.cs

@@ -0,0 +1,17 @@
+using JetBrains.Annotations;
+using Volo.Abp.GlobalFeatures;
+
+namespace Volo.CmsKit.GlobalFeatures
+{
+    [GlobalFeatureName(Name)]
+    public class ReactionsFeature : GlobalFeature
+    {
+        public const string Name = "CmsKit.Reactions";
+
+        public ReactionsFeature(
+            [NotNull] GlobalCmsKitFeatures cmsKit
+            ) : base(cmsKit, Name)
+        {
+        }
+    }
+}

modules/cms-kit/src/Volo.CmsKit.EntityFrameworkCore/Volo/CmsKit/EntityFrameworkCore/CmsKitDbContextModelCreatingExtensions.cs

@@ -7,6 +7,7 @@ using Volo.CmsKit.Comments;
 using Volo.CmsKit.Reactions;
 using Volo.CmsKit.Users;
 using Volo.Abp.Users.EntityFrameworkCore;
+using Volo.CmsKit.GlobalFeatures;
 
 namespace Volo.CmsKit.EntityFrameworkCore
 {
@@ -33,7 +34,7 @@ namespace Volo.CmsKit.EntityFrameworkCore
                 b.ConfigureAbpUser();
             });
 
-            if (GlobalFeatureManager.Instance.Modules().CmsKit().Reactions().IsEnabled)
+            if (GlobalFeatureManager.Instance.IsEnabled<ReactionsFeature>())
             {
                 builder.Entity<UserReaction>(b =>
                 {
@@ -50,7 +51,7 @@ namespace Volo.CmsKit.EntityFrameworkCore
                 });
             }
 
-            if (GlobalFeatureManager.Instance.Modules().CmsKit().Comments().IsEnabled)
+            if (GlobalFeatureManager.Instance.IsEnabled<CommentsFeature>())
             {
                 builder.Entity<Comment>(b =>
                 {

modules/cms-kit/test/Volo.CmsKit.TestBase/CmsKitTestBaseModule.cs

@@ -19,7 +19,7 @@ namespace Volo.CmsKit
     {
         public override void ConfigureServices(ServiceConfigurationContext context)
         {
-            GlobalFeatureManager.Instance.Modules().CmsKit().EnableAll();
+            GlobalFeatureManager.Instance.Modules.CmsKit().EnableAll();
 
             context.Services.AddAlwaysAllowAuthorization();
         }