Merge pull request #3985 from abpframework/maliming/map-claims

Add AbpClaimsMapMiddleware.

framework/src/Volo.Abp.AspNetCore/Microsoft/AspNetCore/Builder/AbpApplicationBuilderExtensions.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using JetBrains.Annotations;
 using Microsoft.AspNetCore.RequestLocalization;
 using Microsoft.Extensions.DependencyInjection;
@@ -6,6 +6,7 @@ using Microsoft.Extensions.Hosting;
 using Volo.Abp;
 using Volo.Abp.AspNetCore.Auditing;
 using Volo.Abp.AspNetCore.ExceptionHandling;
+using Volo.Abp.AspNetCore.Security.Claims;
 using Volo.Abp.AspNetCore.Tracing;
 using Volo.Abp.AspNetCore.Uow;
 using Volo.Abp.DependencyInjection;
@@ -76,5 +77,10 @@ namespace Microsoft.AspNetCore.Builder
             app.Properties[ExceptionHandlingMiddlewareMarker] = true;
             return app.UseMiddleware<AbpExceptionHandlingMiddleware>();
         }
+
+        public static IApplicationBuilder UseAbpClaimsMap(this IApplicationBuilder app)
+        {
+            return app.UseMiddleware<AbpClaimsMapMiddleware>();
+        }
     }
-}
+}

framework/src/Volo.Abp.AspNetCore/Volo/Abp/AspNetCore/Security/Claims/AbpClaimsMapMiddleware.cs

@@ -0,0 +1,29 @@
+using System.Linq;
+using System.Security.Claims;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Security.Claims;
+
+namespace Volo.Abp.AspNetCore.Security.Claims
+{
+    public class AbpClaimsMapMiddleware : IMiddleware, ITransientDependency
+    {
+        public async Task InvokeAsync(HttpContext context, RequestDelegate next)
+        {
+            var currentPrincipalAccessor = context.RequestServices.GetRequiredService<ICurrentPrincipalAccessor>();
+            var mapOptions = context.RequestServices.GetRequiredService<IOptions<AbpClaimsMapOptions>>().Value;
+
+            var mapClaims = currentPrincipalAccessor.Principal.Claims.Where(p => mapOptions.Maps.Keys.Contains(p.Type));
+            currentPrincipalAccessor.Principal.AddIdentity(new ClaimsIdentity(mapClaims.Select(p => new Claim(
+                mapOptions.Maps[p.Type],
+                p.Value,
+                p.ValueType,
+                p.Issuer))));
+
+            await next(context);
+        }
+    }
+}

framework/src/Volo.Abp.AspNetCore/Volo/Abp/AspNetCore/Security/Claims/AbpClaimsMapOptions.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using Volo.Abp.Security.Claims;
+
+namespace Volo.Abp.AspNetCore.Security.Claims
+{
+    public class AbpClaimsMapOptions
+    {
+        public Dictionary<string, string> Maps { get; }
+
+        public AbpClaimsMapOptions()
+        {
+            Maps = new Dictionary<string, string>()
+            {
+                { "sub", AbpClaimTypes.UserId },
+                { "role", AbpClaimTypes.Role },
+                { "email", AbpClaimTypes.Email },
+            };
+        }
+    }
+}

framework/test/Volo.Abp.AspNetCore.Mvc.Tests/Volo/Abp/AspNetCore/Mvc/AbpAspNetCoreMvcTestModule.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Security.Claims;
 using Localization.Resources.AbpUi;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Mvc.ApplicationModels;
@@ -8,11 +10,13 @@ using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp.AspNetCore.Mvc.Authorization;
 using Volo.Abp.AspNetCore.Mvc.Localization;
 using Volo.Abp.AspNetCore.Mvc.Localization.Resource;
+using Volo.Abp.AspNetCore.Security.Claims;
 using Volo.Abp.AspNetCore.TestBase;
 using Volo.Abp.Autofac;
 using Volo.Abp.Localization;
 using Volo.Abp.MemoryDb;
 using Volo.Abp.Modularity;
+using Volo.Abp.Security.Claims;
 using Volo.Abp.TestApp;
 using Volo.Abp.Validation.Localization;
 using Volo.Abp.VirtualFileSystem;
@@ -76,11 +80,17 @@ namespace Volo.Abp.AspNetCore.Mvc
                 options.Languages.Add(new LanguageInfo("en", "en", "English"));
                 options.Languages.Add(new LanguageInfo("tr", "tr", "Türkçe"));
             });
-            
+
             Configure<RazorPagesOptions>(options =>
             {
                 options.RootDirectory = "/Volo/Abp/AspNetCore/Mvc";
             });
+
+            Configure<AbpClaimsMapOptions>(options =>
+            {
+                options.Maps.Add("SerialNumber", ClaimTypes.SerialNumber);
+                options.Maps.Add("DateOfBirth", ClaimTypes.DateOfBirth);
+            });
         }
 
         public override void OnApplicationInitialization(ApplicationInitializationContext context)
@@ -92,6 +102,7 @@ namespace Volo.Abp.AspNetCore.Mvc
             app.UseAbpRequestLocalization();
             app.UseRouting();
             app.UseMiddleware<FakeAuthenticationMiddleware>();
+            app.UseAbpClaimsMap();
             app.UseAuthorization();
             app.UseAuditing();
             app.UseUnitOfWork();

framework/test/Volo.Abp.AspNetCore.Mvc.Tests/Volo/Abp/AspNetCore/Mvc/Security/Claims/ClaimsMapTestController.cs

@@ -0,0 +1,22 @@
+using System.Security.Claims;
+using Microsoft.AspNetCore.Mvc;
+using Shouldly;
+
+namespace Volo.Abp.AspNetCore.Mvc.Security.Claims
+{
+    public class ClaimsMapTestController : AbpController
+    {
+        public ActionResult ClaimsMapTest()
+        {
+            var serialNumber = CurrentUser.FindClaim(ClaimTypes.SerialNumber);
+            serialNumber.ShouldNotBeNull();
+            serialNumber.Value.ShouldBe("123456");
+
+            var dateOfBirth = CurrentUser.FindClaim(ClaimTypes.DateOfBirth);
+            dateOfBirth.ShouldNotBeNull();
+            dateOfBirth.Value.ShouldBe("2020");
+
+            return Content("OK");
+        }
+    }
+}

framework/test/Volo.Abp.AspNetCore.Mvc.Tests/Volo/Abp/AspNetCore/Mvc/Security/Claims/ClaimsMapTestController_Tests.cs

@@ -0,0 +1,41 @@
+using System.Security.Claims;
+using System.Threading.Tasks;
+using Shouldly;
+using Volo.Abp.AspNetCore.Mvc.Authorization;
+using Volo.Abp.AspNetCore.TestBase;
+using Volo.Abp.Autofac;
+using Volo.Abp.MemoryDb;
+using Volo.Abp.Modularity;
+using Xunit;
+
+namespace Volo.Abp.AspNetCore.Mvc.Security.Claims
+{
+    [DependsOn(
+        typeof(AbpAspNetCoreTestBaseModule),
+        typeof(AbpMemoryDbTestModule),
+        typeof(AbpAspNetCoreMvcModule),
+        typeof(AbpAutofacModule)
+    )]
+    public class ClaimsMapTestController_Tests : AspNetCoreMvcTestBase
+    {
+        private readonly FakeUserClaims _fakeRequiredService;
+
+        public ClaimsMapTestController_Tests()
+        {
+            _fakeRequiredService = GetRequiredService<FakeUserClaims>();
+        }
+
+        [Fact]
+        public async Task Claims_Should_Be_Mapped()
+        {
+            _fakeRequiredService.Claims.AddRange(new[]
+            {
+                new Claim("SerialNumber", "123456"),
+                new Claim("DateOfBirth", "2020")
+            });
+
+            var result = await GetResponseAsStringAsync("/ClaimsMapTest/ClaimsMapTest");
+            result.ShouldBe("OK");
+        }
+    }
+}

samples/MicroserviceDemo/gateways/BackendAdminAppGateway.Host/BackendAdminAppGatewayHostModule.cs

@@ -110,21 +110,8 @@ namespace BackendAdminAppGateway.Host
             app.UseVirtualFiles();
             app.UseRouting();
             app.UseAuthentication();
+            app.UseAbpClaimsMap();
 
-            app.Use(async (ctx, next) =>
-            {
-                var currentPrincipalAccessor = ctx.RequestServices.GetRequiredService<ICurrentPrincipalAccessor>();
-                var map = new Dictionary<string, string>()
-                {
-                    { "sub", AbpClaimTypes.UserId },
-                    { "role", AbpClaimTypes.Role },
-                    { "email", AbpClaimTypes.Email },
-                    //any other map
-                };
-                var mapClaims = currentPrincipalAccessor.Principal.Claims.Where(p => map.Keys.Contains(p.Type)).ToList();
-                currentPrincipalAccessor.Principal.AddIdentity(new ClaimsIdentity(mapClaims.Select(p => new Claim(map[p.Type], p.Value, p.ValueType, p.Issuer))));
-                await next();
-            });
             if (MsDemoConsts.IsMultiTenancyEnabled)
             {
                 app.UseMultiTenancy();

samples/MicroserviceDemo/gateways/InternalGateway.Host/InternalGatewayHostModule.cs

@@ -89,21 +89,7 @@ namespace InternalGateway.Host
             app.UseVirtualFiles();
             app.UseRouting();
             app.UseAuthentication();
-
-            app.Use(async (ctx, next) =>
-            {
-                var currentPrincipalAccessor = ctx.RequestServices.GetRequiredService<ICurrentPrincipalAccessor>();
-                var map = new Dictionary<string, string>()
-                {
-                    { "sub", AbpClaimTypes.UserId },
-                    { "role", AbpClaimTypes.Role },
-                    { "email", AbpClaimTypes.Email },
-                    //any other map
-                };
-                var mapClaims = currentPrincipalAccessor.Principal.Claims.Where(p => map.Keys.Contains(p.Type)).ToList();
-                currentPrincipalAccessor.Principal.AddIdentity(new ClaimsIdentity(mapClaims.Select(p => new Claim(map[p.Type], p.Value, p.ValueType, p.Issuer))));
-                await next();
-            });
+            app.UseAbpClaimsMap();
             if (MsDemoConsts.IsMultiTenancyEnabled)
             {
                 app.UseMultiTenancy();

samples/MicroserviceDemo/gateways/PublicWebSiteGateway.Host/PublicWebSiteGatewayHostModule.cs

@@ -85,21 +85,7 @@ namespace PublicWebSiteGateway.Host
             app.UseVirtualFiles();
             app.UseRouting();
             app.UseAuthentication();
-
-            app.Use(async (ctx, next) =>
-            {
-                var currentPrincipalAccessor = ctx.RequestServices.GetRequiredService<ICurrentPrincipalAccessor>();
-                var map = new Dictionary<string, string>()
-                {
-                    { "sub", AbpClaimTypes.UserId },
-                    { "role", AbpClaimTypes.Role },
-                    { "email", AbpClaimTypes.Email },
-                    //any other map
-                };
-                var mapClaims = currentPrincipalAccessor.Principal.Claims.Where(p => map.Keys.Contains(p.Type)).ToList();
-                currentPrincipalAccessor.Principal.AddIdentity(new ClaimsIdentity(mapClaims.Select(p => new Claim(map[p.Type], p.Value, p.ValueType, p.Issuer))));
-                await next();
-            });
+            app.UseAbpClaimsMap();
             if (MsDemoConsts.IsMultiTenancyEnabled)
             {
                 app.UseMultiTenancy();

samples/MicroserviceDemo/microservices/BloggingService.Host/BloggingServiceHostModule.cs

@@ -121,21 +121,7 @@ namespace BloggingService.Host
             app.UseVirtualFiles();
             app.UseRouting();
             app.UseAuthentication();
-
-            app.Use(async (ctx, next) =>
-            {
-                var currentPrincipalAccessor = ctx.RequestServices.GetRequiredService<ICurrentPrincipalAccessor>();
-                var map = new Dictionary<string, string>()
-                {
-                    { "sub", AbpClaimTypes.UserId },
-                    { "role", AbpClaimTypes.Role },
-                    { "email", AbpClaimTypes.Email },
-                    //any other map
-                };
-                var mapClaims = currentPrincipalAccessor.Principal.Claims.Where(p => map.Keys.Contains(p.Type)).ToList();
-                currentPrincipalAccessor.Principal.AddIdentity(new ClaimsIdentity(mapClaims.Select(p => new Claim(map[p.Type], p.Value, p.ValueType, p.Issuer))));
-                await next();
-            });
+            app.UseAbpClaimsMap();
             
             if (MsDemoConsts.IsMultiTenancyEnabled)
             {

samples/MicroserviceDemo/microservices/IdentityService.Host/IdentityServiceHostModule.cs

@@ -102,26 +102,13 @@ namespace IdentityService.Host
             app.UseVirtualFiles();
             app.UseRouting();
             app.UseAuthentication();
+            app.UseAbpClaimsMap();
 
             if (MsDemoConsts.IsMultiTenancyEnabled)
             {
                 app.UseMultiTenancy();
             }
-            
-            app.Use(async (ctx, next) =>
-            {
-                var currentPrincipalAccessor = ctx.RequestServices.GetRequiredService<ICurrentPrincipalAccessor>();
-                var map = new Dictionary<string, string>()
-                {
-                    { "sub", AbpClaimTypes.UserId },
-                    { "role", AbpClaimTypes.Role },
-                    { "email", AbpClaimTypes.Email },
-                    //any other map
-                };
-                var mapClaims = currentPrincipalAccessor.Principal.Claims.Where(p => map.Keys.Contains(p.Type)).ToList();
-                currentPrincipalAccessor.Principal.AddIdentity(new ClaimsIdentity(mapClaims.Select(p => new Claim(map[p.Type], p.Value, p.ValueType, p.Issuer))));
-                await next();
-            });
+
             app.UseAbpRequestLocalization(); //TODO: localization?
             app.UseSwagger();
             app.UseSwaggerUI(options =>

samples/MicroserviceDemo/microservices/ProductService.Host/ProductServiceHostModule.cs

@@ -105,21 +105,7 @@ namespace ProductService.Host
             app.UseVirtualFiles();
             app.UseRouting();
             app.UseAuthentication();
-
-            app.Use(async (ctx, next) =>
-            {
-                var currentPrincipalAccessor = ctx.RequestServices.GetRequiredService<ICurrentPrincipalAccessor>();
-                var map = new Dictionary<string, string>()
-                {
-                    { "sub", AbpClaimTypes.UserId },
-                    { "role", AbpClaimTypes.Role },
-                    { "email", AbpClaimTypes.Email },
-                    //any other map
-                };
-                var mapClaims = currentPrincipalAccessor.Principal.Claims.Where(p => map.Keys.Contains(p.Type)).ToList();
-                currentPrincipalAccessor.Principal.AddIdentity(new ClaimsIdentity(mapClaims.Select(p => new Claim(map[p.Type], p.Value, p.ValueType, p.Issuer))));
-                await next();
-            });
+            app.UseAbpClaimsMap();
             
             if (MsDemoConsts.IsMultiTenancyEnabled)
             {

samples/MicroserviceDemo/microservices/TenantManagementService.Host/TenantManagementServiceHostModule.cs

@@ -106,21 +106,7 @@ namespace TenantManagementService.Host
             app.UseVirtualFiles();
             app.UseRouting();
             app.UseAuthentication();
-
-            app.Use(async (ctx, next) =>
-            {
-                var currentPrincipalAccessor = ctx.RequestServices.GetRequiredService<ICurrentPrincipalAccessor>();
-                var map = new Dictionary<string, string>()
-                {
-                    { "sub", AbpClaimTypes.UserId },
-                    { "role", AbpClaimTypes.Role },
-                    { "email", AbpClaimTypes.Email },
-                    //any other map
-                };
-                var mapClaims = currentPrincipalAccessor.Principal.Claims.Where(p => map.Keys.Contains(p.Type)).ToList();
-                currentPrincipalAccessor.Principal.AddIdentity(new ClaimsIdentity(mapClaims.Select(p => new Claim(map[p.Type], p.Value, p.ValueType, p.Issuer))));
-                await next();
-            });
+            app.UseAbpClaimsMap();
             
             if (MsDemoConsts.IsMultiTenancyEnabled)
             {

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.HttpApi.Host/MyProjectNameHttpApiHostModule.cs

@@ -168,25 +168,11 @@ namespace MyCompanyName.MyProjectName
             app.UseRouting();
             app.UseCors(DefaultCorsPolicyName);        
             app.UseAuthentication();
-
+            app.UseAbpClaimsMap();
             if (MultiTenancyConsts.IsEnabled)
             {
                 app.UseMultiTenancy();
             }
-            app.Use(async (ctx, next) =>
-            {
-                var currentPrincipalAccessor = ctx.RequestServices.GetRequiredService<ICurrentPrincipalAccessor>();
-                var map = new Dictionary<string, string>()
-                {
-                    { "sub", AbpClaimTypes.UserId },
-                    { "role", AbpClaimTypes.Role },
-                    { "email", AbpClaimTypes.Email },
-                    //any other map
-                };
-                var mapClaims = currentPrincipalAccessor.Principal.Claims.Where(p => map.Keys.Contains(p.Type)).ToList();
-                currentPrincipalAccessor.Principal.AddIdentity(new ClaimsIdentity(mapClaims.Select(p => new Claim(map[p.Type], p.Value, p.ValueType, p.Issuer))));
-                await next();
-            });
             app.UseAbpRequestLocalization();
             app.UseAuthorization();
             app.UseSwagger();