Merge pull request #9784 from abpframework/liangshwei/permission

Optimize the performance of PermissionAppService

modules/identity/src/Volo.Abp.PermissionManagement.Domain.Identity/Volo/Abp/PermissionManagement/Identity/RolePermissionManagementProvider.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.Guids;
@@ -26,14 +28,22 @@ namespace Volo.Abp.PermissionManagement.Identity
             UserRoleFinder = userRoleFinder;
         }
 
-        public async override Task<PermissionValueProviderGrantInfo> CheckAsync(string name, string providerName, string providerKey)
+        public override async Task<PermissionValueProviderGrantInfo> CheckAsync(string name, string providerName, string providerKey)
         {
+            var multipleGrantInfo = await CheckAsync(new[] {name}, providerName, providerKey);
+
+            return multipleGrantInfo.Result.Values.First();
+        }
+
+        public override async Task<MultiplePermissionValueProviderGrantInfo> CheckAsync(string[] names, string providerName, string providerKey)
+        {
+            var multiplePermissionValueProviderGrantInfo = new MultiplePermissionValueProviderGrantInfo(names);
+            var permissionGrants = new List<PermissionGrant>();
+
             if (providerName == Name)
             {
-                return new PermissionValueProviderGrantInfo(
-                    await PermissionGrantRepository.FindAsync(name, providerName, providerKey) != null,
-                    providerKey
-                );
+                 permissionGrants.AddRange(await PermissionGrantRepository.GetListAsync(names, providerName, providerKey));
+
             }
 
             if (providerName == UserPermissionValueProvider.ProviderName)
@@ -43,15 +53,26 @@ namespace Volo.Abp.PermissionManagement.Identity
 
                 foreach (var roleName in roleNames)
                 {
-                    var permissionGrant = await PermissionGrantRepository.FindAsync(name, Name, roleName);
-                    if (permissionGrant != null)
-                    {
-                        return new PermissionValueProviderGrantInfo(true, roleName);
-                    }
+                    permissionGrants.AddRange(await PermissionGrantRepository.GetListAsync(names, Name, roleName));
+                }
+            }
+
+            permissionGrants = permissionGrants.Distinct().ToList();
+            if (!permissionGrants.Any())
+            {
+                return multiplePermissionValueProviderGrantInfo;
+            }
+
+            foreach (var permissionName in names)
+            {
+                var permissionGrant = permissionGrants.FirstOrDefault(x => x.Name == permissionName);
+                if (permissionGrant != null)
+                {
+                    multiplePermissionValueProviderGrantInfo.Result[permissionName] = new PermissionValueProviderGrantInfo(true, permissionGrant.ProviderKey);
                 }
             }
 
-            return PermissionValueProviderGrantInfo.NonGranted;
+            return multiplePermissionValueProviderGrantInfo;
         }
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.Application/Volo/Abp/PermissionManagement/PermissionAppService.cs

@@ -6,6 +6,7 @@ using Microsoft.AspNetCore.Authorization;
 using Microsoft.Extensions.Options;
 using Volo.Abp.Application.Services;
 using Volo.Abp.Authorization.Permissions;
+using Volo.Abp.Features;
 using Volo.Abp.MultiTenancy;
 using Volo.Abp.SimpleStateChecking;
 
@@ -52,38 +53,38 @@ namespace Volo.Abp.PermissionManagement
                     Permissions = new List<PermissionGrantInfoDto>()
                 };
 
-                foreach (var permission in group.GetPermissionsWithChildren())
+                var neededCheckPermissions = new List<PermissionDefinition>();
+
+                foreach (var permission in group.GetPermissionsWithChildren()
+                                                .Where(x => x.IsEnabled)
+                                                .Where(x => !x.Providers.Any() || x.Providers.Contains(providerName))
+                                                .Where(x => x.MultiTenancySide.HasFlag(multiTenancySide)))
                 {
-                    if (!permission.IsEnabled)
+                    if (await SimpleStateCheckerManager.IsEnabledAsync(permission))
                     {
-                        continue;
+                        neededCheckPermissions.Add(permission);
                     }
+                }
 
-                    if (!await SimpleStateCheckerManager.IsEnabledAsync(permission))
-                    {
-                        continue;
-                    }
+                if (!neededCheckPermissions.Any())
+                {
+                    return result;
+                }
 
-                    if (permission.Providers.Any() && !permission.Providers.Contains(providerName))
-                    {
-                        continue;
-                    }
+                var grantInfoDtos = neededCheckPermissions.Select(x => new PermissionGrantInfoDto
+                {
+                    Name = x.Name,
+                    DisplayName = x.DisplayName.Localize(StringLocalizerFactory),
+                    ParentName = x.Parent?.Name,
+                    AllowedProviders = x.Providers,
+                    GrantedProviders = new List<ProviderInfoDto>()
+                }).ToList();
 
-                    if (!permission.MultiTenancySide.HasFlag(multiTenancySide))
-                    {
-                        continue;
-                    }
+                var multipleGrantInfo = await PermissionManager.GetAsync(neededCheckPermissions.Select(x=>x.Name).ToArray(), providerName, providerKey);
 
-                    var grantInfoDto = new PermissionGrantInfoDto
-                    {
-                        Name = permission.Name,
-                        DisplayName = permission.DisplayName.Localize(StringLocalizerFactory),
-                        ParentName = permission.Parent?.Name,
-                        AllowedProviders = permission.Providers,
-                        GrantedProviders = new List<ProviderInfoDto>()
-                    };
-
-                    var grantInfo = await PermissionManager.GetAsync(permission.Name, providerName, providerKey);
+                foreach (var grantInfo in multipleGrantInfo.Result)
+                {
+                    var grantInfoDto = grantInfoDtos.First(x => x.Name == grantInfo.Name);
 
                     grantInfoDto.IsGranted = grantInfo.IsGranted;
 

modules/permission-management/src/Volo.Abp.PermissionManagement.Domain/Volo/Abp/PermissionManagement/IPermissionManagementProvider.cs

@@ -15,10 +15,16 @@ namespace Volo.Abp.PermissionManagement
             [NotNull] string providerKey
         );
 
+        Task<MultiplePermissionValueProviderGrantInfo> CheckAsync(
+            [NotNull] string[] names,
+            [NotNull] string providerName,
+            [NotNull] string providerKey
+        );
+
         Task SetAsync(
             [NotNull] string name,
             [NotNull] string providerKey,
             bool isGranted
         );
     }
-}
+}

modules/permission-management/src/Volo.Abp.PermissionManagement.Domain/Volo/Abp/PermissionManagement/IPermissionManager.cs

@@ -10,6 +10,8 @@ namespace Volo.Abp.PermissionManagement
     {
         Task<PermissionWithGrantedProviders> GetAsync(string permissionName, string providerName, string providerKey);
 
+        Task<MultiplePermissionWithGrantedProviders> GetAsync(string[] permissionNames, string provideName, string providerKey);
+
         Task<List<PermissionWithGrantedProviders>> GetAllAsync([NotNull] string providerName, [NotNull] string providerKey);
 
         Task SetAsync(string permissionName, string providerName, string providerKey, bool isGranted);

modules/permission-management/src/Volo.Abp.PermissionManagement.Domain/Volo/Abp/PermissionManagement/MultiplePermissionValueProviderGrantInfo.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+
+namespace Volo.Abp.PermissionManagement
+{
+    public class MultiplePermissionValueProviderGrantInfo
+    {
+        public Dictionary<string, PermissionValueProviderGrantInfo> Result { get; }
+
+        public MultiplePermissionValueProviderGrantInfo()
+        {
+            Result = new Dictionary<string, PermissionValueProviderGrantInfo>();
+        }
+
+        public MultiplePermissionValueProviderGrantInfo(string[] names)
+        {
+            Check.NotNull(names, nameof(names));
+
+            Result = new Dictionary<string, PermissionValueProviderGrantInfo>();
+
+            foreach (var name in names)
+            {
+                Result.Add(name, PermissionValueProviderGrantInfo.NonGranted);
+            }
+        }
+    }
+}

modules/permission-management/src/Volo.Abp.PermissionManagement.Domain/Volo/Abp/PermissionManagement/MultiplePermissionWithGrantedProviders.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+
+namespace Volo.Abp.PermissionManagement
+{
+    public class MultiplePermissionWithGrantedProviders
+    {
+        public List<PermissionWithGrantedProviders> Result { get; }
+
+        public MultiplePermissionWithGrantedProviders()
+        {
+            Result = new List<PermissionWithGrantedProviders>();
+        }
+
+        public MultiplePermissionWithGrantedProviders(string[] names)
+        {
+            Check.NotNull(names, nameof(names));
+
+            Result = new List<PermissionWithGrantedProviders>();
+
+            foreach (var name in names)
+            {
+                Result.Add(new PermissionWithGrantedProviders(name, false));
+            }
+        }
+    }
+}

modules/permission-management/src/Volo.Abp.PermissionManagement.Domain/Volo/Abp/PermissionManagement/PermissionManagementProvider.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Linq;
+using System.Threading.Tasks;
 using Volo.Abp.Guids;
 using Volo.Abp.MultiTenancy;
 
@@ -23,18 +24,31 @@ namespace Volo.Abp.PermissionManagement
             GuidGenerator = guidGenerator;
             CurrentTenant = currentTenant;
         }
-        
+
         public virtual async Task<PermissionValueProviderGrantInfo> CheckAsync(string name, string providerName, string providerKey)
         {
+            var multiplePermissionValueProviderGrantInfo = await CheckAsync(new[] {name}, providerName, providerKey);
+
+            return multiplePermissionValueProviderGrantInfo.Result.First().Value;
+        }
+
+        public virtual async Task<MultiplePermissionValueProviderGrantInfo> CheckAsync(string[] names, string providerName, string providerKey)
+        {
+            var multiplePermissionValueProviderGrantInfo = new MultiplePermissionValueProviderGrantInfo(names);
             if (providerName != Name)
             {
-                return PermissionValueProviderGrantInfo.NonGranted;
+                return multiplePermissionValueProviderGrantInfo;
             }
 
-            return new PermissionValueProviderGrantInfo(
-                await PermissionGrantRepository.FindAsync(name, providerName, providerKey) != null,
-                providerKey
-            );
+            var permissionGrants = await PermissionGrantRepository.GetListAsync(names, providerName, providerKey);
+
+            foreach (var permissionName in names)
+            {
+                var isGrant = permissionGrants.Any(x => x.Name == permissionName);
+                multiplePermissionValueProviderGrantInfo.Result[permissionName] = new PermissionValueProviderGrantInfo(isGrant, providerKey);
+            }
+
+            return multiplePermissionValueProviderGrantInfo;
         }
 
         public virtual Task SetAsync(string name, string providerKey, bool isGranted)
@@ -74,4 +88,4 @@ namespace Volo.Abp.PermissionManagement
             await PermissionGrantRepository.DeleteAsync(permissionGrant);
         }
     }
-}
+}

modules/permission-management/src/Volo.Abp.PermissionManagement.Domain/Volo/Abp/PermissionManagement/PermissionManager.cs

@@ -65,16 +65,20 @@ namespace Volo.Abp.PermissionManagement
             return await GetInternalAsync(PermissionDefinitionManager.Get(permissionName), providerName, providerKey);
         }
 
+        public virtual async Task<MultiplePermissionWithGrantedProviders> GetAsync(string[] permissionNames, string providerName, string providerKey)
+        {
+            var permissionDefinitions = permissionNames.Select(x => PermissionDefinitionManager.Get(x)).ToArray();
+            return await GetInternalAsync(permissionDefinitions, providerName, providerKey);
+        }
+
         public virtual async Task<List<PermissionWithGrantedProviders>> GetAllAsync(string providerName, string providerKey)
         {
-            var results = new List<PermissionWithGrantedProviders>();
+            var permissionDefinitions = PermissionDefinitionManager.GetPermissions().ToArray();
 
-            foreach (var permissionDefinition in PermissionDefinitionManager.GetPermissions())
-            {
-                results.Add(await GetInternalAsync(permissionDefinition, providerName, providerKey));
-            }
+            var multiplePermissionWithGrantedProviders = await GetInternalAsync(permissionDefinitions, providerName, providerKey);
+
+            return multiplePermissionWithGrantedProviders.Result;
 
-            return results;
         }
 
         public virtual async Task SetAsync(string permissionName, string providerName, string providerKey, bool isGranted)
@@ -144,39 +148,53 @@ namespace Volo.Abp.PermissionManagement
 
         protected virtual async Task<PermissionWithGrantedProviders> GetInternalAsync(PermissionDefinition permission, string providerName, string providerKey)
         {
-            var result = new PermissionWithGrantedProviders(permission.Name, false);
+            var multiplePermissionWithGrantedProviders = await GetInternalAsync(new PermissionDefinition[]{permission}, providerName, providerKey);
 
-            if (!permission.IsEnabled)
-            {
-                return result;
-            }
+            return multiplePermissionWithGrantedProviders.Result.First();
+        }
 
-            if (!await SimpleStateCheckerManager.IsEnabledAsync(permission))
-            {
-                return result;
-            }
+        protected virtual async Task<MultiplePermissionWithGrantedProviders> GetInternalAsync(PermissionDefinition[] permissions, string providerName, string providerKey)
+        {
+            var permissionNames = permissions.Select(x => x.Name).ToArray();
+            var multiplePermissionWithGrantedProviders = new MultiplePermissionWithGrantedProviders(permissionNames);
 
-            if (!permission.MultiTenancySide.HasFlag(CurrentTenant.GetMultiTenancySide()))
+            var neededCheckPermissions = new List<PermissionDefinition>();
+
+            foreach (var permission in permissions
+                                        .Where(x => x.IsEnabled)
+                                        .Where(x => x.MultiTenancySide.HasFlag(CurrentTenant.GetMultiTenancySide()))
+                                        .Where(x => !x.Providers.Any() || x.Providers.Contains(providerName)))
             {
-                return result;
+                if (await SimpleStateCheckerManager.IsEnabledAsync(permission))
+                {
+                    neededCheckPermissions.Add(permission);
+                }
             }
 
-            if (permission.Providers.Any() && !permission.Providers.Contains(providerName))
+            if (!neededCheckPermissions.Any())
             {
-                return result;
+                return multiplePermissionWithGrantedProviders;
             }
 
             foreach (var provider in ManagementProviders)
             {
-                var providerResult = await provider.CheckAsync(permission.Name, providerName, providerKey);
-                if (providerResult.IsGranted)
+                permissionNames = neededCheckPermissions.Select(x => x.Name).ToArray();
+                var multiplePermissionValueProviderGrantInfo = await provider.CheckAsync(permissionNames, providerName, providerKey);
+
+                foreach (var providerResultDict in multiplePermissionValueProviderGrantInfo.Result)
                 {
-                    result.IsGranted = true;
-                    result.Providers.Add(new PermissionValueProviderInfo(provider.Name, providerResult.ProviderKey));
+                    if (providerResultDict.Value.IsGranted)
+                    {
+                        var permissionWithGrantedProvider = multiplePermissionWithGrantedProviders.Result
+                            .First(x => x.Name == providerResultDict.Key);
+
+                        permissionWithGrantedProvider.IsGranted = true;
+                        permissionWithGrantedProvider.Providers.Add(new PermissionValueProviderInfo(provider.Name, providerResultDict.Value.ProviderKey));
+                    }
                 }
             }
 
-            return result;
+            return multiplePermissionWithGrantedProviders;
         }
     }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.Domain.Tests/Volo/Abp/PermissionManagement/PermissionManager_Tests.cs

@@ -40,6 +40,37 @@ namespace Volo.Abp.PermissionManagement
             grantedProviders.Providers.ShouldContain(x => x.Key == "Test");
         }
 
+        [Fact]
+        public async Task Multiple_GetAsync()
+        {
+            await _permissionGrantRepository.InsertAsync(new PermissionGrant(
+                Guid.NewGuid(),
+                "MyPermission1",
+                "Test",
+                "Test")
+            );
+            await _permissionGrantRepository.InsertAsync(new PermissionGrant(
+                Guid.NewGuid(),
+                "MyPermission2",
+                "Test",
+                "Test")
+            );
+
+            var grantedProviders = await _permissionManager.GetAsync(
+                new[] {"MyPermission1", "MyPermission2"},
+                "Test",
+                "Test");
+
+            grantedProviders.Result.Count.ShouldBe(2);
+            grantedProviders.Result.First().IsGranted.ShouldBeTrue();
+            grantedProviders.Result.First().Name.ShouldBe("MyPermission1");
+            grantedProviders.Result.First().Providers.ShouldContain(x => x.Key == "Test");
+
+            grantedProviders.Result.Last().IsGranted.ShouldBeTrue();
+            grantedProviders.Result.Last().Name.ShouldBe("MyPermission2");
+            grantedProviders.Result.Last().Providers.ShouldContain(x => x.Key == "Test");
+        }
+
         [Fact]
         public async Task Get_Should_Exception_When_Permission_Undefined()
         {

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Application.Contracts/Permissions/MyProjectNamePermissionDefinitionProvider.cs

@@ -9,7 +9,6 @@ namespace MyCompanyName.MyProjectName.Permissions
         public override void Define(IPermissionDefinitionContext context)
         {
             var myGroup = context.AddGroup(MyProjectNamePermissions.GroupName);
-
             //Define your own permissions here. Example:
             //myGroup.AddPermission(MyProjectNamePermissions.MyPermission1, L("Permission:MyPermission1"));
         }