Added initial setting definition manager.

src/Volo.Abp.Settings/Volo/Abp/Settings/DefaultSettingContributor.cs

@@ -12,7 +12,7 @@ namespace Volo.Abp.Settings
             _settingStore = settingStore;
         }
         
-        public async Task<string> GetOrNull(string name, string entityType, string entityId, bool fallback = true)
+        public async Task<string> GetOrNullAsync(string name, string entityType, string entityId, bool fallback = true)
         {
             //TODO: Optimization: Get all settings and cache it!
             return await _settingStore.GetOrNullAsync(name, null, null);

src/Volo.Abp.Settings/Volo/Abp/Settings/ISettingContributor.cs

@@ -4,6 +4,6 @@ namespace Volo.Abp.Settings
 {
     public interface ISettingContributor
     {
-        Task<string> GetOrNull(string name, string entityType, string entityId, bool fallback = true);
+        Task<string> GetOrNullAsync(string name, string entityType, string entityId, bool fallback = true);
     }
 }

src/Volo.Abp.Settings/Volo/Abp/Settings/ISettingDefinitionContext.cs

@@ -0,0 +1,9 @@
+namespace Volo.Abp.Settings
+{
+    public interface ISettingDefinitionContext
+    {
+        SettingDefinition GetOrNull(string name);
+
+        void Add(params SettingDefinition[] definitions);
+    }
+}

src/Volo.Abp.Settings/Volo/Abp/Settings/ISettingDefinitionManager.cs

@@ -0,0 +1,7 @@
+namespace Volo.Abp.Settings
+{
+    public interface ISettingDefinitionManager
+    {
+        SettingDefinition Get(string name);
+    }
+}

src/Volo.Abp.Settings/Volo/Abp/Settings/ISettingProvider.cs

@@ -0,0 +1,7 @@
+namespace Volo.Abp.Settings
+{
+    public interface ISettingProvider
+    {
+        void Define(ISettingDefinitionContext context);
+    }
+}

src/Volo.Abp.Settings/Volo/Abp/Settings/SettingDefinition.cs

@@ -0,0 +1,16 @@
+namespace Volo.Abp.Settings
+{
+    public class SettingDefinition
+    {
+        public string Name { get; }
+
+        public string DefaultValue { get; set; }
+
+        public SettingDefinition(string name, string defaultValue = null)
+        {
+            Name = name;
+
+            DefaultValue = defaultValue;
+        }
+    }
+}

src/Volo.Abp.Settings/Volo/Abp/Settings/SettingDefinitionContext.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+
+namespace Volo.Abp.Settings
+{
+    public class SettingDefinitionContext : ISettingDefinitionContext
+    {
+        protected Dictionary<string, SettingDefinition> Settings { get; }
+
+        public SettingDefinitionContext(Dictionary<string, SettingDefinition> settings)
+        {
+            Settings = settings;
+        }
+
+        public virtual SettingDefinition GetOrNull(string name)
+        {
+            return Settings.GetOrDefault(name);
+        }
+
+        public virtual void Add(params SettingDefinition[] definitions)
+        {
+            if (definitions.IsNullOrEmpty())
+            {
+                return;
+            }
+
+            foreach (var definition in definitions)
+            {
+                Settings[definition.Name] = definition;
+            }
+        }
+    }
+}

src/Volo.Abp.Settings/Volo/Abp/Settings/SettingDefinitionManager.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using Volo.Abp.DependencyInjection;
+
+namespace Volo.Abp.Settings
+{
+    public class SettingDefinitionManager : ISettingDefinitionManager, ISingletonDependency
+    {
+        protected Lazy<List<ISettingProvider>> Providers { get; }
+
+        protected Lazy<IDictionary<string, SettingDefinition>> SettingDefinitions { get; }
+
+        protected SettingOptions Options { get; }
+
+        private readonly IServiceProvider _serviceProvider;
+
+        public SettingDefinitionManager(
+            IOptions<SettingOptions> options,
+            IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+            Options = options.Value;
+
+            Providers = new Lazy<List<ISettingProvider>>(CreateSettingProviders, true);
+            SettingDefinitions = new Lazy<IDictionary<string, SettingDefinition>>(CreateSettingDefinitions, true);
+        }
+
+        public virtual SettingDefinition Get(string name)
+        {
+            var settingDefinition = GetOrNull(name);
+
+            if (settingDefinition == null)
+            {
+                throw new AbpException("Undefined setting: " + name);
+            }
+
+            return settingDefinition;
+        }
+
+        public virtual SettingDefinition GetOrNull(string name)
+        {
+            return SettingDefinitions.Value.GetOrDefault(name);
+        }
+
+        private List<ISettingProvider> CreateSettingProviders()
+        {
+            return Options
+                .Providers
+                .Select(p => _serviceProvider.GetRequiredService(p) as ISettingProvider)
+                .ToList();
+        }
+
+        private IDictionary<string, SettingDefinition> CreateSettingDefinitions()
+        {
+            var settings = new Dictionary<string, SettingDefinition>();
+
+            foreach (var provider in Providers.Value)
+            {
+                provider.Define(new SettingDefinitionContext(settings));
+            }
+
+            return settings;
+        }
+    }
+}

src/Volo.Abp.Settings/Volo/Abp/Settings/SettingManager.cs

@@ -10,12 +10,18 @@ namespace Volo.Abp.Settings
 {
     public class SettingManager : ISettingManager, ISingletonDependency
     {
+        protected ISettingDefinitionManager SettingDefinitionManager { get; }
+
         protected Lazy<List<ISettingContributor>> Contributors { get; }
 
         protected SettingOptions Options { get; }
 
-        public SettingManager(IOptions<SettingOptions> options, IServiceProvider serviceProvider)
+        public SettingManager(
+            IOptions<SettingOptions> options, 
+            IServiceProvider serviceProvider, 
+            ISettingDefinitionManager settingDefinitionManager)
         {
+            SettingDefinitionManager = settingDefinitionManager;
             Options = options.Value;
 
             Contributors = new Lazy<List<ISettingContributor>>(
@@ -32,18 +38,20 @@ namespace Volo.Abp.Settings
             return GetOrNullAsync(name, null, null);
         }
 
-        public Task<string> GetOrNullAsync(string name, string entityType, string entityId, bool fallback = true)
+        public async Task<string> GetOrNullAsync(string name, string entityType, string entityId, bool fallback = true)
         {
+            var settingDefinition = SettingDefinitionManager.Get(name);
+
             foreach (var contributor in Contributors.Value)
             {
-                var value = contributor.GetOrNull(name, entityType, entityId, fallback);
+                var value = await contributor.GetOrNullAsync(name, entityType, entityId, fallback);
                 if (value != null)
                 {
                     return value;
                 }
             }
 
-            return null;
+            return settingDefinition.DefaultValue;
         }
 
         public Task<List<SettingValue>> GetAllAsync()

src/Volo.Abp.Settings/Volo/Abp/Settings/SettingOptions.cs

@@ -6,12 +6,16 @@ namespace Volo.Abp.Settings
     {
         public ITypeList<ISettingContributor> Contributors { get; }
 
+        public ITypeList<ISettingProvider> Providers { get; set; }
+
         public SettingOptions()
         {
             Contributors = new TypeList<ISettingContributor>
             {
                 typeof(DefaultSettingContributor)
             };
+
+            Providers = new TypeList<ISettingProvider>();
         }
     }
 }

src/Volo.Abp.Settings/Volo/Abp/Settings/SettingProvider.cs

@@ -0,0 +1,9 @@
+using Volo.Abp.DependencyInjection;
+
+namespace Volo.Abp.Settings
+{
+    public abstract class SettingProvider : ISettingProvider, ISingletonDependency
+    {
+        public abstract void Define(ISettingDefinitionContext context);
+    }
+}

test/Volo.Abp.Settings.Tests/Volo/Abp/Settings/AbpIdentityApplicationTestModule.cs

@@ -32,6 +32,11 @@ namespace Volo.Abp.Settings
             {
                 options.TransactionBehavior = UnitOfWorkTransactionBehavior.Disabled; //EF in-memory database does not support transactions
             });
+
+            services.Configure<SettingOptions>(options =>
+            {
+                options.Providers.Add<TestSettingProvider>();
+            });
         }
 
         public override void OnApplicationInitialization(ApplicationInitializationContext context)

test/Volo.Abp.Settings.Tests/Volo/Abp/Settings/SettingManager_Tests.cs

@@ -14,7 +14,22 @@ namespace Volo.Abp.Settings
         }
 
         [Fact]
-        public async Task Test1()
+        public async Task Should_Throw_Exception_When_Try_To_Get_An_Undefined_Setting()
+        {
+            await Assert.ThrowsAsync<AbpException>(
+                async () => await _settingManager.GetOrNullAsync("UndefinedSetting")
+            );
+        }
+
+        [Fact]
+        public async Task Should_Get_Default_Value_If_Not_Set_In_Store()
+        {
+            var value = await _settingManager.GetOrNullAsync("SettingNotSetInStore");
+            value.ShouldBe("default-value");
+        }
+
+        [Fact]
+        public async Task Should_Get_From_Store_Without_Entity_Props()
         {
             var value = await _settingManager.GetOrNullAsync("MySetting1");
             value.ShouldBe("42");

test/Volo.Abp.Settings.Tests/Volo/Abp/Settings/TestSettingProvider.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Volo.Abp.Settings
+{
+    public class TestSettingProvider : SettingProvider
+    {
+        public override void Define(ISettingDefinitionContext context)
+        {
+            context.Add(new SettingDefinition("MySetting1"));
+            context.Add(new SettingDefinition("SettingNotSetInStore", defaultValue: "default-value"));
+        }
+    }
+}