Merge pull request #6368 from abpframework/maliming/patch-AbpOptionsFactory

Use AbpDynamicOptionsManager to replace AbpOptionsFactory.

framework/src/Volo.Abp.AspNetCore/Microsoft/AspNetCore/RequestLocalization/AbpRequestLocalizationMiddleware.cs

@@ -23,15 +23,13 @@ namespace Microsoft.AspNetCore.RequestLocalization
 
         public async Task InvokeAsync(HttpContext context, RequestDelegate next)
         {
+
             var middleware = new RequestLocalizationMiddleware(
                 next,
-                new OptionsWrapper<RequestLocalizationOptions>(
-                    await _requestLocalizationOptionsProvider.GetLocalizationOptionsAsync()
-),
-                _loggerFactory
+                new OptionsWrapper<RequestLocalizationOptions>(await _requestLocalizationOptionsProvider.GetLocalizationOptionsAsync()), _loggerFactory
             );
 
             await middleware.Invoke(context);
         }
     }
-}
+}

framework/src/Volo.Abp.AspNetCore/Microsoft/AspNetCore/RequestLocalization/AbpRequestLocalizationOptionsFactory.cs

@@ -1,28 +0,0 @@
-using System.Collections.Generic;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.Extensions.Options;
-using Volo.Abp.Options;
-
-namespace Microsoft.AspNetCore.RequestLocalization
-{
-    public class AbpRequestLocalizationOptionsFactory : AbpOptionsFactory<RequestLocalizationOptions>
-    {
-        private readonly IAbpRequestLocalizationOptionsProvider _abpRequestLocalizationOptionsProvider;
-
-        public AbpRequestLocalizationOptionsFactory(
-            IAbpRequestLocalizationOptionsProvider abpRequestLocalizationOptionsProvider,
-            IEnumerable<IConfigureOptions<RequestLocalizationOptions>> setups, 
-            IEnumerable<IPostConfigureOptions<RequestLocalizationOptions>> postConfigures) 
-            : base(
-                setups, 
-                postConfigures)
-        {
-            _abpRequestLocalizationOptionsProvider = abpRequestLocalizationOptionsProvider;
-        }
-
-        public override RequestLocalizationOptions Create(string name)
-        {
-            return _abpRequestLocalizationOptionsProvider.GetLocalizationOptions();
-        }
-    }
-}

framework/src/Volo.Abp.AspNetCore/Microsoft/AspNetCore/RequestLocalization/AbpRequestLocalizationOptionsManager.cs

@@ -0,0 +1,32 @@
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.Options;
+using Volo.Abp.Options;
+
+namespace Microsoft.AspNetCore.RequestLocalization
+{
+    public class AbpRequestLocalizationOptionsManager : AbpDynamicOptionsManager<RequestLocalizationOptions>
+    {
+        private RequestLocalizationOptions _options;
+
+        private readonly IAbpRequestLocalizationOptionsProvider _abpRequestLocalizationOptionsProvider;
+
+        public AbpRequestLocalizationOptionsManager(
+            IOptionsFactory<RequestLocalizationOptions> factory,
+            IAbpRequestLocalizationOptionsProvider abpRequestLocalizationOptionsProvider)
+            : base(factory)
+        {
+            _abpRequestLocalizationOptionsProvider = abpRequestLocalizationOptionsProvider;
+        }
+
+        public override RequestLocalizationOptions Get(string name)
+        {
+            return _options ?? base.Get(name);
+        }
+
+        protected override async Task OverrideOptionsAsync(string name, RequestLocalizationOptions options)
+        {
+            _options = await _abpRequestLocalizationOptionsProvider.GetLocalizationOptionsAsync();
+        }
+    }
+}

framework/src/Volo.Abp.AspNetCore/Microsoft/AspNetCore/RequestLocalization/DefaultAbpRequestLocalizationOptionsProvider.cs

@@ -11,7 +11,6 @@ using Nito.AsyncEx;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Localization;
 using Volo.Abp.Settings;
-using Volo.Abp.Threading;
 
 namespace Microsoft.AspNetCore.RequestLocalization
 {
@@ -33,16 +32,6 @@ namespace Microsoft.AspNetCore.RequestLocalization
             _optionsAction = optionsAction;
         }
 
-        public RequestLocalizationOptions GetLocalizationOptions()
-        {
-            if (_requestLocalizationOptions != null)
-            {
-                return _requestLocalizationOptions;
-            }
-
-            return AsyncHelper.RunSync(GetLocalizationOptionsAsync);
-        }
-
         public async Task<RequestLocalizationOptions> GetLocalizationOptionsAsync()
         {
             if (_requestLocalizationOptions == null)

framework/src/Volo.Abp.AspNetCore/Microsoft/AspNetCore/RequestLocalization/IAbpRequestLocalizationOptionsProvider.cs

@@ -8,8 +8,6 @@ namespace Microsoft.AspNetCore.RequestLocalization
     {
         void InitLocalizationOptions(Action<RequestLocalizationOptions> optionsAction = null);
 
-        RequestLocalizationOptions GetLocalizationOptions();
-
         Task<RequestLocalizationOptions> GetLocalizationOptionsAsync();
     }
-}
+}

framework/src/Volo.Abp.AspNetCore/Volo/Abp/AspNetCore/AbpAspNetCoreModule.cs

@@ -38,7 +38,7 @@ namespace Volo.Abp.AspNetCore
             AddAspNetServices(context.Services);
             context.Services.AddObjectAccessor<IApplicationBuilder>();
 
-            context.Services.Replace(ServiceDescriptor.Transient<IOptionsFactory<RequestLocalizationOptions>, AbpRequestLocalizationOptionsFactory>());
+            context.Services.AddAbpDynamicOptions<RequestLocalizationOptions, AbpRequestLocalizationOptionsManager>();
         }
 
         private static void AddAspNetServices(IServiceCollection services)

framework/src/Volo.Abp.Core/Volo/Abp/Options/AbpDynamicOptionsManager.cs

@@ -16,9 +16,9 @@ namespace Volo.Abp.Options
 
         public virtual Task SetAsync(string name)
         {
-            return OverrideOptionsAsync(base.Get(name));
+            return OverrideOptionsAsync(name, base.Get(name));
         }
 
-        protected abstract Task OverrideOptionsAsync(T options);
+        protected abstract Task OverrideOptionsAsync(string name, T options);
     }
 }

framework/src/Volo.Abp.Core/Volo/Abp/Options/AbpOptionsFactory.cs

@@ -4,21 +4,44 @@ using Microsoft.Extensions.Options;
 namespace Volo.Abp.Options
 {
     //TODO: Derive from OptionsFactory when this is released: https://github.com/aspnet/Options/pull/258 (or completely remove this!)
+    // https://github.com/dotnet/runtime/blob/master/src/libraries/Microsoft.Extensions.Options/src/OptionsFactory.cs
     public class AbpOptionsFactory<TOptions> : IOptionsFactory<TOptions> where TOptions : class, new()
     {
         private readonly IEnumerable<IConfigureOptions<TOptions>> _setups;
         private readonly IEnumerable<IPostConfigureOptions<TOptions>> _postConfigures;
+        private readonly IEnumerable<IValidateOptions<TOptions>> _validations;
 
-        public AbpOptionsFactory(IEnumerable<IConfigureOptions<TOptions>> setups, IEnumerable<IPostConfigureOptions<TOptions>> postConfigures)
+        public AbpOptionsFactory(
+            IEnumerable<IConfigureOptions<TOptions>> setups,
+            IEnumerable<IPostConfigureOptions<TOptions>> postConfigures)
+            : this(setups, postConfigures, validations: null)
+        {
+
+        }
+
+        public AbpOptionsFactory(
+            IEnumerable<IConfigureOptions<TOptions>> setups,
+            IEnumerable<IPostConfigureOptions<TOptions>> postConfigures,
+            IEnumerable<IValidateOptions<TOptions>> validations)
         {
             _setups = setups;
             _postConfigures = postConfigures;
+            _validations = validations;
         }
 
         public virtual TOptions Create(string name)
         {
             var options = new TOptions();
 
+            ConfigureOptions(name, options);
+            PostConfigureOptions(name, options);
+            ValidateOptions(name, options);
+
+            return options;
+        }
+
+        protected virtual void ConfigureOptions(string name, TOptions options)
+        {
             foreach (var setup in _setups)
             {
                 if (setup is IConfigureNamedOptions<TOptions> namedSetup)
@@ -30,13 +53,34 @@ namespace Volo.Abp.Options
                     setup.Configure(options);
                 }
             }
+        }
 
+        protected virtual void PostConfigureOptions(string name, TOptions options)
+        {
             foreach (var post in _postConfigures)
             {
                 post.PostConfigure(name, options);
             }
+        }
 
-            return options;
+        protected virtual void ValidateOptions(string name, TOptions options)
+        {
+            if (_validations != null)
+            {
+                var failures = new List<string>();
+                foreach (var validate in _validations)
+                {
+                    var result = validate.Validate(name, options);
+                    if (result.Failed)
+                    {
+                        failures.AddRange(result.Failures);
+                    }
+                }
+                if (failures.Count > 0)
+                {
+                    throw new OptionsValidationException(name, typeof(TOptions), failures);
+                }
+            }
         }
     }
-}
+}

framework/src/Volo.Abp.Ldap/Volo.Abp.Ldap.csproj

@@ -15,7 +15,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Novell.Directory.Ldap.NETStandard" Version="3.2.0" />
+    <PackageReference Include="LdapForNet" Version="2.7.11" />
   </ItemGroup>
 
   <ItemGroup>

framework/src/Volo.Abp.Ldap/Volo/Abp/Ldap/AbpAbpLdapOptionsFactory.cs → framework/src/Volo.Abp.Ldap/Volo/Abp/Ldap/AbpAbpLdapOptionsManager.cs

@@ -1,36 +1,22 @@
 using System;
-using System.Collections.Generic;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Options;
 using Volo.Abp.Options;
 using Volo.Abp.Settings;
-using Volo.Abp.Threading;
 
 namespace Volo.Abp.Ldap
 {
-    public class AbpAbpLdapOptionsFactory : AbpOptionsFactory<AbpLdapOptions>
+    public class AbpAbpLdapOptionsManager : AbpDynamicOptionsManager<AbpLdapOptions>
     {
         protected ISettingProvider SettingProvider { get; }
 
-        public AbpAbpLdapOptionsFactory(
-            IEnumerable<IConfigureOptions<AbpLdapOptions>> setups,
-            IEnumerable<IPostConfigureOptions<AbpLdapOptions>> postConfigures,
-            ISettingProvider settingProvider)
-            : base(setups, postConfigures)
+        public AbpAbpLdapOptionsManager(IOptionsFactory<AbpLdapOptions> factory, ISettingProvider settingProvider)
+            : base(factory)
         {
             SettingProvider = settingProvider;
         }
 
-        public override AbpLdapOptions Create(string name)
-        {
-            var options = base.Create(name);
-
-            AsyncHelper.RunSync(() => OverrideOptionsAsync(options));
-
-            return options;
-        }
-
-        protected virtual async Task OverrideOptionsAsync(AbpLdapOptions options)
+        protected override async Task OverrideOptionsAsync(string name, AbpLdapOptions options)
         {
             options.ServerHost = await GetSettingOrDefaultValue(LdapSettingNames.ServerHost, options.ServerHost);
             options.ServerPort = await SettingProvider.GetAsync(LdapSettingNames.ServerPort, options.ServerPort);

framework/src/Volo.Abp.Ldap/Volo/Abp/Ldap/AbpLdapModule.cs

@@ -18,8 +18,7 @@ namespace Volo.Abp.Ldap
     {
         public override void ConfigureServices(ServiceConfigurationContext context)
         {
-            context.Services.Replace(ServiceDescriptor.Transient<IOptionsFactory<AbpLdapOptions>, AbpAbpLdapOptionsFactory>());
-            context.Services.Replace(ServiceDescriptor.Scoped<IOptions<AbpLdapOptions>, OptionsManager<AbpLdapOptions>>());
+            context.Services.AddAbpDynamicOptions<AbpLdapOptions, AbpAbpLdapOptionsManager>();
 
             var configuration = context.Services.GetConfiguration();
             var ldapConfiguration = configuration["Ldap"];

framework/src/Volo.Abp.Ldap/Volo/Abp/Ldap/ILdapManager.cs

@@ -1,7 +1,9 @@
-namespace Volo.Abp.Ldap
+using System.Threading.Tasks;
+
+namespace Volo.Abp.Ldap
 {
     public interface ILdapManager
     {
-        bool Authenticate(string username, string password);
+        Task<bool> AuthenticateAsync(string username, string password);
     }
 }

framework/src/Volo.Abp.Ldap/Volo/Abp/Ldap/LdapManager.cs

@@ -1,6 +1,8 @@
 using System;
+using System.Threading.Tasks;
+using LdapForNet;
+using LdapForNet.Native;
 using Microsoft.Extensions.Options;
-using Novell.Directory.Ldap;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using Volo.Abp.DependencyInjection;
@@ -15,17 +17,16 @@ namespace Volo.Abp.Ldap
         public LdapManager(IOptions<AbpLdapOptions> ldapSettingsOptions)
         {
             LdapOptions = ldapSettingsOptions.Value;
-
             Logger = NullLogger<LdapManager>.Instance;
         }
 
-        public bool Authenticate(string username, string password)
+        public virtual async Task<bool> AuthenticateAsync(string username, string password)
         {
             try
             {
-                using (var conn = CreateLdapConnection())
+                using (var conn = await CreateLdapConnectionAsync())
                 {
-                    AuthenticateLdapConnection(conn, username, password);
+                    await AuthenticateLdapConnectionAsync(conn, username, password);
                     return true;
                 }
             }
@@ -36,22 +37,33 @@ namespace Volo.Abp.Ldap
             }
         }
 
-        protected virtual ILdapConnection CreateLdapConnection()
+        protected virtual async Task<ILdapConnection> CreateLdapConnectionAsync()
         {
             var ldapConnection = new LdapConnection();
-            ConfigureLdapConnection(ldapConnection);
-            ldapConnection.Connect(LdapOptions.ServerHost, LdapOptions.ServerPort);
+            await ConfigureLdapConnectionAsync(ldapConnection);
+            await ConnectAsync(ldapConnection);
             return ldapConnection;
         }
 
-        protected virtual void ConfigureLdapConnection(ILdapConnection connection)
+        protected virtual Task ConfigureLdapConnectionAsync(ILdapConnection ldapConnection)
         {
+            return Task.CompletedTask;
+        }
 
+        protected virtual Task ConnectAsync(ILdapConnection ldapConnection)
+        {
+            ldapConnection.Connect(LdapOptions.ServerHost, LdapOptions.ServerPort);
+
+            return Task.CompletedTask;
         }
 
-        protected virtual void AuthenticateLdapConnection(ILdapConnection connection, string username, string password)
+        protected virtual async Task AuthenticateLdapConnectionAsync(ILdapConnection connection, string username, string password)
         {
-            connection.Bind(username, password);
+            await connection.BindAsync(Native.LdapAuthType.Simple, new LdapCredential()
+            {
+                UserName = username,
+                Password = password
+            });
         }
     }
 }

framework/test/Volo.Abp.Ldap.Tests/Volo/Abp/Ldap/LdapManager_Tests.cs

@@ -1,4 +1,5 @@
-using Shouldly;
+using System.Threading.Tasks;
+using Shouldly;
 using Volo.Abp.Testing;
 using Xunit;
 
@@ -19,10 +20,11 @@ namespace Volo.Abp.Ldap
         }
 
         [Fact(Skip = "Required Ldap environment")]
-        public void Authenticate()
+        public async Task AuthenticateAsync()
         {
-            _ldapManager.Authenticate("cn=abp,dc=abp,dc=io", "123qwe").ShouldBe(true);
-            _ldapManager.Authenticate("NoExists", "123qwe").ShouldBe(false);
+            (await _ldapManager.AuthenticateAsync("cn=abp,dc=abp,dc=io", "123qwe")).ShouldBe(true);
+            (await _ldapManager.AuthenticateAsync("cn=abp,dc=abp,dc=io", "123123")).ShouldBe(false);
+            (await _ldapManager.AuthenticateAsync("NoExists", "123qwe")).ShouldBe(false);
         }
     }
 }

framework/test/Volo.Abp.Ldap.Tests/Volo/Abp/Ldap/LdapOptions_Tests.cs

@@ -15,7 +15,7 @@ namespace Volo.Abp.Ldap
         [Fact]
         public void Should_Resolve_AbpAbpLdapOptionsFactory()
         {
-            GetRequiredService<IOptionsFactory<AbpLdapOptions>>().ShouldBeOfType(typeof(AbpAbpLdapOptionsFactory));
+            GetRequiredService<IOptions<AbpLdapOptions>>().ShouldBeOfType(typeof(AbpAbpLdapOptionsManager));
         }
     }
 }

modules/blogging/app/Volo.BloggingTestApp/BloggingTestAppModule.cs

@@ -166,7 +166,7 @@ namespace Volo.BloggingTestApp
 
             app.UseAuthentication();
 
-            app.UseRequestLocalization(app.ApplicationServices.GetRequiredService<IOptions<RequestLocalizationOptions>>().Value);
+            app.UseAbpRequestLocalization();
 
             app.UseConfiguredEndpoints();
 

modules/identity/src/Volo.Abp.Identity.Domain/Volo/Abp/Identity/AbpIdentityOptionsManager.cs

@@ -19,7 +19,7 @@ namespace Volo.Abp.Identity
             SettingProvider = settingProvider;
         }
 
-        protected override async Task OverrideOptionsAsync(IdentityOptions options)
+        protected override async Task OverrideOptionsAsync(string name, IdentityOptions options)
         {
             options.Password.RequiredLength = await SettingProvider.GetAsync(IdentitySettingNames.Password.RequiredLength, options.Password.RequiredLength);
             options.Password.RequiredUniqueChars = await SettingProvider.GetAsync(IdentitySettingNames.Password.RequiredUniqueChars, options.Password.RequiredUniqueChars);