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,7 +28,7 @@ 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)
         {
             if (providerName == Name)
             {
@@ -53,5 +55,43 @@ namespace Volo.Abp.PermissionManagement.Identity
 
             return PermissionValueProviderGrantInfo.NonGranted;
         }
+
+        public override async Task<MultiplePermissionValueProviderGrantInfo> CheckAsync(string[] names, string providerName, string providerKey)
+        {
+            var multiplePermissionValueProviderGrantInfo = new MultiplePermissionValueProviderGrantInfo(names);
+            List<PermissionGrant> permissionGrants = null;
+
+            if (providerName == Name)
+            {
+                 permissionGrants = await PermissionGrantRepository.GetListAsync(names, providerName, providerKey);
+
+            }
+
+            if (providerName == UserPermissionValueProvider.ProviderName)
+            {
+                var userId = Guid.Parse(providerKey);
+                var roleNames = await UserRoleFinder.GetRolesAsync(userId);
+
+                foreach (var roleName in roleNames)
+                {
+                    permissionGrants = await PermissionGrantRepository.GetListAsync(names, Name, roleName);
+                }
+            }
+
+            if (permissionGrants == null)
+            {
+                return multiplePermissionValueProviderGrantInfo;
+            }
+
+            foreach (var permissionName in names)
+            {
+                if (permissionGrants.Any(x => x.Name == permissionName))
+                {
+                    multiplePermissionValueProviderGrantInfo.Result[permissionName] = new PermissionValueProviderGrantInfo(true, providerKey);
+                }
+            }
+
+            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;
 
@@ -19,16 +20,19 @@ namespace Volo.Abp.PermissionManagement
         protected IPermissionDefinitionManager PermissionDefinitionManager { get; }
         protected ISimpleStateCheckerManager<PermissionDefinition> SimpleStateCheckerManager { get; }
 
+        private readonly IPermissionChecker _permissionChecker;
+
         public PermissionAppService(
             IPermissionManager permissionManager,
             IPermissionDefinitionManager permissionDefinitionManager,
             IOptions<PermissionManagementOptions> options,
-            ISimpleStateCheckerManager<PermissionDefinition> simpleStateCheckerManager)
+            ISimpleStateCheckerManager<PermissionDefinition> simpleStateCheckerManager, IPermissionChecker permissionChecker)
         {
             Options = options.Value;
             PermissionManager = permissionManager;
             PermissionDefinitionManager = permissionDefinitionManager;
             SimpleStateCheckerManager = simpleStateCheckerManager;
+            _permissionChecker = permissionChecker;
         }
 
         public virtual async Task<GetPermissionListResultDto> GetAsync(string providerName, string providerKey)
@@ -52,38 +56,33 @@ namespace Volo.Abp.PermissionManagement
                     Permissions = new List<PermissionGrantInfoDto>()
                 };
 
-                foreach (var permission in group.GetPermissionsWithChildren())
-                {
-                    if (!permission.IsEnabled)
-                    {
-                        continue;
-                    }
+                var neededCheckPermissions = new List<PermissionDefinition>();
 
-                    if (!await SimpleStateCheckerManager.IsEnabledAsync(permission))
+                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 (await SimpleStateCheckerManager.IsEnabledAsync(permission))
                     {
-                        continue;
+                        neededCheckPermissions.Add(permission);
                     }
+                }
 
-                    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,7 +24,7 @@ namespace Volo.Abp.PermissionManagement
             GuidGenerator = guidGenerator;
             CurrentTenant = currentTenant;
         }
-        
+
         public virtual async Task<PermissionValueProviderGrantInfo> CheckAsync(string name, string providerName, string providerKey)
         {
             if (providerName != Name)
@@ -37,6 +38,27 @@ namespace Volo.Abp.PermissionManagement
             );
         }
 
+        public virtual async Task<MultiplePermissionValueProviderGrantInfo> CheckAsync(string[] names, string providerName, string providerKey)
+        {
+            var multiplePermissionValueProviderGrantInfo = new MultiplePermissionValueProviderGrantInfo(names);
+            if (providerName != Name)
+            {
+                return multiplePermissionValueProviderGrantInfo;
+            }
+
+            var permissionGrants = await PermissionGrantRepository.GetListAsync(names, providerName, providerKey);
+
+            foreach (var permissionName in names)
+            {
+                if (permissionGrants.Any(x => x.Name == permissionName))
+                {
+                    multiplePermissionValueProviderGrantInfo.Result[permissionName] = new PermissionValueProviderGrantInfo(true, providerKey);
+                }
+            }
+
+            return multiplePermissionValueProviderGrantInfo;
+        }
+
         public virtual Task SetAsync(string name, string providerKey, bool isGranted)
         {
             return isGranted
@@ -74,4 +96,4 @@ namespace Volo.Abp.PermissionManagement
             await PermissionGrantRepository.DeleteAsync(permissionGrant);
         }
     }
-}
+}

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

@@ -65,6 +65,12 @@ 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>();
@@ -178,5 +184,44 @@ namespace Volo.Abp.PermissionManagement
 
             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);
+
+            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)))
+            {
+                if (await SimpleStateCheckerManager.IsEnabledAsync(permission))
+                {
+                    neededCheckPermissions.Add(permission);
+                }
+            }
+
+            foreach (var provider in ManagementProviders)
+            {
+                permissionNames = neededCheckPermissions.Select(x => x.Name).ToArray();
+                var multiplePermissionValueProviderGrantInfo = await provider.CheckAsync(permissionNames, providerName, providerKey);
+
+                foreach (var providerResultDict in multiplePermissionValueProviderGrantInfo.Result)
+                {
+                    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 multiplePermissionWithGrantedProviders;
+        }
     }
 }