Create interceptor for global features

Resolve #8188

framework/src/Volo.Abp.AspNetCore.Mvc/Volo/Abp/AspNetCore/Mvc/GlobalFeatures/GlobalFeatureActionFilter.cs

@@ -1,13 +1,13 @@
-using System;
+using System;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Abstractions;
 using Microsoft.AspNetCore.Mvc.Filters;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
+using Volo.Abp.Aspects;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.GlobalFeatures;
-using Volo.Abp.Reflection;
 
 namespace Volo.Abp.AspNetCore.Mvc.GlobalFeatures
 {
@@ -21,7 +21,7 @@ namespace Volo.Abp.AspNetCore.Mvc.GlobalFeatures
                 return;
             }
 
-            if (!IsGlobalFeatureEnabled(context.Controller.GetType(), out var attribute))
+            if (!GlobalFeatureHelper.IsGlobalFeatureEnabled(context.Controller.GetType(), out var attribute))
             {
                 var logger = context.GetService<ILogger<GlobalFeatureActionFilter>>(NullLogger<GlobalFeatureActionFilter>.Instance);
                 logger.LogWarning($"The '{context.Controller.GetType().FullName}' controller needs to enable '{attribute.Name}' feature.");
@@ -29,13 +29,10 @@ namespace Volo.Abp.AspNetCore.Mvc.GlobalFeatures
                 return;
             }
 
-            await next();
+            using (AbpCrossCuttingConcerns.Applying(context.Controller, AbpCrossCuttingConcerns.GlobalFeatureChecking))
-        }
+            {
-
+                await next();
-        protected virtual bool IsGlobalFeatureEnabled(Type controllerType, out RequiresGlobalFeatureAttribute attribute)
+            }
-        {
-            attribute = ReflectionHelper.GetSingleAttributeOrDefault<RequiresGlobalFeatureAttribute>(controllerType);
-            return attribute == null || GlobalFeatureManager.Instance.IsEnabled(attribute.GetFeatureName());
         }
     }
 }

framework/src/Volo.Abp.AspNetCore.Mvc/Volo/Abp/AspNetCore/Mvc/GlobalFeatures/GlobalFeaturePageFilter.cs

@@ -1,13 +1,13 @@
-using System;
+using System;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Abstractions;
 using Microsoft.AspNetCore.Mvc.Filters;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
+using Volo.Abp.Aspects;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.GlobalFeatures;
-using Volo.Abp.Reflection;
 
 namespace Volo.Abp.AspNetCore.Mvc.GlobalFeatures
 {
@@ -26,7 +26,7 @@ namespace Volo.Abp.AspNetCore.Mvc.GlobalFeatures
                 return;
             }
 
-            if (!IsGlobalFeatureEnabled(context.HandlerInstance.GetType(), out var attribute))
+            if (!GlobalFeatureHelper.IsGlobalFeatureEnabled(context.HandlerInstance.GetType(), out var attribute))
             {
                 var logger = context.GetService<ILogger<GlobalFeatureActionFilter>>(NullLogger<GlobalFeatureActionFilter>.Instance);
                 logger.LogWarning($"The '{context.HandlerInstance.GetType().FullName}' page needs to enable '{attribute.Name}' feature.");
@@ -34,13 +34,10 @@ namespace Volo.Abp.AspNetCore.Mvc.GlobalFeatures
                 return;
             }
 
-            await next();
+            using (AbpCrossCuttingConcerns.Applying(context.HandlerInstance, AbpCrossCuttingConcerns.GlobalFeatureChecking))
-        }
+            {
-
+                await next();
-        protected virtual bool IsGlobalFeatureEnabled(Type controllerType, out RequiresGlobalFeatureAttribute attribute)
+            }
-        {
-            attribute = ReflectionHelper.GetSingleAttributeOrDefault<RequiresGlobalFeatureAttribute>(controllerType);
-            return attribute == null || GlobalFeatureManager.Instance.IsEnabled(attribute.GetFeatureName());
         }
     }
 }

framework/src/Volo.Abp.Core/Volo/Abp/Aspects/AbpCrossCuttingConcerns.cs

@@ -11,6 +11,7 @@ namespace Volo.Abp.Aspects
         public const string Auditing = "AbpAuditing";
         public const string UnitOfWork = "AbpUnitOfWork";
         public const string FeatureChecking = "AbpFeatureChecking";
+        public const string GlobalFeatureChecking = "AbpGlobalFeatureChecking";
 
         public static void AddApplied(object obj, params string[] concerns)
         {

framework/src/Volo.Abp.Ddd.Application/Volo.Abp.Ddd.Application.csproj

@@ -19,6 +19,7 @@
     <ProjectReference Include="..\Volo.Abp.Ddd.Application.Contracts\Volo.Abp.Ddd.Application.Contracts.csproj" />
     <ProjectReference Include="..\Volo.Abp.Ddd.Domain\Volo.Abp.Ddd.Domain.csproj" />
     <ProjectReference Include="..\Volo.Abp.Features\Volo.Abp.Features.csproj" />
+    <ProjectReference Include="..\Volo.Abp.GlobalFeatures\Volo.Abp.GlobalFeatures.csproj" />
     <ProjectReference Include="..\Volo.Abp.Http.Abstractions\Volo.Abp.Http.Abstractions.csproj" />
     <ProjectReference Include="..\Volo.Abp.Localization\Volo.Abp.Localization.csproj" />
     <ProjectReference Include="..\Volo.Abp.ObjectMapping\Volo.Abp.ObjectMapping.csproj" />

framework/src/Volo.Abp.Ddd.Application/Volo/Abp/Application/AbpDddApplicationModule.cs

@@ -3,6 +3,7 @@ using Volo.Abp.Application.Services;
 using Volo.Abp.Authorization;
 using Volo.Abp.Domain;
 using Volo.Abp.Features;
+using Volo.Abp.GlobalFeatures;
 using Volo.Abp.Http;
 using Volo.Abp.Http.Modeling;
 using Volo.Abp.Modularity;
@@ -23,7 +24,8 @@ namespace Volo.Abp.Application
         typeof(AbpAuthorizationModule),
         typeof(AbpHttpAbstractionsModule),
         typeof(AbpSettingsModule),
-        typeof(AbpFeaturesModule)
+        typeof(AbpFeaturesModule),
+        typeof(AbpGlobalFeaturesModule)
         )]
     public class AbpDddApplicationModule : AbpModule
     {

framework/src/Volo.Abp.Ddd.Application/Volo/Abp/Application/Services/ApplicationService.cs

@@ -12,6 +12,7 @@ using Volo.Abp.Auditing;
 using Volo.Abp.Authorization;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Features;
+using Volo.Abp.GlobalFeatures;
 using Volo.Abp.Guids;
 using Volo.Abp.Linq;
 using Volo.Abp.Localization;
@@ -31,6 +32,7 @@ namespace Volo.Abp.Application.Services
         IValidationEnabled,
         IUnitOfWorkEnabled,
         IAuditingEnabled,
+        IGlobalFeatureCheckingEnabled,
         ITransientDependency
     {
         public IAbpLazyServiceProvider LazyServiceProvider { get; set; }

framework/src/Volo.Abp.GlobalFeatures/Volo.Abp.GlobalFeatures.csproj

@@ -14,8 +14,15 @@
         <RootNamespace />
     </PropertyGroup>
 
+    <ItemGroup>
+        <None Remove="Volo\Abp\GlobalFeatures\Localization\*.json" />
+        <EmbeddedResource Include="Volo\Abp\GlobalFeatures\Localization\*.json" />
+    </ItemGroup>
+
     <ItemGroup>
         <ProjectReference Include="..\Volo.Abp.Core\Volo.Abp.Core.csproj" />
+        <ProjectReference Include="..\Volo.Abp.Localization\Volo.Abp.Localization.csproj" />
+        <ProjectReference Include="..\Volo.Abp.VirtualFileSystem\Volo.Abp.VirtualFileSystem.csproj" />
     </ItemGroup>
 
 </Project>

framework/src/Volo.Abp.GlobalFeatures/Volo/Abp/GlobalFeatures/AbpGlobalFeatureErrorCodes.cs

@@ -0,0 +1,7 @@
+namespace Volo.Abp.GlobalFeatures
+{
+    public class AbpGlobalFeatureErrorCodes
+    {
+        public const string GlobalFeatureIsNotEnabled = "Volo.GlobalFeature:010001";
+    }
+}

framework/src/Volo.Abp.GlobalFeatures/Volo/Abp/GlobalFeatures/AbpGlobalFeatureNotEnableException.cs

@@ -0,0 +1,22 @@
+using System;
+using Volo.Abp.ExceptionHandling;
+
+namespace Volo.Abp.GlobalFeatures
+{
+    public class AbpGlobalFeatureNotEnableException : AbpException, IHasErrorCode
+    {
+        public string Code { get; }
+
+        public AbpGlobalFeatureNotEnableException(string message = null, string code = null, Exception innerException = null)
+            : base(message, innerException)
+        {
+            Code = code;
+        }
+
+        public AbpGlobalFeatureNotEnableException WithData(string name, object value)
+        {
+            Data[name] = value;
+            return this;
+        }
+    }
+}

framework/src/Volo.Abp.GlobalFeatures/Volo/Abp/GlobalFeatures/AbpGlobalFeaturesModule.cs

@@ -1,9 +1,42 @@
-using Volo.Abp.Modularity;
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp.GlobalFeatures.Localization;
+using Volo.Abp.Localization;
+using Volo.Abp.Localization.ExceptionHandling;
+using Volo.Abp.Modularity;
+using Volo.Abp.VirtualFileSystem;
 
 namespace Volo.Abp.GlobalFeatures
 {
+    [DependsOn(
+        typeof(AbpLocalizationModule),
+        typeof(AbpVirtualFileSystemModule)
+    )]
     public class AbpGlobalFeaturesModule : AbpModule
     {
+        public override void PreConfigureServices(ServiceConfigurationContext context)
+        {
+            context.Services.OnRegistred(GlobalFeatureInterceptorRegistrar.RegisterIfNeeded);
+        }
 
+        public override void ConfigureServices(ServiceConfigurationContext context)
+        {
+
+            Configure<AbpVirtualFileSystemOptions>(options =>
+            {
+                options.FileSets.AddEmbedded<AbpGlobalFeatureResource>();
+            });
+
+            Configure<AbpLocalizationOptions>(options =>
+            {
+                options.Resources
+                    .Add<AbpGlobalFeatureResource>("en")
+                    .AddVirtualJson("/Volo/Abp/GlobalFeatures/Localization");
+            });
+
+            Configure<AbpExceptionLocalizationOptions>(options =>
+            {
+                options.MapCodeNamespace("Volo.GlobalFeature", typeof(AbpGlobalFeatureResource));
+            });
+        }
     }
 }

framework/src/Volo.Abp.GlobalFeatures/Volo/Abp/GlobalFeatures/GlobalFeatureHelper.cs

@@ -0,0 +1,14 @@
+using System;
+using Volo.Abp.Reflection;
+
+namespace Volo.Abp.GlobalFeatures
+{
+    public static class GlobalFeatureHelper
+    {
+        public static bool IsGlobalFeatureEnabled(Type controllerType, out RequiresGlobalFeatureAttribute attribute)
+        {
+            attribute = ReflectionHelper.GetSingleAttributeOrDefault<RequiresGlobalFeatureAttribute>(controllerType);
+            return attribute == null || GlobalFeatureManager.Instance.IsEnabled(attribute.GetFeatureName());
+        }
+    }
+}

framework/src/Volo.Abp.GlobalFeatures/Volo/Abp/GlobalFeatures/GlobalFeatureInterceptor.cs

@@ -0,0 +1,28 @@
+using System.Threading.Tasks;
+using Volo.Abp.Aspects;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.DynamicProxy;
+
+namespace Volo.Abp.GlobalFeatures
+{
+    public class GlobalFeatureInterceptor : AbpInterceptor, ITransientDependency
+    {
+        public override async Task InterceptAsync(IAbpMethodInvocation invocation)
+        {
+            if (AbpCrossCuttingConcerns.IsApplied(invocation.TargetObject, AbpCrossCuttingConcerns.GlobalFeatureChecking))
+            {
+                await invocation.ProceedAsync();
+                return;
+            }
+
+            if (!GlobalFeatureHelper.IsGlobalFeatureEnabled(invocation.TargetObject.GetType(), out var attribute))
+            {
+                throw new AbpGlobalFeatureNotEnableException(code: AbpGlobalFeatureErrorCodes.GlobalFeatureIsNotEnabled)
+                    .WithData("ServiceName", invocation.TargetObject.GetType().FullName)
+                    .WithData("GlobalFeatureName", attribute.Name);
+            }
+
+            await invocation.ProceedAsync();
+        }
+    }
+}

framework/src/Volo.Abp.GlobalFeatures/Volo/Abp/GlobalFeatures/GlobalFeatureInterceptorRegistrar.cs

@@ -0,0 +1,22 @@
+using System;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.DynamicProxy;
+
+namespace Volo.Abp.GlobalFeatures
+{
+    public static class GlobalFeatureInterceptorRegistrar
+    {
+        public static void RegisterIfNeeded(IOnServiceRegistredContext context)
+        {
+            if (ShouldIntercept(context.ImplementationType))
+            {
+                context.Interceptors.TryAdd<GlobalFeatureInterceptor>();
+            }
+        }
+
+        private static bool ShouldIntercept(Type type)
+        {
+            return !DynamicProxyIgnoreTypes.Contains(type) && typeof(IGlobalFeatureCheckingEnabled).IsAssignableFrom(type);
+        }
+    }
+}

framework/src/Volo.Abp.GlobalFeatures/Volo/Abp/GlobalFeatures/IGlobalFeatureCheckingEnabled.cs

@@ -0,0 +1,7 @@
+namespace Volo.Abp.GlobalFeatures
+{
+    public interface IGlobalFeatureCheckingEnabled
+    {
+
+    }
+}

framework/src/Volo.Abp.GlobalFeatures/Volo/Abp/GlobalFeatures/Localization/AbpGlobalFeatureResource.cs

@@ -0,0 +1,10 @@
+using Volo.Abp.Localization;
+
+namespace Volo.Abp.GlobalFeatures.Localization
+{
+    [LocalizationResourceName("AbpGlobalFeature")]
+    public class AbpGlobalFeatureResource
+    {
+
+    }
+}

framework/src/Volo.Abp.GlobalFeatures/Volo/Abp/GlobalFeatures/Localization/en.json

@@ -0,0 +1,6 @@
+{
+  "culture": "en",
+  "texts": {
+    "Volo.GlobalFeature:010001": "The '{ServiceName}' service needs to enable '{GlobalFeatureName}' feature."
+  }
+}

framework/src/Volo.Abp.GlobalFeatures/Volo/Abp/GlobalFeatures/Localization/tr.json

@@ -0,0 +1,6 @@
+{
+  "culture": "tr",
+  "texts": {
+    "Volo.GlobalFeature:010001": "'{ServiceName}' hizmetinin '{GlobalFeatureName}' özelliğini etkinleştirmesi gerekiyor."
+  }
+}

framework/src/Volo.Abp.GlobalFeatures/Volo/Abp/GlobalFeatures/Localization/zh-Hans.json

@@ -0,0 +1,6 @@
+{
+  "culture": "zh-Hans",
+  "texts": {
+    "Volo.GlobalFeature:010001": "'{ServiceName}'服务需要启用'{GlobalFeatureName}'功能."
+  }
+}

framework/src/Volo.Abp.GlobalFeatures/Volo/Abp/GlobalFeatures/Localization/zh-Hant.json

@@ -0,0 +1,6 @@
+{
+  "culture": "zh-Hant",
+  "texts": {
+    "Volo.GlobalFeature:010001": "'{ServiceName}'服務需要啟用'{GlobalFeatureName}'功能."
+  }
+}

framework/test/Volo.Abp.GlobalFeatures.Tests/Volo.Abp.GlobalFeatures.Tests.csproj

@@ -8,8 +8,11 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <ProjectReference Include="..\AbpTestBase\AbpTestBase.csproj" />
+        <ProjectReference Include="..\..\src\Volo.Abp.Autofac\Volo.Abp.Autofac.csproj" />
+        <ProjectReference Include="..\..\src\Volo.Abp.Ddd.Application\Volo.Abp.Ddd.Application.csproj" />
         <ProjectReference Include="..\..\src\Volo.Abp.GlobalFeatures\Volo.Abp.GlobalFeatures.csproj" />
+        <ProjectReference Include="..\..\src\Volo.Abp.ExceptionHandling\Volo.Abp.ExceptionHandling.csproj" />
+        <ProjectReference Include="..\AbpTestBase\AbpTestBase.csproj" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(MicrosoftNETTestSdkPackageVersion)" />
     </ItemGroup>
 

framework/test/Volo.Abp.GlobalFeatures.Tests/Volo/Abp/GlobalFeatures/AbpGlobalFeatureNotEnableException_Localization_Test.cs

@@ -0,0 +1,30 @@
+using Shouldly;
+using Volo.Abp.AspNetCore.ExceptionHandling;
+using Volo.Abp.Localization;
+using Xunit;
+
+namespace Volo.Abp.GlobalFeatures
+{
+    public class AbpGlobalFeatureNotEnableException_Localization_Test : GlobalFeatureTestBase
+    {
+        private readonly IExceptionToErrorInfoConverter _exceptionToErrorInfoConverter;
+
+        public AbpGlobalFeatureNotEnableException_Localization_Test()
+        {
+            _exceptionToErrorInfoConverter = GetRequiredService<IExceptionToErrorInfoConverter>();
+        }
+
+        [Fact]
+        public void AbpAuthorizationException_Localization()
+        {
+            using (CultureHelper.Use("zh-Hans"))
+            {
+                var exception = new AbpGlobalFeatureNotEnableException(code: AbpGlobalFeatureErrorCodes.GlobalFeatureIsNotEnabled)
+                    .WithData("ServiceName", "MyService")
+                    .WithData("GlobalFeatureName", "TestFeature");;
+                var errorInfo = _exceptionToErrorInfoConverter.Convert(exception, false);
+                errorInfo.Message.ShouldBe("'MyService'服务需要启用'TestFeature'功能.");
+            }
+        }
+    }
+}

framework/test/Volo.Abp.GlobalFeatures.Tests/Volo/Abp/GlobalFeatures/GlobalFeatureInterceptor_Tests.cs

@@ -0,0 +1,61 @@
+using System.Threading.Tasks;
+using Shouldly;
+using Volo.Abp.Application.Services;
+using Volo.Abp.DependencyInjection;
+using Xunit;
+
+namespace Volo.Abp.GlobalFeatures
+{
+    public class GlobalFeatureInterceptor_Tests : GlobalFeatureTestBase
+    {
+        private readonly TestAppServiceV1 _testAppServiceV1;
+        private readonly TestAppServiceV2 _testAppServiceV2;
+
+        public GlobalFeatureInterceptor_Tests()
+        {
+            _testAppServiceV1 = GetRequiredService<TestAppServiceV1>();
+            _testAppServiceV2 = GetRequiredService<TestAppServiceV2>();
+        }
+
+        [Fact]
+        public async Task Interceptor_Test()
+        {
+            var ex = await Assert.ThrowsAsync<AbpGlobalFeatureNotEnableException>(async () =>
+            {
+                await _testAppServiceV1.TestMethod();
+            });
+
+            ex.Data["ServiceName"].ShouldBe(_testAppServiceV1.GetType().FullName);
+            ex.Data["GlobalFeatureName"].ShouldBe(TestFeature.Name);
+
+            GlobalFeatureManager.Instance.Enable(TestFeature.Name);
+
+            (await _testAppServiceV1.TestMethod()).ShouldBe(1);
+            (await _testAppServiceV2.TestMethod()).ShouldBe(1);
+        }
+
+        public interface ITestAppService : IApplicationService
+        {
+            Task<int> TestMethod();
+        }
+
+        [RequiresGlobalFeature(TestFeature.Name)]
+        [ExposeServices(typeof(TestAppServiceV1))]
+        public class TestAppServiceV1 : ApplicationService, ITestAppService
+        {
+            public virtual Task<int> TestMethod()
+            {
+                return Task.FromResult(1);
+            }
+        }
+
+        [ExposeServices(typeof(TestAppServiceV2))]
+        public class TestAppServiceV2 : ApplicationService, ITestAppService
+        {
+            public virtual Task<int> TestMethod()
+            {
+                return Task.FromResult(1);
+            }
+        }
+    }
+}

framework/test/Volo.Abp.GlobalFeatures.Tests/Volo/Abp/GlobalFeatures/GlobalFeatureManager_Tests.cs

@@ -3,21 +3,21 @@ using Xunit;
 
 namespace Volo.Abp.GlobalFeatures
 {
-    public class GlobalFeatureManager_Tests
+    public class GlobalFeatureManager_Tests : GlobalFeatureTestBase
     {
-        private readonly GlobalFeatureManager _featureManeger;
+        private readonly GlobalFeatureManager _featureManager;
 
         public GlobalFeatureManager_Tests()
         {
-            _featureManeger = new GlobalFeatureManager();
+            _featureManager = new GlobalFeatureManager();
         }
 
         [Fact]
         public void Enable_Feature_By_Name()
         {
-            _featureManeger.IsEnabled("Feature1").ShouldBeFalse();
+            _featureManager.IsEnabled("Feature1").ShouldBeFalse();
-            _featureManeger.Enable("Feature1");
+            _featureManager.Enable("Feature1");
-            _featureManeger.IsEnabled("Feature1").ShouldBeTrue();
+            _featureManager.IsEnabled("Feature1").ShouldBeTrue();
         }
     }
 }

framework/test/Volo.Abp.GlobalFeatures.Tests/Volo/Abp/GlobalFeatures/GlobalFeatureTestBase.cs

@@ -0,0 +1,12 @@
+using Volo.Abp.Testing;
+
+namespace Volo.Abp.GlobalFeatures
+{
+    public abstract class GlobalFeatureTestBase : AbpIntegratedTest<GlobalFeatureTestModule>
+    {
+        protected override void SetAbpApplicationCreationOptions(AbpApplicationCreationOptions options)
+        {
+            options.UseAutofac();
+        }
+    }
+}

framework/test/Volo.Abp.GlobalFeatures.Tests/Volo/Abp/GlobalFeatures/GlobalFeatureTestModule.cs

@@ -0,0 +1,16 @@
+using Volo.Abp.Application;
+using Volo.Abp.Autofac;
+using Volo.Abp.ExceptionHandling;
+using Volo.Abp.Modularity;
+
+namespace Volo.Abp.GlobalFeatures
+{
+    [DependsOn(typeof(AbpAutofacModule))]
+    [DependsOn(typeof(AbpGlobalFeaturesModule))]
+    [DependsOn(typeof(AbpDddApplicationModule))]
+    [DependsOn(typeof(AbpExceptionHandlingModule))]
+    public class GlobalFeatureTestModule : AbpModule
+    {
+
+    }
+}

framework/test/Volo.Abp.GlobalFeatures.Tests/Volo/Abp/GlobalFeatures/TestFeature.cs

@@ -0,0 +1,27 @@
+namespace Volo.Abp.GlobalFeatures
+{
+    [GlobalFeatureName(Name)]
+    public class TestFeature : Abp.GlobalFeatures.GlobalFeature
+    {
+        public const string Name = "TestFeature1";
+
+        internal  TestFeature(TestGlobalModuleFeatures testGlobalModule)
+            : base(testGlobalModule)
+        {
+
+        }
+    }
+
+    public class TestGlobalModuleFeatures : GlobalModuleFeatures
+    {
+        public const string ModuleName = "GlobalFeatureTest";
+
+        public TestFeature Test => GetFeature<TestFeature>();
+
+        public TestGlobalModuleFeatures(GlobalFeatureManager featureManager)
+            : base(featureManager)
+        {
+            AddFeature(new TestFeature(this));
+        }
+    }
+}