use file-scoped namespacing for permissionManagement module

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

@@ -2,13 +2,12 @@
 using Volo.Abp.Authorization;
 using Volo.Abp.Modularity;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+[DependsOn(typeof(AbpDddApplicationContractsModule))]
+[DependsOn(typeof(AbpPermissionManagementDomainSharedModule))]
+[DependsOn(typeof(AbpAuthorizationAbstractionsModule))]
+public class AbpPermissionManagementApplicationContractsModule : AbpModule
 {
-    [DependsOn(typeof(AbpDddApplicationContractsModule))]
-    [DependsOn(typeof(AbpPermissionManagementDomainSharedModule))]
-    [DependsOn(typeof(AbpAuthorizationAbstractionsModule))]
-    public class AbpPermissionManagementApplicationContractsModule : AbpModule
-    {
-        
-    }
+
 }

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

@@ -1,11 +1,10 @@
 using System.Collections.Generic;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class GetPermissionListResultDto
 {
-    public class GetPermissionListResultDto
-    {
-        public string EntityDisplayName { get; set; }
+    public string EntityDisplayName { get; set; }
 
-        public List<PermissionGroupDto> Groups { get; set; }
-    }
-}
+    public List<PermissionGroupDto> Groups { get; set; }
+}

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

@@ -2,12 +2,11 @@
 using JetBrains.Annotations;
 using Volo.Abp.Application.Services;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public interface IPermissionAppService : IApplicationService
 {
-    public interface IPermissionAppService : IApplicationService
-    {
-        Task<GetPermissionListResultDto> GetAsync([NotNull] string providerName, [NotNull] string providerKey);
+    Task<GetPermissionListResultDto> GetAsync([NotNull] string providerName, [NotNull] string providerKey);
 
-        Task UpdateAsync([NotNull] string providerName, [NotNull] string providerKey, UpdatePermissionsDto input);
-    }
-}
+    Task UpdateAsync([NotNull] string providerName, [NotNull] string providerKey, UpdatePermissionsDto input);
+}

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

@@ -1,19 +1,18 @@
 using System.Collections.Generic;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionGrantInfoDto
 {
-    public class PermissionGrantInfoDto
-    {
-        public string Name { get; set; }
+    public string Name { get; set; }
 
-        public string DisplayName { get; set; }
+    public string DisplayName { get; set; }
 
-        public string ParentName { get; set; }
+    public string ParentName { get; set; }
 
-        public bool IsGranted { get; set; }
+    public bool IsGranted { get; set; }
 
-        public List<string> AllowedProviders { get; set; }
+    public List<string> AllowedProviders { get; set; }
 
-        public List<ProviderInfoDto> GrantedProviders { get; set; }
-    }
-}
+    public List<ProviderInfoDto> GrantedProviders { get; set; }
+}

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

@@ -1,13 +1,12 @@
 using System.Collections.Generic;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionGroupDto
 {
-    public class PermissionGroupDto
-    {
-        public string Name { get; set; }
+    public string Name { get; set; }
 
-        public string DisplayName { get; set; }
+    public string DisplayName { get; set; }
 
-        public List<PermissionGrantInfoDto> Permissions { get; set; }
-    }
-}
+    public List<PermissionGrantInfoDto> Permissions { get; set; }
+}

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

@@ -1,9 +1,8 @@
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionManagementRemoteServiceConsts
 {
-    public class PermissionManagementRemoteServiceConsts
-    {
-        public const string RemoteServiceName = "AbpPermissionManagement";
+    public const string RemoteServiceName = "AbpPermissionManagement";
 
-        public const string ModuleName = "permissionManagement";
-    }
+    public const string ModuleName = "permissionManagement";
 }

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

@@ -1,9 +1,8 @@
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class ProviderInfoDto
 {
-    public class ProviderInfoDto
-    {
-        public string ProviderName { get; set; }
+    public string ProviderName { get; set; }
 
-        public string ProviderKey { get; set; }
-    }
-}
+    public string ProviderKey { get; set; }
+}

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

@@ -1,9 +1,8 @@
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class UpdatePermissionDto
 {
-    public class UpdatePermissionDto
-    {
-        public string Name { get; set; }
+    public string Name { get; set; }
 
-        public bool IsGranted { get; set; }
-    }
-}
+    public bool IsGranted { get; set; }
+}

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

@@ -1,7 +1,6 @@
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class UpdatePermissionsDto
 {
-    public class UpdatePermissionsDto
-    {
-        public UpdatePermissionDto[] Permissions { get; set; }
-    }
-}
+    public UpdatePermissionDto[] Permissions { get; set; }
+}

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

@@ -1,15 +1,14 @@
 using Volo.Abp.Application;
 using Volo.Abp.Modularity;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+[DependsOn(
+    typeof(AbpPermissionManagementDomainModule),
+    typeof(AbpPermissionManagementApplicationContractsModule),
+    typeof(AbpDddApplicationModule)
+    )]
+public class AbpPermissionManagementApplicationModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpPermissionManagementDomainModule), 
-        typeof(AbpPermissionManagementApplicationContractsModule),
-        typeof(AbpDddApplicationModule)
-        )]
-    public class AbpPermissionManagementApplicationModule : AbpModule
-    {
-        
-    }
+
 }

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

@@ -9,124 +9,123 @@ using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.MultiTenancy;
 using Volo.Abp.SimpleStateChecking;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+[Authorize]
+public class PermissionAppService : ApplicationService, IPermissionAppService
 {
-    [Authorize]
-    public class PermissionAppService : ApplicationService, IPermissionAppService
+    protected PermissionManagementOptions Options { get; }
+    protected IPermissionManager PermissionManager { get; }
+    protected IPermissionDefinitionManager PermissionDefinitionManager { get; }
+    protected ISimpleStateCheckerManager<PermissionDefinition> SimpleStateCheckerManager { get; }
+
+    public PermissionAppService(
+        IPermissionManager permissionManager,
+        IPermissionDefinitionManager permissionDefinitionManager,
+        IOptions<PermissionManagementOptions> options,
+        ISimpleStateCheckerManager<PermissionDefinition> simpleStateCheckerManager)
     {
-        protected PermissionManagementOptions Options { get; }
-        protected IPermissionManager PermissionManager { get; }
-        protected IPermissionDefinitionManager PermissionDefinitionManager { get; }
-        protected ISimpleStateCheckerManager<PermissionDefinition> SimpleStateCheckerManager { get; }
-
-        public PermissionAppService(
-            IPermissionManager permissionManager,
-            IPermissionDefinitionManager permissionDefinitionManager,
-            IOptions<PermissionManagementOptions> options,
-            ISimpleStateCheckerManager<PermissionDefinition> simpleStateCheckerManager)
-        {
-            Options = options.Value;
-            PermissionManager = permissionManager;
-            PermissionDefinitionManager = permissionDefinitionManager;
-            SimpleStateCheckerManager = simpleStateCheckerManager;
-        }
+        Options = options.Value;
+        PermissionManager = permissionManager;
+        PermissionDefinitionManager = permissionDefinitionManager;
+        SimpleStateCheckerManager = simpleStateCheckerManager;
+    }
+
+    public virtual async Task<GetPermissionListResultDto> GetAsync(string providerName, string providerKey)
+    {
+        await CheckProviderPolicy(providerName);
 
-        public virtual async Task<GetPermissionListResultDto> GetAsync(string providerName, string providerKey)
+        var result = new GetPermissionListResultDto
         {
-            await CheckProviderPolicy(providerName);
+            EntityDisplayName = providerKey,
+            Groups = new List<PermissionGroupDto>()
+        };
+
+        var multiTenancySide = CurrentTenant.GetMultiTenancySide();
 
-            var result = new GetPermissionListResultDto
+        foreach (var group in PermissionDefinitionManager.GetGroups())
+        {
+            var groupDto = new PermissionGroupDto
             {
-                EntityDisplayName = providerKey,
-                Groups = new List<PermissionGroupDto>()
+                Name = group.Name,
+                DisplayName = group.DisplayName.Localize(StringLocalizerFactory),
+                Permissions = new List<PermissionGrantInfoDto>()
             };
 
-            var multiTenancySide = CurrentTenant.GetMultiTenancySide();
+            var neededCheckPermissions = new List<PermissionDefinition>();
 
-            foreach (var group in PermissionDefinitionManager.GetGroups())
+            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)))
             {
-                var groupDto = new PermissionGroupDto
-                {
-                    Name = group.Name,
-                    DisplayName = group.DisplayName.Localize(StringLocalizerFactory),
-                    Permissions = new List<PermissionGrantInfoDto>()
-                };
-
-                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 (await SimpleStateCheckerManager.IsEnabledAsync(permission))
                 {
-                    if (await SimpleStateCheckerManager.IsEnabledAsync(permission))
-                    {
-                        neededCheckPermissions.Add(permission);
-                    }
+                    neededCheckPermissions.Add(permission);
                 }
+            }
 
-                if (!neededCheckPermissions.Any())
-                {
-                    continue;
-                }
+            if (!neededCheckPermissions.Any())
+            {
+                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();
+            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();
 
-                var multipleGrantInfo = await PermissionManager.GetAsync(neededCheckPermissions.Select(x=>x.Name).ToArray(), providerName, providerKey);
+            var multipleGrantInfo = await PermissionManager.GetAsync(neededCheckPermissions.Select(x => x.Name).ToArray(), providerName, providerKey);
 
-                foreach (var grantInfo in multipleGrantInfo.Result)
-                {
-                    var grantInfoDto = grantInfoDtos.First(x => x.Name == grantInfo.Name);
+            foreach (var grantInfo in multipleGrantInfo.Result)
+            {
+                var grantInfoDto = grantInfoDtos.First(x => x.Name == grantInfo.Name);
 
-                    grantInfoDto.IsGranted = grantInfo.IsGranted;
+                grantInfoDto.IsGranted = grantInfo.IsGranted;
 
-                    foreach (var provider in grantInfo.Providers)
+                foreach (var provider in grantInfo.Providers)
+                {
+                    grantInfoDto.GrantedProviders.Add(new ProviderInfoDto
                     {
-                        grantInfoDto.GrantedProviders.Add(new ProviderInfoDto
-                        {
-                            ProviderName = provider.Name,
-                            ProviderKey = provider.Key,
-                        });
-                    }
-
-                    groupDto.Permissions.Add(grantInfoDto);
+                        ProviderName = provider.Name,
+                        ProviderKey = provider.Key,
+                    });
                 }
 
-                if (groupDto.Permissions.Any())
-                {
-                    result.Groups.Add(groupDto);
-                }
+                groupDto.Permissions.Add(grantInfoDto);
             }
 
-            return result;
-        }
-
-        public virtual async Task UpdateAsync(string providerName, string providerKey, UpdatePermissionsDto input)
-        {
-            await CheckProviderPolicy(providerName);
-
-            foreach (var permissionDto in input.Permissions)
+            if (groupDto.Permissions.Any())
             {
-                await PermissionManager.SetAsync(permissionDto.Name, providerName, providerKey, permissionDto.IsGranted);
+                result.Groups.Add(groupDto);
             }
         }
 
-        protected virtual async Task CheckProviderPolicy(string providerName)
+        return result;
+    }
+
+    public virtual async Task UpdateAsync(string providerName, string providerKey, UpdatePermissionsDto input)
+    {
+        await CheckProviderPolicy(providerName);
+
+        foreach (var permissionDto in input.Permissions)
         {
-            var policyName = Options.ProviderPolicies.GetOrDefault(providerName);
-            if (policyName.IsNullOrEmpty())
-            {
-                throw new AbpException($"No policy defined to get/set permissions for the provider '{providerName}'. Use {nameof(PermissionManagementOptions)} to map the policy.");
-            }
+            await PermissionManager.SetAsync(permissionDto.Name, providerName, providerKey, permissionDto.IsGranted);
+        }
+    }
 
-            await AuthorizationService.CheckAsync(policyName);
+    protected virtual async Task CheckProviderPolicy(string providerName)
+    {
+        var policyName = Options.ProviderPolicies.GetOrDefault(providerName);
+        if (policyName.IsNullOrEmpty())
+        {
+            throw new AbpException($"No policy defined to get/set permissions for the provider '{providerName}'. Use {nameof(PermissionManagementOptions)} to map the policy.");
         }
+
+        await AuthorizationService.CheckAsync(policyName);
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.Blazor.Server/AbpPermissionManagementBlazorServerModule.cs

@@ -1,13 +1,12 @@
 using Volo.Abp.AspNetCore.Components.Server.Theming;
 using Volo.Abp.Modularity;
 
-namespace Volo.Abp.PermissionManagement.Blazor.Server
+namespace Volo.Abp.PermissionManagement.Blazor.Server;
+
+[DependsOn(
+    typeof(AbpPermissionManagementBlazorModule),
+    typeof(AbpAspNetCoreComponentsServerThemingModule)
+)]
+public class AbpPermissionManagementBlazorServerModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpPermissionManagementBlazorModule),
-        typeof(AbpAspNetCoreComponentsServerThemingModule)
-    )]
-    public class AbpPermissionManagementBlazorServerModule : AbpModule
-    {
-    }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.Blazor.WebAssembly/AbpPermissionManagementBlazorWebAssemblyModule.cs

@@ -1,14 +1,13 @@
 using Volo.Abp.AspNetCore.Components.WebAssembly.Theming;
 using Volo.Abp.Modularity;
 
-namespace Volo.Abp.PermissionManagement.Blazor.WebAssembly
+namespace Volo.Abp.PermissionManagement.Blazor.WebAssembly;
+
+[DependsOn(
+    typeof(AbpPermissionManagementBlazorModule),
+    typeof(AbpAspNetCoreComponentsWebAssemblyThemingModule),
+    typeof(AbpPermissionManagementHttpApiClientModule)
+)]
+public class AbpPermissionManagementBlazorWebAssemblyModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpPermissionManagementBlazorModule),
-        typeof(AbpAspNetCoreComponentsWebAssemblyThemingModule),
-        typeof(AbpPermissionManagementHttpApiClientModule)
-    )]
-    public class AbpPermissionManagementBlazorWebAssemblyModule : AbpModule
-    {
-    }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.Blazor/AbpPermissionManagementBlazorModule.cs

@@ -2,15 +2,14 @@
 using Volo.Abp.AutoMapper;
 using Volo.Abp.Modularity;
 
-namespace Volo.Abp.PermissionManagement.Blazor
+namespace Volo.Abp.PermissionManagement.Blazor;
+
+[DependsOn(
+    typeof(AbpAspNetCoreComponentsWebThemingModule),
+    typeof(AbpAutoMapperModule),
+    typeof(AbpPermissionManagementApplicationContractsModule)
+    )]
+public class AbpPermissionManagementBlazorModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpAspNetCoreComponentsWebThemingModule),
-        typeof(AbpAutoMapperModule),
-        typeof(AbpPermissionManagementApplicationContractsModule)
-        )]
-    public class AbpPermissionManagementBlazorModule : AbpModule
-    {
 
-    }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.Blazor/Components/PermissionManagementModal.razor.cs

@@ -7,238 +7,234 @@ using Microsoft.AspNetCore.Components;
 using Volo.Abp.AspNetCore.Components.Web.Configuration;
 using Volo.Abp.PermissionManagement.Localization;
 
-namespace Volo.Abp.PermissionManagement.Blazor.Components
+namespace Volo.Abp.PermissionManagement.Blazor.Components;
+
+public partial class PermissionManagementModal
 {
-    public partial class PermissionManagementModal
-    {
-        [Inject] private IPermissionAppService PermissionAppService { get; set; }
-        [Inject] private ICurrentApplicationConfigurationCacheResetService CurrentApplicationConfigurationCacheResetService { get; set; }
+    [Inject] private IPermissionAppService PermissionAppService { get; set; }
+    [Inject] private ICurrentApplicationConfigurationCacheResetService CurrentApplicationConfigurationCacheResetService { get; set; }
 
-        private Modal _modal;
+    private Modal _modal;
 
-        private string _providerName;
-        private string _providerKey;
+    private string _providerName;
+    private string _providerKey;
 
-        private string _entityDisplayName;
-        private List<PermissionGroupDto> _groups;
+    private string _entityDisplayName;
+    private List<PermissionGroupDto> _groups;
 
-        private List<PermissionGrantInfoDto> _disabledPermissions = new List<PermissionGrantInfoDto>();
+    private List<PermissionGrantInfoDto> _disabledPermissions = new List<PermissionGrantInfoDto>();
 
-        private string _selectedTabName;
+    private string _selectedTabName;
 
-        private int _grantedPermissionCount = 0;
-        private int _notGrantedPermissionCount = 0;
+    private int _grantedPermissionCount = 0;
+    private int _notGrantedPermissionCount = 0;
 
-        private bool GrantAll
-        {
-            get
+    private bool GrantAll {
+        get {
+            if (_notGrantedPermissionCount == 0)
             {
-                if (_notGrantedPermissionCount == 0)
-                {
-                    return true;
-                }
-
-                return false;
+                return true;
             }
-            set
+
+            return false;
+        }
+        set {
+            if (_groups == null)
             {
-                if (_groups == null)
-                {
-                    return;
-                }
+                return;
+            }
 
-                _grantedPermissionCount = 0;
-                _notGrantedPermissionCount = 0;
+            _grantedPermissionCount = 0;
+            _notGrantedPermissionCount = 0;
 
-                foreach (var permission in _groups.SelectMany(x => x.Permissions))
+            foreach (var permission in _groups.SelectMany(x => x.Permissions))
+            {
+                if (!IsDisabledPermission(permission))
                 {
-                    if (!IsDisabledPermission(permission))
+                    permission.IsGranted = value;
+
+                    if (value)
                     {
-                        permission.IsGranted = value;
-
-                        if (value)
-                        {
-                            _grantedPermissionCount++;
-                        }
-                        else
-                        {
-                            _notGrantedPermissionCount++;
-                        }
+                        _grantedPermissionCount++;
+                    }
+                    else
+                    {
+                        _notGrantedPermissionCount++;
                     }
                 }
             }
         }
+    }
 
-        public PermissionManagementModal()
-        {
-            LocalizationResource = typeof(AbpPermissionManagementResource);
-        }
+    public PermissionManagementModal()
+    {
+        LocalizationResource = typeof(AbpPermissionManagementResource);
+    }
 
-        public async Task OpenAsync(string providerName, string providerKey, string entityDisplayName = null)
+    public async Task OpenAsync(string providerName, string providerKey, string entityDisplayName = null)
+    {
+        try
         {
-            try
-            {
-                _providerName = providerName;
-                _providerKey = providerKey;
+            _providerName = providerName;
+            _providerKey = providerKey;
 
-                var result = await PermissionAppService.GetAsync(_providerName, _providerKey);
+            var result = await PermissionAppService.GetAsync(_providerName, _providerKey);
 
-                _entityDisplayName = entityDisplayName ?? result.EntityDisplayName;
-                _groups = result.Groups;
+            _entityDisplayName = entityDisplayName ?? result.EntityDisplayName;
+            _groups = result.Groups;
 
-                _grantedPermissionCount = 0;
-                _notGrantedPermissionCount = 0;
-                foreach (var permission in _groups.SelectMany(x => x.Permissions))
+            _grantedPermissionCount = 0;
+            _notGrantedPermissionCount = 0;
+            foreach (var permission in _groups.SelectMany(x => x.Permissions))
+            {
+                if (permission.IsGranted && permission.GrantedProviders.All(x => x.ProviderName != _providerName))
                 {
-                    if (permission.IsGranted && permission.GrantedProviders.All(x => x.ProviderName != _providerName))
-                    {
-                        _disabledPermissions.Add(permission);
-                        continue;
-                    }
+                    _disabledPermissions.Add(permission);
+                    continue;
+                }
 
-                    if (permission.IsGranted)
-                    {
-                        _grantedPermissionCount++;
-                    }
-                    else
-                    {
-                        _notGrantedPermissionCount++;
-                    }
+                if (permission.IsGranted)
+                {
+                    _grantedPermissionCount++;
                 }
+                else
+                {
+                    _notGrantedPermissionCount++;
+                }
+            }
 
-                _selectedTabName = GetNormalizedGroupName(_groups.First().Name);
+            _selectedTabName = GetNormalizedGroupName(_groups.First().Name);
 
-                await InvokeAsync(_modal.Show);
-            }
-            catch (Exception ex)
-            {
-                await HandleErrorAsync(ex);
-            }
+            await InvokeAsync(_modal.Show);
         }
-
-        private Task CloseModal()
+        catch (Exception ex)
         {
-            return InvokeAsync(_modal.Hide);
+            await HandleErrorAsync(ex);
         }
+    }
+
+    private Task CloseModal()
+    {
+        return InvokeAsync(_modal.Hide);
+    }
 
-        private async Task SaveAsync()
+    private async Task SaveAsync()
+    {
+        try
         {
-            try
+            var updateDto = new UpdatePermissionsDto
             {
-                var updateDto = new UpdatePermissionsDto
-                {
-                    Permissions = _groups
-                        .SelectMany(g => g.Permissions)
-                        .Select(p => new UpdatePermissionDto { IsGranted = p.IsGranted, Name = p.Name })
-                        .ToArray()
-                };
+                Permissions = _groups
+                    .SelectMany(g => g.Permissions)
+                    .Select(p => new UpdatePermissionDto { IsGranted = p.IsGranted, Name = p.Name })
+                    .ToArray()
+            };
 
-                await PermissionAppService.UpdateAsync(_providerName, _providerKey, updateDto);
+            await PermissionAppService.UpdateAsync(_providerName, _providerKey, updateDto);
 
-                await CurrentApplicationConfigurationCacheResetService.ResetAsync();
+            await CurrentApplicationConfigurationCacheResetService.ResetAsync();
 
-                await InvokeAsync(_modal.Hide);
-            }
-            catch (Exception ex)
-            {
-                await HandleErrorAsync(ex);
-            }
+            await InvokeAsync(_modal.Hide);
         }
-
-        private string GetNormalizedGroupName(string name)
+        catch (Exception ex)
         {
-            return "PermissionGroup_" + name.Replace(".", "_");
+            await HandleErrorAsync(ex);
         }
+    }
 
-        private void GroupGrantAllChanged(bool value, PermissionGroupDto permissionGroup)
+    private string GetNormalizedGroupName(string name)
+    {
+        return "PermissionGroup_" + name.Replace(".", "_");
+    }
+
+    private void GroupGrantAllChanged(bool value, PermissionGroupDto permissionGroup)
+    {
+        foreach (var permission in permissionGroup.Permissions)
         {
-            foreach (var permission in permissionGroup.Permissions)
+            if (!IsDisabledPermission(permission))
             {
-                if (!IsDisabledPermission(permission))
-                {
-                    SetPermissionGrant(permission, value);
-                }
+                SetPermissionGrant(permission, value);
             }
         }
+    }
 
-        private void PermissionChanged(bool value, PermissionGroupDto permissionGroup, PermissionGrantInfoDto permission)
-        {
-            SetPermissionGrant(permission, value);
-
-            if (value && permission.ParentName != null)
-            {
-                var parentPermission = GetParentPermission(permissionGroup, permission);
+    private void PermissionChanged(bool value, PermissionGroupDto permissionGroup, PermissionGrantInfoDto permission)
+    {
+        SetPermissionGrant(permission, value);
 
-                SetPermissionGrant(parentPermission, true);
-            }
-            else if (value == false)
-            {
-                var childPermissions = GetChildPermissions(permissionGroup, permission);
+        if (value && permission.ParentName != null)
+        {
+            var parentPermission = GetParentPermission(permissionGroup, permission);
 
-                foreach (var childPermission in childPermissions)
-                {
-                    SetPermissionGrant(childPermission, false);
-                }
-            }
+            SetPermissionGrant(parentPermission, true);
         }
-
-        private void SetPermissionGrant(PermissionGrantInfoDto permission, bool value)
+        else if (value == false)
         {
-            if (permission.IsGranted == value)
-            {
-                return;
-            }
+            var childPermissions = GetChildPermissions(permissionGroup, permission);
 
-            if (value)
-            {
-                _grantedPermissionCount++;
-                _notGrantedPermissionCount--;
-            }
-            else
+            foreach (var childPermission in childPermissions)
             {
-                _grantedPermissionCount--;
-                _notGrantedPermissionCount++;
+                SetPermissionGrant(childPermission, false);
             }
-
-            permission.IsGranted = value;
         }
+    }
 
-        private PermissionGrantInfoDto GetParentPermission(PermissionGroupDto permissionGroup, PermissionGrantInfoDto permission)
+    private void SetPermissionGrant(PermissionGrantInfoDto permission, bool value)
+    {
+        if (permission.IsGranted == value)
         {
-            return permissionGroup.Permissions.First(x => x.Name == permission.ParentName);
+            return;
         }
 
-        private List<PermissionGrantInfoDto> GetChildPermissions(PermissionGroupDto permissionGroup, PermissionGrantInfoDto permission)
+        if (value)
         {
-            return permissionGroup.Permissions.Where(x => x.Name.StartsWith(permission.Name)).ToList();
+            _grantedPermissionCount++;
+            _notGrantedPermissionCount--;
         }
-
-        private bool IsDisabledPermission(PermissionGrantInfoDto permissionGrantInfo)
+        else
         {
-            return _disabledPermissions.Any(x => x == permissionGrantInfo);
+            _grantedPermissionCount--;
+            _notGrantedPermissionCount++;
         }
 
-        private string GetShownName(PermissionGrantInfoDto permissionGrantInfo)
-        {
-            if (!IsDisabledPermission(permissionGrantInfo))
-            {
-                return permissionGrantInfo.DisplayName;
-            }
+        permission.IsGranted = value;
+    }
 
-            return string.Format(
-                "{0} ({1})",
-                permissionGrantInfo.DisplayName,
-                permissionGrantInfo.GrantedProviders
-                    .Where(p => p.ProviderName != _providerName)
-                    .Select(p => p.ProviderName)
-                    .JoinAsString(", ")
-            );
-        }
+    private PermissionGrantInfoDto GetParentPermission(PermissionGroupDto permissionGroup, PermissionGrantInfoDto permission)
+    {
+        return permissionGroup.Permissions.First(x => x.Name == permission.ParentName);
+    }
+
+    private List<PermissionGrantInfoDto> GetChildPermissions(PermissionGroupDto permissionGroup, PermissionGrantInfoDto permission)
+    {
+        return permissionGroup.Permissions.Where(x => x.Name.StartsWith(permission.Name)).ToList();
+    }
+
+    private bool IsDisabledPermission(PermissionGrantInfoDto permissionGrantInfo)
+    {
+        return _disabledPermissions.Any(x => x == permissionGrantInfo);
+    }
 
-        protected virtual Task ClosingModal(ModalClosingEventArgs eventArgs)
+    private string GetShownName(PermissionGrantInfoDto permissionGrantInfo)
+    {
+        if (!IsDisabledPermission(permissionGrantInfo))
         {
-            eventArgs.Cancel = eventArgs.CloseReason == CloseReason.FocusLostClosing;
-            return Task.CompletedTask;
+            return permissionGrantInfo.DisplayName;
         }
+
+        return string.Format(
+            "{0} ({1})",
+            permissionGrantInfo.DisplayName,
+            permissionGrantInfo.GrantedProviders
+                .Where(p => p.ProviderName != _providerName)
+                .Select(p => p.ProviderName)
+                .JoinAsString(", ")
+        );
+    }
+
+    protected virtual Task ClosingModal(ModalClosingEventArgs eventArgs)
+    {
+        eventArgs.Cancel = eventArgs.CloseReason == CloseReason.FocusLostClosing;
+        return Task.CompletedTask;
     }
 }

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

@@ -5,28 +5,27 @@ using Volo.Abp.Validation;
 using Volo.Abp.Validation.Localization;
 using Volo.Abp.VirtualFileSystem;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+[DependsOn(
+    typeof(AbpValidationModule)
+    )]
+public class AbpPermissionManagementDomainSharedModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpValidationModule)
-        )]
-    public class AbpPermissionManagementDomainSharedModule : AbpModule
+    public override void ConfigureServices(ServiceConfigurationContext context)
     {
-        public override void ConfigureServices(ServiceConfigurationContext context)
+        Configure<AbpVirtualFileSystemOptions>(options =>
         {
-            Configure<AbpVirtualFileSystemOptions>(options =>
-            {
-                options.FileSets.AddEmbedded<AbpPermissionManagementDomainSharedModule>();
-            });
+            options.FileSets.AddEmbedded<AbpPermissionManagementDomainSharedModule>();
+        });
 
-            Configure<AbpLocalizationOptions>(options =>
-            {
-                options.Resources
-                    .Add<AbpPermissionManagementResource>("en")
-                    .AddBaseTypes(
-                        typeof(AbpValidationResource)
-                    ).AddVirtualJson("/Volo/Abp/PermissionManagement/Localization/Domain");
-            });
-        }
+        Configure<AbpLocalizationOptions>(options =>
+        {
+            options.Resources
+                .Add<AbpPermissionManagementResource>("en")
+                .AddBaseTypes(
+                    typeof(AbpValidationResource)
+                ).AddVirtualJson("/Volo/Abp/PermissionManagement/Localization/Domain");
+        });
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.Domain.Shared/Volo/Abp/PermissionManagement/Localization/AbpPermissionManagementResource.cs

@@ -1,10 +1,9 @@
 using Volo.Abp.Localization;
 
-namespace Volo.Abp.PermissionManagement.Localization
+namespace Volo.Abp.PermissionManagement.Localization;
+
+[LocalizationResourceName("AbpPermissionManagement")]
+public class AbpPermissionManagementResource
 {
-    [LocalizationResourceName("AbpPermissionManagement")]
-    public class AbpPermissionManagementResource
-    {
-        
-    }
+
 }

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

@@ -1,20 +1,19 @@
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public static class PermissionGrantConsts
 {
-    public static class PermissionGrantConsts
-    {
-        /// <summary>
-        /// Default value: 128
-        /// </summary>
-        public static int MaxNameLength { get; set; } = 128;
+    /// <summary>
+    /// Default value: 128
+    /// </summary>
+    public static int MaxNameLength { get; set; } = 128;
 
-        /// <summary>
-        /// Default value: 64
-        /// </summary>
-        public static int MaxProviderNameLength { get; set; } = 64;
+    /// <summary>
+    /// Default value: 64
+    /// </summary>
+    public static int MaxProviderNameLength { get; set; } = 64;
 
-        /// <summary>
-        /// Default value: 64
-        /// </summary>
-        public static int MaxProviderKeyLength { get; set; } = 64;
-    }
+    /// <summary>
+    /// Default value: 64
+    /// </summary>
+    public static int MaxProviderKeyLength { get; set; } = 64;
 }

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

@@ -1,13 +1,12 @@
 using Volo.Abp.Data;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public static class AbpPermissionManagementDbProperties
 {
-    public static class AbpPermissionManagementDbProperties
-    {
-        public static string DbTablePrefix { get; set; } = AbpCommonDbProperties.DbTablePrefix;
+    public static string DbTablePrefix { get; set; } = AbpCommonDbProperties.DbTablePrefix;
 
-        public static string DbSchema { get; set; } = AbpCommonDbProperties.DbSchema;
+    public static string DbSchema { get; set; } = AbpCommonDbProperties.DbSchema;
 
-        public const string ConnectionStringName = "AbpPermissionManagement";
-    }
+    public const string ConnectionStringName = "AbpPermissionManagement";
 }

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

@@ -7,15 +7,14 @@ using Volo.Abp.Domain;
 using Volo.Abp.Json;
 using Volo.Abp.Modularity;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+[DependsOn(typeof(AbpAuthorizationModule))]
+[DependsOn(typeof(AbpDddDomainModule))]
+[DependsOn(typeof(AbpPermissionManagementDomainSharedModule))]
+[DependsOn(typeof(AbpCachingModule))]
+[DependsOn(typeof(AbpJsonModule))]
+public class AbpPermissionManagementDomainModule : AbpModule
 {
-    [DependsOn(typeof(AbpAuthorizationModule))]
-    [DependsOn(typeof(AbpDddDomainModule))]
-    [DependsOn(typeof(AbpPermissionManagementDomainSharedModule))]
-    [DependsOn(typeof(AbpCachingModule))]
-    [DependsOn(typeof(AbpJsonModule))]
-    public class AbpPermissionManagementDomainModule : AbpModule
-    {
 
-    }
 }

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

@@ -2,15 +2,14 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public interface IPermissionDataSeeder
 {
-    public interface IPermissionDataSeeder
-    {
-        Task SeedAsync(
-            string providerName,
-            string providerKey,
-            IEnumerable<string> grantedPermissions,
-            Guid? tenantId = null
-        );
-    }
+    Task SeedAsync(
+        string providerName,
+        string providerKey,
+        IEnumerable<string> grantedPermissions,
+        Guid? tenantId = null
+    );
 }

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

@@ -4,28 +4,27 @@ using System.Threading;
 using System.Threading.Tasks;
 using Volo.Abp.Domain.Repositories;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public interface IPermissionGrantRepository : IBasicRepository<PermissionGrant, Guid>
 {
-    public interface IPermissionGrantRepository : IBasicRepository<PermissionGrant, Guid>
-    {
-        Task<PermissionGrant> FindAsync(
-            string name,
-            string providerName,
-            string providerKey,
-            CancellationToken cancellationToken = default
-        );
+    Task<PermissionGrant> FindAsync(
+        string name,
+        string providerName,
+        string providerKey,
+        CancellationToken cancellationToken = default
+    );
 
-        Task<List<PermissionGrant>> GetListAsync(
-            string providerName,
-            string providerKey,
-            CancellationToken cancellationToken = default
-        );
+    Task<List<PermissionGrant>> GetListAsync(
+        string providerName,
+        string providerKey,
+        CancellationToken cancellationToken = default
+    );
 
-        Task<List<PermissionGrant>> GetListAsync(
-            string[] names,
-            string providerName,
-            string providerKey,
-            CancellationToken cancellationToken = default
-        );
-    }
+    Task<List<PermissionGrant>> GetListAsync(
+        string[] names,
+        string providerName,
+        string providerKey,
+        CancellationToken cancellationToken = default
+    );
 }

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

@@ -3,28 +3,27 @@ using JetBrains.Annotations;
 using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.DependencyInjection;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public interface IPermissionManagementProvider : ISingletonDependency //TODO: Consider to remove this pre-assumption
 {
-    public interface IPermissionManagementProvider : ISingletonDependency //TODO: Consider to remove this pre-assumption
-    {
-        string Name { get; }
+    string Name { get; }
 
-        Task<PermissionValueProviderGrantInfo> CheckAsync(
-            [NotNull] string name,
-            [NotNull] string providerName,
-            [NotNull] string providerKey
-        );
+    Task<PermissionValueProviderGrantInfo> CheckAsync(
+        [NotNull] string name,
+        [NotNull] string providerName,
+        [NotNull] string providerKey
+    );
 
-        Task<MultiplePermissionValueProviderGrantInfo> CheckAsync(
-            [NotNull] string[] names,
-            [NotNull] string providerName,
-            [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
-        );
-    }
+    Task SetAsync(
+        [NotNull] string name,
+        [NotNull] string providerKey,
+        bool isGranted
+    );
 }

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

@@ -2,22 +2,21 @@
 using System.Threading.Tasks;
 using JetBrains.Annotations;
 
-namespace Volo.Abp.PermissionManagement
-{
-    //TODO: Write extension methods for simple IsGranted check
+namespace Volo.Abp.PermissionManagement;
+
+//TODO: Write extension methods for simple IsGranted check
 
-    public interface IPermissionManager
-    {
-        Task<PermissionWithGrantedProviders> GetAsync(string permissionName, string providerName, string providerKey);
+public interface IPermissionManager
+{
+    Task<PermissionWithGrantedProviders> GetAsync(string permissionName, string providerName, string providerKey);
 
-        Task<MultiplePermissionWithGrantedProviders> GetAsync(string[] permissionNames, string provideName, string providerKey);
+    Task<MultiplePermissionWithGrantedProviders> GetAsync(string[] permissionNames, string provideName, string providerKey);
 
-        Task<List<PermissionWithGrantedProviders>> GetAllAsync([NotNull] string providerName, [NotNull] string providerKey);
+    Task<List<PermissionWithGrantedProviders>> GetAllAsync([NotNull] string providerName, [NotNull] string providerKey);
 
-        Task SetAsync(string permissionName, string providerName, string providerKey, bool isGranted);
+    Task SetAsync(string permissionName, string providerName, string providerKey, bool isGranted);
 
-        Task<PermissionGrant> UpdateProviderKeyAsync(PermissionGrant permissionGrant, string providerKey);
+    Task<PermissionGrant> UpdateProviderKeyAsync(PermissionGrant permissionGrant, string providerKey);
 
-        Task DeleteAsync(string providerName, string providerKey);
-    }
+    Task DeleteAsync(string providerName, string providerKey);
 }

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

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

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

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

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

@@ -5,40 +5,39 @@ using Volo.Abp.Data;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.MultiTenancy;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionDataSeedContributor : IDataSeedContributor, ITransientDependency
 {
-    public class PermissionDataSeedContributor : IDataSeedContributor, ITransientDependency
-    {
-        protected ICurrentTenant CurrentTenant { get; }
-        protected IPermissionDefinitionManager PermissionDefinitionManager { get; }
-        protected IPermissionDataSeeder PermissionDataSeeder { get; }
+    protected ICurrentTenant CurrentTenant { get; }
+    protected IPermissionDefinitionManager PermissionDefinitionManager { get; }
+    protected IPermissionDataSeeder PermissionDataSeeder { get; }
 
-        public PermissionDataSeedContributor(
-            IPermissionDefinitionManager permissionDefinitionManager,
-            IPermissionDataSeeder permissionDataSeeder,
-            ICurrentTenant currentTenant)
-        {
-            PermissionDefinitionManager = permissionDefinitionManager;
-            PermissionDataSeeder = permissionDataSeeder;
-            CurrentTenant = currentTenant;
-        }
+    public PermissionDataSeedContributor(
+        IPermissionDefinitionManager permissionDefinitionManager,
+        IPermissionDataSeeder permissionDataSeeder,
+        ICurrentTenant currentTenant)
+    {
+        PermissionDefinitionManager = permissionDefinitionManager;
+        PermissionDataSeeder = permissionDataSeeder;
+        CurrentTenant = currentTenant;
+    }
 
-        public virtual Task SeedAsync(DataSeedContext context)
-        {
-            var multiTenancySide = CurrentTenant.GetMultiTenancySide();
-            var permissionNames = PermissionDefinitionManager
-                .GetPermissions()
-                .Where(p => p.MultiTenancySide.HasFlag(multiTenancySide))
-                .Where(p => !p.Providers.Any() || p.Providers.Contains(RolePermissionValueProvider.ProviderName))
-                .Select(p => p.Name)
-                .ToArray();
+    public virtual Task SeedAsync(DataSeedContext context)
+    {
+        var multiTenancySide = CurrentTenant.GetMultiTenancySide();
+        var permissionNames = PermissionDefinitionManager
+            .GetPermissions()
+            .Where(p => p.MultiTenancySide.HasFlag(multiTenancySide))
+            .Where(p => !p.Providers.Any() || p.Providers.Contains(RolePermissionValueProvider.ProviderName))
+            .Select(p => p.Name)
+            .ToArray();
 
-            return PermissionDataSeeder.SeedAsync(
-                RolePermissionValueProvider.ProviderName,
-                "admin",
-                permissionNames,
-                context?.TenantId
-            );
-        }
+        return PermissionDataSeeder.SeedAsync(
+            RolePermissionValueProvider.ProviderName,
+            "admin",
+            permissionNames,
+            context?.TenantId
+        );
     }
 }

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

@@ -6,48 +6,47 @@ using Volo.Abp.DependencyInjection;
 using Volo.Abp.Guids;
 using Volo.Abp.MultiTenancy;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionDataSeeder : IPermissionDataSeeder, ITransientDependency
 {
-    public class PermissionDataSeeder : IPermissionDataSeeder, ITransientDependency
-    {
-        protected IPermissionGrantRepository PermissionGrantRepository { get; }
-        protected IGuidGenerator GuidGenerator { get; }
+    protected IPermissionGrantRepository PermissionGrantRepository { get; }
+    protected IGuidGenerator GuidGenerator { get; }
 
-        protected ICurrentTenant CurrentTenant { get; }
+    protected ICurrentTenant CurrentTenant { get; }
 
-        public PermissionDataSeeder(
-            IPermissionGrantRepository permissionGrantRepository,
-            IGuidGenerator guidGenerator,
-            ICurrentTenant currentTenant)
-        {
-            PermissionGrantRepository = permissionGrantRepository;
-            GuidGenerator = guidGenerator;
-            CurrentTenant = currentTenant;
-        }
+    public PermissionDataSeeder(
+        IPermissionGrantRepository permissionGrantRepository,
+        IGuidGenerator guidGenerator,
+        ICurrentTenant currentTenant)
+    {
+        PermissionGrantRepository = permissionGrantRepository;
+        GuidGenerator = guidGenerator;
+        CurrentTenant = currentTenant;
+    }
 
-        public virtual async Task SeedAsync(
-            string providerName,
-            string providerKey,
-            IEnumerable<string> grantedPermissions,
-            Guid? tenantId = null)
+    public virtual async Task SeedAsync(
+        string providerName,
+        string providerKey,
+        IEnumerable<string> grantedPermissions,
+        Guid? tenantId = null)
+    {
+        using (CurrentTenant.Change(tenantId))
         {
-            using (CurrentTenant.Change(tenantId))
-            {
-                var names = grantedPermissions.ToArray();
-                var existsPermissionGrants = (await PermissionGrantRepository.GetListAsync(names, providerName, providerKey)).Select(x => x.Name).ToList();
+            var names = grantedPermissions.ToArray();
+            var existsPermissionGrants = (await PermissionGrantRepository.GetListAsync(names, providerName, providerKey)).Select(x => x.Name).ToList();
 
-                foreach (var permissionName in names.Except(existsPermissionGrants))
-                {
-                    await PermissionGrantRepository.InsertAsync(
-                        new PermissionGrant(
-                            GuidGenerator.Create(),
-                            permissionName,
-                            providerName,
-                            providerKey,
-                            tenantId
-                        )
-                    );
-                }
+            foreach (var permissionName in names.Except(existsPermissionGrants))
+            {
+                await PermissionGrantRepository.InsertAsync(
+                    new PermissionGrant(
+                        GuidGenerator.Create(),
+                        permissionName,
+                        providerName,
+                        providerKey,
+                        tenantId
+                    )
+                );
             }
         }
     }

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

@@ -3,41 +3,40 @@ using JetBrains.Annotations;
 using Volo.Abp.Domain.Entities;
 using Volo.Abp.MultiTenancy;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+//TODO: To aggregate root?
+public class PermissionGrant : Entity<Guid>, IMultiTenant
 {
-    //TODO: To aggregate root?
-    public class PermissionGrant : Entity<Guid>, IMultiTenant
-    {
-        public virtual Guid? TenantId { get; protected set; }
+    public virtual Guid? TenantId { get; protected set; }
 
-        [NotNull]
-        public virtual string Name { get; protected set; }
+    [NotNull]
+    public virtual string Name { get; protected set; }
 
-        [NotNull]
-        public virtual string ProviderName { get; protected set; }
+    [NotNull]
+    public virtual string ProviderName { get; protected set; }
 
-        [CanBeNull]
-        public virtual string ProviderKey { get; protected internal set; }
+    [CanBeNull]
+    public virtual string ProviderKey { get; protected internal set; }
 
-        protected PermissionGrant()
-        {
+    protected PermissionGrant()
+    {
 
-        }
+    }
 
-        public PermissionGrant(
-            Guid id,
-            [NotNull] string name,
-            [NotNull] string providerName ,
-            [CanBeNull] string providerKey,
-            Guid? tenantId = null)
-        {
-            Check.NotNull(name, nameof(name));
+    public PermissionGrant(
+        Guid id,
+        [NotNull] string name,
+        [NotNull] string providerName,
+        [CanBeNull] string providerKey,
+        Guid? tenantId = null)
+    {
+        Check.NotNull(name, nameof(name));
 
-            Id = id;
-            Name = Check.NotNullOrWhiteSpace(name, nameof(name));
-            ProviderName = Check.NotNullOrWhiteSpace(providerName, nameof(providerName));
-            ProviderKey = providerKey;
-            TenantId = tenantId;
-        }
+        Id = id;
+        Name = Check.NotNullOrWhiteSpace(name, nameof(name));
+        ProviderName = Check.NotNullOrWhiteSpace(providerName, nameof(providerName));
+        ProviderKey = providerKey;
+        TenantId = tenantId;
     }
 }

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

@@ -2,34 +2,33 @@
 using System.Linq;
 using Volo.Abp.Text.Formatting;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+[Serializable]
+public class PermissionGrantCacheItem
 {
-    [Serializable]
-    public class PermissionGrantCacheItem
-    {
-        private const string CacheKeyFormat = "pn:{0},pk:{1},n:{2}";
+    private const string CacheKeyFormat = "pn:{0},pk:{1},n:{2}";
 
-        public bool IsGranted { get; set; }
+    public bool IsGranted { get; set; }
 
-        public PermissionGrantCacheItem()
-        {
+    public PermissionGrantCacheItem()
+    {
 
-        }
+    }
 
-        public PermissionGrantCacheItem(bool isGranted)
-        {
-            IsGranted = isGranted;
-        }
+    public PermissionGrantCacheItem(bool isGranted)
+    {
+        IsGranted = isGranted;
+    }
 
-        public static string CalculateCacheKey(string name, string providerName, string providerKey)
-        {
-            return string.Format(CacheKeyFormat, providerName, providerKey, name);
-        }
+    public static string CalculateCacheKey(string name, string providerName, string providerKey)
+    {
+        return string.Format(CacheKeyFormat, providerName, providerKey, name);
+    }
 
-        public static string GetPermissionNameFormCacheKeyOrNull(string cacheKey)
-        {
-            var result = FormattedStringValueExtracter.Extract(cacheKey, CacheKeyFormat, true);
-            return result.IsMatch ? result.Matches.Last().Value : null;
-        }
+    public static string GetPermissionNameFormCacheKeyOrNull(string cacheKey)
+    {
+        var result = FormattedStringValueExtracter.Extract(cacheKey, CacheKeyFormat, true);
+        return result.IsMatch ? result.Matches.Last().Value : null;
     }
 }

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

@@ -5,39 +5,38 @@ using Volo.Abp.Domain.Entities.Events;
 using Volo.Abp.EventBus;
 using Volo.Abp.MultiTenancy;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionGrantCacheItemInvalidator :
+    ILocalEventHandler<EntityChangedEventData<PermissionGrant>>,
+    ITransientDependency
 {
-    public class PermissionGrantCacheItemInvalidator : 
-        ILocalEventHandler<EntityChangedEventData<PermissionGrant>>, 
-        ITransientDependency
-    {
-        protected ICurrentTenant CurrentTenant { get; }
+    protected ICurrentTenant CurrentTenant { get; }
 
-        protected IDistributedCache<PermissionGrantCacheItem> Cache { get; }
+    protected IDistributedCache<PermissionGrantCacheItem> Cache { get; }
 
-        public PermissionGrantCacheItemInvalidator(IDistributedCache<PermissionGrantCacheItem> cache, ICurrentTenant currentTenant)
-        {
-            Cache = cache;
-            CurrentTenant = currentTenant;
-        }
-
-        public virtual async Task HandleEventAsync(EntityChangedEventData<PermissionGrant> eventData)
-        {
-            var cacheKey = CalculateCacheKey(
-                eventData.Entity.Name,
-                eventData.Entity.ProviderName,
-                eventData.Entity.ProviderKey
-            );
+    public PermissionGrantCacheItemInvalidator(IDistributedCache<PermissionGrantCacheItem> cache, ICurrentTenant currentTenant)
+    {
+        Cache = cache;
+        CurrentTenant = currentTenant;
+    }
 
-            using (CurrentTenant.Change(eventData.Entity.TenantId))
-            {
-                await Cache.RemoveAsync(cacheKey);
-            }
-        }
+    public virtual async Task HandleEventAsync(EntityChangedEventData<PermissionGrant> eventData)
+    {
+        var cacheKey = CalculateCacheKey(
+            eventData.Entity.Name,
+            eventData.Entity.ProviderName,
+            eventData.Entity.ProviderKey
+        );
 
-        protected virtual string CalculateCacheKey(string name, string providerName, string providerKey)
+        using (CurrentTenant.Change(eventData.Entity.TenantId))
         {
-            return PermissionGrantCacheItem.CalculateCacheKey(name, providerName, providerKey);
+            await Cache.RemoveAsync(cacheKey);
         }
     }
-}
+
+    protected virtual string CalculateCacheKey(string name, string providerName, string providerKey)
+    {
+        return PermissionGrantCacheItem.CalculateCacheKey(name, providerName, providerKey);
+    }
+}

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

@@ -1,18 +1,17 @@
 using System.Collections.Generic;
 using Volo.Abp.Collections;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionManagementOptions
 {
-    public class PermissionManagementOptions
-    {
-        public ITypeList<IPermissionManagementProvider> ManagementProviders { get; }
+    public ITypeList<IPermissionManagementProvider> ManagementProviders { get; }
 
-        public Dictionary<string, string> ProviderPolicies { get; }
+    public Dictionary<string, string> ProviderPolicies { get; }
 
-        public PermissionManagementOptions()
-        {
-            ManagementProviders = new TypeList<IPermissionManagementProvider>();
-            ProviderPolicies = new Dictionary<string, string>();
-        }
+    public PermissionManagementOptions()
+    {
+        ManagementProviders = new TypeList<IPermissionManagementProvider>();
+        ProviderPolicies = new Dictionary<string, string>();
     }
 }

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

@@ -3,89 +3,88 @@ using System.Threading.Tasks;
 using Volo.Abp.Guids;
 using Volo.Abp.MultiTenancy;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public abstract class PermissionManagementProvider : IPermissionManagementProvider
 {
-    public abstract class PermissionManagementProvider : IPermissionManagementProvider
-    {
-        public abstract string Name { get; }
+    public abstract string Name { get; }
 
-        protected IPermissionGrantRepository PermissionGrantRepository { get; }
+    protected IPermissionGrantRepository PermissionGrantRepository { get; }
 
-        protected IGuidGenerator GuidGenerator { get; }
+    protected IGuidGenerator GuidGenerator { get; }
 
-        protected ICurrentTenant CurrentTenant { get; }
+    protected ICurrentTenant CurrentTenant { get; }
 
-        protected PermissionManagementProvider(
-            IPermissionGrantRepository permissionGrantRepository,
-            IGuidGenerator guidGenerator,
-            ICurrentTenant currentTenant)
-        {
-            PermissionGrantRepository = permissionGrantRepository;
-            GuidGenerator = guidGenerator;
-            CurrentTenant = currentTenant;
-        }
+    protected PermissionManagementProvider(
+        IPermissionGrantRepository permissionGrantRepository,
+        IGuidGenerator guidGenerator,
+        ICurrentTenant currentTenant)
+    {
+        PermissionGrantRepository = permissionGrantRepository;
+        GuidGenerator = guidGenerator;
+        CurrentTenant = currentTenant;
+    }
 
-        public virtual async Task<PermissionValueProviderGrantInfo> CheckAsync(string name, string providerName, string providerKey)
-        {
-            var multiplePermissionValueProviderGrantInfo = await CheckAsync(new[] {name}, providerName, providerKey);
+    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;
-        }
+        return multiplePermissionValueProviderGrantInfo.Result.First().Value;
+    }
 
-        public virtual async Task<MultiplePermissionValueProviderGrantInfo> CheckAsync(string[] names, string providerName, string providerKey)
+    public virtual async Task<MultiplePermissionValueProviderGrantInfo> CheckAsync(string[] names, string providerName, string providerKey)
+    {
+        var multiplePermissionValueProviderGrantInfo = new MultiplePermissionValueProviderGrantInfo(names);
+        if (providerName != Name)
         {
-            var multiplePermissionValueProviderGrantInfo = new MultiplePermissionValueProviderGrantInfo(names);
-            if (providerName != Name)
-            {
-                return multiplePermissionValueProviderGrantInfo;
-            }
-
-            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)
+        var permissionGrants = await PermissionGrantRepository.GetListAsync(names, providerName, providerKey);
+
+        foreach (var permissionName in names)
         {
-            return isGranted
-                ? GrantAsync(name, providerKey)
-                : RevokeAsync(name, providerKey);
+            var isGrant = permissionGrants.Any(x => x.Name == permissionName);
+            multiplePermissionValueProviderGrantInfo.Result[permissionName] = new PermissionValueProviderGrantInfo(isGrant, providerKey);
         }
 
-        protected virtual async Task GrantAsync(string name, string providerKey)
+        return multiplePermissionValueProviderGrantInfo;
+    }
+
+    public virtual Task SetAsync(string name, string providerKey, bool isGranted)
+    {
+        return isGranted
+            ? GrantAsync(name, providerKey)
+            : RevokeAsync(name, providerKey);
+    }
+
+    protected virtual async Task GrantAsync(string name, string providerKey)
+    {
+        var permissionGrant = await PermissionGrantRepository.FindAsync(name, Name, providerKey);
+        if (permissionGrant != null)
         {
-            var permissionGrant = await PermissionGrantRepository.FindAsync(name, Name, providerKey);
-            if (permissionGrant != null)
-            {
-                return;
-            }
-
-            await PermissionGrantRepository.InsertAsync(
-                new PermissionGrant(
-                    GuidGenerator.Create(),
-                    name,
-                    Name,
-                    providerKey,
-                    CurrentTenant.Id
-                )
-            );
+            return;
         }
 
-        protected virtual async Task RevokeAsync(string name, string providerKey)
-        {
-            var permissionGrant = await PermissionGrantRepository.FindAsync(name, Name, providerKey);
-            if (permissionGrant == null)
-            {
-                return;
-            }
+        await PermissionGrantRepository.InsertAsync(
+            new PermissionGrant(
+                GuidGenerator.Create(),
+                name,
+                Name,
+                providerKey,
+                CurrentTenant.Id
+            )
+        );
+    }
 
-            await PermissionGrantRepository.DeleteAsync(permissionGrant);
+    protected virtual async Task RevokeAsync(string name, string providerKey)
+    {
+        var permissionGrant = await PermissionGrantRepository.FindAsync(name, Name, providerKey);
+        if (permissionGrant == null)
+        {
+            return;
         }
+
+        await PermissionGrantRepository.DeleteAsync(permissionGrant);
     }
 }

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

@@ -11,190 +11,189 @@ using Volo.Abp.Guids;
 using Volo.Abp.MultiTenancy;
 using Volo.Abp.SimpleStateChecking;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionManager : IPermissionManager, ISingletonDependency
 {
-    public class PermissionManager : IPermissionManager, ISingletonDependency
-    {
-        protected IPermissionGrantRepository PermissionGrantRepository { get; }
+    protected IPermissionGrantRepository PermissionGrantRepository { get; }
+
+    protected IPermissionDefinitionManager PermissionDefinitionManager { get; }
 
-        protected IPermissionDefinitionManager PermissionDefinitionManager { get; }
+    protected ISimpleStateCheckerManager<PermissionDefinition> SimpleStateCheckerManager { get; }
 
-        protected ISimpleStateCheckerManager<PermissionDefinition> SimpleStateCheckerManager { get; }
+    protected IGuidGenerator GuidGenerator { get; }
 
-        protected IGuidGenerator GuidGenerator { get; }
+    protected ICurrentTenant CurrentTenant { get; }
 
-        protected ICurrentTenant CurrentTenant { get; }
+    protected IReadOnlyList<IPermissionManagementProvider> ManagementProviders => _lazyProviders.Value;
 
-        protected IReadOnlyList<IPermissionManagementProvider> ManagementProviders => _lazyProviders.Value;
+    protected PermissionManagementOptions Options { get; }
 
-        protected PermissionManagementOptions Options { get; }
+    protected IDistributedCache<PermissionGrantCacheItem> Cache { get; }
 
-        protected IDistributedCache<PermissionGrantCacheItem> Cache { get; }
+    private readonly Lazy<List<IPermissionManagementProvider>> _lazyProviders;
+
+    public PermissionManager(
+        IPermissionDefinitionManager permissionDefinitionManager,
+        ISimpleStateCheckerManager<PermissionDefinition> simpleStateCheckerManager,
+        IPermissionGrantRepository permissionGrantRepository,
+        IServiceProvider serviceProvider,
+        IGuidGenerator guidGenerator,
+        IOptions<PermissionManagementOptions> options,
+        ICurrentTenant currentTenant,
+        IDistributedCache<PermissionGrantCacheItem> cache)
+    {
+        GuidGenerator = guidGenerator;
+        CurrentTenant = currentTenant;
+        Cache = cache;
+        SimpleStateCheckerManager = simpleStateCheckerManager;
+        PermissionGrantRepository = permissionGrantRepository;
+        PermissionDefinitionManager = permissionDefinitionManager;
+        Options = options.Value;
+
+        _lazyProviders = new Lazy<List<IPermissionManagementProvider>>(
+            () => Options
+                .ManagementProviders
+                .Select(c => serviceProvider.GetRequiredService(c) as IPermissionManagementProvider)
+                .ToList(),
+            true
+        );
+    }
+
+    public virtual async Task<PermissionWithGrantedProviders> GetAsync(string permissionName, string providerName, string providerKey)
+    {
+        return await GetInternalAsync(PermissionDefinitionManager.Get(permissionName), providerName, providerKey);
+    }
 
-        private readonly Lazy<List<IPermissionManagementProvider>> _lazyProviders;
+    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 permissionDefinitions = PermissionDefinitionManager.GetPermissions().ToArray();
+
+        var multiplePermissionWithGrantedProviders = await GetInternalAsync(permissionDefinitions, providerName, providerKey);
+
+        return multiplePermissionWithGrantedProviders.Result;
+
+    }
 
-        public PermissionManager(
-            IPermissionDefinitionManager permissionDefinitionManager,
-            ISimpleStateCheckerManager<PermissionDefinition> simpleStateCheckerManager,
-            IPermissionGrantRepository permissionGrantRepository,
-            IServiceProvider serviceProvider,
-            IGuidGenerator guidGenerator,
-            IOptions<PermissionManagementOptions> options,
-            ICurrentTenant currentTenant,
-            IDistributedCache<PermissionGrantCacheItem> cache)
+    public virtual async Task SetAsync(string permissionName, string providerName, string providerKey, bool isGranted)
+    {
+        var permission = PermissionDefinitionManager.Get(permissionName);
+
+        if (!permission.IsEnabled || !await SimpleStateCheckerManager.IsEnabledAsync(permission))
         {
-            GuidGenerator = guidGenerator;
-            CurrentTenant = currentTenant;
-            Cache = cache;
-            SimpleStateCheckerManager = simpleStateCheckerManager;
-            PermissionGrantRepository = permissionGrantRepository;
-            PermissionDefinitionManager = permissionDefinitionManager;
-            Options = options.Value;
-
-            _lazyProviders = new Lazy<List<IPermissionManagementProvider>>(
-                () => Options
-                    .ManagementProviders
-                    .Select(c => serviceProvider.GetRequiredService(c) as IPermissionManagementProvider)
-                    .ToList(),
-                true
-            );
+            //TODO: BusinessException
+            throw new ApplicationException($"The permission named '{permission.Name}' is disabled!");
         }
 
-        public virtual async Task<PermissionWithGrantedProviders> GetAsync(string permissionName, string providerName, string providerKey)
+        if (permission.Providers.Any() && !permission.Providers.Contains(providerName))
         {
-            return await GetInternalAsync(PermissionDefinitionManager.Get(permissionName), providerName, providerKey);
+            //TODO: BusinessException
+            throw new ApplicationException($"The permission named '{permission.Name}' has not compatible with the provider named '{providerName}'");
         }
 
-        public virtual async Task<MultiplePermissionWithGrantedProviders> GetAsync(string[] permissionNames, string providerName, string providerKey)
+        if (!permission.MultiTenancySide.HasFlag(CurrentTenant.GetMultiTenancySide()))
         {
-            var permissionDefinitions = permissionNames.Select(x => PermissionDefinitionManager.Get(x)).ToArray();
-            return await GetInternalAsync(permissionDefinitions, providerName, providerKey);
+            //TODO: BusinessException
+            throw new ApplicationException($"The permission named '{permission.Name}' has multitenancy side '{permission.MultiTenancySide}' which is not compatible with the current multitenancy side '{CurrentTenant.GetMultiTenancySide()}'");
         }
 
-        public virtual async Task<List<PermissionWithGrantedProviders>> GetAllAsync(string providerName, string providerKey)
+        var currentGrantInfo = await GetInternalAsync(permission, providerName, providerKey);
+        if (currentGrantInfo.IsGranted == isGranted)
         {
-            var permissionDefinitions = PermissionDefinitionManager.GetPermissions().ToArray();
-
-            var multiplePermissionWithGrantedProviders = await GetInternalAsync(permissionDefinitions, providerName, providerKey);
-
-            return multiplePermissionWithGrantedProviders.Result;
-
+            return;
         }
 
-        public virtual async Task SetAsync(string permissionName, string providerName, string providerKey, bool isGranted)
+        var provider = ManagementProviders.FirstOrDefault(m => m.Name == providerName);
+        if (provider == null)
         {
-            var permission = PermissionDefinitionManager.Get(permissionName);
+            //TODO: BusinessException
+            throw new AbpException("Unknown permission management provider: " + providerName);
+        }
 
-            if (!permission.IsEnabled || !await SimpleStateCheckerManager.IsEnabledAsync(permission))
-            {
-                //TODO: BusinessException
-                throw new ApplicationException($"The permission named '{permission.Name}' is disabled!");
-            }
+        await provider.SetAsync(permissionName, providerKey, isGranted);
+    }
 
-            if (permission.Providers.Any() && !permission.Providers.Contains(providerName))
-            {
-                //TODO: BusinessException
-                throw new ApplicationException($"The permission named '{permission.Name}' has not compatible with the provider named '{providerName}'");
-            }
+    public virtual async Task<PermissionGrant> UpdateProviderKeyAsync(PermissionGrant permissionGrant, string providerKey)
+    {
+        using (CurrentTenant.Change(permissionGrant.TenantId))
+        {
+            //Invalidating the cache for the old key
+            await Cache.RemoveAsync(
+                PermissionGrantCacheItem.CalculateCacheKey(
+                    permissionGrant.Name,
+                    permissionGrant.ProviderName,
+                    permissionGrant.ProviderKey
+                )
+            );
+        }
 
-            if (!permission.MultiTenancySide.HasFlag(CurrentTenant.GetMultiTenancySide()))
-            {
-                //TODO: BusinessException
-                throw new ApplicationException($"The permission named '{permission.Name}' has multitenancy side '{permission.MultiTenancySide}' which is not compatible with the current multitenancy side '{CurrentTenant.GetMultiTenancySide()}'");
-            }
+        permissionGrant.ProviderKey = providerKey;
+        return await PermissionGrantRepository.UpdateAsync(permissionGrant);
+    }
 
-            var currentGrantInfo = await GetInternalAsync(permission, providerName, providerKey);
-            if (currentGrantInfo.IsGranted == isGranted)
-            {
-                return;
-            }
+    public virtual async Task DeleteAsync(string providerName, string providerKey)
+    {
+        var permissionGrants = await PermissionGrantRepository.GetListAsync(providerName, providerKey);
+        foreach (var permissionGrant in permissionGrants)
+        {
+            await PermissionGrantRepository.DeleteAsync(permissionGrant);
+        }
+    }
 
-            var provider = ManagementProviders.FirstOrDefault(m => m.Name == providerName);
-            if (provider == null)
-            {
-                //TODO: BusinessException
-                throw new AbpException("Unknown permission management provider: " + providerName);
-            }
+    protected virtual async Task<PermissionWithGrantedProviders> GetInternalAsync(PermissionDefinition permission, string providerName, string providerKey)
+    {
+        var multiplePermissionWithGrantedProviders = await GetInternalAsync(new PermissionDefinition[] { permission }, providerName, providerKey);
 
-            await provider.SetAsync(permissionName, providerKey, isGranted);
-        }
+        return multiplePermissionWithGrantedProviders.Result.First();
+    }
 
-        public virtual async Task<PermissionGrant> UpdateProviderKeyAsync(PermissionGrant permissionGrant, string providerKey)
-        {
-            using (CurrentTenant.Change(permissionGrant.TenantId))
-            {
-                //Invalidating the cache for the old key
-                await Cache.RemoveAsync(
-                    PermissionGrantCacheItem.CalculateCacheKey(
-                        permissionGrant.Name,
-                        permissionGrant.ProviderName,
-                        permissionGrant.ProviderKey
-                    )
-                );
-            }
+    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);
 
-            permissionGrant.ProviderKey = providerKey;
-            return await PermissionGrantRepository.UpdateAsync(permissionGrant);
-        }
+        var neededCheckPermissions = new List<PermissionDefinition>();
 
-        public virtual async Task DeleteAsync(string providerName, string providerKey)
+        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)))
         {
-            var permissionGrants = await PermissionGrantRepository.GetListAsync(providerName, providerKey);
-            foreach (var permissionGrant in permissionGrants)
+            if (await SimpleStateCheckerManager.IsEnabledAsync(permission))
             {
-                await PermissionGrantRepository.DeleteAsync(permissionGrant);
+                neededCheckPermissions.Add(permission);
             }
         }
 
-        protected virtual async Task<PermissionWithGrantedProviders> GetInternalAsync(PermissionDefinition permission, string providerName, string providerKey)
+        if (!neededCheckPermissions.Any())
         {
-            var multiplePermissionWithGrantedProviders = await GetInternalAsync(new PermissionDefinition[]{permission}, providerName, providerKey);
-
-            return multiplePermissionWithGrantedProviders.Result.First();
+            return multiplePermissionWithGrantedProviders;
         }
 
-        protected virtual async Task<MultiplePermissionWithGrantedProviders> GetInternalAsync(PermissionDefinition[] permissions, string providerName, string providerKey)
+        foreach (var provider in ManagementProviders)
         {
-            var permissionNames = permissions.Select(x => x.Name).ToArray();
-            var multiplePermissionWithGrantedProviders = new MultiplePermissionWithGrantedProviders(permissionNames);
+            permissionNames = neededCheckPermissions.Select(x => x.Name).ToArray();
+            var multiplePermissionValueProviderGrantInfo = await provider.CheckAsync(permissionNames, providerName, providerKey);
 
-            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)))
+            foreach (var providerResultDict in multiplePermissionValueProviderGrantInfo.Result)
             {
-                if (await SimpleStateCheckerManager.IsEnabledAsync(permission))
+                if (providerResultDict.Value.IsGranted)
                 {
-                    neededCheckPermissions.Add(permission);
-                }
-            }
-
-            if (!neededCheckPermissions.Any())
-            {
-                return multiplePermissionWithGrantedProviders;
-            }
-
-            foreach (var provider in ManagementProviders)
-            {
-                permissionNames = neededCheckPermissions.Select(x => x.Name).ToArray();
-                var multiplePermissionValueProviderGrantInfo = await provider.CheckAsync(permissionNames, providerName, providerKey);
+                    var permissionWithGrantedProvider = multiplePermissionWithGrantedProviders.Result
+                        .First(x => x.Name == providerResultDict.Key);
 
-                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));
-                    }
+                    permissionWithGrantedProvider.IsGranted = true;
+                    permissionWithGrantedProvider.Providers.Add(new PermissionValueProviderInfo(provider.Name, providerResultDict.Value.ProviderKey));
                 }
             }
-
-            return multiplePermissionWithGrantedProviders;
         }
+
+        return multiplePermissionWithGrantedProviders;
     }
 }

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

@@ -7,206 +7,205 @@ using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.Caching;
 using Volo.Abp.DependencyInjection;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionStore : IPermissionStore, ITransientDependency
 {
-    public class PermissionStore : IPermissionStore, ITransientDependency
+    public ILogger<PermissionStore> Logger { get; set; }
+
+    protected IPermissionGrantRepository PermissionGrantRepository { get; }
+
+    protected IPermissionDefinitionManager PermissionDefinitionManager { get; }
+
+    protected IDistributedCache<PermissionGrantCacheItem> Cache { get; }
+
+    public PermissionStore(
+        IPermissionGrantRepository permissionGrantRepository,
+        IDistributedCache<PermissionGrantCacheItem> cache,
+        IPermissionDefinitionManager permissionDefinitionManager)
     {
-        public ILogger<PermissionStore> Logger { get; set; }
+        PermissionGrantRepository = permissionGrantRepository;
+        Cache = cache;
+        PermissionDefinitionManager = permissionDefinitionManager;
+        Logger = NullLogger<PermissionStore>.Instance;
+    }
 
-        protected IPermissionGrantRepository PermissionGrantRepository { get; }
+    public virtual async Task<bool> IsGrantedAsync(string name, string providerName, string providerKey)
+    {
+        return (await GetCacheItemAsync(name, providerName, providerKey)).IsGranted;
+    }
 
-        protected IPermissionDefinitionManager PermissionDefinitionManager { get; }
+    protected virtual async Task<PermissionGrantCacheItem> GetCacheItemAsync(
+        string name,
+        string providerName,
+        string providerKey)
+    {
+        var cacheKey = CalculateCacheKey(name, providerName, providerKey);
 
-        protected IDistributedCache<PermissionGrantCacheItem> Cache { get; }
+        Logger.LogDebug($"PermissionStore.GetCacheItemAsync: {cacheKey}");
 
-        public PermissionStore(
-            IPermissionGrantRepository permissionGrantRepository,
-            IDistributedCache<PermissionGrantCacheItem> cache,
-            IPermissionDefinitionManager permissionDefinitionManager)
-        {
-            PermissionGrantRepository = permissionGrantRepository;
-            Cache = cache;
-            PermissionDefinitionManager = permissionDefinitionManager;
-            Logger = NullLogger<PermissionStore>.Instance;
-        }
+        var cacheItem = await Cache.GetAsync(cacheKey);
 
-        public virtual async Task<bool> IsGrantedAsync(string name, string providerName, string providerKey)
+        if (cacheItem != null)
         {
-            return (await GetCacheItemAsync(name, providerName, providerKey)).IsGranted;
+            Logger.LogDebug($"Found in the cache: {cacheKey}");
+            return cacheItem;
         }
 
-        protected virtual async Task<PermissionGrantCacheItem> GetCacheItemAsync(
-            string name,
-            string providerName,
-            string providerKey)
-        {
-            var cacheKey = CalculateCacheKey(name, providerName, providerKey);
+        Logger.LogDebug($"Not found in the cache: {cacheKey}");
 
-            Logger.LogDebug($"PermissionStore.GetCacheItemAsync: {cacheKey}");
+        cacheItem = new PermissionGrantCacheItem(false);
 
-            var cacheItem = await Cache.GetAsync(cacheKey);
+        await SetCacheItemsAsync(providerName, providerKey, name, cacheItem);
 
-            if (cacheItem != null)
-            {
-                Logger.LogDebug($"Found in the cache: {cacheKey}");
-                return cacheItem;
-            }
+        return cacheItem;
+    }
+
+    protected virtual async Task SetCacheItemsAsync(
+        string providerName,
+        string providerKey,
+        string currentName,
+        PermissionGrantCacheItem currentCacheItem)
+    {
+        var permissions = PermissionDefinitionManager.GetPermissions();
 
-            Logger.LogDebug($"Not found in the cache: {cacheKey}");
+        Logger.LogDebug($"Getting all granted permissions from the repository for this provider name,key: {providerName},{providerKey}");
 
-            cacheItem = new PermissionGrantCacheItem(false);
+        var grantedPermissionsHashSet = new HashSet<string>(
+            (await PermissionGrantRepository.GetListAsync(providerName, providerKey)).Select(p => p.Name)
+        );
 
-            await SetCacheItemsAsync(providerName, providerKey, name, cacheItem);
+        Logger.LogDebug($"Setting the cache items. Count: {permissions.Count}");
 
-            return cacheItem;
-        }
+        var cacheItems = new List<KeyValuePair<string, PermissionGrantCacheItem>>();
 
-        protected virtual async Task SetCacheItemsAsync(
-            string providerName,
-            string providerKey,
-            string currentName,
-            PermissionGrantCacheItem currentCacheItem)
+        foreach (var permission in permissions)
         {
-            var permissions = PermissionDefinitionManager.GetPermissions();
+            var isGranted = grantedPermissionsHashSet.Contains(permission.Name);
 
-            Logger.LogDebug($"Getting all granted permissions from the repository for this provider name,key: {providerName},{providerKey}");
-
-            var grantedPermissionsHashSet = new HashSet<string>(
-                (await PermissionGrantRepository.GetListAsync(providerName, providerKey)).Select(p => p.Name)
+            cacheItems.Add(new KeyValuePair<string, PermissionGrantCacheItem>(
+                CalculateCacheKey(permission.Name, providerName, providerKey),
+                new PermissionGrantCacheItem(isGranted))
             );
 
-            Logger.LogDebug($"Setting the cache items. Count: {permissions.Count}");
-
-            var cacheItems = new List<KeyValuePair<string, PermissionGrantCacheItem>>();
-
-            foreach (var permission in permissions)
+            if (permission.Name == currentName)
             {
-                var isGranted = grantedPermissionsHashSet.Contains(permission.Name);
-
-                cacheItems.Add(new KeyValuePair<string, PermissionGrantCacheItem>(
-                    CalculateCacheKey(permission.Name, providerName, providerKey),
-                    new PermissionGrantCacheItem(isGranted))
-                );
-
-                if (permission.Name == currentName)
-                {
-                    currentCacheItem.IsGranted = isGranted;
-                }
+                currentCacheItem.IsGranted = isGranted;
             }
-
-            await Cache.SetManyAsync(cacheItems);
-
-            Logger.LogDebug($"Finished setting the cache items. Count: {permissions.Count}");
         }
 
-        public virtual async Task<MultiplePermissionGrantResult> IsGrantedAsync(string[] names, string providerName, string providerKey)
-        {
-            Check.NotNullOrEmpty(names, nameof(names));
+        await Cache.SetManyAsync(cacheItems);
 
-            var result = new MultiplePermissionGrantResult();
+        Logger.LogDebug($"Finished setting the cache items. Count: {permissions.Count}");
+    }
 
-            if (names.Length == 1)
-            {
-                var name = names.First();
-                result.Result.Add(name,
-                    await IsGrantedAsync(names.First(), providerName, providerKey)
-                        ? PermissionGrantResult.Granted
-                        : PermissionGrantResult.Undefined);
-                return result;
-            }
+    public virtual async Task<MultiplePermissionGrantResult> IsGrantedAsync(string[] names, string providerName, string providerKey)
+    {
+        Check.NotNullOrEmpty(names, nameof(names));
 
-            var cacheItems = await GetCacheItemsAsync(names, providerName, providerKey);
-            foreach (var item in cacheItems)
-            {
-                result.Result.Add(GetPermissionNameFormCacheKeyOrNull(item.Key),
-                    item.Value != null && item.Value.IsGranted
-                        ? PermissionGrantResult.Granted
-                        : PermissionGrantResult.Undefined);
-            }
+        var result = new MultiplePermissionGrantResult();
 
+        if (names.Length == 1)
+        {
+            var name = names.First();
+            result.Result.Add(name,
+                await IsGrantedAsync(names.First(), providerName, providerKey)
+                    ? PermissionGrantResult.Granted
+                    : PermissionGrantResult.Undefined);
             return result;
         }
 
-        protected virtual async Task<List<KeyValuePair<string, PermissionGrantCacheItem>>> GetCacheItemsAsync(
-            string[] names,
-            string providerName,
-            string providerKey)
+        var cacheItems = await GetCacheItemsAsync(names, providerName, providerKey);
+        foreach (var item in cacheItems)
         {
-            var cacheKeys = names.Select(x => CalculateCacheKey(x, providerName, providerKey)).ToList();
+            result.Result.Add(GetPermissionNameFormCacheKeyOrNull(item.Key),
+                item.Value != null && item.Value.IsGranted
+                    ? PermissionGrantResult.Granted
+                    : PermissionGrantResult.Undefined);
+        }
 
-            Logger.LogDebug($"PermissionStore.GetCacheItemAsync: {string.Join(",", cacheKeys)}");
+        return result;
+    }
 
-            var cacheItems = (await Cache.GetManyAsync(cacheKeys)).ToList();
-            if (cacheItems.All(x => x.Value != null))
-            {
-                Logger.LogDebug($"Found in the cache: {string.Join(",", cacheKeys)}");
-                return cacheItems;
-            }
+    protected virtual async Task<List<KeyValuePair<string, PermissionGrantCacheItem>>> GetCacheItemsAsync(
+        string[] names,
+        string providerName,
+        string providerKey)
+    {
+        var cacheKeys = names.Select(x => CalculateCacheKey(x, providerName, providerKey)).ToList();
 
-            var notCacheKeys = cacheItems.Where(x => x.Value == null).Select(x => x.Key).ToList();
+        Logger.LogDebug($"PermissionStore.GetCacheItemAsync: {string.Join(",", cacheKeys)}");
 
-            Logger.LogDebug($"Not found in the cache: {string.Join(",", notCacheKeys)}");
+        var cacheItems = (await Cache.GetManyAsync(cacheKeys)).ToList();
+        if (cacheItems.All(x => x.Value != null))
+        {
+            Logger.LogDebug($"Found in the cache: {string.Join(",", cacheKeys)}");
+            return cacheItems;
+        }
 
-            var newCacheItems = await SetCacheItemsAsync(providerName, providerKey, notCacheKeys);
+        var notCacheKeys = cacheItems.Where(x => x.Value == null).Select(x => x.Key).ToList();
 
-            var result = new List<KeyValuePair<string, PermissionGrantCacheItem>>();
-            foreach (var key in cacheKeys)
-            {
-                var item = newCacheItems.FirstOrDefault(x => x.Key == key);
-                if (item.Value == null)
-                {
-                    item = cacheItems.FirstOrDefault(x => x.Key == key);
-                }
+        Logger.LogDebug($"Not found in the cache: {string.Join(",", notCacheKeys)}");
+
+        var newCacheItems = await SetCacheItemsAsync(providerName, providerKey, notCacheKeys);
 
-                result.Add(new KeyValuePair<string, PermissionGrantCacheItem>(key, item.Value));
+        var result = new List<KeyValuePair<string, PermissionGrantCacheItem>>();
+        foreach (var key in cacheKeys)
+        {
+            var item = newCacheItems.FirstOrDefault(x => x.Key == key);
+            if (item.Value == null)
+            {
+                item = cacheItems.FirstOrDefault(x => x.Key == key);
             }
 
-            return result;
+            result.Add(new KeyValuePair<string, PermissionGrantCacheItem>(key, item.Value));
         }
 
-        protected virtual async Task<List<KeyValuePair<string, PermissionGrantCacheItem>>> SetCacheItemsAsync(
-            string providerName,
-            string providerKey,
-            List<string> notCacheKeys)
-        {
-            var permissions = PermissionDefinitionManager.GetPermissions().Where(x => notCacheKeys.Any(k => GetPermissionNameFormCacheKeyOrNull(k) == x.Name)).ToList();
+        return result;
+    }
+
+    protected virtual async Task<List<KeyValuePair<string, PermissionGrantCacheItem>>> SetCacheItemsAsync(
+        string providerName,
+        string providerKey,
+        List<string> notCacheKeys)
+    {
+        var permissions = PermissionDefinitionManager.GetPermissions().Where(x => notCacheKeys.Any(k => GetPermissionNameFormCacheKeyOrNull(k) == x.Name)).ToList();
 
-            Logger.LogDebug($"Getting not cache granted permissions from the repository for this provider name,key: {providerName},{providerKey}");
+        Logger.LogDebug($"Getting not cache granted permissions from the repository for this provider name,key: {providerName},{providerKey}");
 
-            var grantedPermissionsHashSet = new HashSet<string>(
-                (await PermissionGrantRepository.GetListAsync(notCacheKeys.Select(GetPermissionNameFormCacheKeyOrNull).ToArray(), providerName, providerKey)).Select(p => p.Name)
-            );
+        var grantedPermissionsHashSet = new HashSet<string>(
+            (await PermissionGrantRepository.GetListAsync(notCacheKeys.Select(GetPermissionNameFormCacheKeyOrNull).ToArray(), providerName, providerKey)).Select(p => p.Name)
+        );
 
-            Logger.LogDebug($"Setting the cache items. Count: {permissions.Count}");
+        Logger.LogDebug($"Setting the cache items. Count: {permissions.Count}");
 
-            var cacheItems = new List<KeyValuePair<string, PermissionGrantCacheItem>>();
+        var cacheItems = new List<KeyValuePair<string, PermissionGrantCacheItem>>();
 
-            foreach (var permission in permissions)
-            {
-                var isGranted = grantedPermissionsHashSet.Contains(permission.Name);
+        foreach (var permission in permissions)
+        {
+            var isGranted = grantedPermissionsHashSet.Contains(permission.Name);
 
-                cacheItems.Add(new KeyValuePair<string, PermissionGrantCacheItem>(
-                    CalculateCacheKey(permission.Name, providerName, providerKey),
-                    new PermissionGrantCacheItem(isGranted))
-                );
-            }
+            cacheItems.Add(new KeyValuePair<string, PermissionGrantCacheItem>(
+                CalculateCacheKey(permission.Name, providerName, providerKey),
+                new PermissionGrantCacheItem(isGranted))
+            );
+        }
 
-            await Cache.SetManyAsync(cacheItems);
+        await Cache.SetManyAsync(cacheItems);
 
-            Logger.LogDebug($"Finished setting the cache items. Count: {permissions.Count}");
+        Logger.LogDebug($"Finished setting the cache items. Count: {permissions.Count}");
 
-            return cacheItems;
-        }
+        return cacheItems;
+    }
 
-        protected virtual string CalculateCacheKey(string name, string providerName, string providerKey)
-        {
-            return PermissionGrantCacheItem.CalculateCacheKey(name, providerName, providerKey);
-        }
+    protected virtual string CalculateCacheKey(string name, string providerName, string providerKey)
+    {
+        return PermissionGrantCacheItem.CalculateCacheKey(name, providerName, providerKey);
+    }
 
-        protected virtual string GetPermissionNameFormCacheKeyOrNull(string key)
-        {
-            //TODO: throw ex when name is null?
-            return PermissionGrantCacheItem.GetPermissionNameFormCacheKeyOrNull(key);
-        }
+    protected virtual string GetPermissionNameFormCacheKeyOrNull(string key)
+    {
+        //TODO: throw ex when name is null?
+        return PermissionGrantCacheItem.GetPermissionNameFormCacheKeyOrNull(key);
     }
 }

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

@@ -1,19 +1,18 @@
 using JetBrains.Annotations;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionValueProviderGrantInfo //TODO: Rename to PermissionGrantInfo
 {
-    public class PermissionValueProviderGrantInfo //TODO: Rename to PermissionGrantInfo
-    {
-        public static PermissionValueProviderGrantInfo NonGranted { get; } = new PermissionValueProviderGrantInfo(false);
+    public static PermissionValueProviderGrantInfo NonGranted { get; } = new PermissionValueProviderGrantInfo(false);
 
-        public virtual bool IsGranted { get; }
+    public virtual bool IsGranted { get; }
 
-        public virtual string ProviderKey { get; }
+    public virtual string ProviderKey { get; }
 
-        public PermissionValueProviderGrantInfo(bool isGranted, [CanBeNull] string providerKey = null)
-        {
-            IsGranted = isGranted;
-            ProviderKey = providerKey;
-        }
+    public PermissionValueProviderGrantInfo(bool isGranted, [CanBeNull] string providerKey = null)
+    {
+        IsGranted = isGranted;
+        ProviderKey = providerKey;
     }
-}
+}

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

@@ -1,20 +1,19 @@
 using JetBrains.Annotations;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionValueProviderInfo
 {
-    public class PermissionValueProviderInfo
-    {
-        public string Name { get; }
+    public string Name { get; }
 
-        public string Key { get; }
-        
-        public PermissionValueProviderInfo([NotNull]string name, [NotNull]string key)
-        {
-            Check.NotNull(name, nameof(name));
-            Check.NotNull(key, nameof(key));
+    public string Key { get; }
+
+    public PermissionValueProviderInfo([NotNull] string name, [NotNull] string key)
+    {
+        Check.NotNull(name, nameof(name));
+        Check.NotNull(key, nameof(key));
 
-            Name = name;
-            Key = key;
-        }
+        Name = name;
+        Key = key;
     }
-}
+}

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

@@ -1,24 +1,23 @@
 using System.Collections.Generic;
 using JetBrains.Annotations;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionWithGrantedProviders
 {
-    public class PermissionWithGrantedProviders
-    {
-        public string Name { get; }
+    public string Name { get; }
 
-        public bool IsGranted { get; set; }
+    public bool IsGranted { get; set; }
 
-        public List<PermissionValueProviderInfo> Providers { get; set; }
+    public List<PermissionValueProviderInfo> Providers { get; set; }
 
-        public PermissionWithGrantedProviders([NotNull] string name, bool isGranted)
-        {
-            Check.NotNull(name, nameof(name));
+    public PermissionWithGrantedProviders([NotNull] string name, bool isGranted)
+    {
+        Check.NotNull(name, nameof(name));
 
-            Name = name;
-            IsGranted = isGranted;
+        Name = name;
+        IsGranted = isGranted;
 
-            Providers = new List<PermissionValueProviderInfo>();
-        }
+        Providers = new List<PermissionValueProviderInfo>();
     }
-}
+}

modules/permission-management/src/Volo.Abp.PermissionManagement.EntityFrameworkCore/Volo/Abp/PermissionManagement/EntityFrameworkCore/AbpPermissionManagementDbContextModelBuilderExtensions.cs

@@ -2,31 +2,30 @@
 using Microsoft.EntityFrameworkCore;
 using Volo.Abp.EntityFrameworkCore.Modeling;
 
-namespace Volo.Abp.PermissionManagement.EntityFrameworkCore
+namespace Volo.Abp.PermissionManagement.EntityFrameworkCore;
+
+public static class AbpPermissionManagementDbContextModelBuilderExtensions
 {
-    public static class AbpPermissionManagementDbContextModelBuilderExtensions
+    public static void ConfigurePermissionManagement(
+        [NotNull] this ModelBuilder builder)
     {
-        public static void ConfigurePermissionManagement(
-            [NotNull] this ModelBuilder builder)
-        {
-            Check.NotNull(builder, nameof(builder));
+        Check.NotNull(builder, nameof(builder));
 
-            builder.Entity<PermissionGrant>(b =>
-            {
-                b.ToTable(AbpPermissionManagementDbProperties.DbTablePrefix + "PermissionGrants", AbpPermissionManagementDbProperties.DbSchema);
+        builder.Entity<PermissionGrant>(b =>
+        {
+            b.ToTable(AbpPermissionManagementDbProperties.DbTablePrefix + "PermissionGrants", AbpPermissionManagementDbProperties.DbSchema);
 
-                b.ConfigureByConvention();
+            b.ConfigureByConvention();
 
-                b.Property(x => x.Name).HasMaxLength(PermissionGrantConsts.MaxNameLength).IsRequired();
-                b.Property(x => x.ProviderName).HasMaxLength(PermissionGrantConsts.MaxProviderNameLength).IsRequired();
-                b.Property(x => x.ProviderKey).HasMaxLength(PermissionGrantConsts.MaxProviderKeyLength).IsRequired();
+            b.Property(x => x.Name).HasMaxLength(PermissionGrantConsts.MaxNameLength).IsRequired();
+            b.Property(x => x.ProviderName).HasMaxLength(PermissionGrantConsts.MaxProviderNameLength).IsRequired();
+            b.Property(x => x.ProviderKey).HasMaxLength(PermissionGrantConsts.MaxProviderKeyLength).IsRequired();
 
-                b.HasIndex(x => new {x.TenantId, x.Name, x.ProviderName, x.ProviderKey}).IsUnique(true);
+            b.HasIndex(x => new { x.TenantId, x.Name, x.ProviderName, x.ProviderKey }).IsUnique(true);
 
-                b.ApplyObjectExtensionMappings();
-            });
+            b.ApplyObjectExtensionMappings();
+        });
 
-            builder.TryConfigureObjectExtensions<PermissionManagementDbContext>();
-        }
+        builder.TryConfigureObjectExtensions<PermissionManagementDbContext>();
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.EntityFrameworkCore/Volo/Abp/PermissionManagement/EntityFrameworkCore/AbpPermissionManagementEntityFrameworkCoreModule.cs

@@ -2,20 +2,19 @@
 using Volo.Abp.EntityFrameworkCore;
 using Volo.Abp.Modularity;
 
-namespace Volo.Abp.PermissionManagement.EntityFrameworkCore
+namespace Volo.Abp.PermissionManagement.EntityFrameworkCore;
+
+[DependsOn(typeof(AbpPermissionManagementDomainModule))]
+[DependsOn(typeof(AbpEntityFrameworkCoreModule))]
+public class AbpPermissionManagementEntityFrameworkCoreModule : AbpModule
 {
-    [DependsOn(typeof(AbpPermissionManagementDomainModule))]
-    [DependsOn(typeof(AbpEntityFrameworkCoreModule))]
-    public class AbpPermissionManagementEntityFrameworkCoreModule : AbpModule
+    public override void ConfigureServices(ServiceConfigurationContext context)
     {
-        public override void ConfigureServices(ServiceConfigurationContext context)
+        context.Services.AddAbpDbContext<PermissionManagementDbContext>(options =>
         {
-            context.Services.AddAbpDbContext<PermissionManagementDbContext>(options =>
-            {
-                options.AddDefaultRepositories<IPermissionManagementDbContext>();
+            options.AddDefaultRepositories<IPermissionManagementDbContext>();
 
-                options.AddRepository<PermissionGrant, EfCorePermissionGrantRepository>();
-            });
-        }
+            options.AddRepository<PermissionGrant, EfCorePermissionGrantRepository>();
+        });
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.EntityFrameworkCore/Volo/Abp/PermissionManagement/EntityFrameworkCore/EfCorePermissionGrantRepository.cs

@@ -7,54 +7,53 @@ using Microsoft.EntityFrameworkCore;
 using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
 using Volo.Abp.EntityFrameworkCore;
 
-namespace Volo.Abp.PermissionManagement.EntityFrameworkCore
+namespace Volo.Abp.PermissionManagement.EntityFrameworkCore;
+
+public class EfCorePermissionGrantRepository : EfCoreRepository<IPermissionManagementDbContext, PermissionGrant, Guid>,
+    IPermissionGrantRepository
 {
-    public class EfCorePermissionGrantRepository : EfCoreRepository<IPermissionManagementDbContext, PermissionGrant, Guid>,
-        IPermissionGrantRepository
+    public EfCorePermissionGrantRepository(IDbContextProvider<IPermissionManagementDbContext> dbContextProvider)
+        : base(dbContextProvider)
     {
-        public EfCorePermissionGrantRepository(IDbContextProvider<IPermissionManagementDbContext> dbContextProvider)
-            : base(dbContextProvider)
-        {
 
-        }
+    }
 
-        public virtual async Task<PermissionGrant> FindAsync(
-            string name,
-            string providerName,
-            string providerKey,
-            CancellationToken cancellationToken = default)
-        {
-            return await (await GetDbSetAsync())
-                .OrderBy(x => x.Id)
-                .FirstOrDefaultAsync(s =>
-                    s.Name == name &&
-                    s.ProviderName == providerName &&
-                    s.ProviderKey == providerKey,
-                    GetCancellationToken(cancellationToken)
-                );
-        }
+    public virtual async Task<PermissionGrant> FindAsync(
+        string name,
+        string providerName,
+        string providerKey,
+        CancellationToken cancellationToken = default)
+    {
+        return await (await GetDbSetAsync())
+            .OrderBy(x => x.Id)
+            .FirstOrDefaultAsync(s =>
+                s.Name == name &&
+                s.ProviderName == providerName &&
+                s.ProviderKey == providerKey,
+                GetCancellationToken(cancellationToken)
+            );
+    }
 
-        public virtual async Task<List<PermissionGrant>> GetListAsync(
-            string providerName,
-            string providerKey,
-            CancellationToken cancellationToken = default)
-        {
-            return await (await GetDbSetAsync())
-                .Where(s =>
-                    s.ProviderName == providerName &&
-                    s.ProviderKey == providerKey
-                ).ToListAsync(GetCancellationToken(cancellationToken));
-        }
+    public virtual async Task<List<PermissionGrant>> GetListAsync(
+        string providerName,
+        string providerKey,
+        CancellationToken cancellationToken = default)
+    {
+        return await (await GetDbSetAsync())
+            .Where(s =>
+                s.ProviderName == providerName &&
+                s.ProviderKey == providerKey
+            ).ToListAsync(GetCancellationToken(cancellationToken));
+    }
 
-        public virtual async Task<List<PermissionGrant>> GetListAsync(string[] names, string providerName, string providerKey,
-            CancellationToken cancellationToken = default)
-        {
-            return await (await GetDbSetAsync())
-                .Where(s =>
-                    names.Contains(s.Name) &&
-                    s.ProviderName == providerName &&
-                    s.ProviderKey == providerKey
-                ).ToListAsync(GetCancellationToken(cancellationToken));
-        }
+    public virtual async Task<List<PermissionGrant>> GetListAsync(string[] names, string providerName, string providerKey,
+        CancellationToken cancellationToken = default)
+    {
+        return await (await GetDbSetAsync())
+            .Where(s =>
+                names.Contains(s.Name) &&
+                s.ProviderName == providerName &&
+                s.ProviderKey == providerKey
+            ).ToListAsync(GetCancellationToken(cancellationToken));
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.EntityFrameworkCore/Volo/Abp/PermissionManagement/EntityFrameworkCore/IPermissionManagementDbContext.cs

@@ -2,11 +2,10 @@
 using Volo.Abp.Data;
 using Volo.Abp.EntityFrameworkCore;
 
-namespace Volo.Abp.PermissionManagement.EntityFrameworkCore
+namespace Volo.Abp.PermissionManagement.EntityFrameworkCore;
+
+[ConnectionStringName(AbpPermissionManagementDbProperties.ConnectionStringName)]
+public interface IPermissionManagementDbContext : IEfCoreDbContext
 {
-    [ConnectionStringName(AbpPermissionManagementDbProperties.ConnectionStringName)]
-    public interface IPermissionManagementDbContext : IEfCoreDbContext
-    {
-        DbSet<PermissionGrant> PermissionGrants { get; }
-    }
-}
+    DbSet<PermissionGrant> PermissionGrants { get; }
+}

modules/permission-management/src/Volo.Abp.PermissionManagement.EntityFrameworkCore/Volo/Abp/PermissionManagement/EntityFrameworkCore/PermissionManagementDbContext.cs

@@ -2,24 +2,23 @@
 using Volo.Abp.Data;
 using Volo.Abp.EntityFrameworkCore;
 
-namespace Volo.Abp.PermissionManagement.EntityFrameworkCore
+namespace Volo.Abp.PermissionManagement.EntityFrameworkCore;
+
+[ConnectionStringName(AbpPermissionManagementDbProperties.ConnectionStringName)]
+public class PermissionManagementDbContext : AbpDbContext<PermissionManagementDbContext>, IPermissionManagementDbContext
 {
-    [ConnectionStringName(AbpPermissionManagementDbProperties.ConnectionStringName)]
-    public class PermissionManagementDbContext : AbpDbContext<PermissionManagementDbContext>, IPermissionManagementDbContext
-    {
-        public DbSet<PermissionGrant> PermissionGrants { get; set; }
+    public DbSet<PermissionGrant> PermissionGrants { get; set; }
 
-        public PermissionManagementDbContext(DbContextOptions<PermissionManagementDbContext> options)
-            : base(options)
-        {
+    public PermissionManagementDbContext(DbContextOptions<PermissionManagementDbContext> options)
+        : base(options)
+    {
 
-        }
+    }
 
-        protected override void OnModelCreating(ModelBuilder builder)
-        {
-            base.OnModelCreating(builder);
+    protected override void OnModelCreating(ModelBuilder builder)
+    {
+        base.OnModelCreating(builder);
 
-            builder.ConfigurePermissionManagement();
-        }
+        builder.ConfigurePermissionManagement();
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.HttpApi.Client/ClientProxies/PermissionsClientProxy.cs

@@ -1,8 +1,7 @@
 // This file is part of PermissionsClientProxy, you can customize it here
 // ReSharper disable once CheckNamespace
-namespace Volo.Abp.PermissionManagement.ClientProxies
+namespace Volo.Abp.PermissionManagement.ClientProxies;
+
+public partial class PermissionsClientProxy
 {
-    public partial class PermissionsClientProxy
-    {
-    }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.HttpApi.Client/Volo/Abp/PermissionManagement/AbpPermissionManagementHttpApiClientModule.cs

@@ -4,24 +4,23 @@ using Volo.Abp.Http.Client;
 using Volo.Abp.Modularity;
 using Volo.Abp.VirtualFileSystem;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+[DependsOn(
+    typeof(AbpPermissionManagementApplicationContractsModule),
+    typeof(AbpHttpClientModule))]
+public class AbpPermissionManagementHttpApiClientModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpPermissionManagementApplicationContractsModule),
-        typeof(AbpHttpClientModule))]
-    public class AbpPermissionManagementHttpApiClientModule : AbpModule
+    public override void ConfigureServices(ServiceConfigurationContext context)
     {
-        public override void ConfigureServices(ServiceConfigurationContext context)
-        {
-            context.Services.AddStaticHttpClientProxies(
-                typeof(AbpPermissionManagementApplicationContractsModule).Assembly,
-                PermissionManagementRemoteServiceConsts.RemoteServiceName
-            );
+        context.Services.AddStaticHttpClientProxies(
+            typeof(AbpPermissionManagementApplicationContractsModule).Assembly,
+            PermissionManagementRemoteServiceConsts.RemoteServiceName
+        );
 
-            Configure<AbpVirtualFileSystemOptions>(options =>
-            {
-                options.FileSets.AddEmbedded<AbpPermissionManagementHttpApiClientModule>();
-            });
-        }
+        Configure<AbpVirtualFileSystemOptions>(options =>
+        {
+            options.FileSets.AddEmbedded<AbpPermissionManagementHttpApiClientModule>();
+        });
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.HttpApi/Volo/Abp/PermissionManagement/AbpPermissionManagementHttpApiModule.cs

@@ -5,32 +5,31 @@ using Volo.Abp.Modularity;
 using Volo.Abp.PermissionManagement.Localization;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace Volo.Abp.PermissionManagement.HttpApi
+namespace Volo.Abp.PermissionManagement.HttpApi;
+
+[DependsOn(
+    typeof(AbpPermissionManagementApplicationContractsModule),
+    typeof(AbpAspNetCoreMvcModule)
+    )]
+public class AbpPermissionManagementHttpApiModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpPermissionManagementApplicationContractsModule),
-        typeof(AbpAspNetCoreMvcModule)
-        )]
-    public class AbpPermissionManagementHttpApiModule : AbpModule
+    public override void PreConfigureServices(ServiceConfigurationContext context)
     {
-        public override void PreConfigureServices(ServiceConfigurationContext context)
+        PreConfigure<IMvcBuilder>(mvcBuilder =>
         {
-            PreConfigure<IMvcBuilder>(mvcBuilder =>
-            {
-                mvcBuilder.AddApplicationPartIfNotExists(typeof(AbpPermissionManagementHttpApiModule).Assembly);
-            });
-        }
+            mvcBuilder.AddApplicationPartIfNotExists(typeof(AbpPermissionManagementHttpApiModule).Assembly);
+        });
+    }
 
-        public override void ConfigureServices(ServiceConfigurationContext context)
+    public override void ConfigureServices(ServiceConfigurationContext context)
+    {
+        Configure<AbpLocalizationOptions>(options =>
         {
-            Configure<AbpLocalizationOptions>(options =>
-            {
-                options.Resources
-                    .Get<AbpPermissionManagementResource>()
-                    .AddBaseTypes(
-                        typeof(AbpUiResource)
-                    );
-            });
-        }
+            options.Resources
+                .Get<AbpPermissionManagementResource>()
+                .AddBaseTypes(
+                    typeof(AbpUiResource)
+                );
+        });
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.HttpApi/Volo/Abp/PermissionManagement/PermissionsController.cs

@@ -2,30 +2,29 @@
 using Microsoft.AspNetCore.Mvc;
 using Volo.Abp.AspNetCore.Mvc;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+[RemoteService(Name = PermissionManagementRemoteServiceConsts.RemoteServiceName)]
+[Area(PermissionManagementRemoteServiceConsts.ModuleName)]
+[Route("api/permission-management/permissions")]
+public class PermissionsController : AbpControllerBase, IPermissionAppService
 {
-    [RemoteService(Name = PermissionManagementRemoteServiceConsts.RemoteServiceName)]
-    [Area(PermissionManagementRemoteServiceConsts.ModuleName)]
-    [Route("api/permission-management/permissions")]
-    public class PermissionsController : AbpControllerBase, IPermissionAppService
-    {
-        protected IPermissionAppService PermissionAppService { get; }
+    protected IPermissionAppService PermissionAppService { get; }
 
-        public PermissionsController(IPermissionAppService permissionAppService)
-        {
-            PermissionAppService = permissionAppService;
-        }
+    public PermissionsController(IPermissionAppService permissionAppService)
+    {
+        PermissionAppService = permissionAppService;
+    }
 
-        [HttpGet]
-        public virtual Task<GetPermissionListResultDto> GetAsync(string providerName, string providerKey)
-        {
-            return PermissionAppService.GetAsync(providerName, providerKey);
-        }
+    [HttpGet]
+    public virtual Task<GetPermissionListResultDto> GetAsync(string providerName, string providerKey)
+    {
+        return PermissionAppService.GetAsync(providerName, providerKey);
+    }
 
-        [HttpPut]
-        public virtual Task UpdateAsync(string providerName, string providerKey, UpdatePermissionsDto input)
-        {
-            return PermissionAppService.UpdateAsync(providerName, providerKey, input);
-        }
+    [HttpPut]
+    public virtual Task UpdateAsync(string providerName, string providerKey, UpdatePermissionsDto input)
+    {
+        return PermissionAppService.UpdateAsync(providerName, providerKey, input);
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.Installer/Volo/Abp/PermissionManagement/AbpPermissionManagementInstallerModule.cs

@@ -2,20 +2,19 @@
 using Volo.Abp.Studio;
 using Volo.Abp.VirtualFileSystem;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+[DependsOn(
+    typeof(AbpStudioModuleInstallerModule),
+    typeof(AbpVirtualFileSystemModule)
+    )]
+public class AbpPermissionManagementInstallerModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpStudioModuleInstallerModule),
-        typeof(AbpVirtualFileSystemModule)
-        )]
-    public class AbpPermissionManagementInstallerModule : AbpModule
+    public override void ConfigureServices(ServiceConfigurationContext context)
     {
-        public override void ConfigureServices(ServiceConfigurationContext context)
+        Configure<AbpVirtualFileSystemOptions>(options =>
         {
-            Configure<AbpVirtualFileSystemOptions>(options =>
-            {
-                options.FileSets.AddEmbedded<AbpPermissionManagementInstallerModule>();
-            });
-        }
+            options.FileSets.AddEmbedded<AbpPermissionManagementInstallerModule>();
+        });
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.Installer/Volo/Abp/PermissionManagement/PermissionManagementInstallerPipelineBuilder.cs

@@ -3,22 +3,21 @@ using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Studio.ModuleInstalling;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+[Dependency(ServiceLifetime.Transient, ReplaceServices = true)]
+[ExposeServices(typeof(IModuleInstallingPipelineBuilder))]
+public class PermissionManagementInstallerPipelineBuilder : ModuleInstallingPipelineBuilderBase, IModuleInstallingPipelineBuilder, ITransientDependency
 {
-    [Dependency(ServiceLifetime.Transient, ReplaceServices = true)]
-    [ExposeServices(typeof(IModuleInstallingPipelineBuilder))]
-    public class PermissionManagementInstallerPipelineBuilder : ModuleInstallingPipelineBuilderBase, IModuleInstallingPipelineBuilder, ITransientDependency
+    public async Task<ModuleInstallingPipeline> BuildAsync(ModuleInstallingContext context)
     {
-        public async Task<ModuleInstallingPipeline> BuildAsync(ModuleInstallingContext context)
-        {
-            context.AddEfCoreConfigurationMethodDeclaration(
-                new EfCoreConfigurationMethodDeclaration(
-                    "Volo.Abp.PermissionManagement.EntityFrameworkCore",
-                    "ConfigurePermissionManagement"
-                )
-            );
-            
-            return GetBasePipeline(context);
-        }
+        context.AddEfCoreConfigurationMethodDeclaration(
+            new EfCoreConfigurationMethodDeclaration(
+                "Volo.Abp.PermissionManagement.EntityFrameworkCore",
+                "ConfigurePermissionManagement"
+            )
+        );
+
+        return GetBasePipeline(context);
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.MongoDB/Volo/Abp/PermissionManagement/MongoDb/AbpPermissionManagementMongoDbContextExtensions.cs

@@ -1,18 +1,17 @@
 using Volo.Abp.MongoDB;
 
-namespace Volo.Abp.PermissionManagement.MongoDB
+namespace Volo.Abp.PermissionManagement.MongoDB;
+
+public static class AbpPermissionManagementMongoDbContextExtensions
 {
-    public static class AbpPermissionManagementMongoDbContextExtensions
+    public static void ConfigurePermissionManagement(
+        this IMongoModelBuilder builder)
     {
-        public static void ConfigurePermissionManagement(
-            this IMongoModelBuilder builder)
-        {
-            Check.NotNull(builder, nameof(builder));
+        Check.NotNull(builder, nameof(builder));
 
-            builder.Entity<PermissionGrant>(b =>
-            {
-                b.CollectionName = AbpPermissionManagementDbProperties.DbTablePrefix + "PermissionGrants";
-            });
-        }
+        builder.Entity<PermissionGrant>(b =>
+        {
+            b.CollectionName = AbpPermissionManagementDbProperties.DbTablePrefix + "PermissionGrants";
+        });
     }
-}
+}

modules/permission-management/src/Volo.Abp.PermissionManagement.MongoDB/Volo/Abp/PermissionManagement/MongoDb/AbpPermissionManagementMongoDbModule.cs

@@ -2,22 +2,21 @@
 using Volo.Abp.Modularity;
 using Volo.Abp.MongoDB;
 
-namespace Volo.Abp.PermissionManagement.MongoDB
+namespace Volo.Abp.PermissionManagement.MongoDB;
+
+[DependsOn(
+    typeof(AbpPermissionManagementDomainModule),
+    typeof(AbpMongoDbModule)
+    )]
+public class AbpPermissionManagementMongoDbModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpPermissionManagementDomainModule),
-        typeof(AbpMongoDbModule)
-        )]
-    public class AbpPermissionManagementMongoDbModule : AbpModule
+    public override void ConfigureServices(ServiceConfigurationContext context)
     {
-        public override void ConfigureServices(ServiceConfigurationContext context)
+        context.Services.AddMongoDbContext<PermissionManagementMongoDbContext>(options =>
         {
-            context.Services.AddMongoDbContext<PermissionManagementMongoDbContext>(options =>
-            {
-                options.AddDefaultRepositories<IPermissionManagementMongoDbContext>();
+            options.AddDefaultRepositories<IPermissionManagementMongoDbContext>();
 
-                options.AddRepository<PermissionGrant, MongoPermissionGrantRepository>();
-            });
-        }
+            options.AddRepository<PermissionGrant, MongoPermissionGrantRepository>();
+        });
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.MongoDB/Volo/Abp/PermissionManagement/MongoDb/IPermissionManagementMongoDbContext.cs

@@ -2,11 +2,10 @@
 using Volo.Abp.Data;
 using Volo.Abp.MongoDB;
 
-namespace Volo.Abp.PermissionManagement.MongoDB
+namespace Volo.Abp.PermissionManagement.MongoDB;
+
+[ConnectionStringName(AbpPermissionManagementDbProperties.ConnectionStringName)]
+public interface IPermissionManagementMongoDbContext : IAbpMongoDbContext
 {
-    [ConnectionStringName(AbpPermissionManagementDbProperties.ConnectionStringName)]
-    public interface IPermissionManagementMongoDbContext : IAbpMongoDbContext
-    {
-        IMongoCollection<PermissionGrant> PermissionGrants { get; }
-    }
-}
+    IMongoCollection<PermissionGrant> PermissionGrants { get; }
+}

modules/permission-management/src/Volo.Abp.PermissionManagement.MongoDB/Volo/Abp/PermissionManagement/MongoDb/MongoPermissionGrantRepository.cs

@@ -8,56 +8,55 @@ using MongoDB.Driver.Linq;
 using Volo.Abp.Domain.Repositories.MongoDB;
 using Volo.Abp.MongoDB;
 
-namespace Volo.Abp.PermissionManagement.MongoDB
+namespace Volo.Abp.PermissionManagement.MongoDB;
+
+public class MongoPermissionGrantRepository : MongoDbRepository<IPermissionManagementMongoDbContext, PermissionGrant, Guid>, IPermissionGrantRepository
 {
-    public class MongoPermissionGrantRepository : MongoDbRepository<IPermissionManagementMongoDbContext, PermissionGrant, Guid>, IPermissionGrantRepository
+    public MongoPermissionGrantRepository(IMongoDbContextProvider<IPermissionManagementMongoDbContext> dbContextProvider)
+        : base(dbContextProvider)
     {
-        public MongoPermissionGrantRepository(IMongoDbContextProvider<IPermissionManagementMongoDbContext> dbContextProvider)
-            : base(dbContextProvider)
-        {
 
-        }
+    }
 
-        public virtual async Task<PermissionGrant> FindAsync(
-            string name,
-            string providerName,
-            string providerKey,
-            CancellationToken cancellationToken = default)
-        {
-            cancellationToken = GetCancellationToken(cancellationToken);
-            return await (await GetMongoQueryableAsync(cancellationToken))
-                .OrderBy(x => x.Id)
-                .FirstOrDefaultAsync(s =>
-                    s.Name == name &&
-                    s.ProviderName == providerName &&
-                    s.ProviderKey == providerKey,
-                    cancellationToken
-                );
-        }
+    public virtual async Task<PermissionGrant> FindAsync(
+        string name,
+        string providerName,
+        string providerKey,
+        CancellationToken cancellationToken = default)
+    {
+        cancellationToken = GetCancellationToken(cancellationToken);
+        return await (await GetMongoQueryableAsync(cancellationToken))
+            .OrderBy(x => x.Id)
+            .FirstOrDefaultAsync(s =>
+                s.Name == name &&
+                s.ProviderName == providerName &&
+                s.ProviderKey == providerKey,
+                cancellationToken
+            );
+    }
 
-        public virtual async Task<List<PermissionGrant>> GetListAsync(
-            string providerName,
-            string providerKey,
-            CancellationToken cancellationToken = default)
-        {
-            cancellationToken = GetCancellationToken(cancellationToken);
-            return await (await GetMongoQueryableAsync(cancellationToken))
-                .Where(s =>
-                    s.ProviderName == providerName &&
-                    s.ProviderKey == providerKey
-                ).ToListAsync(cancellationToken);
-        }
+    public virtual async Task<List<PermissionGrant>> GetListAsync(
+        string providerName,
+        string providerKey,
+        CancellationToken cancellationToken = default)
+    {
+        cancellationToken = GetCancellationToken(cancellationToken);
+        return await (await GetMongoQueryableAsync(cancellationToken))
+            .Where(s =>
+                s.ProviderName == providerName &&
+                s.ProviderKey == providerKey
+            ).ToListAsync(cancellationToken);
+    }
 
-        public virtual async Task<List<PermissionGrant>> GetListAsync(string[] names, string providerName, string providerKey,
-            CancellationToken cancellationToken = default)
-        {
-            cancellationToken = GetCancellationToken(cancellationToken);
-            return await (await GetMongoQueryableAsync(cancellationToken))
-                .Where(s =>
-                    names.Contains(s.Name) &&
-                    s.ProviderName == providerName &&
-                    s.ProviderKey == providerKey
-                ).ToListAsync(cancellationToken);
-        }
+    public virtual async Task<List<PermissionGrant>> GetListAsync(string[] names, string providerName, string providerKey,
+        CancellationToken cancellationToken = default)
+    {
+        cancellationToken = GetCancellationToken(cancellationToken);
+        return await (await GetMongoQueryableAsync(cancellationToken))
+            .Where(s =>
+                names.Contains(s.Name) &&
+                s.ProviderName == providerName &&
+                s.ProviderKey == providerKey
+            ).ToListAsync(cancellationToken);
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.MongoDB/Volo/Abp/PermissionManagement/MongoDb/PermissionManagementMongoDbContext.cs

@@ -2,18 +2,17 @@
 using Volo.Abp.Data;
 using Volo.Abp.MongoDB;
 
-namespace Volo.Abp.PermissionManagement.MongoDB
+namespace Volo.Abp.PermissionManagement.MongoDB;
+
+[ConnectionStringName(AbpPermissionManagementDbProperties.ConnectionStringName)]
+public class PermissionManagementMongoDbContext : AbpMongoDbContext, IPermissionManagementMongoDbContext
 {
-    [ConnectionStringName(AbpPermissionManagementDbProperties.ConnectionStringName)]
-    public class PermissionManagementMongoDbContext : AbpMongoDbContext, IPermissionManagementMongoDbContext
-    {
-        public IMongoCollection<PermissionGrant> PermissionGrants => Collection<PermissionGrant>();
+    public IMongoCollection<PermissionGrant> PermissionGrants => Collection<PermissionGrant>();
 
-        protected override void CreateModel(IMongoModelBuilder modelBuilder)
-        {
-            base.CreateModel(modelBuilder);
+    protected override void CreateModel(IMongoModelBuilder modelBuilder)
+    {
+        base.CreateModel(modelBuilder);
 
-            modelBuilder.ConfigurePermissionManagement();
-        }
+        modelBuilder.ConfigurePermissionManagement();
     }
-}
+}

modules/permission-management/src/Volo.Abp.PermissionManagement.Web/AbpPermissionManagementWebAutoMapperProfile.cs

@@ -2,18 +2,17 @@
 using Volo.Abp.AutoMapper;
 using Volo.Abp.PermissionManagement.Web.Pages.AbpPermissionManagement;
 
-namespace Volo.Abp.PermissionManagement.Web
+namespace Volo.Abp.PermissionManagement.Web;
+
+public class AbpPermissionManagementWebAutoMapperProfile : Profile
 {
-    public class AbpPermissionManagementWebAutoMapperProfile : Profile
+    public AbpPermissionManagementWebAutoMapperProfile()
     {
-        public AbpPermissionManagementWebAutoMapperProfile()
-        {
-            CreateMap<PermissionGroupDto, PermissionManagementModal.PermissionGroupViewModel>().Ignore(p=>p.IsAllPermissionsGranted);
+        CreateMap<PermissionGroupDto, PermissionManagementModal.PermissionGroupViewModel>().Ignore(p => p.IsAllPermissionsGranted);
 
-            CreateMap<PermissionGrantInfoDto, PermissionManagementModal.PermissionGrantInfoViewModel>()
-                .ForMember(p => p.Depth, opts => opts.Ignore());
+        CreateMap<PermissionGrantInfoDto, PermissionManagementModal.PermissionGrantInfoViewModel>()
+            .ForMember(p => p.Depth, opts => opts.Ignore());
 
-            CreateMap<ProviderInfoDto, PermissionManagementModal.ProviderInfoViewModel>();
-        }
+        CreateMap<ProviderInfoDto, PermissionManagementModal.ProviderInfoViewModel>();
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.Web/AbpPermissionManagementWebModule.cs

@@ -7,43 +7,42 @@ using Volo.Abp.Modularity;
 using Volo.Abp.PermissionManagement.Localization;
 using Volo.Abp.VirtualFileSystem;
 
-namespace Volo.Abp.PermissionManagement.Web
+namespace Volo.Abp.PermissionManagement.Web;
+
+[DependsOn(typeof(AbpPermissionManagementApplicationContractsModule))]
+[DependsOn(typeof(AbpAspNetCoreMvcUiBootstrapModule))]
+[DependsOn(typeof(AbpAutoMapperModule))]
+public class AbpPermissionManagementWebModule : AbpModule
 {
-    [DependsOn(typeof(AbpPermissionManagementApplicationContractsModule))]
-    [DependsOn(typeof(AbpAspNetCoreMvcUiBootstrapModule))]
-    [DependsOn(typeof(AbpAutoMapperModule))]
-    public class AbpPermissionManagementWebModule : AbpModule
+    public override void PreConfigureServices(ServiceConfigurationContext context)
     {
-        public override void PreConfigureServices(ServiceConfigurationContext context)
+        context.Services.PreConfigure<AbpMvcDataAnnotationsLocalizationOptions>(options =>
         {
-            context.Services.PreConfigure<AbpMvcDataAnnotationsLocalizationOptions>(options =>
-            {
-                options.AddAssemblyResource(typeof(AbpPermissionManagementResource));
-            });
+            options.AddAssemblyResource(typeof(AbpPermissionManagementResource));
+        });
 
-            PreConfigure<IMvcBuilder>(mvcBuilder =>
-            {
-                mvcBuilder.AddApplicationPartIfNotExists(typeof(AbpPermissionManagementWebModule).Assembly);
-            });
-        }
+        PreConfigure<IMvcBuilder>(mvcBuilder =>
+        {
+            mvcBuilder.AddApplicationPartIfNotExists(typeof(AbpPermissionManagementWebModule).Assembly);
+        });
+    }
 
-        public override void ConfigureServices(ServiceConfigurationContext context)
+    public override void ConfigureServices(ServiceConfigurationContext context)
+    {
+        Configure<AbpVirtualFileSystemOptions>(options =>
         {
-            Configure<AbpVirtualFileSystemOptions>(options =>
-            {
-                options.FileSets.AddEmbedded<AbpPermissionManagementWebModule>();
-            });
+            options.FileSets.AddEmbedded<AbpPermissionManagementWebModule>();
+        });
 
-            context.Services.AddAutoMapperObjectMapper<AbpPermissionManagementWebModule>();
-            Configure<AbpAutoMapperOptions>(options =>
-            {
-                options.AddProfile<AbpPermissionManagementWebAutoMapperProfile>(validate: true);
-            });
+        context.Services.AddAutoMapperObjectMapper<AbpPermissionManagementWebModule>();
+        Configure<AbpAutoMapperOptions>(options =>
+        {
+            options.AddProfile<AbpPermissionManagementWebAutoMapperProfile>(validate: true);
+        });
 
-            Configure<DynamicJavaScriptProxyOptions>(options =>
-            {
-                options.DisableModule(PermissionManagementRemoteServiceConsts.ModuleName);
-            });
-        }
+        Configure<DynamicJavaScriptProxyOptions>(options =>
+        {
+            options.DisableModule(PermissionManagementRemoteServiceConsts.ModuleName);
+        });
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.Web/Pages/AbpPermissionManagement/PermissionManagementModal.cshtml.cs

@@ -8,167 +8,166 @@ using Volo.Abp.AspNetCore.Mvc.UI.RazorPages;
 using Volo.Abp.EventBus.Local;
 using Volo.Abp.PermissionManagement.Web.Utils;
 
-namespace Volo.Abp.PermissionManagement.Web.Pages.AbpPermissionManagement
+namespace Volo.Abp.PermissionManagement.Web.Pages.AbpPermissionManagement;
+
+public class PermissionManagementModal : AbpPageModel
 {
-    public class PermissionManagementModal : AbpPageModel
-    {
-        [Required]
-        [HiddenInput]
-        [BindProperty(SupportsGet = true)]
-        public string ProviderName { get; set; }
+    [Required]
+    [HiddenInput]
+    [BindProperty(SupportsGet = true)]
+    public string ProviderName { get; set; }
 
-        [Required]
-        [HiddenInput]
-        [BindProperty(SupportsGet = true)]
-        public string ProviderKey { get; set; }
+    [Required]
+    [HiddenInput]
+    [BindProperty(SupportsGet = true)]
+    public string ProviderKey { get; set; }
 
-        [BindProperty(SupportsGet = true)]
-        public string ProviderKeyDisplayName { get; set; }
+    [BindProperty(SupportsGet = true)]
+    public string ProviderKeyDisplayName { get; set; }
 
-        [BindProperty]
-        public List<PermissionGroupViewModel> Groups { get; set; }
+    [BindProperty]
+    public List<PermissionGroupViewModel> Groups { get; set; }
 
-        public string EntityDisplayName { get; set; }
+    public string EntityDisplayName { get; set; }
 
-        public bool SelectAllInThisTab { get; set; }
+    public bool SelectAllInThisTab { get; set; }
 
-        public bool SelectAllInAllTabs { get; set; }
+    public bool SelectAllInAllTabs { get; set; }
 
-        protected IPermissionAppService PermissionAppService { get; }
+    protected IPermissionAppService PermissionAppService { get; }
 
-        protected ILocalEventBus LocalEventBus { get; }
+    protected ILocalEventBus LocalEventBus { get; }
 
-        public PermissionManagementModal(
-        IPermissionAppService permissionAppService,
-        ILocalEventBus localEventBus)
-        {
-            ObjectMapperContext = typeof(AbpPermissionManagementWebModule);
+    public PermissionManagementModal(
+    IPermissionAppService permissionAppService,
+    ILocalEventBus localEventBus)
+    {
+        ObjectMapperContext = typeof(AbpPermissionManagementWebModule);
+
+        PermissionAppService = permissionAppService;
+        LocalEventBus = localEventBus;
+    }
+
+    public virtual async Task<IActionResult> OnGetAsync()
+    {
+        ValidateModel();
 
-            PermissionAppService = permissionAppService;
-            LocalEventBus = localEventBus;
+        var result = await PermissionAppService.GetAsync(ProviderName, ProviderKey);
+
+        EntityDisplayName = !string.IsNullOrWhiteSpace(ProviderKeyDisplayName)
+            ? ProviderKeyDisplayName
+            : result.EntityDisplayName;
+
+        Groups = ObjectMapper
+            .Map<List<PermissionGroupDto>, List<PermissionGroupViewModel>>(result.Groups)
+            .OrderBy(g => g.DisplayName)
+            .ToList();
+
+        foreach (var group in Groups)
+        {
+            new FlatTreeDepthFinder<PermissionGrantInfoViewModel>().SetDepths(group.Permissions);
         }
 
-        public virtual async Task<IActionResult> OnGetAsync()
+        foreach (var group in Groups)
         {
-            ValidateModel();
+            group.IsAllPermissionsGranted = group.Permissions.All(p => p.IsGranted);
+        }
 
-            var result = await PermissionAppService.GetAsync(ProviderName, ProviderKey);
+        SelectAllInAllTabs = Groups.All(g => g.IsAllPermissionsGranted);
 
-            EntityDisplayName = !string.IsNullOrWhiteSpace(ProviderKeyDisplayName)
-                ? ProviderKeyDisplayName
-                : result.EntityDisplayName;
+        return Page();
+    }
 
-            Groups = ObjectMapper
-                .Map<List<PermissionGroupDto>, List<PermissionGroupViewModel>>(result.Groups)
-                .OrderBy(g => g.DisplayName)
-                .ToList();
+    public virtual async Task<IActionResult> OnPostAsync()
+    {
+        ValidateModel();
 
-            foreach (var group in Groups)
+        var updatePermissionDtos = Groups
+            .SelectMany(g => g.Permissions)
+            .Select(p => new UpdatePermissionDto
             {
-                new FlatTreeDepthFinder<PermissionGrantInfoViewModel>().SetDepths(group.Permissions);
-            }
-
-            foreach (var group in Groups)
+                Name = p.Name,
+                IsGranted = p.IsGranted
+            })
+            .ToArray();
+
+        await PermissionAppService.UpdateAsync(
+            ProviderName,
+            ProviderKey,
+            new UpdatePermissionsDto
             {
-                group.IsAllPermissionsGranted = group.Permissions.All(p => p.IsGranted);
+                Permissions = updatePermissionDtos
             }
+        );
 
-            SelectAllInAllTabs = Groups.All(g => g.IsAllPermissionsGranted);
-
-            return Page();
-        }
-
-        public virtual async Task<IActionResult> OnPostAsync()
-        {
-            ValidateModel();
-
-            var updatePermissionDtos = Groups
-                .SelectMany(g => g.Permissions)
-                .Select(p => new UpdatePermissionDto
-                {
-                    Name = p.Name,
-                    IsGranted = p.IsGranted
-                })
-                .ToArray();
-
-            await PermissionAppService.UpdateAsync(
-                ProviderName,
-                ProviderKey,
-                new UpdatePermissionsDto
-                {
-                    Permissions = updatePermissionDtos
-                }
-            );
+        await LocalEventBus.PublishAsync(
+            new CurrentApplicationConfigurationCacheResetEventData()
+        );
 
-            await LocalEventBus.PublishAsync(
-                new CurrentApplicationConfigurationCacheResetEventData()
-            );
-
-            return NoContent();
-        }
+        return NoContent();
+    }
 
-        public class PermissionGroupViewModel
-        {
-            public string Name { get; set; }
+    public class PermissionGroupViewModel
+    {
+        public string Name { get; set; }
 
-            public bool IsAllPermissionsGranted { get; set; }
+        public bool IsAllPermissionsGranted { get; set; }
 
-            public string DisplayName { get; set; }
+        public string DisplayName { get; set; }
 
-            public List<PermissionGrantInfoViewModel> Permissions { get; set; }
+        public List<PermissionGrantInfoViewModel> Permissions { get; set; }
 
-            public string GetNormalizedGroupName()
-            {
-                return Name.Replace(".", "_");
-            }
+        public string GetNormalizedGroupName()
+        {
+            return Name.Replace(".", "_");
         }
+    }
 
-        public class PermissionGrantInfoViewModel : IFlatTreeItem
-        {
-            [Required]
-            [HiddenInput]
-            public string Name { get; set; }
+    public class PermissionGrantInfoViewModel : IFlatTreeItem
+    {
+        [Required]
+        [HiddenInput]
+        public string Name { get; set; }
 
-            public string DisplayName { get; set; }
+        public string DisplayName { get; set; }
 
-            public int Depth { get; set; }
+        public int Depth { get; set; }
 
-            public string ParentName { get; set; }
+        public string ParentName { get; set; }
 
-            public bool IsGranted { get; set; }
+        public bool IsGranted { get; set; }
 
-            public List<string> AllowedProviders { get; set; }
+        public List<string> AllowedProviders { get; set; }
 
-            public List<ProviderInfoViewModel> GrantedProviders { get; set; }
+        public List<ProviderInfoViewModel> GrantedProviders { get; set; }
 
-            public bool IsDisabled(string currentProviderName)
-            {
-                return IsGranted && GrantedProviders.All(p => p.ProviderName != currentProviderName);
-            }
+        public bool IsDisabled(string currentProviderName)
+        {
+            return IsGranted && GrantedProviders.All(p => p.ProviderName != currentProviderName);
+        }
 
-            public string GetShownName(string currentProviderName)
+        public string GetShownName(string currentProviderName)
+        {
+            if (!IsDisabled(currentProviderName))
             {
-                if (!IsDisabled(currentProviderName))
-                {
-                    return DisplayName;
-                }
-
-                return string.Format(
-                    "{0} <span class=\"text-muted\">({1})</span>",
-                    DisplayName,
-                    GrantedProviders
-                        .Where(p => p.ProviderName != currentProviderName)
-                        .Select(p => p.ProviderName)
-                        .JoinAsString(", ")
-                );
+                return DisplayName;
             }
+
+            return string.Format(
+                "{0} <span class=\"text-muted\">({1})</span>",
+                DisplayName,
+                GrantedProviders
+                    .Where(p => p.ProviderName != currentProviderName)
+                    .Select(p => p.ProviderName)
+                    .JoinAsString(", ")
+            );
         }
+    }
 
-        public class ProviderInfoViewModel
-        {
-            public string ProviderName { get; set; }
+    public class ProviderInfoViewModel
+    {
+        public string ProviderName { get; set; }
 
-            public string ProviderKey { get; set; }
-        }
+        public string ProviderKey { get; set; }
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.Web/Utils/FlatTreeDepthFinder.cs

@@ -1,24 +1,23 @@
 using System.Collections.Generic;
 
-namespace Volo.Abp.PermissionManagement.Web.Utils
+namespace Volo.Abp.PermissionManagement.Web.Utils;
+
+public class FlatTreeDepthFinder<T>
+    where T : class, IFlatTreeItem
 {
-    public class FlatTreeDepthFinder<T>
-        where T : class, IFlatTreeItem
+    public virtual void SetDepths(List<T> items)
     {
-        public virtual void SetDepths(List<T> items)
-        {
-            SetDepths(items, null, 0);
-        }
+        SetDepths(items, null, 0);
+    }
 
-        private static void SetDepths(List<T> items, string currentParent, int currentDepth)
+    private static void SetDepths(List<T> items, string currentParent, int currentDepth)
+    {
+        foreach (var item in items)
         {
-            foreach (var item in items)
+            if (item.ParentName == currentParent)
             {
-                if (item.ParentName == currentParent)
-                {
-                    item.Depth = currentDepth;
-                    SetDepths(items, item.Name, currentDepth + 1);
-                }
+                item.Depth = currentDepth;
+                SetDepths(items, item.Name, currentDepth + 1);
             }
         }
     }

modules/permission-management/src/Volo.Abp.PermissionManagement.Web/Utils/IFlatTreeItem.cs

@@ -1,11 +1,10 @@
-namespace Volo.Abp.PermissionManagement.Web.Utils
+namespace Volo.Abp.PermissionManagement.Web.Utils;
+
+public interface IFlatTreeItem
 {
-    public interface IFlatTreeItem
-    {
-        string Name { get; }
+    string Name { get; }
 
-        string ParentName { get; }
+    string ParentName { get; }
 
-        int Depth { get; set; }
-    }
-}
+    int Depth { get; set; }
+}

modules/permission-management/test/Volo.Abp.PermissionManagement.Application.Tests/Volo/Abp/PermissionManagement/AbpPermissionManagementApplicationTestBase.cs

@@ -5,23 +5,22 @@ using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
 using Volo.Abp.Users;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class AbpPermissionManagementApplicationTestBase : PermissionManagementTestBase<AbpPermissionManagementApplicationTestModule>
 {
-    public class AbpPermissionManagementApplicationTestBase : PermissionManagementTestBase<AbpPermissionManagementApplicationTestModule>
-    {
-        protected Guid? CurrentUserId { get; set; }
+    protected Guid? CurrentUserId { get; set; }
 
-        protected AbpPermissionManagementApplicationTestBase()
-        {
-            CurrentUserId = Guid.NewGuid();
-        }
-        protected override void AfterAddApplication(IServiceCollection services)
-        {
-            var currentUser = Substitute.For<ICurrentUser>();
-            currentUser.Roles.Returns(new []{ "admin" });
-            currentUser.IsAuthenticated.Returns(true);
+    protected AbpPermissionManagementApplicationTestBase()
+    {
+        CurrentUserId = Guid.NewGuid();
+    }
+    protected override void AfterAddApplication(IServiceCollection services)
+    {
+        var currentUser = Substitute.For<ICurrentUser>();
+        currentUser.Roles.Returns(new[] { "admin" });
+        currentUser.IsAuthenticated.Returns(true);
 
-            services.AddSingleton(currentUser);
-        }
+        services.AddSingleton(currentUser);
     }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.Application.Tests/Volo/Abp/PermissionManagement/AbpPermissionManagementApplicationTestModule.cs

@@ -5,24 +5,23 @@ using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.Modularity;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+[DependsOn(
+    typeof(AbpPermissionManagementApplicationModule),
+    typeof(AbpPermissionManagementTestModule)
+)]
+public class AbpPermissionManagementApplicationTestModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpPermissionManagementApplicationModule),
-        typeof(AbpPermissionManagementTestModule)
-    )]
-    public class AbpPermissionManagementApplicationTestModule : AbpModule
+    public override void ConfigureServices(ServiceConfigurationContext context)
     {
-        public override void ConfigureServices(ServiceConfigurationContext context)
-        {
-            context.Services.AddAlwaysAllowAuthorization();
+        context.Services.AddAlwaysAllowAuthorization();
 
-            context.Services.Configure<PermissionManagementOptions>(options =>
-            {
-                options.ProviderPolicies[UserPermissionValueProvider.ProviderName] = UserPermissionValueProvider.ProviderName;
-                options.ProviderPolicies["Test"] = "Test";
-                options.ManagementProviders.Add<TestPermissionManagementProvider>();
-            });
-        }
+        context.Services.Configure<PermissionManagementOptions>(options =>
+        {
+            options.ProviderPolicies[UserPermissionValueProvider.ProviderName] = UserPermissionValueProvider.ProviderName;
+            options.ProviderPolicies["Test"] = "Test";
+            options.ManagementProviders.Add<TestPermissionManagementProvider>();
+        });
     }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.Application.Tests/Volo/Abp/PermissionManagement/PermissionAppService_Tests.cs

@@ -9,99 +9,98 @@ using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.Security.Claims;
 using Xunit;
 
-namespace Volo.Abp.PermissionManagement.Application.Tests.Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement.Application.Tests.Volo.Abp.PermissionManagement;
+
+public class PermissionAppService_Tests : AbpPermissionManagementApplicationTestBase
 {
-    public class PermissionAppService_Tests : AbpPermissionManagementApplicationTestBase
-    {
-        private readonly IPermissionAppService _permissionAppService;
-        private readonly IPermissionGrantRepository _permissionGrantRepository;
-        private readonly ICurrentPrincipalAccessor _currentPrincipalAccessor;
+    private readonly IPermissionAppService _permissionAppService;
+    private readonly IPermissionGrantRepository _permissionGrantRepository;
+    private readonly ICurrentPrincipalAccessor _currentPrincipalAccessor;
 
-        public PermissionAppService_Tests()
-        {
-            _permissionAppService = GetRequiredService<IPermissionAppService>();
-            _permissionGrantRepository = GetRequiredService<IPermissionGrantRepository>();
-            _currentPrincipalAccessor = GetRequiredService<ICurrentPrincipalAccessor>();
-        }
+    public PermissionAppService_Tests()
+    {
+        _permissionAppService = GetRequiredService<IPermissionAppService>();
+        _permissionGrantRepository = GetRequiredService<IPermissionGrantRepository>();
+        _currentPrincipalAccessor = GetRequiredService<ICurrentPrincipalAccessor>();
+    }
 
-        [Fact]
-        public async Task GetAsync()
-        {
-            var permissionListResultDto = await _permissionAppService.GetAsync(UserPermissionValueProvider.ProviderName,
-                PermissionTestDataBuilder.User1Id.ToString());
+    [Fact]
+    public async Task GetAsync()
+    {
+        var permissionListResultDto = await _permissionAppService.GetAsync(UserPermissionValueProvider.ProviderName,
+            PermissionTestDataBuilder.User1Id.ToString());
 
-            permissionListResultDto.ShouldNotBeNull();
-            permissionListResultDto.EntityDisplayName.ShouldBe(PermissionTestDataBuilder.User1Id.ToString());
-            permissionListResultDto.Groups.Count.ShouldBe(1);
-            permissionListResultDto.Groups.ShouldContain(x => x.Name == "TestGroup");
+        permissionListResultDto.ShouldNotBeNull();
+        permissionListResultDto.EntityDisplayName.ShouldBe(PermissionTestDataBuilder.User1Id.ToString());
+        permissionListResultDto.Groups.Count.ShouldBe(1);
+        permissionListResultDto.Groups.ShouldContain(x => x.Name == "TestGroup");
 
-            permissionListResultDto.Groups.First().Permissions.ShouldContain(x => x.Name == "MyPermission1");
-            permissionListResultDto.Groups.First().Permissions.ShouldContain(x => x.Name == "MyPermission2");
-            permissionListResultDto.Groups.First().Permissions.ShouldContain(x => x.Name == "MyPermission2.ChildPermission1");
-            permissionListResultDto.Groups.First().Permissions.ShouldContain(x => x.Name == "MyPermission3");
-            permissionListResultDto.Groups.First().Permissions.ShouldContain(x => x.Name == "MyPermission4");
+        permissionListResultDto.Groups.First().Permissions.ShouldContain(x => x.Name == "MyPermission1");
+        permissionListResultDto.Groups.First().Permissions.ShouldContain(x => x.Name == "MyPermission2");
+        permissionListResultDto.Groups.First().Permissions.ShouldContain(x => x.Name == "MyPermission2.ChildPermission1");
+        permissionListResultDto.Groups.First().Permissions.ShouldContain(x => x.Name == "MyPermission3");
+        permissionListResultDto.Groups.First().Permissions.ShouldContain(x => x.Name == "MyPermission4");
 
-            permissionListResultDto.Groups.First().Permissions.ShouldNotContain(x => x.Name == "MyPermission5");
+        permissionListResultDto.Groups.First().Permissions.ShouldNotContain(x => x.Name == "MyPermission5");
 
-            using (_currentPrincipalAccessor.Change(new Claim(AbpClaimTypes.Role, "super-admin")))
-            {
-                (await _permissionAppService.GetAsync(UserPermissionValueProvider.ProviderName, PermissionTestDataBuilder.User1Id.ToString())).Groups.First().Permissions
-                    .ShouldContain(x => x.Name == "MyPermission5");
-            }
+        using (_currentPrincipalAccessor.Change(new Claim(AbpClaimTypes.Role, "super-admin")))
+        {
+            (await _permissionAppService.GetAsync(UserPermissionValueProvider.ProviderName, PermissionTestDataBuilder.User1Id.ToString())).Groups.First().Permissions
+                .ShouldContain(x => x.Name == "MyPermission5");
         }
+    }
 
-        [Fact]
-        public async Task UpdateAsync()
-        {
-            (await _permissionGrantRepository.FindAsync("MyPermission1", "Test",
-                "Test")).ShouldBeNull();
+    [Fact]
+    public async Task UpdateAsync()
+    {
+        (await _permissionGrantRepository.FindAsync("MyPermission1", "Test",
+            "Test")).ShouldBeNull();
 
-            await _permissionAppService.UpdateAsync("Test",
-                "Test", new UpdatePermissionsDto()
+        await _permissionAppService.UpdateAsync("Test",
+            "Test", new UpdatePermissionsDto()
+            {
+                Permissions = new UpdatePermissionDto[]
                 {
-                    Permissions = new UpdatePermissionDto[]
-                    {
                         new UpdatePermissionDto()
                         {
                             IsGranted = true,
                             Name = "MyPermission1"
                         }
-                    }
-                });
+                }
+            });
 
-            (await _permissionGrantRepository.FindAsync("MyPermission1", "Test",
-                "Test")).ShouldNotBeNull();
-        }
+        (await _permissionGrantRepository.FindAsync("MyPermission1", "Test",
+            "Test")).ShouldNotBeNull();
+    }
 
-        [Fact]
-        public async Task Update_Revoke_Test()
-        {
-            await _permissionGrantRepository.InsertAsync(
-                new PermissionGrant(
-                    Guid.NewGuid(),
-                    "MyPermission1",
-                    "Test",
-                    "Test"
-                )
-            );
-            (await _permissionGrantRepository.FindAsync("MyPermission1", "Test",
-                "Test")).ShouldNotBeNull();
+    [Fact]
+    public async Task Update_Revoke_Test()
+    {
+        await _permissionGrantRepository.InsertAsync(
+            new PermissionGrant(
+                Guid.NewGuid(),
+                "MyPermission1",
+                "Test",
+                "Test"
+            )
+        );
+        (await _permissionGrantRepository.FindAsync("MyPermission1", "Test",
+            "Test")).ShouldNotBeNull();
 
-            await _permissionAppService.UpdateAsync("Test",
-                "Test", new UpdatePermissionsDto()
+        await _permissionAppService.UpdateAsync("Test",
+            "Test", new UpdatePermissionsDto()
+            {
+                Permissions = new UpdatePermissionDto[]
                 {
-                    Permissions = new UpdatePermissionDto[]
-                    {
                         new UpdatePermissionDto()
                         {
                             IsGranted = false,
                             Name = "MyPermission1"
                         }
-                    }
-                });
+                }
+            });
 
-            (await _permissionGrantRepository.FindAsync("MyPermission1", "Test",
-                "Test")).ShouldBeNull();
-        }
+        (await _permissionGrantRepository.FindAsync("MyPermission1", "Test",
+            "Test")).ShouldBeNull();
     }
 }

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

@@ -6,31 +6,30 @@ using Volo.Abp.Modularity;
 using Volo.Abp.PermissionManagement.EntityFrameworkCore;
 using Volo.Abp.Uow;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+[DependsOn(
+    typeof(AbpPermissionManagementEntityFrameworkCoreModule),
+    typeof(AbpPermissionManagementTestBaseModule))]
+public class AbpPermissionManagementTestModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpPermissionManagementEntityFrameworkCoreModule), 
-        typeof(AbpPermissionManagementTestBaseModule))]
-    public class AbpPermissionManagementTestModule : AbpModule
+    public override void ConfigureServices(ServiceConfigurationContext context)
     {
-        public override void ConfigureServices(ServiceConfigurationContext context)
-        {
-            context.Services.AddEntityFrameworkInMemoryDatabase();
+        context.Services.AddEntityFrameworkInMemoryDatabase();
 
-            var databaseName = Guid.NewGuid().ToString();
+        var databaseName = Guid.NewGuid().ToString();
 
-            Configure<AbpDbContextOptions>(options =>
+        Configure<AbpDbContextOptions>(options =>
+        {
+            options.Configure(abpDbContextConfigurationContext =>
             {
-                options.Configure(abpDbContextConfigurationContext =>
-                {
-                    abpDbContextConfigurationContext.DbContextOptions.UseInMemoryDatabase(databaseName);
-                });
+                abpDbContextConfigurationContext.DbContextOptions.UseInMemoryDatabase(databaseName);
             });
+        });
 
-            Configure<AbpUnitOfWorkDefaultOptions>(options =>
-            {
-                options.TransactionBehavior = UnitOfWorkTransactionBehavior.Disabled; //EF in-memory database does not support transactions
+        Configure<AbpUnitOfWorkDefaultOptions>(options =>
+        {
+            options.TransactionBehavior = UnitOfWorkTransactionBehavior.Disabled; //EF in-memory database does not support transactions
             });
-        }
     }
 }

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

@@ -3,29 +3,28 @@ using Shouldly;
 using Volo.Abp.Authorization.Permissions;
 using Xunit;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionChecker_Basic_Tests : PermissionTestBase
 {
-    public class PermissionChecker_Basic_Tests : PermissionTestBase
-    {
-        private readonly IPermissionChecker _permissionChecker;
+    private readonly IPermissionChecker _permissionChecker;
 
-        public PermissionChecker_Basic_Tests()
-        {
-            _permissionChecker = GetRequiredService<IPermissionChecker>();
-        }
+    public PermissionChecker_Basic_Tests()
+    {
+        _permissionChecker = GetRequiredService<IPermissionChecker>();
+    }
 
-        [Fact]
-        public async Task Should_Throw_Exception_If_Permission_Is_Not_Defined()
-        {
-            await Assert.ThrowsAsync<AbpException>(async () =>
-                await _permissionChecker.IsGrantedAsync("UndefinedPermissionName")
-            );
-        }
+    [Fact]
+    public async Task Should_Throw_Exception_If_Permission_Is_Not_Defined()
+    {
+        await Assert.ThrowsAsync<AbpException>(async () =>
+            await _permissionChecker.IsGrantedAsync("UndefinedPermissionName")
+        );
+    }
 
-        [Fact]
-        public async Task Should_Return_False_As_Default_For_Any_Permission()
-        {
-            (await _permissionChecker.IsGrantedAsync("MyPermission1")).ShouldBeFalse();
-        }
+    [Fact]
+    public async Task Should_Return_False_As_Default_For_Any_Permission()
+    {
+        (await _permissionChecker.IsGrantedAsync("MyPermission1")).ShouldBeFalse();
     }
 }

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

@@ -6,102 +6,101 @@ using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.Security.Claims;
 using Xunit;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionChecker_User_Tests : PermissionTestBase
 {
-    public class PermissionChecker_User_Tests : PermissionTestBase
+    private readonly IPermissionChecker _permissionChecker;
+    private readonly ICurrentPrincipalAccessor _currentPrincipalAccessor;
+
+    public PermissionChecker_User_Tests()
     {
-        private readonly IPermissionChecker _permissionChecker;
-        private readonly ICurrentPrincipalAccessor _currentPrincipalAccessor;
+        _permissionChecker = GetRequiredService<IPermissionChecker>();
+        _currentPrincipalAccessor = GetRequiredService<ICurrentPrincipalAccessor>();
+    }
 
-        public PermissionChecker_User_Tests()
-        {
-            _permissionChecker = GetRequiredService<IPermissionChecker>();
-            _currentPrincipalAccessor = GetRequiredService<ICurrentPrincipalAccessor>();
-        }
+    [Fact]
+    public async Task Should_Return_True_For_Granted_Current_User()
+    {
+        (await _permissionChecker.IsGrantedAsync(
+            CreatePrincipal(PermissionTestDataBuilder.User1Id),
+            "MyPermission1"
+        )).ShouldBeTrue();
+    }
 
-        [Fact]
-        public async Task Should_Return_True_For_Granted_Current_User()
-        {
-            (await _permissionChecker.IsGrantedAsync(
-                CreatePrincipal(PermissionTestDataBuilder.User1Id),
-                "MyPermission1"
-            )).ShouldBeTrue();
-        }
+    [Fact]
+    public async Task Should_Return_False_For_Non_Granted_Current_User()
+    {
+        (await _permissionChecker.IsGrantedAsync(
+            CreatePrincipal(PermissionTestDataBuilder.User2Id),
+            "MyPermission1"
+        )).ShouldBeFalse();
+    }
 
-        [Fact]
-        public async Task Should_Return_False_For_Non_Granted_Current_User()
-        {
-            (await _permissionChecker.IsGrantedAsync(
-                CreatePrincipal(PermissionTestDataBuilder.User2Id),
-                "MyPermission1"
-            )).ShouldBeFalse();
-        }
 
+    [Fact]
+    public async Task Should_Return_False_For_Granted_Current_User_If_The_Permission_Is_Disabled()
+    {
+        //Disabled permissions always returns false!
+        (await _permissionChecker.IsGrantedAsync(
+            CreatePrincipal(PermissionTestDataBuilder.User1Id),
+            "MyDisabledPermission1"
+        )).ShouldBeFalse();
+    }
 
-        [Fact]
-        public async Task Should_Return_False_For_Granted_Current_User_If_The_Permission_Is_Disabled()
-        {
-            //Disabled permissions always returns false!
-            (await _permissionChecker.IsGrantedAsync(
-                CreatePrincipal(PermissionTestDataBuilder.User1Id),
-                "MyDisabledPermission1"
-            )).ShouldBeFalse();
-        }
+    [Fact]
+    public async Task Should_Return_False_For_Current_User_If_Anonymous()
+    {
+        (await _permissionChecker.IsGrantedAsync(
+            CreatePrincipal(null),
+            "MyPermission1"
+        )).ShouldBeFalse();
+    }
 
-        [Fact]
-        public async Task Should_Return_False_For_Current_User_If_Anonymous()
-        {
-            (await _permissionChecker.IsGrantedAsync(
-                CreatePrincipal(null),
-                "MyPermission1"
-            )).ShouldBeFalse();
-        }
+    [Fact]
+    public async Task Should_Not_Allow_Host_Permission_To_Tenant_User_Even_Granted_Before()
+    {
+        (await _permissionChecker.IsGrantedAsync(
+            CreatePrincipal(PermissionTestDataBuilder.User1Id, Guid.NewGuid()),
+            "MyPermission3"
+        )).ShouldBeFalse();
+    }
 
-        [Fact]
-        public async Task Should_Not_Allow_Host_Permission_To_Tenant_User_Even_Granted_Before()
-        {
-            (await _permissionChecker.IsGrantedAsync(
-                CreatePrincipal(PermissionTestDataBuilder.User1Id, Guid.NewGuid()),
-                "MyPermission3"
-            )).ShouldBeFalse();
-        }
+    [Fact]
+    public async Task Should_Return_False_For_Granted_Current_User_If_The_Permission_State_Is_Disabled()
+    {
+        (await _permissionChecker.IsGrantedAsync(
+            CreatePrincipal(PermissionTestDataBuilder.User1Id, Guid.NewGuid()),
+            "MyPermission5"
+        )).ShouldBeFalse();
+    }
 
-        [Fact]
-        public async Task Should_Return_False_For_Granted_Current_User_If_The_Permission_State_Is_Disabled()
+    [Fact]
+    public async Task Should_Return_True_For_Granted_Current_User_If_The_Permission_State_Is_Enabled()
+    {
+        using (_currentPrincipalAccessor.Change(new Claim(AbpClaimTypes.Role, "super-admin")))
         {
             (await _permissionChecker.IsGrantedAsync(
                 CreatePrincipal(PermissionTestDataBuilder.User1Id, Guid.NewGuid()),
                 "MyPermission5"
-            )).ShouldBeFalse();
+            )).ShouldBeTrue();
         }
+    }
+
+    private static ClaimsPrincipal CreatePrincipal(Guid? userId, Guid? tenantId = null)
+    {
+        var claimsIdentity = new ClaimsIdentity();
 
-        [Fact]
-        public async Task Should_Return_True_For_Granted_Current_User_If_The_Permission_State_Is_Enabled()
+        if (userId != null)
         {
-            using (_currentPrincipalAccessor.Change(new Claim(AbpClaimTypes.Role, "super-admin")))
-            {
-                (await _permissionChecker.IsGrantedAsync(
-                    CreatePrincipal(PermissionTestDataBuilder.User1Id, Guid.NewGuid()),
-                    "MyPermission5"
-                )).ShouldBeTrue();
-            }
+            claimsIdentity.AddClaim(new Claim(AbpClaimTypes.UserId, userId.ToString()));
         }
 
-        private static ClaimsPrincipal CreatePrincipal(Guid? userId, Guid? tenantId = null)
+        if (tenantId != null)
         {
-            var claimsIdentity = new ClaimsIdentity();
-
-            if (userId != null)
-            {
-                claimsIdentity.AddClaim(new Claim(AbpClaimTypes.UserId, userId.ToString()));
-            }
-
-            if (tenantId != null)
-            {
-                claimsIdentity.AddClaim(new Claim(AbpClaimTypes.TenantId, tenantId.ToString()));
-            }
-
-            return new ClaimsPrincipal(claimsIdentity);
+            claimsIdentity.AddClaim(new Claim(AbpClaimTypes.TenantId, tenantId.ToString()));
         }
+
+        return new ClaimsPrincipal(claimsIdentity);
     }
 }

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

@@ -4,29 +4,28 @@ using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.Data;
 using Xunit;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionDataSeedContributor_Tests : PermissionTestBase
 {
-    public class PermissionDataSeedContributor_Tests : PermissionTestBase
-    {
-        private readonly PermissionDataSeedContributor _permissionDataSeedContributor;
-        private readonly IPermissionGrantRepository _grantpermissionGrantRepository;
+    private readonly PermissionDataSeedContributor _permissionDataSeedContributor;
+    private readonly IPermissionGrantRepository _grantpermissionGrantRepository;
 
-        public PermissionDataSeedContributor_Tests()
-        {
-            _permissionDataSeedContributor = GetRequiredService<PermissionDataSeedContributor>();
-            _grantpermissionGrantRepository = GetRequiredService<IPermissionGrantRepository>();
-        }
+    public PermissionDataSeedContributor_Tests()
+    {
+        _permissionDataSeedContributor = GetRequiredService<PermissionDataSeedContributor>();
+        _grantpermissionGrantRepository = GetRequiredService<IPermissionGrantRepository>();
+    }
 
-        [Fact]
-        public async Task SeedAsync()
-        {
-            (await _grantpermissionGrantRepository.FindAsync("MyPermission1", RolePermissionValueProvider.ProviderName, "admin")).ShouldBeNull();
-            (await _grantpermissionGrantRepository.FindAsync("MyPermission4", RolePermissionValueProvider.ProviderName, "admin")).ShouldBeNull();
+    [Fact]
+    public async Task SeedAsync()
+    {
+        (await _grantpermissionGrantRepository.FindAsync("MyPermission1", RolePermissionValueProvider.ProviderName, "admin")).ShouldBeNull();
+        (await _grantpermissionGrantRepository.FindAsync("MyPermission4", RolePermissionValueProvider.ProviderName, "admin")).ShouldBeNull();
 
-            await _permissionDataSeedContributor.SeedAsync(new DataSeedContext(null));
+        await _permissionDataSeedContributor.SeedAsync(new DataSeedContext(null));
 
-            (await _grantpermissionGrantRepository.FindAsync("MyPermission1", RolePermissionValueProvider.ProviderName, "admin")).ShouldNotBeNull();
-            (await _grantpermissionGrantRepository.FindAsync("MyPermission4", RolePermissionValueProvider.ProviderName, "admin")).ShouldBeNull();
-        }
+        (await _grantpermissionGrantRepository.FindAsync("MyPermission1", RolePermissionValueProvider.ProviderName, "admin")).ShouldNotBeNull();
+        (await _grantpermissionGrantRepository.FindAsync("MyPermission4", RolePermissionValueProvider.ProviderName, "admin")).ShouldBeNull();
     }
 }

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

@@ -6,66 +6,65 @@ using Shouldly;
 using Volo.Abp.MultiTenancy;
 using Xunit;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionDataSeeder_Tests : PermissionTestBase
 {
-    public class PermissionDataSeeder_Tests : PermissionTestBase
-    {
-        private readonly IPermissionDataSeeder _permissionDataSeeder;
-        private readonly IPermissionGrantRepository _grantpermissionGrantRepository;
-        private readonly ICurrentTenant _currentTenant;
+    private readonly IPermissionDataSeeder _permissionDataSeeder;
+    private readonly IPermissionGrantRepository _grantpermissionGrantRepository;
+    private readonly ICurrentTenant _currentTenant;
 
-        public PermissionDataSeeder_Tests()
-        {
-            _permissionDataSeeder = GetRequiredService<IPermissionDataSeeder>();
-            _grantpermissionGrantRepository = GetRequiredService<IPermissionGrantRepository>();
-            _currentTenant = GetRequiredService<ICurrentTenant>();
-        }
+    public PermissionDataSeeder_Tests()
+    {
+        _permissionDataSeeder = GetRequiredService<IPermissionDataSeeder>();
+        _grantpermissionGrantRepository = GetRequiredService<IPermissionGrantRepository>();
+        _currentTenant = GetRequiredService<ICurrentTenant>();
+    }
 
-        [Fact]
-        public async Task SeedAsync()
-        {
-            (await _grantpermissionGrantRepository.FindAsync("MyPermission1", "Test", "Test")).ShouldBeNull();
-            (await _grantpermissionGrantRepository.FindAsync("MyPermission2", "Test", "Test")).ShouldBeNull();
+    [Fact]
+    public async Task SeedAsync()
+    {
+        (await _grantpermissionGrantRepository.FindAsync("MyPermission1", "Test", "Test")).ShouldBeNull();
+        (await _grantpermissionGrantRepository.FindAsync("MyPermission2", "Test", "Test")).ShouldBeNull();
 
-            await _permissionDataSeeder.SeedAsync("Test", "Test", new List<string>()
+        await _permissionDataSeeder.SeedAsync("Test", "Test", new List<string>()
             {
                 "MyPermission1",
                 "MyPermission2"
             });
 
-            (await _grantpermissionGrantRepository.FindAsync("MyPermission1", "Test", "Test")).ShouldNotBeNull();
-            (await _grantpermissionGrantRepository.FindAsync("MyPermission2", "Test", "Test")).ShouldNotBeNull();
-        }
+        (await _grantpermissionGrantRepository.FindAsync("MyPermission1", "Test", "Test")).ShouldNotBeNull();
+        (await _grantpermissionGrantRepository.FindAsync("MyPermission2", "Test", "Test")).ShouldNotBeNull();
+    }
 
-        [Fact]
-        public async Task Seed_With_TenantId()
-        {
-            //Seed without tenant
-            await _permissionDataSeeder.SeedAsync("Test", "Test", new List<string>()
+    [Fact]
+    public async Task Seed_With_TenantId()
+    {
+        //Seed without tenant
+        await _permissionDataSeeder.SeedAsync("Test", "Test", new List<string>()
             {
                 "MyPermission1",
                 "MyPermission2"
             });
 
-            var tenantId = Guid.NewGuid();
+        var tenantId = Guid.NewGuid();
 
-            using (_currentTenant.Change(tenantId))
-            {
-                (await _grantpermissionGrantRepository.FindAsync("MyPermission1", "Test", "Test")).ShouldBeNull();
-                (await _grantpermissionGrantRepository.FindAsync("MyPermission2", "Test", "Test")).ShouldBeNull();
-            }
+        using (_currentTenant.Change(tenantId))
+        {
+            (await _grantpermissionGrantRepository.FindAsync("MyPermission1", "Test", "Test")).ShouldBeNull();
+            (await _grantpermissionGrantRepository.FindAsync("MyPermission2", "Test", "Test")).ShouldBeNull();
+        }
 
-            await _permissionDataSeeder.SeedAsync("Test", "Test", new List<string>()
+        await _permissionDataSeeder.SeedAsync("Test", "Test", new List<string>()
             {
                 "MyPermission1",
                 "MyPermission2"
             }, tenantId);
 
-            using (_currentTenant.Change(tenantId))
-            {
-                (await _grantpermissionGrantRepository.FindAsync("MyPermission1", "Test", "Test")).ShouldNotBeNull();
-                (await _grantpermissionGrantRepository.FindAsync("MyPermission2", "Test", "Test")).ShouldNotBeNull();
-            }
+        using (_currentTenant.Change(tenantId))
+        {
+            (await _grantpermissionGrantRepository.FindAsync("MyPermission1", "Test", "Test")).ShouldNotBeNull();
+            (await _grantpermissionGrantRepository.FindAsync("MyPermission2", "Test", "Test")).ShouldNotBeNull();
         }
     }
 }

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

@@ -8,56 +8,55 @@ using Volo.Abp.Caching;
 using Volo.Abp.MultiTenancy;
 using Xunit;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionGrantCacheItemInvalidator_Tests : PermissionTestBase
 {
-    public class PermissionGrantCacheItemInvalidator_Tests : PermissionTestBase
+    private readonly IDistributedCache<PermissionGrantCacheItem> _cache;
+    private readonly IPermissionStore _permissionStore;
+    private readonly IPermissionGrantRepository _permissionGrantRepository;
+
+    public PermissionGrantCacheItemInvalidator_Tests()
+    {
+        _cache = GetRequiredService<IDistributedCache<PermissionGrantCacheItem>>();
+        _permissionStore = GetRequiredService<IPermissionStore>();
+        _permissionGrantRepository = GetRequiredService<IPermissionGrantRepository>();
+    }
+
+    [Fact]
+    public async Task PermissionStore_IsGrantedAsync_Should_Cache_PermissionGrant()
+    {
+        (await _cache.GetAsync(PermissionGrantCacheItem.CalculateCacheKey("MyPermission1",
+            UserPermissionValueProvider.ProviderName,
+            PermissionTestDataBuilder.User1Id.ToString()))).ShouldBeNull();
+
+
+        await _permissionStore.IsGrantedAsync("MyPermission1",
+            UserPermissionValueProvider.ProviderName,
+            PermissionTestDataBuilder.User1Id.ToString());
+
+
+        (await _cache.GetAsync(PermissionGrantCacheItem.CalculateCacheKey("MyPermission1",
+            UserPermissionValueProvider.ProviderName,
+            PermissionTestDataBuilder.User1Id.ToString()))).ShouldNotBeNull();
+    }
+
+    [Fact]
+    public async Task Cache_Should_Invalidator_WhenPermissionGrantChanged()
     {
-        private readonly IDistributedCache<PermissionGrantCacheItem> _cache;
-        private readonly IPermissionStore _permissionStore;
-        private readonly IPermissionGrantRepository _permissionGrantRepository;
-
-        public PermissionGrantCacheItemInvalidator_Tests()
-        {
-            _cache = GetRequiredService<IDistributedCache<PermissionGrantCacheItem>>();
-            _permissionStore = GetRequiredService<IPermissionStore>();
-            _permissionGrantRepository = GetRequiredService<IPermissionGrantRepository>();
-        }
-
-        [Fact]
-        public async Task PermissionStore_IsGrantedAsync_Should_Cache_PermissionGrant()
-        {
-            (await _cache.GetAsync(PermissionGrantCacheItem.CalculateCacheKey("MyPermission1",
-                UserPermissionValueProvider.ProviderName,
-                PermissionTestDataBuilder.User1Id.ToString()))).ShouldBeNull();
-
-
-            await _permissionStore.IsGrantedAsync("MyPermission1",
-                UserPermissionValueProvider.ProviderName,
-                PermissionTestDataBuilder.User1Id.ToString());
-
-
-            (await _cache.GetAsync(PermissionGrantCacheItem.CalculateCacheKey("MyPermission1",
-                UserPermissionValueProvider.ProviderName,
-                PermissionTestDataBuilder.User1Id.ToString()))).ShouldNotBeNull();
-        }
-
-        [Fact]
-        public async Task Cache_Should_Invalidator_WhenPermissionGrantChanged()
-        {
-            // IsGrantedAsync will cache PermissionGrant
-            await _permissionStore.IsGrantedAsync("MyPermission1",
-                UserPermissionValueProvider.ProviderName,
-                PermissionTestDataBuilder.User1Id.ToString());
-
-            var permissionGrant = await _permissionGrantRepository.FindAsync("MyPermission1",
-                UserPermissionValueProvider.ProviderName,
-                PermissionTestDataBuilder.User1Id.ToString());
-            permissionGrant.ShouldNotBeNull();
-            await _permissionGrantRepository.DeleteAsync(permissionGrant);
-
-            (await _cache.GetAsync(PermissionGrantCacheItem.CalculateCacheKey("MyPermission1",
-                UserPermissionValueProvider.ProviderName,
-                PermissionTestDataBuilder.User1Id.ToString()))).ShouldBeNull();
-        }
+        // IsGrantedAsync will cache PermissionGrant
+        await _permissionStore.IsGrantedAsync("MyPermission1",
+            UserPermissionValueProvider.ProviderName,
+            PermissionTestDataBuilder.User1Id.ToString());
+
+        var permissionGrant = await _permissionGrantRepository.FindAsync("MyPermission1",
+            UserPermissionValueProvider.ProviderName,
+            PermissionTestDataBuilder.User1Id.ToString());
+        permissionGrant.ShouldNotBeNull();
+        await _permissionGrantRepository.DeleteAsync(permissionGrant);
+
+        (await _cache.GetAsync(PermissionGrantCacheItem.CalculateCacheKey("MyPermission1",
+            UserPermissionValueProvider.ProviderName,
+            PermissionTestDataBuilder.User1Id.ToString()))).ShouldBeNull();
     }
 }

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

@@ -1,16 +1,15 @@
 using Shouldly;
 using Xunit;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionGrantCacheItem_Tests
 {
-    public class PermissionGrantCacheItem_Tests
+    [Fact]
+    public void GetPermissionNameFormCacheKeyOrNull()
     {
-        [Fact]
-        public void GetPermissionNameFormCacheKeyOrNull()
-        {
-            var key = PermissionGrantCacheItem.CalculateCacheKey("aaa", "bbb", "ccc");
-            PermissionGrantCacheItem.GetPermissionNameFormCacheKeyOrNull(key).ShouldBe("aaa");
-            PermissionGrantCacheItem.GetPermissionNameFormCacheKeyOrNull("aaabbbccc").ShouldBeNull();
-        }
+        var key = PermissionGrantCacheItem.CalculateCacheKey("aaa", "bbb", "ccc");
+        PermissionGrantCacheItem.GetPermissionNameFormCacheKeyOrNull(key).ShouldBe("aaa");
+        PermissionGrantCacheItem.GetPermissionNameFormCacheKeyOrNull("aaabbbccc").ShouldBeNull();
     }
 }

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

@@ -4,76 +4,75 @@ using Shouldly;
 using Volo.Abp.Authorization.Permissions;
 using Xunit;
 
-namespace Volo.Abp.PermissionManagement
-{
-    public class PermissionManagementProvider_Tests : PermissionTestBase
-    {
-        private readonly IPermissionManagementProvider _permissionManagementProvider;
-        private readonly IPermissionGrantRepository _permissionGrantRepository;
+namespace Volo.Abp.PermissionManagement;
 
+public class PermissionManagementProvider_Tests : PermissionTestBase
+{
+    private readonly IPermissionManagementProvider _permissionManagementProvider;
+    private readonly IPermissionGrantRepository _permissionGrantRepository;
 
-        public PermissionManagementProvider_Tests()
-        {
-            _permissionManagementProvider = GetRequiredService<TestPermissionManagementProvider>();
-            _permissionGrantRepository = GetRequiredService<IPermissionGrantRepository>();
-        }
 
+    public PermissionManagementProvider_Tests()
+    {
+        _permissionManagementProvider = GetRequiredService<TestPermissionManagementProvider>();
+        _permissionGrantRepository = GetRequiredService<IPermissionGrantRepository>();
+    }
 
-        [Fact]
-        public async Task CheckAsync()
-        {
-            await _permissionGrantRepository.InsertAsync(
-                new PermissionGrant(
-                    Guid.NewGuid(),
-                    "MyPermission1",
-                    "Test",
-                    "Test"
-                )
-            );
 
-            var permissionValueProviderGrantInfo = await _permissionManagementProvider.CheckAsync("MyPermission1",
+    [Fact]
+    public async Task CheckAsync()
+    {
+        await _permissionGrantRepository.InsertAsync(
+            new PermissionGrant(
+                Guid.NewGuid(),
+                "MyPermission1",
                 "Test",
-                "Test");
+                "Test"
+            )
+        );
 
-            permissionValueProviderGrantInfo.IsGranted.ShouldBeTrue();
-            permissionValueProviderGrantInfo.ProviderKey.ShouldBe("Test");
-        }
+        var permissionValueProviderGrantInfo = await _permissionManagementProvider.CheckAsync("MyPermission1",
+            "Test",
+            "Test");
 
-        [Fact]
-        public async Task Check_Should_Return_NonGranted_When_ProviderName_NotEquals_Name()
-        {
-            var permissionValueProviderGrantInfo = await _permissionManagementProvider.CheckAsync("MyPermission1",
-                "TestNotExist",
-                "Test");
+        permissionValueProviderGrantInfo.IsGranted.ShouldBeTrue();
+        permissionValueProviderGrantInfo.ProviderKey.ShouldBe("Test");
+    }
 
-            permissionValueProviderGrantInfo.IsGranted.ShouldBeFalse();
-            permissionValueProviderGrantInfo.ProviderKey.ShouldBeNull();
-        }
+    [Fact]
+    public async Task Check_Should_Return_NonGranted_When_ProviderName_NotEquals_Name()
+    {
+        var permissionValueProviderGrantInfo = await _permissionManagementProvider.CheckAsync("MyPermission1",
+            "TestNotExist",
+            "Test");
 
+        permissionValueProviderGrantInfo.IsGranted.ShouldBeFalse();
+        permissionValueProviderGrantInfo.ProviderKey.ShouldBeNull();
+    }
 
-        [Fact]
-        public async Task SetAsync()
-        {
-            await _permissionGrantRepository.InsertAsync(
-                new PermissionGrant(
-                    Guid.NewGuid(),
-                    "MyPermission1",
-                    "Test",
-                    "Test"
-                )
-            );
-            (await _permissionGrantRepository.FindAsync("MyPermission1",
-                "Test",
-                "Test")).ShouldNotBeNull();
 
-            await _permissionManagementProvider.SetAsync("MyPermission1",
+    [Fact]
+    public async Task SetAsync()
+    {
+        await _permissionGrantRepository.InsertAsync(
+            new PermissionGrant(
+                Guid.NewGuid(),
+                "MyPermission1",
                 "Test",
-                false);
+                "Test"
+            )
+        );
+        (await _permissionGrantRepository.FindAsync("MyPermission1",
+            "Test",
+            "Test")).ShouldNotBeNull();
 
-            (await _permissionGrantRepository.FindAsync("MyPermission1",
-                "Test",
-                "Test")).ShouldBeNull();
-        }
+        await _permissionManagementProvider.SetAsync("MyPermission1",
+            "Test",
+            false);
 
+        (await _permissionGrantRepository.FindAsync("MyPermission1",
+            "Test",
+            "Test")).ShouldBeNull();
     }
+
 }

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

@@ -7,148 +7,147 @@ using Shouldly;
 using Volo.Abp.Authorization.Permissions;
 using Xunit;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionManager_Tests : PermissionTestBase
 {
-    public class PermissionManager_Tests : PermissionTestBase
+    private readonly IPermissionManager _permissionManager;
+    private readonly IPermissionGrantRepository _permissionGrantRepository;
+
+    public PermissionManager_Tests()
+    {
+        _permissionManager = GetRequiredService<IPermissionManager>();
+        _permissionGrantRepository = GetRequiredService<IPermissionGrantRepository>();
+    }
+
+    [Fact]
+    public async Task GetAsync()
+    {
+        await _permissionGrantRepository.InsertAsync(new PermissionGrant(
+            Guid.NewGuid(),
+            "MyPermission1",
+            "Test",
+            "Test")
+        );
+
+        var grantedProviders = await _permissionManager.GetAsync("MyPermission1",
+            "Test",
+            "Test");
+
+        grantedProviders.ShouldNotBeNull();
+        grantedProviders.IsGranted.ShouldBeTrue();
+        grantedProviders.Name.ShouldBe("MyPermission1");
+        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()
+    {
+        await Assert.ThrowsAsync<AbpException>(async () => await _permissionManager.GetAsync(
+            "MyPermission1NotExist",
+            "Test",
+            "Test"));
+    }
+
+    [Fact]
+    public async Task GetAllAsync()
+    {
+        await _permissionGrantRepository.InsertAsync(new PermissionGrant(
+            Guid.NewGuid(),
+            "MyPermission1",
+            "Test",
+            "Test")
+        );
+
+        await _permissionGrantRepository.InsertAsync(new PermissionGrant(
+            Guid.NewGuid(),
+            "MyPermission2",
+            "Test",
+            "Test")
+        );
+
+        var permissionWithGrantedProviders = await _permissionManager.GetAllAsync(
+            "Test",
+            "Test");
+
+        permissionWithGrantedProviders.ShouldNotBeNull();
+        permissionWithGrantedProviders.ShouldContain(x =>
+            x.IsGranted && x.Name == "MyPermission1" && x.Providers.Any(p => p.Key == "Test"));
+        permissionWithGrantedProviders.ShouldContain(x =>
+            x.IsGranted && x.Name == "MyPermission2" && x.Providers.Any(p => p.Key == "Test"));
+    }
+
+    [Fact]
+    public async Task SetAsync()
+    {
+        (await _permissionGrantRepository.FindAsync("MyPermission2",
+            "Test",
+            "Test")).ShouldBeNull();
+
+        await _permissionManager.SetAsync(
+            "MyPermission2",
+            "Test",
+            "Test", true);
+
+        (await _permissionGrantRepository.FindAsync("MyPermission2",
+            "Test",
+            "Test")).ShouldNotBeNull();
+    }
+
+    [Fact]
+    public async Task Set_Should_Exception_When_Permission_Undefined()
+    {
+        await Assert.ThrowsAsync<AbpException>(async () => await _permissionManager.SetAsync(
+            "MyPermission1NotExist",
+            "Test",
+            "Test",
+            true));
+    }
+
+    [Fact]
+    public async Task UpdateProviderKey()
     {
-        private readonly IPermissionManager _permissionManager;
-        private readonly IPermissionGrantRepository _permissionGrantRepository;
-
-        public PermissionManager_Tests()
-        {
-            _permissionManager = GetRequiredService<IPermissionManager>();
-            _permissionGrantRepository = GetRequiredService<IPermissionGrantRepository>();
-        }
-
-        [Fact]
-        public async Task GetAsync()
-        {
-            await _permissionGrantRepository.InsertAsync(new PermissionGrant(
-                Guid.NewGuid(),
-                "MyPermission1",
-                "Test",
-                "Test")
-            );
-
-            var grantedProviders = await _permissionManager.GetAsync("MyPermission1",
-                "Test",
-                "Test");
-
-            grantedProviders.ShouldNotBeNull();
-            grantedProviders.IsGranted.ShouldBeTrue();
-            grantedProviders.Name.ShouldBe("MyPermission1");
-            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()
-        {
-            await Assert.ThrowsAsync<AbpException>(async () => await _permissionManager.GetAsync(
-                "MyPermission1NotExist",
-                "Test",
-                "Test"));
-        }
-
-        [Fact]
-        public async Task GetAllAsync()
-        {
-            await _permissionGrantRepository.InsertAsync(new PermissionGrant(
-                Guid.NewGuid(),
-                "MyPermission1",
-                "Test",
-                "Test")
-            );
-
-            await _permissionGrantRepository.InsertAsync(new PermissionGrant(
-                Guid.NewGuid(),
-                "MyPermission2",
-                "Test",
-                "Test")
-            );
-
-            var permissionWithGrantedProviders = await _permissionManager.GetAllAsync(
-                "Test",
-                "Test");
-
-            permissionWithGrantedProviders.ShouldNotBeNull();
-            permissionWithGrantedProviders.ShouldContain(x =>
-                x.IsGranted && x.Name == "MyPermission1" && x.Providers.Any(p => p.Key == "Test"));
-            permissionWithGrantedProviders.ShouldContain(x =>
-                x.IsGranted && x.Name == "MyPermission2" && x.Providers.Any(p => p.Key == "Test"));
-        }
-
-        [Fact]
-        public async Task SetAsync()
-        {
-            (await _permissionGrantRepository.FindAsync("MyPermission2",
-                "Test",
-                "Test")).ShouldBeNull();
-
-            await _permissionManager.SetAsync(
-                "MyPermission2",
-                "Test",
-                "Test", true);
-
-            (await _permissionGrantRepository.FindAsync("MyPermission2",
-                "Test",
-                "Test")).ShouldNotBeNull();
-        }
-
-        [Fact]
-        public async Task Set_Should_Exception_When_Permission_Undefined()
-        {
-            await Assert.ThrowsAsync<AbpException>(async () => await _permissionManager.SetAsync(
-                "MyPermission1NotExist",
-                "Test",
-                "Test",
-                true));
-        }
-
-        [Fact]
-        public async Task UpdateProviderKey()
-        {
-            await _permissionGrantRepository.InsertAsync(new PermissionGrant(
-                Guid.NewGuid(),
-                "MyPermission1",
-                "Test",
-                "Test")
-            );
-            var permissionGrant = await _permissionGrantRepository.FindAsync("MyPermission1", "Test", "Test");
-            permissionGrant.ProviderKey.ShouldBe("Test");
-
-            await _permissionManager.UpdateProviderKeyAsync(permissionGrant, "NewProviderKey");
-            (await _permissionGrantRepository.FindAsync("MyPermission1", "Test", "NewProviderKey")).ShouldNotBeNull();
-        }
+        await _permissionGrantRepository.InsertAsync(new PermissionGrant(
+            Guid.NewGuid(),
+            "MyPermission1",
+            "Test",
+            "Test")
+        );
+        var permissionGrant = await _permissionGrantRepository.FindAsync("MyPermission1", "Test", "Test");
+        permissionGrant.ProviderKey.ShouldBe("Test");
+
+        await _permissionManager.UpdateProviderKeyAsync(permissionGrant, "NewProviderKey");
+        (await _permissionGrantRepository.FindAsync("MyPermission1", "Test", "NewProviderKey")).ShouldNotBeNull();
     }
 }

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

@@ -4,40 +4,39 @@ using Shouldly;
 using Volo.Abp.Authorization.Permissions;
 using Xunit;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionStore_Tests : PermissionTestBase
 {
-    public class PermissionStore_Tests : PermissionTestBase
+    private readonly IPermissionStore _permissionStore;
+
+    public PermissionStore_Tests()
+    {
+        _permissionStore = GetRequiredService<IPermissionStore>();
+    }
+
+    [Fact]
+    public async Task IsGrantedAsync()
     {
-        private readonly IPermissionStore _permissionStore;
-
-        public PermissionStore_Tests()
-        {
-            _permissionStore = GetRequiredService<IPermissionStore>();
-        }
-
-        [Fact]
-        public async Task IsGrantedAsync()
-        {
-            (await _permissionStore.IsGrantedAsync("MyPermission1",
-                UserPermissionValueProvider.ProviderName,
-                PermissionTestDataBuilder.User1Id.ToString())).ShouldBeTrue();
-
-            (await _permissionStore.IsGrantedAsync("MyPermission1NotExist",
-                UserPermissionValueProvider.ProviderName,
-                PermissionTestDataBuilder.User1Id.ToString())).ShouldBeFalse();
-        }
-
-        [Fact]
-        public async Task IsGranted_Multiple()
-        {
-            var result = await _permissionStore.IsGrantedAsync(new[] {"MyPermission1", "MyPermission1NotExist"},
-                UserPermissionValueProvider.ProviderName,
-                PermissionTestDataBuilder.User1Id.ToString());
-
-            result.Result.Count.ShouldBe(2);
-
-            result.Result.FirstOrDefault(x => x.Key == "MyPermission1").Value.ShouldBe(PermissionGrantResult.Granted);
-            result.Result.FirstOrDefault(x => x.Key == "MyPermission1NotExist").Value.ShouldBe(PermissionGrantResult.Undefined);
-        }
+        (await _permissionStore.IsGrantedAsync("MyPermission1",
+            UserPermissionValueProvider.ProviderName,
+            PermissionTestDataBuilder.User1Id.ToString())).ShouldBeTrue();
+
+        (await _permissionStore.IsGrantedAsync("MyPermission1NotExist",
+            UserPermissionValueProvider.ProviderName,
+            PermissionTestDataBuilder.User1Id.ToString())).ShouldBeFalse();
+    }
+
+    [Fact]
+    public async Task IsGranted_Multiple()
+    {
+        var result = await _permissionStore.IsGrantedAsync(new[] { "MyPermission1", "MyPermission1NotExist" },
+            UserPermissionValueProvider.ProviderName,
+            PermissionTestDataBuilder.User1Id.ToString());
+
+        result.Result.Count.ShouldBe(2);
+
+        result.Result.FirstOrDefault(x => x.Key == "MyPermission1").Value.ShouldBe(PermissionGrantResult.Granted);
+        result.Result.FirstOrDefault(x => x.Key == "MyPermission1NotExist").Value.ShouldBe(PermissionGrantResult.Undefined);
     }
 }

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

@@ -1,24 +1,23 @@
 using System;
 using Volo.Abp.PermissionManagement.EntityFrameworkCore;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public abstract class PermissionTestBase : PermissionManagementTestBase<AbpPermissionManagementTestModule>
 {
-    public abstract class PermissionTestBase : PermissionManagementTestBase<AbpPermissionManagementTestModule>
+    protected virtual void UsingDbContext(Action<IPermissionManagementDbContext> action)
     {
-        protected virtual void UsingDbContext(Action<IPermissionManagementDbContext> action)
+        using (var dbContext = GetRequiredService<IPermissionManagementDbContext>())
         {
-            using (var dbContext = GetRequiredService<IPermissionManagementDbContext>())
-            {
-                action.Invoke(dbContext);
-            }
+            action.Invoke(dbContext);
         }
+    }
 
-        protected virtual T UsingDbContext<T>(Func<IPermissionManagementDbContext, T> action)
+    protected virtual T UsingDbContext<T>(Func<IPermissionManagementDbContext, T> action)
+    {
+        using (var dbContext = GetRequiredService<IPermissionManagementDbContext>())
         {
-            using (var dbContext = GetRequiredService<IPermissionManagementDbContext>())
-            {
-                return action.Invoke(dbContext);
-            }
+            return action.Invoke(dbContext);
         }
     }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.EntityFrameworkCore.Tests/Volo/Abp/PermissionManagement/EntityFrameworkCore/AbpPermissionManagementEntityFrameworkCoreTestModule.cs

@@ -5,31 +5,30 @@ using Volo.Abp.EntityFrameworkCore;
 using Volo.Abp.Modularity;
 using Volo.Abp.Uow;
 
-namespace Volo.Abp.PermissionManagement.EntityFrameworkCore
+namespace Volo.Abp.PermissionManagement.EntityFrameworkCore;
+
+[DependsOn(
+    typeof(AbpPermissionManagementEntityFrameworkCoreModule),
+    typeof(AbpPermissionManagementTestBaseModule))]
+public class AbpPermissionManagementEntityFrameworkCoreTestModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpPermissionManagementEntityFrameworkCoreModule),
-        typeof(AbpPermissionManagementTestBaseModule))]
-    public class AbpPermissionManagementEntityFrameworkCoreTestModule : AbpModule
+    public override void ConfigureServices(ServiceConfigurationContext context)
     {
-        public override void ConfigureServices(ServiceConfigurationContext context)
-        {
-            context.Services.AddEntityFrameworkInMemoryDatabase();
+        context.Services.AddEntityFrameworkInMemoryDatabase();
 
-            var databaseName = Guid.NewGuid().ToString();
+        var databaseName = Guid.NewGuid().ToString();
 
-            Configure<AbpDbContextOptions>(options =>
+        Configure<AbpDbContextOptions>(options =>
+        {
+            options.Configure(abpDbContextConfigurationContext =>
             {
-                options.Configure(abpDbContextConfigurationContext =>
-                {
-                    abpDbContextConfigurationContext.DbContextOptions.UseInMemoryDatabase(databaseName);
-                });
+                abpDbContextConfigurationContext.DbContextOptions.UseInMemoryDatabase(databaseName);
             });
+        });
 
-            Configure<AbpUnitOfWorkDefaultOptions>(options =>
-            {
-                options.TransactionBehavior = UnitOfWorkTransactionBehavior.Disabled; //EF in-memory database does not support transactions
+        Configure<AbpUnitOfWorkDefaultOptions>(options =>
+        {
+            options.TransactionBehavior = UnitOfWorkTransactionBehavior.Disabled; //EF in-memory database does not support transactions
             });
-        }
     }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.EntityFrameworkCore.Tests/Volo/Abp/PermissionManagement/EntityFrameworkCore/PermissionGrantRepository_Tests.cs

@@ -1,7 +1,6 @@
-namespace Volo.Abp.PermissionManagement.EntityFrameworkCore
+namespace Volo.Abp.PermissionManagement.EntityFrameworkCore;
+
+public class PermissionGrantRepository_Tests : PermissionGrantRepository_Tests<AbpPermissionManagementEntityFrameworkCoreTestModule>
 {
-    public class PermissionGrantRepository_Tests : PermissionGrantRepository_Tests<AbpPermissionManagementEntityFrameworkCoreTestModule>
-    {
 
-    }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.MongoDB.Tests/Volo/Abp/PermissionManagement/MongoDb/AbpPermissionManagementMongoDbTestModule.cs

@@ -3,24 +3,23 @@ using Volo.Abp.Data;
 using Volo.Abp.Modularity;
 using Volo.Abp.Uow;
 
-namespace Volo.Abp.PermissionManagement.MongoDB
+namespace Volo.Abp.PermissionManagement.MongoDB;
+
+[DependsOn(
+    typeof(AbpPermissionManagementMongoDbModule),
+    typeof(AbpPermissionManagementTestBaseModule))]
+public class AbpPermissionManagementMongoDbTestModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpPermissionManagementMongoDbModule),
-        typeof(AbpPermissionManagementTestBaseModule))]
-    public class AbpPermissionManagementMongoDbTestModule : AbpModule
+    public override void ConfigureServices(ServiceConfigurationContext context)
     {
-        public override void ConfigureServices(ServiceConfigurationContext context)
-        {
-            var stringArray = MongoDbFixture.ConnectionString.Split('?');
-            var connectionString = stringArray[0].EnsureEndsWith('/')  +
-                                       "Db_" +
-                                   Guid.NewGuid().ToString("N") + "/?" + stringArray[1];
+        var stringArray = MongoDbFixture.ConnectionString.Split('?');
+        var connectionString = stringArray[0].EnsureEndsWith('/') +
+                                   "Db_" +
+                               Guid.NewGuid().ToString("N") + "/?" + stringArray[1];
 
-            Configure<AbpDbConnectionOptions>(options =>
-            {
-                options.ConnectionStrings.Default = connectionString;
-            });
-        }
+        Configure<AbpDbConnectionOptions>(options =>
+        {
+            options.ConnectionStrings.Default = connectionString;
+        });
     }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.MongoDB.Tests/Volo/Abp/PermissionManagement/MongoDb/MongoDbFixture.cs

@@ -1,22 +1,21 @@
 using System;
 using Mongo2Go;
 
-namespace Volo.Abp.PermissionManagement.MongoDB
+namespace Volo.Abp.PermissionManagement.MongoDB;
+
+public class MongoDbFixture : IDisposable
 {
-    public class MongoDbFixture : IDisposable
-    {
-        private static readonly MongoDbRunner MongoDbRunner;
-        public static readonly string ConnectionString;
+    private static readonly MongoDbRunner MongoDbRunner;
+    public static readonly string ConnectionString;
 
-        static MongoDbFixture()
-        {
-            MongoDbRunner = MongoDbRunner.Start(singleNodeReplSet: true, singleNodeReplSetWaitTimeout: 20);
-            ConnectionString = MongoDbRunner.ConnectionString;
-        }
+    static MongoDbFixture()
+    {
+        MongoDbRunner = MongoDbRunner.Start(singleNodeReplSet: true, singleNodeReplSetWaitTimeout: 20);
+        ConnectionString = MongoDbRunner.ConnectionString;
+    }
 
-        public void Dispose()
-        {
-            MongoDbRunner?.Dispose();
-        }
+    public void Dispose()
+    {
+        MongoDbRunner?.Dispose();
     }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.MongoDB.Tests/Volo/Abp/PermissionManagement/MongoDb/MongoTestCollection.cs

@@ -1,10 +1,9 @@
 using Xunit;
 
-namespace Volo.Abp.PermissionManagement.MongoDB
+namespace Volo.Abp.PermissionManagement.MongoDB;
+
+[CollectionDefinition(Name)]
+public class MongoTestCollection : ICollectionFixture<MongoDbFixture>
 {
-    [CollectionDefinition(Name)]
-    public class MongoTestCollection : ICollectionFixture<MongoDbFixture>
-    {
-        public const string Name = "MongoDB Collection";
-    }
-}
+    public const string Name = "MongoDB Collection";
+}

modules/permission-management/test/Volo.Abp.PermissionManagement.MongoDB.Tests/Volo/Abp/PermissionManagement/MongoDb/PermissionGrantRepository_Tests.cs

@@ -1,10 +1,9 @@
 using Xunit;
 
-namespace Volo.Abp.PermissionManagement.MongoDB
+namespace Volo.Abp.PermissionManagement.MongoDB;
+
+[Collection(MongoTestCollection.Name)]
+public class PermissionGrantRepository_Tests : PermissionGrantRepository_Tests<AbpPermissionManagementMongoDbTestModule>
 {
-    [Collection(MongoTestCollection.Name)]
-    public class PermissionGrantRepository_Tests : PermissionGrantRepository_Tests<AbpPermissionManagementMongoDbTestModule>
-    {
 
-    }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.TestBase/Volo/Abp/PermissionManagement/AbpPermissionManagementTestBaseModule.cs

@@ -4,36 +4,35 @@ using Volo.Abp.Autofac;
 using Volo.Abp.Modularity;
 using Volo.Abp.Threading;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+[DependsOn(
+    typeof(AbpPermissionManagementDomainModule),
+    typeof(AbpAutofacModule),
+    typeof(AbpTestBaseModule)
+    )]
+public class AbpPermissionManagementTestBaseModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpPermissionManagementDomainModule),
-        typeof(AbpAutofacModule),
-        typeof(AbpTestBaseModule)
-        )]
-    public class AbpPermissionManagementTestBaseModule : AbpModule
+    public override void ConfigureServices(ServiceConfigurationContext context)
     {
-        public override void ConfigureServices(ServiceConfigurationContext context)
+        context.Services.Configure<PermissionManagementOptions>(options =>
         {
-            context.Services.Configure<PermissionManagementOptions>(options =>
-            {
-                options.ManagementProviders.Add<TestPermissionManagementProvider>();
-            });
-        }
+            options.ManagementProviders.Add<TestPermissionManagementProvider>();
+        });
+    }
 
-        public override void OnApplicationInitialization(ApplicationInitializationContext context)
-        {
-            SeedTestData(context);
-        }
+    public override void OnApplicationInitialization(ApplicationInitializationContext context)
+    {
+        SeedTestData(context);
+    }
 
-        private static void SeedTestData(ApplicationInitializationContext context)
+    private static void SeedTestData(ApplicationInitializationContext context)
+    {
+        using (var scope = context.ServiceProvider.CreateScope())
         {
-            using (var scope = context.ServiceProvider.CreateScope())
-            {
-                AsyncHelper.RunSync(() => scope.ServiceProvider
-                    .GetRequiredService<PermissionTestDataBuilder>()
-                    .BuildAsync());
-            }
+            AsyncHelper.RunSync(() => scope.ServiceProvider
+                .GetRequiredService<PermissionTestDataBuilder>()
+                .BuildAsync());
         }
     }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.TestBase/Volo/Abp/PermissionManagement/PermissionGrantRepository_Tests.cs

@@ -4,42 +4,41 @@ using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.Modularity;
 using Xunit;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public abstract class PermissionGrantRepository_Tests<TStartupModule> : PermissionManagementTestBase<TStartupModule>
+    where TStartupModule : IAbpModule
 {
-    public abstract class PermissionGrantRepository_Tests<TStartupModule> : PermissionManagementTestBase<TStartupModule>
-        where TStartupModule : IAbpModule
+    protected IPermissionGrantRepository PermissionGrantRepository { get; }
+
+    protected PermissionGrantRepository_Tests()
+    {
+        PermissionGrantRepository = GetRequiredService<IPermissionGrantRepository>();
+    }
+
+    [Fact]
+    public async Task FindAsync()
+    {
+        (await PermissionGrantRepository.FindAsync("MyPermission1", UserPermissionValueProvider.ProviderName, PermissionTestDataBuilder.User1Id.ToString())).ShouldNotBeNull();
+
+        (await PermissionGrantRepository.FindAsync("Undefined-Permission", UserPermissionValueProvider.ProviderName, PermissionTestDataBuilder.User1Id.ToString())).ShouldBeNull();
+        (await PermissionGrantRepository.FindAsync("MyPermission1", "Undefined-Provider", "Unknown-Id")).ShouldBeNull();
+    }
+
+    [Fact]
+    public async Task GetListAsync()
     {
-        protected IPermissionGrantRepository PermissionGrantRepository { get; }
-
-        protected PermissionGrantRepository_Tests()
-        {
-            PermissionGrantRepository = GetRequiredService<IPermissionGrantRepository>();
-        }
-
-        [Fact]
-        public async Task FindAsync()
-        {
-            (await PermissionGrantRepository.FindAsync("MyPermission1", UserPermissionValueProvider.ProviderName, PermissionTestDataBuilder.User1Id.ToString())).ShouldNotBeNull();
-
-            (await PermissionGrantRepository.FindAsync("Undefined-Permission", UserPermissionValueProvider.ProviderName, PermissionTestDataBuilder.User1Id.ToString())).ShouldBeNull();
-            (await PermissionGrantRepository.FindAsync("MyPermission1", "Undefined-Provider", "Unknown-Id")).ShouldBeNull();
-        }
-
-        [Fact]
-        public async Task GetListAsync()
-        {
-            var permissionGrants = await PermissionGrantRepository.GetListAsync(UserPermissionValueProvider.ProviderName, PermissionTestDataBuilder.User1Id.ToString());
-
-            permissionGrants.ShouldContain(p => p.Name == "MyPermission1");
-        }
-
-        [Fact]
-        public async Task GetList_With_Names()
-        {
-            var permissionGrants = await PermissionGrantRepository.GetListAsync(new []{"MyPermission1", "MyPermission3"},UserPermissionValueProvider.ProviderName, PermissionTestDataBuilder.User1Id.ToString());
-
-            permissionGrants.ShouldContain(p => p.Name == "MyPermission1");
-            permissionGrants.ShouldContain(p => p.Name == "MyPermission3");
-        }
+        var permissionGrants = await PermissionGrantRepository.GetListAsync(UserPermissionValueProvider.ProviderName, PermissionTestDataBuilder.User1Id.ToString());
+
+        permissionGrants.ShouldContain(p => p.Name == "MyPermission1");
+    }
+
+    [Fact]
+    public async Task GetList_With_Names()
+    {
+        var permissionGrants = await PermissionGrantRepository.GetListAsync(new[] { "MyPermission1", "MyPermission3" }, UserPermissionValueProvider.ProviderName, PermissionTestDataBuilder.User1Id.ToString());
+
+        permissionGrants.ShouldContain(p => p.Name == "MyPermission1");
+        permissionGrants.ShouldContain(p => p.Name == "MyPermission3");
     }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.TestBase/Volo/Abp/PermissionManagement/PermissionManagementTestBase.cs

@@ -1,14 +1,13 @@
 using Volo.Abp.Modularity;
 using Volo.Abp.Testing;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public abstract class PermissionManagementTestBase<TStartupModule> : AbpIntegratedTest<TStartupModule>
+    where TStartupModule : IAbpModule
 {
-    public abstract class PermissionManagementTestBase<TStartupModule> : AbpIntegratedTest<TStartupModule>
-        where TStartupModule : IAbpModule
+    protected override void SetAbpApplicationCreationOptions(AbpApplicationCreationOptions options)
     {
-        protected override void SetAbpApplicationCreationOptions(AbpApplicationCreationOptions options)
-        {
-            options.UseAutofac();
-        }
+        options.UseAutofac();
     }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.TestBase/Volo/Abp/PermissionManagement/PermissionTestDataBuilder.cs

@@ -4,59 +4,58 @@ using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Guids;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class PermissionTestDataBuilder : ITransientDependency
 {
-    public class PermissionTestDataBuilder : ITransientDependency
+    public static Guid User1Id { get; } = Guid.NewGuid();
+    public static Guid User2Id { get; } = Guid.NewGuid();
+
+    private readonly IPermissionGrantRepository _permissionGrantRepository;
+    private readonly IGuidGenerator _guidGenerator;
+
+    public PermissionTestDataBuilder(IGuidGenerator guidGenerator, IPermissionGrantRepository permissionGrantRepository)
     {
-        public static Guid User1Id { get; } = Guid.NewGuid();
-        public static Guid User2Id { get; } = Guid.NewGuid();
-
-        private readonly IPermissionGrantRepository _permissionGrantRepository;
-        private readonly IGuidGenerator _guidGenerator;
-
-        public PermissionTestDataBuilder(IGuidGenerator guidGenerator, IPermissionGrantRepository permissionGrantRepository)
-        {
-            _guidGenerator = guidGenerator;
-            _permissionGrantRepository = permissionGrantRepository;
-        }
-
-        public async Task BuildAsync()
-        {
-            await _permissionGrantRepository.InsertAsync(
-                new PermissionGrant(
-                    _guidGenerator.Create(),
-                    "MyPermission1",
-                    UserPermissionValueProvider.ProviderName,
-                    User1Id.ToString()
-                )
-            );
-
-            await _permissionGrantRepository.InsertAsync(
-                new PermissionGrant(
-                    _guidGenerator.Create(),
-                    "MyDisabledPermission1",
-                    UserPermissionValueProvider.ProviderName,
-                    User1Id.ToString()
-                )
-            );
-
-            await _permissionGrantRepository.InsertAsync(
-                new PermissionGrant(
-                    _guidGenerator.Create(),
-                    "MyPermission3",
-                    UserPermissionValueProvider.ProviderName,
-                    User1Id.ToString()
-                )
-            );
-
-            await _permissionGrantRepository.InsertAsync(
-                new PermissionGrant(
-                    _guidGenerator.Create(),
-                    "MyPermission5",
-                    UserPermissionValueProvider.ProviderName,
-                    User1Id.ToString()
-                )
-            );
-        }
+        _guidGenerator = guidGenerator;
+        _permissionGrantRepository = permissionGrantRepository;
+    }
+
+    public async Task BuildAsync()
+    {
+        await _permissionGrantRepository.InsertAsync(
+            new PermissionGrant(
+                _guidGenerator.Create(),
+                "MyPermission1",
+                UserPermissionValueProvider.ProviderName,
+                User1Id.ToString()
+            )
+        );
+
+        await _permissionGrantRepository.InsertAsync(
+            new PermissionGrant(
+                _guidGenerator.Create(),
+                "MyDisabledPermission1",
+                UserPermissionValueProvider.ProviderName,
+                User1Id.ToString()
+            )
+        );
+
+        await _permissionGrantRepository.InsertAsync(
+            new PermissionGrant(
+                _guidGenerator.Create(),
+                "MyPermission3",
+                UserPermissionValueProvider.ProviderName,
+                User1Id.ToString()
+            )
+        );
+
+        await _permissionGrantRepository.InsertAsync(
+            new PermissionGrant(
+                _guidGenerator.Create(),
+                "MyPermission5",
+                UserPermissionValueProvider.ProviderName,
+                User1Id.ToString()
+            )
+        );
     }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.TestBase/Volo/Abp/PermissionManagement/TestPermissionDefinitionProvider.cs

@@ -1,25 +1,24 @@
 using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.MultiTenancy;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class TestPermissionDefinitionProvider : PermissionDefinitionProvider
 {
-    public class TestPermissionDefinitionProvider : PermissionDefinitionProvider
+    public override void Define(IPermissionDefinitionContext context)
     {
-        public override void Define(IPermissionDefinitionContext context)
-        {
-            var testGroup = context.AddGroup("TestGroup");
+        var testGroup = context.AddGroup("TestGroup");
 
-            testGroup.AddPermission("MyPermission1");
-            testGroup.AddPermission("MyDisabledPermission1", isEnabled: false);
+        testGroup.AddPermission("MyPermission1");
+        testGroup.AddPermission("MyDisabledPermission1", isEnabled: false);
 
-            var myPermission2 = testGroup.AddPermission("MyPermission2");
-            myPermission2.AddChild("MyPermission2.ChildPermission1");
+        var myPermission2 = testGroup.AddPermission("MyPermission2");
+        myPermission2.AddChild("MyPermission2.ChildPermission1");
 
-            testGroup.AddPermission("MyPermission3", multiTenancySide: MultiTenancySides.Host);
+        testGroup.AddPermission("MyPermission3", multiTenancySide: MultiTenancySides.Host);
 
-            testGroup.AddPermission("MyPermission4", multiTenancySide: MultiTenancySides.Host).WithProviders(UserPermissionValueProvider.ProviderName);
+        testGroup.AddPermission("MyPermission4", multiTenancySide: MultiTenancySides.Host).WithProviders(UserPermissionValueProvider.ProviderName);
 
-            testGroup.AddPermission("MyPermission5").StateCheckers.Add(new TestRequireRolePermissionStateProvider("super-admin"));
-        }
+        testGroup.AddPermission("MyPermission5").StateCheckers.Add(new TestRequireRolePermissionStateProvider("super-admin"));
     }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.TestBase/Volo/Abp/PermissionManagement/TestPermissionManagementProvider.cs

@@ -4,22 +4,21 @@ using System.Text;
 using Volo.Abp.Guids;
 using Volo.Abp.MultiTenancy;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class TestPermissionManagementProvider : PermissionManagementProvider
 {
-    public class TestPermissionManagementProvider : PermissionManagementProvider
-    {
-        public override string Name => "Test";
+    public override string Name => "Test";
 
-        public TestPermissionManagementProvider(
-            IPermissionGrantRepository permissionGrantRepository,
-            IGuidGenerator guidGenerator,
-            ICurrentTenant currentTenant)
-            : base(
-                permissionGrantRepository,
-                guidGenerator,
-                currentTenant)
-        {
+    public TestPermissionManagementProvider(
+        IPermissionGrantRepository permissionGrantRepository,
+        IGuidGenerator guidGenerator,
+        ICurrentTenant currentTenant)
+        : base(
+            permissionGrantRepository,
+            guidGenerator,
+            currentTenant)
+    {
 
-        }
     }
 }

modules/permission-management/test/Volo.Abp.PermissionManagement.TestBase/Volo/Abp/PermissionManagement/TestRequireRolePermissionStateProvider.cs

@@ -6,21 +6,20 @@ using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.Security.Claims;
 using Volo.Abp.SimpleStateChecking;
 
-namespace Volo.Abp.PermissionManagement
+namespace Volo.Abp.PermissionManagement;
+
+public class TestRequireRolePermissionStateProvider : ISimpleStateChecker<PermissionDefinition>
 {
-    public class TestRequireRolePermissionStateProvider : ISimpleStateChecker<PermissionDefinition>
-    {
-        private readonly List<string> _allowRoles = new List<string>();
+    private readonly List<string> _allowRoles = new List<string>();
 
-        public TestRequireRolePermissionStateProvider(params string[] roles)
-        {
-            _allowRoles.AddRange(roles);
-        }
+    public TestRequireRolePermissionStateProvider(params string[] roles)
+    {
+        _allowRoles.AddRange(roles);
+    }
 
-        public Task<bool> IsEnabledAsync(SimpleStateCheckerContext<PermissionDefinition> context)
-        {
-            var currentPrincipalAccessor = context.ServiceProvider.GetRequiredService<ICurrentPrincipalAccessor>();
-            return Task.FromResult(currentPrincipalAccessor.Principal != null && _allowRoles.Any(role => currentPrincipalAccessor.Principal.IsInRole(role)));
-        }
+    public Task<bool> IsEnabledAsync(SimpleStateCheckerContext<PermissionDefinition> context)
+    {
+        var currentPrincipalAccessor = context.ServiceProvider.GetRequiredService<ICurrentPrincipalAccessor>();
+        return Task.FromResult(currentPrincipalAccessor.Principal != null && _allowRoles.Any(role => currentPrincipalAccessor.Principal.IsInRole(role)));
     }
 }