Add resource permission management interfaces and implementations

framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/AbpPermissionOptions.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using Volo.Abp.Authorization.Permissions.Resources;
 using Volo.Abp.Collections;
 
 namespace Volo.Abp.Authorization.Permissions;
@@ -9,6 +10,8 @@ public class AbpPermissionOptions
 
     public ITypeList<IPermissionValueProvider> ValueProviders { get; }
 
+    public ITypeList<IResourcePermissionValueProvider> ResourceValueProviders { get; }
+
     public HashSet<string> DeletedPermissions { get; }
 
     public HashSet<string> DeletedPermissionGroups { get; }
@@ -17,6 +20,7 @@ public class AbpPermissionOptions
     {
         DefinitionProviders = new TypeList<IPermissionDefinitionProvider>();
         ValueProviders = new TypeList<IPermissionValueProvider>();
+        ResourceValueProviders = new TypeList<IResourcePermissionValueProvider>();
 
         DeletedPermissions = new HashSet<string>();
         DeletedPermissionGroups = new HashSet<string>();

framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/Resources/IResourcePermissionChecker.cs

@@ -1,61 +1,16 @@
-using System.Collections.Generic;
+using System.Security.Claims;
 using System.Threading.Tasks;
+using JetBrains.Annotations;
 
 namespace Volo.Abp.Authorization.Permissions.Resources;
 
 public interface IResourcePermissionChecker
 {
-    /// <summary>
-    /// Checks if the given permission is granted for the given resource.
-    /// </summary>
-    /// <param name="permissionName">The name of the permission.</param>
-    /// <param name="resourceName">The name of the resource.</param>
-    /// <param name="resourceKey">Resource key</param>
-    /// <returns>
-    /// True if the permission is granted.
-    /// </returns>
-    Task<bool> IsGrantedAsync(
-        string permissionName,
-        string resourceName,
-        string resourceKey
-    );
-    
-    /// <summary>
-    /// Gets all permissions for the given resource.
-    /// </summary>
-    /// <param name="resourceName">Resource name</param>
-    /// <param name="resourceKey">Resource key</param>
-    /// <returns>
-    /// A dictionary of permission names and their states.
-    /// </returns>
-    Task<IDictionary<string, bool>> GetPermissionsAsync(
-        string resourceName,
-        string resourceKey
-    );
-    
-    /// <summary>
-    /// Gets all granted permissions for the given resource.
-    /// </summary>
-    /// <param name="resourceName">Resource name</param>
-    /// <param name="resourceKey">Resource key</param>
-    /// <returns>
-    /// An array of granted permission names.
-    /// </returns>
-    Task<string[]> GetGrantedPermissionsAsync(
-        string resourceName,
-        string resourceKey
-    );
+    Task<bool> IsGrantedAsync([NotNull] string name, string resourceName, string resourceKey);
 
-    /// <summary>
-    /// Retrieves the keys of resources for which the specified permission is granted.
-    /// </summary>
-    /// <param name="resourceName">The name of the resource.</param>
-    /// <param name="permissionName">The name of the permission.</param>
-    /// <returns>
-    /// An array of resource keys where the specified permission is granted.
-    /// </returns>
-    Task<string[]> GetGrantedResourceKeysAsync(
-        string resourceName,
-        string permissionName
-    );
-}
+    Task<bool> IsGrantedAsync(ClaimsPrincipal? claimsPrincipal, [NotNull] string name, string resourceName, string resourceKey);
+
+    Task<MultiplePermissionGrantResult> IsGrantedAsync([NotNull] string[] names, string resourceName, string resourceKey);
+
+    Task<MultiplePermissionGrantResult> IsGrantedAsync(ClaimsPrincipal? claimsPrincipal, [NotNull] string[] names, string resourceName, string resourceKey);
+}

framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/Resources/IResourcePermissionStore.cs

@@ -0,0 +1,67 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Volo.Abp.Authorization.Permissions.Resources;
+
+public interface IResourcePermissionStore
+{
+    /// <summary>
+    /// Checks if the given permission is granted for the given resource.
+    /// </summary>
+    /// <param name="name">The name of the permission.</param>
+    /// <param name="resourceName">The name of the resource.</param>
+    /// <param name="resourceKey">Resource key</param>
+    /// <returns>
+    /// True if the permission is granted.
+    /// </returns>
+    Task<bool> IsGrantedAsync(
+        string name,
+        string resourceName,
+        string resourceKey
+    );
+
+    Task<MultiplePermissionGrantResult> IsGrantedAsync(
+        string[] names,
+        string resourceName,
+        string resourceKey
+    );
+
+    /// <summary>
+    /// Gets all permissions for the given resource.
+    /// </summary>
+    /// <param name="resourceName">Resource name</param>
+    /// <param name="resourceKey">Resource key</param>
+    /// <returns>
+    /// A dictionary of permission names and their states.
+    /// </returns>
+    Task<IDictionary<string, bool>> GetPermissionsAsync(
+        string resourceName,
+        string resourceKey
+    );
+
+    /// <summary>
+    /// Gets all granted permissions for the given resource.
+    /// </summary>
+    /// <param name="resourceName">Resource name</param>
+    /// <param name="resourceKey">Resource key</param>
+    /// <returns>
+    /// An array of granted permission names.
+    /// </returns>
+    Task<string[]> GetGrantedPermissionsAsync(
+        string resourceName,
+        string resourceKey
+    );
+
+    /// <summary>
+    /// Retrieves the keys of resources for which the specified permission is granted.
+    /// </summary>
+    /// <param name="resourceName">The name of the resource.</param>
+    /// <param name="name">The name of the permission.</param>
+    /// <returns>
+    /// An array of resource keys where the specified permission is granted.
+    /// </returns>
+    Task<string[]> GetGrantedResourceKeysAsync(
+        string resourceName,
+        string name
+    );
+}

framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/Resources/IResourcePermissionValueProvider.cs

@@ -0,0 +1,13 @@
+using System.Threading.Tasks;
+
+namespace Volo.Abp.Authorization.Permissions.Resources;
+
+public interface IResourcePermissionValueProvider
+{
+    string Name { get; }
+
+    //TODO: Rename to GetResult? (CheckAsync throws exception by naming convention)
+    Task<PermissionGrantResult> CheckAsync(ResourcePermissionValueCheckContext context);
+
+    Task<MultiplePermissionGrantResult> CheckAsync(ResourcePermissionValuesCheckContext context);
+}

framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/Resources/IResourcePermissionValueProviderManager.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+
+namespace Volo.Abp.Authorization.Permissions.Resources;
+
+public interface IResourcePermissionValueProviderManager
+{
+    IReadOnlyList<IResourcePermissionValueProvider> ValueProviders { get; }
+}

framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/Resources/NullResourcePermissionStore.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Threading;
+
+namespace Volo.Abp.Authorization.Permissions.Resources;
+
+public class NullResourcePermissionStore : IResourcePermissionStore, ISingletonDependency
+{
+    public ILogger<NullResourcePermissionStore> Logger { get; set; }
+
+    public NullResourcePermissionStore()
+    {
+        Logger = NullLogger<NullResourcePermissionStore>.Instance;
+    }
+
+    public Task<bool> IsGrantedAsync(string name, string resourceName, string resourceKey)
+    {
+        return TaskCache.FalseResult;
+    }
+
+    public Task<MultiplePermissionGrantResult> IsGrantedAsync(string[] names, string resourceName, string resourceKey)
+    {
+        return Task.FromResult(new MultiplePermissionGrantResult(names, PermissionGrantResult.Prohibited));
+    }
+
+    public Task<IDictionary<string, bool>> GetPermissionsAsync(string resourceName, string resourceKey)
+    {
+        return Task.FromResult((IDictionary<string, bool>)new Dictionary<string, bool>());
+    }
+
+    public Task<string[]> GetGrantedPermissionsAsync(string resourceName, string resourceKey)
+    {
+        return Task.FromResult(Array.Empty<string>());
+    }
+
+    public Task<string[]> GetGrantedResourceKeysAsync(string resourceName, string name)
+    {
+        return Task.FromResult(Array.Empty<string>());
+    }
+}

framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/Resources/ResourcePermissionGrantInfo.cs

@@ -0,0 +1,17 @@
+using JetBrains.Annotations;
+
+namespace Volo.Abp.Authorization.Permissions.Resources;
+
+public class ResourcePermissionGrantInfo : PermissionGrantInfo
+{
+    public string ResourceName { get; }
+
+    public string ResourceKey { get; }
+
+    public ResourcePermissionGrantInfo([NotNull] string name, bool isGranted, string resourceName, string resourceKey, string? providerName = null, string? providerKey = null)
+        : base(name, isGranted, providerName, providerKey)
+    {
+        ResourceName = resourceName;
+        ResourceKey = resourceKey;
+    }
+}

framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/Resources/ResourcePermissionCheckerExtensions.cs → framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/Resources/ResourcePermissionStoreExtensions.cs

@@ -3,30 +3,30 @@ using System.Threading.Tasks;
 
 namespace Volo.Abp.Authorization.Permissions.Resources;
 
-public static class ResourcePermissionCheckerExtensions
+public static class ResourcePermissionStoreExtensions
 {
     /// <summary>
     /// Checks if a specific permission is granted for a resource with a given key.
     /// </summary>
     /// <typeparam name="TResource">The type of the resource.</typeparam>
-    /// <param name="resourcePermissionChecker">The resource permission checker instance.</param>
+    /// <param name="resourcePermissionStore">The resource permission checker instance.</param>
     /// <param name="permissionName">The name of the permission to check.</param>
     /// <param name="resource">The resource instance to check permission for.</param>
     /// <param name="resourceKey">The unique key identifying the resource instance.</param>
     /// <returns>A task that represents the asynchronous operation. The task result contains a boolean value indicating whether the permission is granted.</returns>
     public static Task<bool> IsGrantedAsync<TResource>(
-        this IResourcePermissionChecker resourcePermissionChecker,
+        this IResourcePermissionStore resourcePermissionStore,
         string permissionName,
         TResource resource,
         object resourceKey
     )
     {
-        Check.NotNull(resourcePermissionChecker, nameof(resourcePermissionChecker));
+        Check.NotNull(resourcePermissionStore, nameof(resourcePermissionStore));
         Check.NotNullOrWhiteSpace(permissionName, nameof(permissionName));
         Check.NotNull(resource, nameof(resource));
         Check.NotNull(resourceKey, nameof(resourceKey));
 
-        return resourcePermissionChecker.IsGrantedAsync(
+        return resourcePermissionStore.IsGrantedAsync(
             permissionName,
             typeof(TResource).FullName!,
             resourceKey.ToString()!
@@ -37,21 +37,21 @@ public static class ResourcePermissionCheckerExtensions
     /// Retrieves a dictionary of permissions and their granted statuses for a specific resource.
     /// </summary>
     /// <typeparam name="TResource">The type of the resource.</typeparam>
-    /// <param name="resourcePermissionChecker">The resource permission checker instance.</param>
+    /// <param name="resourcePermissionStore">The resource permission checker instance.</param>
     /// <param name="resource">The resource instance for which permissions are being checked.</param>
     /// <param name="resourceKey">The unique key identifying the resource instance.</param>
     /// <returns>A task that represents the asynchronous operation. The task result contains a dictionary where keys are permission names and values indicate whether the corresponding permission is granted.</returns>
     public static Task<IDictionary<string, bool>> GetPermissionsAsync<TResource>(
-        this IResourcePermissionChecker resourcePermissionChecker,
+        this IResourcePermissionStore resourcePermissionStore,
         TResource resource,
         object resourceKey
     )
     {
-        Check.NotNull(resourcePermissionChecker, nameof(resourcePermissionChecker));
+        Check.NotNull(resourcePermissionStore, nameof(resourcePermissionStore));
         Check.NotNull(resource, nameof(resource));
         Check.NotNull(resourceKey, nameof(resourceKey));
 
-        return resourcePermissionChecker.GetPermissionsAsync(
+        return resourcePermissionStore.GetPermissionsAsync(
             typeof(TResource).FullName!,
             resourceKey.ToString()!
         );
@@ -61,21 +61,21 @@ public static class ResourcePermissionCheckerExtensions
     /// Retrieves the list of granted permissions for a specific resource with a given key.
     /// </summary>
     /// <typeparam name="TResource">The type of the resource.</typeparam>
-    /// <param name="resourcePermissionChecker">The resource permission checker instance.</param>
+    /// <param name="resourcePermissionStore">The resource permission checker instance.</param>
     /// <param name="resource">The resource instance to retrieve permissions for.</param>
     /// <param name="resourceKey">The unique key identifying the resource instance.</param>
     /// <returns>A task that represents the asynchronous operation. The task result contains an array of strings representing the granted permissions.</returns>
     public static Task<string[]> GetGrantedPermissionsAsync<TResource>(
-        this IResourcePermissionChecker resourcePermissionChecker,
+        this IResourcePermissionStore resourcePermissionStore,
         TResource resource,
         object resourceKey
     )
     {
-        Check.NotNull(resourcePermissionChecker, nameof(resourcePermissionChecker));
+        Check.NotNull(resourcePermissionStore, nameof(resourcePermissionStore));
         Check.NotNull(resource, nameof(resource));
         Check.NotNull(resourceKey, nameof(resourceKey));
 
-        return resourcePermissionChecker.GetGrantedPermissionsAsync(
+        return resourcePermissionStore.GetGrantedPermissionsAsync(
             typeof(TResource).FullName!,
             resourceKey.ToString()!
         );
@@ -85,23 +85,23 @@ public static class ResourcePermissionCheckerExtensions
     /// Retrieves the keys of the resources granted a specific permission.
     /// </summary>
     /// <typeparam name="TResource">The type of the resource.</typeparam>
-    /// <param name="resourcePermissionChecker">The resource permission checker instance.</param>
+    /// <param name="resourcePermissionStore">The resource permission checker instance.</param>
     /// <param name="resource">The resource instance to check granted permissions for.</param>
     /// <param name="permissionName">The name of the permission to check.</param>
     /// <returns>A task that represents the asynchronous operation. The task result contains an array of strings representing the granted resource keys.</returns>
     public static Task<string[]> GetGrantedResourceKeysAsync<TResource>(
-        this IResourcePermissionChecker resourcePermissionChecker,
+        this IResourcePermissionStore resourcePermissionStore,
         TResource resource,
         string permissionName
     )
     {
-        Check.NotNull(resourcePermissionChecker, nameof(resourcePermissionChecker));
+        Check.NotNull(resourcePermissionStore, nameof(resourcePermissionStore));
         Check.NotNull(resource, nameof(resource));
         Check.NotNullOrWhiteSpace(permissionName, nameof(permissionName));
 
-        return resourcePermissionChecker.GetGrantedResourceKeysAsync(
+        return resourcePermissionStore.GetGrantedResourceKeysAsync(
             typeof(TResource).FullName!,
             permissionName
         );
     }
-}
+}

framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/Resources/ResourcePermissionValueCheckContext.cs

@@ -0,0 +1,25 @@
+using System.Security.Claims;
+using JetBrains.Annotations;
+
+namespace Volo.Abp.Authorization.Permissions.Resources;
+
+public class ResourcePermissionValueCheckContext : PermissionValueCheckContext
+{
+    [NotNull]
+    public string ResourceName { get; }
+
+    [NotNull]
+    public string ResourceKey { get; }
+
+    public ResourcePermissionValueCheckContext([NotNull] PermissionDefinition permission, string resourceName, string resourceKey)
+        : this(permission, null, resourceName, resourceKey)
+    {
+    }
+
+    public ResourcePermissionValueCheckContext([NotNull] PermissionDefinition permission, ClaimsPrincipal? principal, string resourceName, string resourceKey)
+        : base(permission, principal)
+    {
+        ResourceName = resourceName;
+        ResourceKey = resourceKey;
+    }
+}

framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/Resources/ResourcePermissionValueProvider.cs

@@ -0,0 +1,20 @@
+using System.Threading.Tasks;
+using Volo.Abp.DependencyInjection;
+
+namespace Volo.Abp.Authorization.Permissions.Resources;
+
+public abstract class ResourcePermissionValueProvider : IResourcePermissionValueProvider, ITransientDependency
+{
+    public abstract string Name { get; }
+
+    protected IResourcePermissionStore PermissionStore { get; }
+
+    protected ResourcePermissionValueProvider(IResourcePermissionStore permissionStore)
+    {
+        PermissionStore = permissionStore;
+    }
+
+    public abstract Task<PermissionGrantResult> CheckAsync(ResourcePermissionValueCheckContext context);
+
+    public abstract Task<MultiplePermissionGrantResult> CheckAsync(ResourcePermissionValuesCheckContext context);
+}

framework/src/Volo.Abp.Authorization.Abstractions/Volo/Abp/Authorization/Permissions/Resources/ResourcePermissionValuesCheckContext.cs

@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+using System.Security.Claims;
+using JetBrains.Annotations;
+
+namespace Volo.Abp.Authorization.Permissions.Resources;
+
+public class ResourcePermissionValuesCheckContext : PermissionValuesCheckContext
+{
+    [NotNull]
+    public string ResourceName { get; }
+
+    [NotNull]
+    public string ResourceKey { get; }
+
+    public ResourcePermissionValuesCheckContext([NotNull] PermissionDefinition permission,string resourceName, string resourceKey)
+        : this([permission], null, resourceName, resourceKey)
+    {
+
+    }
+
+
+    public ResourcePermissionValuesCheckContext([NotNull] PermissionDefinition permission, ClaimsPrincipal? principal, string resourceName, string resourceKey)
+        : this([permission], principal, resourceName, resourceKey)
+    {
+
+    }
+
+    public ResourcePermissionValuesCheckContext([NotNull] List<PermissionDefinition> permissions, string resourceName, string resourceKey)
+        : this(permissions, null, resourceName, resourceKey)
+    {
+        ResourceName = resourceName;
+        ResourceKey = resourceKey;
+    }
+
+    public ResourcePermissionValuesCheckContext([NotNull] List<PermissionDefinition> permissions, ClaimsPrincipal? principal, string resourceName, string resourceKey)
+        : base(permissions, principal)
+    {
+        ResourceName = resourceName;
+        ResourceKey = resourceKey;
+    }
+}

framework/src/Volo.Abp.Authorization/Volo/Abp/Authorization/Permissions/Resources/ResourcePermissionChecker.cs

@@ -0,0 +1,170 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Claims;
+using System.Security.Principal;
+using System.Threading.Tasks;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.MultiTenancy;
+using Volo.Abp.Security.Claims;
+using Volo.Abp.SimpleStateChecking;
+
+namespace Volo.Abp.Authorization.Permissions.Resources;
+
+public class ResourcePermissionChecker : IResourcePermissionChecker, ITransientDependency
+{
+    protected IPermissionDefinitionManager PermissionDefinitionManager { get; }
+    protected ICurrentPrincipalAccessor PrincipalAccessor { get; }
+    protected ICurrentTenant CurrentTenant { get; }
+    protected IResourcePermissionValueProviderManager PermissionValueProviderManager { get; }
+    protected ISimpleStateCheckerManager<PermissionDefinition> StateCheckerManager { get; }
+
+    public ResourcePermissionChecker(
+        ICurrentPrincipalAccessor principalAccessor,
+        IPermissionDefinitionManager permissionDefinitionManager,
+        ICurrentTenant currentTenant,
+        IResourcePermissionValueProviderManager permissionValueProviderManager,
+        ISimpleStateCheckerManager<PermissionDefinition> stateCheckerManager)
+    {
+        PrincipalAccessor = principalAccessor;
+        PermissionDefinitionManager = permissionDefinitionManager;
+        CurrentTenant = currentTenant;
+        PermissionValueProviderManager = permissionValueProviderManager;
+        StateCheckerManager = stateCheckerManager;
+    }
+
+    public virtual async Task<bool> IsGrantedAsync(string name, string resourceName, string resourceKey)
+    {
+        return await IsGrantedAsync(PrincipalAccessor.Principal, name, resourceName, resourceKey);
+    }
+
+    public virtual async Task<bool> IsGrantedAsync(
+        ClaimsPrincipal? claimsPrincipal,
+        string name,
+        string resourceName,
+        string resourceKey)
+    {
+        Check.NotNull(name, nameof(name));
+
+        var permission = await PermissionDefinitionManager.GetOrNullAsync(name);
+        if (permission == null)
+        {
+            return false;
+        }
+
+        if (!permission.IsEnabled)
+        {
+            return false;
+        }
+
+        if (!await StateCheckerManager.IsEnabledAsync(permission))
+        {
+            return false;
+        }
+
+        var multiTenancySide = claimsPrincipal?.GetMultiTenancySide()
+                               ?? CurrentTenant.GetMultiTenancySide();
+
+        if (!permission.MultiTenancySide.HasFlag(multiTenancySide))
+        {
+            return false;
+        }
+
+        var isGranted = false;
+        var context = new ResourcePermissionValueCheckContext(permission, claimsPrincipal, resourceName, resourceKey);
+        foreach (var provider in PermissionValueProviderManager.ValueProviders)
+        {
+            if (context.Permission.Providers.Any() &&
+                !context.Permission.Providers.Contains(provider.Name))
+            {
+                continue;
+            }
+
+            var result = await provider.CheckAsync(context);
+
+            if (result == PermissionGrantResult.Granted)
+            {
+                isGranted = true;
+            }
+            else if (result == PermissionGrantResult.Prohibited)
+            {
+                return false;
+            }
+        }
+
+        return isGranted;
+    }
+
+    public async Task<MultiplePermissionGrantResult> IsGrantedAsync(string[] names, string resourceName, string resourceKey)
+    {
+        return await IsGrantedAsync(PrincipalAccessor.Principal, names, resourceName,resourceKey);
+    }
+
+    public async Task<MultiplePermissionGrantResult> IsGrantedAsync(ClaimsPrincipal? claimsPrincipal, string[] names, string resourceName, string resourceKey)
+    {
+        Check.NotNull(names, nameof(names));
+
+        var result = new MultiplePermissionGrantResult();
+        if (!names.Any())
+        {
+            return result;
+        }
+
+        var multiTenancySide = claimsPrincipal?.GetMultiTenancySide() ??
+                               CurrentTenant.GetMultiTenancySide();
+
+        var permissionDefinitions = new List<PermissionDefinition>();
+        foreach (var name in names)
+        {
+            var permission = await PermissionDefinitionManager.GetOrNullAsync(name);
+            if (permission == null)
+            {
+                result.Result.Add(name, PermissionGrantResult.Prohibited);
+                continue;
+            }
+
+            result.Result.Add(name, PermissionGrantResult.Undefined);
+
+            if (permission.IsEnabled &&
+                await StateCheckerManager.IsEnabledAsync(permission) &&
+                permission.MultiTenancySide.HasFlag(multiTenancySide))
+            {
+                permissionDefinitions.Add(permission);
+            }
+        }
+
+        foreach (var provider in PermissionValueProviderManager.ValueProviders)
+        {
+            var permissions = permissionDefinitions
+                .Where(x => !x.Providers.Any() || x.Providers.Contains(provider.Name))
+                .ToList();
+
+            if (permissions.IsNullOrEmpty())
+            {
+                continue;
+            }
+
+            var context = new ResourcePermissionValuesCheckContext(
+                permissions,
+                claimsPrincipal,
+                resourceName,
+                resourceKey);
+
+            var multipleResult = await provider.CheckAsync(context);
+            foreach (var grantResult in multipleResult.Result.Where(grantResult =>
+                result.Result.ContainsKey(grantResult.Key) &&
+                result.Result[grantResult.Key] == PermissionGrantResult.Undefined &&
+                grantResult.Value != PermissionGrantResult.Undefined))
+            {
+                result.Result[grantResult.Key] = grantResult.Value;
+                permissionDefinitions.RemoveAll(x => x.Name == grantResult.Key);
+            }
+
+            if (result.AllGranted || result.AllProhibited)
+            {
+                break;
+            }
+        }
+
+        return result;
+    }
+}

framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Authorization/Permissions/Resources/EntityResourcePermissionCheckerExtensions.cs → framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Authorization/Permissions/Resources/EntityResourcePermissionStoreExtensions.cs

@@ -6,28 +6,28 @@ using Volo.Abp.Domain.Entities;
 
 namespace Volo.Abp.Authorization.Permissions.Resources;
 
-public static class EntityResourcePermissionCheckerExtensions
+public static class EntityResourcePermissionStoreExtensions
 {
     /// <summary>
     /// Checks if the specified permission is granted for the given entity.
     /// </summary>
     /// <typeparam name="TEntity">The type of the entity.</typeparam>
-    /// <param name="resourcePermissionChecker">The resource permission checker instance.</param>
+    /// <param name="resourcePermissionStore">The resource permission checker instance.</param>
     /// <param name="permissionName">The name of the permission to check.</param>
     /// <param name="entity">The entity for which the permission is being checked.</param>
     /// <returns>A task that represents the asynchronous operation. The task result is a boolean indicating whether the permission is granted.</returns>
     public static Task<bool> IsGrantedAsync<TEntity>(
-        this IResourcePermissionChecker resourcePermissionChecker,
+        this IResourcePermissionStore resourcePermissionStore,
         string permissionName,
         TEntity entity
     )
         where TEntity : class, IEntity
     {
-        Check.NotNull(resourcePermissionChecker, nameof(resourcePermissionChecker));
+        Check.NotNull(resourcePermissionStore, nameof(resourcePermissionStore));
         Check.NotNullOrWhiteSpace(permissionName, nameof(permissionName));
         Check.NotNull(entity, nameof(entity));
 
-        return resourcePermissionChecker.IsGrantedAsync(
+        return resourcePermissionStore.IsGrantedAsync(
             permissionName,
             typeof(TEntity).FullName!,
             entity.GetKeys().JoinAsString(",")
@@ -38,19 +38,19 @@ public static class EntityResourcePermissionCheckerExtensions
     /// Retrieves a dictionary of permissions and their granted status for the specified entity.
     /// </summary>
     /// <typeparam name="TEntity">The type of the entity.</typeparam>
-    /// <param name="resourcePermissionChecker">The resource permission checker instance.</param>
+    /// <param name="resourcePermissionStore">The resource permission checker instance.</param>
     /// <param name="entity">The entity for which the permissions are being retrieved.</param>
     /// <returns>A dictionary where the keys are permission names and the values are booleans indicating whether the permission is granted.</returns>
     public static Task<IDictionary<string, bool>> GetPermissionsAsync<TEntity>(
-        this IResourcePermissionChecker resourcePermissionChecker,
+        this IResourcePermissionStore resourcePermissionStore,
         TEntity entity
     )
         where TEntity : class, IEntity
     {
-        Check.NotNull(resourcePermissionChecker, nameof(resourcePermissionChecker));
+        Check.NotNull(resourcePermissionStore, nameof(resourcePermissionStore));
         Check.NotNull(entity, nameof(entity));
 
-        return resourcePermissionChecker.GetPermissionsAsync(
+        return resourcePermissionStore.GetPermissionsAsync(
             typeof(TEntity).FullName!,
             entity.GetKeys().JoinAsString(",")
         );
@@ -60,19 +60,19 @@ public static class EntityResourcePermissionCheckerExtensions
     /// Retrieves an array of granted permissions for a specific entity.
     /// </summary>
     /// <typeparam name="TEntity">The type of the entity.</typeparam>
-    /// <param name="resourcePermissionChecker">The resource permission checker instance.</param>
+    /// <param name="resourcePermissionStore">The resource permission checker instance.</param>
     /// <param name="entity">The entity for which the permissions are being checked.</param>
     /// <returns>An array of granted permission names as strings.</returns>
     public static Task<string[]> GetGrantedPermissionsAsync<TEntity>(
-        this IResourcePermissionChecker resourcePermissionChecker,
+        this IResourcePermissionStore resourcePermissionStore,
         TEntity entity
     )
         where TEntity : class, IEntity
     {
-        Check.NotNull(resourcePermissionChecker, nameof(resourcePermissionChecker));
+        Check.NotNull(resourcePermissionStore, nameof(resourcePermissionStore));
         Check.NotNull(entity, nameof(entity));
 
-        return resourcePermissionChecker.GetGrantedPermissionsAsync(
+        return resourcePermissionStore.GetGrantedPermissionsAsync(
             typeof(TEntity).FullName!,
             entity.GetKeys().JoinAsString(",")
         );
@@ -83,26 +83,26 @@ public static class EntityResourcePermissionCheckerExtensions
     /// </summary>
     /// <typeparam name="TEntity">The type of the entity.</typeparam>
     /// <typeparam name="TKey">The type of the entity's primary key.</typeparam>
-    /// <param name="resourcePermissionChecker">The resource permission checker instance.</param>
+    /// <param name="resourcePermissionStore">The resource permission checker instance.</param>
     /// <param name="permissionName">The name of the permission to check.</param>
     /// <returns>An array of entity IDs (of type <typeparamref name="TKey"/>) for which the permission is granted.</returns>
-    public async static Task<TKey[]> GetGrantedEntityIdsAsync<TEntity, TKey>(
-        this IResourcePermissionChecker resourcePermissionChecker,
+    public static async Task<TKey[]> GetGrantedEntityIdsAsync<TEntity, TKey>(
+        this IResourcePermissionStore resourcePermissionStore,
         string permissionName
     )
         where TEntity : class, IEntity<TKey>
     {
-        Check.NotNull(resourcePermissionChecker, nameof(resourcePermissionChecker));
+        Check.NotNull(resourcePermissionStore, nameof(resourcePermissionStore));
         Check.NotNullOrWhiteSpace(permissionName, nameof(permissionName));
 
-        var keys = await resourcePermissionChecker.GetGrantedResourceKeysAsync(
+        var keys = await resourcePermissionStore.GetGrantedResourceKeysAsync(
             typeof(TEntity).FullName!,
             permissionName
         );
-        
+
         return keys
             .Select(x => Convert.ChangeType(x, typeof(TKey)))
             .Cast<TKey>()
             .ToArray();
     }
-}
+}