Merge branch 'dev' into api-definition

framework/src/Volo.Abp.Cli.Core/Volo/Abp/Cli/NuGet/NuGetService.cs

@@ -11,6 +11,7 @@ using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using Polly;
 using Polly.Extensions.Http;
+using Volo.Abp.Cli.Auth;
 using Volo.Abp.Cli.Http;
 using Volo.Abp.Cli.Licensing;
 using Volo.Abp.Cli.ProjectBuilding;
@@ -32,7 +33,8 @@ namespace Volo.Abp.Cli.NuGet
         public NuGetService(
             IJsonSerializer jsonSerializer,
             IRemoteServiceExceptionHandler remoteServiceExceptionHandler,
-            ICancellationTokenProvider cancellationTokenProvider, IApiKeyService apiKeyService)
+            ICancellationTokenProvider cancellationTokenProvider,
+            IApiKeyService apiKeyService)
         {
             JsonSerializer = jsonSerializer;
             RemoteServiceExceptionHandler = remoteServiceExceptionHandler;
@@ -43,21 +45,33 @@ namespace Volo.Abp.Cli.NuGet
 
         public async Task<SemanticVersion> GetLatestVersionOrNullAsync(string packageId, bool includePreviews = false, bool includeNightly = false)
         {
-            var url = includeNightly ?
-                $"https://www.myget.org/F/abp-nightly/api/v3/flatcontainer/{packageId.ToLowerInvariant()}/index.json" :
-                $"https://api.nuget.org/v3-flatcontainer/{packageId.ToLowerInvariant()}/index.json";
+            List<string> proPackageList = null;
+
+            if (AuthService.IsLoggedIn())
+            {
+                proPackageList = await GetProPackageListAsync();
+            }
+
+            string url;
+            if (includeNightly)
+            {
+                url =
+                    $"https://www.myget.org/F/abp-nightly/api/v3/flatcontainer/{packageId.ToLowerInvariant()}/index.json";
+            }
+            else if (proPackageList?.Contains(packageId) ?? false)
+            {
+                url = await GetNuGetUrlForCommercialPackage(packageId);
+            }
+            else
+            {
+                url = $"https://api.nuget.org/v3-flatcontainer/{packageId.ToLowerInvariant()}/index.json";
+            }
 
 
             using (var client = new CliHttpClient(setBearerToken: false))
             {
                 var responseMessage = await GetHttpResponseMessageWithRetryAsync(client, url);
 
-                if (responseMessage.StatusCode == HttpStatusCode.NotFound)
-                {
-                    var commercialNuGetUrl = await GetNuGetUrlForCommercialPackage(packageId);
-                    responseMessage = await GetHttpResponseMessageWithRetryAsync(client, commercialNuGetUrl);
-                }
-
                 if (!responseMessage.IsSuccessStatusCode)
                 {
                     throw new Exception($"ERROR: Remote server returns '{responseMessage.StatusCode}'");
@@ -95,19 +109,21 @@ namespace Volo.Abp.Cli.NuGet
                 .OrResult(msg => !msg.IsSuccessStatusCode)
                 .WaitAndRetryAsync(new[]
                     {
-                        TimeSpan.FromSeconds(1)
+                        TimeSpan.FromSeconds(2),
+                        TimeSpan.FromSeconds(4),
+                        TimeSpan.FromSeconds(7)
                     },
                     (responseMessage, timeSpan, retryCount, context) =>
                     {
                         if (responseMessage.Exception != null)
                         {
-                            Logger.LogDebug(
+                            Logger.LogWarning(
                                 $"{retryCount}. HTTP request attempt failed to {url} with an error: HTTP {(int)responseMessage.Result.StatusCode}-{responseMessage.Exception.Message}. " +
                                 $"Waiting {timeSpan.TotalSeconds} secs for the next try...");
                         }
                         else if (responseMessage.Result != null)
                         {
-                            Logger.LogDebug(
+                            Logger.LogWarning(
                                 $"{retryCount}. HTTP request attempt failed to {url} with an error: {(int)responseMessage.Result.StatusCode}-{responseMessage.Result.ReasonPhrase}. " +
                                 $"Waiting {timeSpan.TotalSeconds} secs for the next try...");
                         }
@@ -115,6 +131,30 @@ namespace Volo.Abp.Cli.NuGet
                 .ExecuteAsync(async () => await client.GetAsync(url, CancellationTokenProvider.Token));
         }
 
+        private async Task<List<string>> GetProPackageListAsync()
+        {
+            using var client = new CliHttpClient();
+
+            var responseMessage = await client.GetAsync(
+                $"{CliUrls.WwwAbpIo}api/app/nugetPackage/proPackageNames",
+                CancellationTokenProvider.Token
+            );
+
+            if (!responseMessage.IsSuccessStatusCode)
+            {
+                var exceptionMessage = "Remote server returns '" + (int)responseMessage.StatusCode + "-" + responseMessage.ReasonPhrase + "'. ";
+                var remoteServiceErrorMessage = await RemoteServiceExceptionHandler.GetAbpRemoteServiceErrorAsync(responseMessage);
+
+                if (remoteServiceErrorMessage != null)
+                {
+                    exceptionMessage += remoteServiceErrorMessage;
+                }
+                Logger.LogInformation(exceptionMessage);
+                return null;
+            }
+
+            return JsonSerializer.Deserialize<List<string>>(await responseMessage.Content.ReadAsStringAsync());
+        }
 
         public class NuGetVersionResultDto
         {

framework/src/Volo.Abp.Cli.Core/Volo/Abp/Cli/Utils/CmdHelper.cs

@@ -65,6 +65,8 @@ namespace Volo.Abp.Cli.Utils
                     }
                 }
 
+                process.WaitForExit();
+
                 exitCode = process.ExitCode;
             }
 

modules/identity/src/Volo.Abp.Identity.Web/Pages/Identity/Roles/CreateModal.cshtml.cs

@@ -9,19 +9,24 @@ namespace Volo.Abp.Identity.Web.Pages.Identity.Roles
         [BindProperty]
         public RoleInfoModel Role { get; set; }
 
-        private readonly IIdentityRoleAppService _identityRoleAppService;
+        protected IIdentityRoleAppService IdentityRoleAppService { get; }
 
         public CreateModalModel(IIdentityRoleAppService identityRoleAppService)
         {
-            _identityRoleAppService = identityRoleAppService;
+            IdentityRoleAppService = identityRoleAppService;
         }
 
-        public async Task<IActionResult> OnPostAsync()
+        public virtual Task OnGetAsync()
+        {
+            return Task.CompletedTask;
+        }
+
+        public virtual async Task<IActionResult> OnPostAsync()
         {
             ValidateModel();
 
             var input = ObjectMapper.Map<RoleInfoModel, IdentityRoleCreateDto>(Role);
-            await _identityRoleAppService.CreateAsync(input);
+            await IdentityRoleAppService.CreateAsync(input);
 
             return NoContent();
         }

modules/identity/src/Volo.Abp.Identity.Web/Pages/Identity/Roles/EditModal.cshtml.cs

@@ -11,26 +11,26 @@ namespace Volo.Abp.Identity.Web.Pages.Identity.Roles
         [BindProperty]
         public RoleInfoModel Role { get; set; }
 
-        private readonly IIdentityRoleAppService _identityRoleAppService;
+        protected IIdentityRoleAppService IdentityRoleAppService { get; }
 
         public EditModalModel(IIdentityRoleAppService identityRoleAppService)
         {
-            _identityRoleAppService = identityRoleAppService;
+            IdentityRoleAppService = identityRoleAppService;
         }
 
-        public async Task OnGetAsync(Guid id)
+        public virtual async Task OnGetAsync(Guid id)
         {
             Role = ObjectMapper.Map<IdentityRoleDto, RoleInfoModel>(
-                await _identityRoleAppService.GetAsync(id)
+                await IdentityRoleAppService.GetAsync(id)
             );
         }
 
-        public async Task<IActionResult> OnPostAsync()
+        public virtual async Task<IActionResult> OnPostAsync()
         {
             ValidateModel();
 
             var input = ObjectMapper.Map<RoleInfoModel, IdentityRoleUpdateDto>(Role);
-            await _identityRoleAppService.UpdateAsync(Role.Id, input);
+            await IdentityRoleAppService.UpdateAsync(Role.Id, input);
 
             return NoContent();
         }

modules/identity/src/Volo.Abp.Identity.Web/Pages/Identity/Roles/Index.cshtml.cs

@@ -1,9 +1,17 @@
+using System.Threading.Tasks;
+
 namespace Volo.Abp.Identity.Web.Pages.Identity.Roles
 {
     public class IndexModel : IdentityPageModel
     {
-        public void OnGet()
+        public virtual Task OnGetAsync()
         {
+            return Task.CompletedTask;
+        }
+
+        public virtual Task OnPostAsync()
+        {
+            return Task.CompletedTask;
         }
     }
 }

modules/identity/src/Volo.Abp.Identity.Web/Pages/Identity/Users/CreateModal.cshtml.cs

@@ -16,20 +16,20 @@ namespace Volo.Abp.Identity.Web.Pages.Identity.Users
         [BindProperty]
         public AssignedRoleViewModel[] Roles { get; set; }
 
-        private readonly IIdentityUserAppService _identityUserAppService;
-        private readonly IIdentityRoleAppService _identityRoleAppService;
+        protected IIdentityUserAppService IdentityUserAppService { get; }
+        protected IIdentityRoleAppService IdentityRoleAppService { get; }
 
         public CreateModalModel(IIdentityUserAppService identityUserAppService, IIdentityRoleAppService identityRoleAppService)
         {
-            _identityUserAppService = identityUserAppService;
-            _identityRoleAppService = identityRoleAppService;
+            IdentityUserAppService = identityUserAppService;
+            IdentityRoleAppService = identityRoleAppService;
         }
 
-        public async Task OnGetAsync()
+        public virtual async Task OnGetAsync()
         {
             UserInfo = new UserInfoViewModel();
 
-            var roleDtoList = (await _identityRoleAppService.GetAllListAsync()).Items;
+            var roleDtoList = (await IdentityRoleAppService.GetAllListAsync()).Items;
 
             Roles = ObjectMapper.Map<IReadOnlyList<IdentityRoleDto>, AssignedRoleViewModel[]>(roleDtoList);
 
@@ -39,14 +39,14 @@ namespace Volo.Abp.Identity.Web.Pages.Identity.Users
             }
         }
 
-        public async Task<NoContentResult> OnPostAsync()
+        public virtual async Task<NoContentResult> OnPostAsync()
         {
             ValidateModel();
 
             var input = ObjectMapper.Map<UserInfoViewModel, IdentityUserCreateDto>(UserInfo);
             input.RoleNames = Roles.Where(r => r.IsAssigned).Select(r => r.Name).ToArray();
 
-            await _identityUserAppService.CreateAsync(input);
+            await IdentityUserAppService.CreateAsync(input);
 
             return NoContent();
         }

modules/identity/src/Volo.Abp.Identity.Web/Pages/Identity/Users/EditModal.cshtml.cs

@@ -18,22 +18,22 @@ namespace Volo.Abp.Identity.Web.Pages.Identity.Users
         [BindProperty]
         public AssignedRoleViewModel[] Roles { get; set; }
 
-        private readonly IIdentityUserAppService _identityUserAppService;
-        private readonly IIdentityRoleAppService _identityRoleAppService;
+        protected IIdentityUserAppService IdentityUserAppService { get; }
+        protected IIdentityRoleAppService IdentityRoleAppService { get; }
 
         public EditModalModel(IIdentityUserAppService identityUserAppService, IIdentityRoleAppService identityRoleAppService)
         {
-            _identityUserAppService = identityUserAppService;
-            _identityRoleAppService = identityRoleAppService;
+            IdentityUserAppService = identityUserAppService;
+            IdentityRoleAppService = identityRoleAppService;
         }
 
-        public async Task OnGetAsync(Guid id)
+        public virtual async Task OnGetAsync(Guid id)
         {
-            UserInfo = ObjectMapper.Map<IdentityUserDto, UserInfoViewModel>(await _identityUserAppService.GetAsync(id));
+            UserInfo = ObjectMapper.Map<IdentityUserDto, UserInfoViewModel>(await IdentityUserAppService.GetAsync(id));
 
-            Roles = ObjectMapper.Map<IReadOnlyList<IdentityRoleDto>, AssignedRoleViewModel[]>((await _identityRoleAppService.GetAllListAsync()).Items);
+            Roles = ObjectMapper.Map<IReadOnlyList<IdentityRoleDto>, AssignedRoleViewModel[]>((await IdentityRoleAppService.GetAllListAsync()).Items);
 
-            var userRoleNames = (await _identityUserAppService.GetRolesAsync(UserInfo.Id)).Items.Select(r => r.Name).ToList();
+            var userRoleNames = (await IdentityUserAppService.GetRolesAsync(UserInfo.Id)).Items.Select(r => r.Name).ToList();
             foreach (var role in Roles)
             {
                 if (userRoleNames.Contains(role.Name))
@@ -43,13 +43,13 @@ namespace Volo.Abp.Identity.Web.Pages.Identity.Users
             }
         }
 
-        public async Task<IActionResult> OnPostAsync()
+        public virtual async Task<IActionResult> OnPostAsync()
         {
             ValidateModel();
 
             var input = ObjectMapper.Map<UserInfoViewModel, IdentityUserUpdateDto>(UserInfo);
             input.RoleNames = Roles.Where(r => r.IsAssigned).Select(r => r.Name).ToArray();
-            await _identityUserAppService.UpdateAsync(UserInfo.Id, input);
+            await IdentityUserAppService.UpdateAsync(UserInfo.Id, input);
 
             return NoContent();
         }

modules/identity/src/Volo.Abp.Identity.Web/Pages/Identity/Users/Index.cshtml.cs

@@ -1,10 +1,17 @@
-namespace Volo.Abp.Identity.Web.Pages.Identity.Users
+using System.Threading.Tasks;
+
+namespace Volo.Abp.Identity.Web.Pages.Identity.Users
 {
     public class IndexModel : IdentityPageModel
     {
-        public void OnGet()
+        public virtual Task OnGetAsync()
         {
+            return Task.CompletedTask;
+        }
 
+        public virtual Task OnPostAsync()
+        {
+            return Task.CompletedTask;
         }
     }
 }

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/AbpCorsPolicyService.cs

@@ -26,7 +26,7 @@ namespace Volo.Abp.IdentityServer
             Logger = NullLogger<AbpCorsPolicyService>.Instance;
         }
 
-        public async Task<bool> IsOriginAllowedAsync(string origin)
+        public virtual async Task<bool> IsOriginAllowedAsync(string origin)
         {
             var cacheItem = await Cache.GetOrAddAsync(AllowedCorsOriginsCacheItem.AllOrigins, CreateCacheItemAsync);
 

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/AllowedCorsOriginsCacheItemInvalidator.cs

@@ -19,12 +19,12 @@ namespace Volo.Abp.IdentityServer
             Cache = cache;
         }
         
-        public async Task HandleEventAsync(EntityChangedEventData<Client> eventData)
+        public virtual async Task HandleEventAsync(EntityChangedEventData<Client> eventData)
         {
             await Cache.RemoveAsync(AllowedCorsOriginsCacheItem.AllOrigins);
         }
 
-        public async Task HandleEventAsync(EntityChangedEventData<ClientCorsOrigin> eventData)
+        public virtual async Task HandleEventAsync(EntityChangedEventData<ClientCorsOrigin> eventData)
         {
             await Cache.RemoveAsync(AllowedCorsOriginsCacheItem.AllOrigins);
         }

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/AspNetIdentity/AbpProfileService.cs

@@ -12,7 +12,7 @@ namespace Volo.Abp.IdentityServer.AspNetIdentity
 {
     public class AbpProfileService : ProfileService<IdentityUser>
     {
-        private readonly ICurrentTenant _currentTenant;
+        protected ICurrentTenant CurrentTenant { get; }
 
         public AbpProfileService(
             IdentityUserManager userManager,
@@ -20,13 +20,13 @@ namespace Volo.Abp.IdentityServer.AspNetIdentity
             ICurrentTenant currentTenant)
             : base(userManager, claimsFactory)
         {
-            _currentTenant = currentTenant;
+            CurrentTenant = currentTenant;
         }
 
         [UnitOfWork]
         public override async Task GetProfileDataAsync(ProfileDataRequestContext context)
         {
-            using (_currentTenant.Change(context.Subject.FindTenantId()))
+            using (CurrentTenant.Change(context.Subject.FindTenantId()))
             {
                 await base.GetProfileDataAsync(context);
             }
@@ -35,7 +35,7 @@ namespace Volo.Abp.IdentityServer.AspNetIdentity
         [UnitOfWork]
         public override async Task IsActiveAsync(IsActiveContext context)
         {
-            using (_currentTenant.Change(context.Subject.FindTenantId()))
+            using (CurrentTenant.Change(context.Subject.FindTenantId()))
             {
                 await base.IsActiveAsync(context);
             }

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/AspNetIdentity/AbpResourceOwnerPasswordValidator.cs

@@ -20,11 +20,11 @@ namespace Volo.Abp.IdentityServer.AspNetIdentity
 {
     public class AbpResourceOwnerPasswordValidator : IResourceOwnerPasswordValidator
     {
-        private readonly SignInManager<IdentityUser> _signInManager;
-        private readonly IEventService _events;
-        private readonly UserManager<IdentityUser> _userManager;
-        private readonly ILogger<ResourceOwnerPasswordValidator<IdentityUser>> _logger;
-        private readonly IStringLocalizer<AbpIdentityServerResource> _localizer;
+        protected SignInManager<IdentityUser> SignInManager { get; }
+        protected IEventService Events { get; }
+        protected UserManager<IdentityUser> UserManager { get; }
+        protected ILogger<ResourceOwnerPasswordValidator<IdentityUser>> Logger { get; }
+        protected IStringLocalizer<AbpIdentityServerResource> Localizer { get; }
 
         public AbpResourceOwnerPasswordValidator(
             UserManager<IdentityUser> userManager,
@@ -33,11 +33,11 @@ namespace Volo.Abp.IdentityServer.AspNetIdentity
             ILogger<ResourceOwnerPasswordValidator<IdentityUser>> logger, 
             IStringLocalizer<AbpIdentityServerResource> localizer)
         {
-            _userManager = userManager;
-            _signInManager = signInManager;
-            _events = events;
-            _logger = logger;
-            _localizer = localizer;
+            UserManager = userManager;
+            SignInManager = signInManager;
+            Events = events;
+            Logger = logger;
+            Localizer = localizer;
         }
 
         /// <summary>
@@ -49,17 +49,17 @@ namespace Volo.Abp.IdentityServer.AspNetIdentity
         public virtual async Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
         {
             await ReplaceEmailToUsernameOfInputIfNeeds(context);
-            var user = await _userManager.FindByNameAsync(context.UserName);
+            var user = await UserManager.FindByNameAsync(context.UserName);
             string errorDescription;
             if (user != null)
             {
-                var result = await _signInManager.CheckPasswordSignInAsync(user, context.Password, true);
+                var result = await SignInManager.CheckPasswordSignInAsync(user, context.Password, true);
                 if (result.Succeeded)
                 {
-                    var sub = await _userManager.GetUserIdAsync(user);
+                    var sub = await UserManager.GetUserIdAsync(user);
 
-                    _logger.LogInformation("Credentials validated for username: {username}", context.UserName);
-                    await _events.RaiseAsync(new UserLoginSuccessEvent(context.UserName, sub, context.UserName, interactive: false));
+                    Logger.LogInformation("Credentials validated for username: {username}", context.UserName);
+                    await Events.RaiseAsync(new UserLoginSuccessEvent(context.UserName, sub, context.UserName, interactive: false));
 
                     var additionalClaims = new List<Claim>();
 
@@ -75,28 +75,28 @@ namespace Volo.Abp.IdentityServer.AspNetIdentity
                 }
                 else if (result.IsLockedOut)
                 {
-                    _logger.LogInformation("Authentication failed for username: {username}, reason: locked out", context.UserName);
-                    await _events.RaiseAsync(new UserLoginFailureEvent(context.UserName, "locked out", interactive: false));
-                    errorDescription = _localizer["UserLockedOut"];
+                    Logger.LogInformation("Authentication failed for username: {username}, reason: locked out", context.UserName);
+                    await Events.RaiseAsync(new UserLoginFailureEvent(context.UserName, "locked out", interactive: false));
+                    errorDescription = Localizer["UserLockedOut"];
                 }
                 else if (result.IsNotAllowed)
                 {
-                    _logger.LogInformation("Authentication failed for username: {username}, reason: not allowed", context.UserName);
-                    await _events.RaiseAsync(new UserLoginFailureEvent(context.UserName, "not allowed", interactive: false));
-                    errorDescription = _localizer["LoginIsNotAllowed"];
+                    Logger.LogInformation("Authentication failed for username: {username}, reason: not allowed", context.UserName);
+                    await Events.RaiseAsync(new UserLoginFailureEvent(context.UserName, "not allowed", interactive: false));
+                    errorDescription = Localizer["LoginIsNotAllowed"];
                 }
                 else
                 {
-                    _logger.LogInformation("Authentication failed for username: {username}, reason: invalid credentials", context.UserName);
-                    await _events.RaiseAsync(new UserLoginFailureEvent(context.UserName, "invalid credentials", interactive: false));
-                    errorDescription = _localizer["InvalidUserNameOrPassword"];
+                    Logger.LogInformation("Authentication failed for username: {username}, reason: invalid credentials", context.UserName);
+                    await Events.RaiseAsync(new UserLoginFailureEvent(context.UserName, "invalid credentials", interactive: false));
+                    errorDescription = Localizer["InvalidUserNameOrPassword"];
                 }
             }
             else
             {
-                _logger.LogInformation("No user found matching username: {username}", context.UserName);
-                await _events.RaiseAsync(new UserLoginFailureEvent(context.UserName, "invalid username", interactive: false));
-                errorDescription = _localizer["InvalidUsername"];
+                Logger.LogInformation("No user found matching username: {username}", context.UserName);
+                await Events.RaiseAsync(new UserLoginFailureEvent(context.UserName, "invalid username", interactive: false));
+                errorDescription = Localizer["InvalidUsername"];
             }
 
             context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, errorDescription);
@@ -109,13 +109,13 @@ namespace Volo.Abp.IdentityServer.AspNetIdentity
                 return;
             }
 
-            var userByUsername = await _userManager.FindByNameAsync(context.UserName);
+            var userByUsername = await UserManager.FindByNameAsync(context.UserName);
             if (userByUsername != null)
             {
                 return;
             }
 
-            var userByEmail = await _userManager.FindByEmailAsync(context.UserName);
+            var userByEmail = await UserManager.FindByEmailAsync(context.UserName);
             if (userByEmail == null)
             {
                 return;

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/Clients/ClientStore.cs

@@ -6,19 +6,19 @@ namespace Volo.Abp.IdentityServer.Clients
 {
     public class ClientStore : IClientStore
     {
-        private readonly IClientRepository _clientRepository;
-        private readonly IObjectMapper<AbpIdentityServerDomainModule> _objectMapper;
+        protected IClientRepository ClientRepository { get; }
+        protected IObjectMapper<AbpIdentityServerDomainModule> ObjectMapper { get; }
 
         public ClientStore(IClientRepository clientRepository, IObjectMapper<AbpIdentityServerDomainModule> objectMapper)
         {
-            _clientRepository = clientRepository;
-            _objectMapper = objectMapper;
+            ClientRepository = clientRepository;
+            ObjectMapper = objectMapper;
         }
 
         public virtual async Task<IdentityServer4.Models.Client> FindClientByIdAsync(string clientId)
         {
-            var client = await _clientRepository.FindByCliendIdAsync(clientId);
-            return _objectMapper.Map<Client, IdentityServer4.Models.Client>(client);
+            var client = await ClientRepository.FindByCliendIdAsync(clientId);
+            return ObjectMapper.Map<Client, IdentityServer4.Models.Client>(client);
         }
     }
 }

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/Devices/DeviceFlowCodes.cs

@@ -17,7 +17,7 @@ namespace Volo.Abp.IdentityServer.Devices
 
         public virtual string Data { get; set; }
 
-        private DeviceFlowCodes()
+        protected DeviceFlowCodes()
         {
 
         }

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/Devices/DeviceFlowStore.cs

@@ -26,7 +26,7 @@ namespace Volo.Abp.IdentityServer.Devices
             PersistentGrantSerializer = persistentGrantSerializer;
         }
 
-        public async Task StoreDeviceAuthorizationAsync(string deviceCode, string userCode, DeviceCode data)
+        public virtual async Task StoreDeviceAuthorizationAsync(string deviceCode, string userCode, DeviceCode data)
         {
             Check.NotNull(deviceCode, nameof(deviceCode));
             Check.NotNull(userCode, nameof(userCode));
@@ -47,7 +47,7 @@ namespace Volo.Abp.IdentityServer.Devices
                 );
         }
         
-        public async Task<DeviceCode> FindByUserCodeAsync(string userCode)
+        public virtual async Task<DeviceCode> FindByUserCodeAsync(string userCode)
         {
             Check.NotNull(userCode, nameof(userCode));
 
@@ -63,7 +63,7 @@ namespace Volo.Abp.IdentityServer.Devices
             return DeserializeToDeviceCode(deviceCodes.Data);
         }
 
-        public async Task<DeviceCode> FindByDeviceCodeAsync(string deviceCode)
+        public virtual async Task<DeviceCode> FindByDeviceCodeAsync(string deviceCode)
         {
             Check.NotNull(deviceCode, nameof(deviceCode));
 
@@ -79,7 +79,7 @@ namespace Volo.Abp.IdentityServer.Devices
             return DeserializeToDeviceCode(deviceCodes.Data);
         }
 
-        public async Task UpdateByUserCodeAsync(string userCode, DeviceCode data)
+        public virtual async Task UpdateByUserCodeAsync(string userCode, DeviceCode data)
         {
             Check.NotNull(userCode, nameof(userCode));
             Check.NotNull(data, nameof(data));
@@ -102,7 +102,7 @@ namespace Volo.Abp.IdentityServer.Devices
                 ;
         }
 
-        public async Task RemoveByDeviceCodeAsync(string deviceCode)
+        public virtual async Task RemoveByDeviceCodeAsync(string deviceCode)
         {
             Check.NotNull(deviceCode, nameof(deviceCode));
 
@@ -120,7 +120,7 @@ namespace Volo.Abp.IdentityServer.Devices
                 ;
         }
 
-        private string Serialize([CanBeNull] DeviceCode deviceCode)
+        protected virtual string Serialize([CanBeNull] DeviceCode deviceCode)
         {
             if (deviceCode == null)
             {

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/Grants/PersistedGrantStore.cs

@@ -10,65 +10,65 @@ namespace Volo.Abp.IdentityServer.Grants
 {
     public class PersistedGrantStore : IPersistedGrantStore
     {
-        private readonly IPersistentGrantRepository _persistentGrantRepository;
-        private readonly IObjectMapper<AbpIdentityServerDomainModule> _objectMapper;
-        private readonly IGuidGenerator _guidGenerator;
+        protected IPersistentGrantRepository PersistentGrantRepository { get; }
+        protected IObjectMapper<AbpIdentityServerDomainModule> ObjectMapper { get; }
+        protected IGuidGenerator GuidGenerator { get; }
 
         public PersistedGrantStore(IPersistentGrantRepository persistentGrantRepository,
             IObjectMapper<AbpIdentityServerDomainModule> objectMapper, IGuidGenerator guidGenerator)
         {
-            _persistentGrantRepository = persistentGrantRepository;
-            _objectMapper = objectMapper;
-            _guidGenerator = guidGenerator;
+            PersistentGrantRepository = persistentGrantRepository;
+            ObjectMapper = objectMapper;
+            GuidGenerator = guidGenerator;
         }
 
         public virtual async Task StoreAsync(IdentityServer4.Models.PersistedGrant grant)
         {
-            var entity = await _persistentGrantRepository.FindByKeyAsync(grant.Key);
+            var entity = await PersistentGrantRepository.FindByKeyAsync(grant.Key);
             if (entity == null)
             {
-                entity = _objectMapper.Map<IdentityServer4.Models.PersistedGrant, PersistedGrant>(grant);
-                EntityHelper.TrySetId(entity, () => _guidGenerator.Create());
-                await _persistentGrantRepository.InsertAsync(entity);
+                entity = ObjectMapper.Map<IdentityServer4.Models.PersistedGrant, PersistedGrant>(grant);
+                EntityHelper.TrySetId(entity, () => GuidGenerator.Create());
+                await PersistentGrantRepository.InsertAsync(entity);
             }
             else
             {
-                _objectMapper.Map(grant, entity);
-                await _persistentGrantRepository.UpdateAsync(entity);
+                ObjectMapper.Map(grant, entity);
+                await PersistentGrantRepository.UpdateAsync(entity);
             }
         }
 
         public virtual async Task<IdentityServer4.Models.PersistedGrant> GetAsync(string key)
         {
-            var persistedGrant = await _persistentGrantRepository.FindByKeyAsync(key);
-            return _objectMapper.Map<PersistedGrant, IdentityServer4.Models.PersistedGrant>(persistedGrant);
+            var persistedGrant = await PersistentGrantRepository.FindByKeyAsync(key);
+            return ObjectMapper.Map<PersistedGrant, IdentityServer4.Models.PersistedGrant>(persistedGrant);
         }
 
         public virtual async Task<IEnumerable<IdentityServer4.Models.PersistedGrant>> GetAllAsync(string subjectId)
         {
-            var persistedGrants = await _persistentGrantRepository.GetListBySubjectIdAsync(subjectId);
-            return persistedGrants.Select(x => _objectMapper.Map<PersistedGrant, IdentityServer4.Models.PersistedGrant>(x));
+            var persistedGrants = await PersistentGrantRepository.GetListBySubjectIdAsync(subjectId);
+            return persistedGrants.Select(x => ObjectMapper.Map<PersistedGrant, IdentityServer4.Models.PersistedGrant>(x));
         }
 
         public virtual async Task RemoveAsync(string key)
         {
-            var persistedGrant = await _persistentGrantRepository.FindByKeyAsync(key);
+            var persistedGrant = await PersistentGrantRepository.FindByKeyAsync(key);
             if (persistedGrant == null)
             {
                 return;
             }
 
-            await _persistentGrantRepository.DeleteAsync(persistedGrant);
+            await PersistentGrantRepository.DeleteAsync(persistedGrant);
         }
 
         public virtual async Task RemoveAllAsync(string subjectId, string clientId)
         {
-            await _persistentGrantRepository.DeleteAsync(subjectId, clientId);
+            await PersistentGrantRepository.DeleteAsync(subjectId, clientId);
         }
 
         public virtual async Task RemoveAllAsync(string subjectId, string clientId, string type)
         {
-            await _persistentGrantRepository.DeleteAsync(subjectId, clientId, type);
+            await PersistentGrantRepository.DeleteAsync(subjectId, clientId, type);
         }
     }
 }

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/ResourceStore.cs

@@ -13,46 +13,46 @@ namespace Volo.Abp.IdentityServer
 {
     public class ResourceStore : IResourceStore
     {
-        private readonly IIdentityResourceRepository _identityResourceRepository;
-        private readonly IApiResourceRepository _apiResourceRepository;
-        private readonly IObjectMapper<AbpIdentityServerDomainModule> _objectMapper;
+        protected IIdentityResourceRepository IdentityResourceRepository { get; }
+        protected IApiResourceRepository ApiResourceRepository { get; }
+        protected IObjectMapper<AbpIdentityServerDomainModule> ObjectMapper { get; }
 
         public ResourceStore(
             IIdentityResourceRepository identityResourceRepository, 
             IObjectMapper<AbpIdentityServerDomainModule> objectMapper, 
             IApiResourceRepository apiResourceRepository)
         {
-            _identityResourceRepository = identityResourceRepository;
-            _objectMapper = objectMapper;
-            _apiResourceRepository = apiResourceRepository;
+            IdentityResourceRepository = identityResourceRepository;
+            ObjectMapper = objectMapper;
+            ApiResourceRepository = apiResourceRepository;
         }
 
         public virtual async Task<IEnumerable<IdentityServer4.Models.IdentityResource>> FindIdentityResourcesByScopeAsync(IEnumerable<string> scopeNames)
         {
-            var resource = await _identityResourceRepository.GetListByScopesAsync(scopeNames.ToArray(), includeDetails: true);
-            return _objectMapper.Map<List<IdentityResource>, List<IdentityServer4.Models.IdentityResource>>(resource);
+            var resource = await IdentityResourceRepository.GetListByScopesAsync(scopeNames.ToArray(), includeDetails: true);
+            return ObjectMapper.Map<List<IdentityResource>, List<IdentityServer4.Models.IdentityResource>>(resource);
         }
 
         public virtual async Task<IEnumerable<ApiResource>> FindApiResourcesByScopeAsync(IEnumerable<string> scopeNames)
         {
-            var resources = await _apiResourceRepository.GetListByScopesAsync(scopeNames.ToArray(), includeDetails: true);
-            return resources.Select(x => _objectMapper.Map<ApiResources.ApiResource, ApiResource>(x));
+            var resources = await ApiResourceRepository.GetListByScopesAsync(scopeNames.ToArray(), includeDetails: true);
+            return resources.Select(x => ObjectMapper.Map<ApiResources.ApiResource, ApiResource>(x));
         }
 
         public virtual async Task<ApiResource> FindApiResourceAsync(string name)
         {
-            var resource = await _apiResourceRepository.FindByNameAsync(name);
-            return _objectMapper.Map<ApiResources.ApiResource, ApiResource>(resource);
+            var resource = await ApiResourceRepository.FindByNameAsync(name);
+            return ObjectMapper.Map<ApiResources.ApiResource, ApiResource>(resource);
         }
 
         public virtual async Task<Resources> GetAllResourcesAsync()
         {
-            var identityResources = await _identityResourceRepository.GetListAsync(includeDetails: true);
-            var apiResources = await _apiResourceRepository.GetListAsync(includeDetails: true);
+            var identityResources = await IdentityResourceRepository.GetListAsync(includeDetails: true);
+            var apiResources = await ApiResourceRepository.GetListAsync(includeDetails: true);
 
             return new Resources(
-                _objectMapper.Map<List<IdentityResource>, IdentityServer4.Models.IdentityResource[]>(identityResources),
-                _objectMapper.Map<List<ApiResources.ApiResource>, ApiResource[]>(apiResources)
+                ObjectMapper.Map<List<IdentityResource>, IdentityServer4.Models.IdentityResource[]>(identityResources),
+                ObjectMapper.Map<List<ApiResources.ApiResource>, ApiResource[]>(apiResources)
             );
         }
     }

modules/identityserver/src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/ApiResources/ApiResourceRepository.cs

@@ -61,7 +61,7 @@ namespace Volo.Abp.IdentityServer.ApiResources
                 .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
-        public async Task<bool> CheckNameExistAsync(string name, Guid? expectedId = null, CancellationToken cancellationToken = default)
+        public virtual async Task<bool> CheckNameExistAsync(string name, Guid? expectedId = null, CancellationToken cancellationToken = default)
         {
             return await DbSet.AnyAsync(ar => ar.Id != expectedId && ar.Name == name, cancellationToken: cancellationToken);
         }

modules/identityserver/src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/Clients/ClientRepository.cs

@@ -37,7 +37,7 @@ namespace Volo.Abp.IdentityServer.Clients
                 .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
-        public async Task<List<string>> GetAllDistinctAllowedCorsOriginsAsync(CancellationToken cancellationToken = default)
+        public virtual async Task<List<string>> GetAllDistinctAllowedCorsOriginsAsync(CancellationToken cancellationToken = default)
         {
             return await DbContext.ClientCorsOrigins
                 .Select(x => x.Origin)
@@ -45,7 +45,7 @@ namespace Volo.Abp.IdentityServer.Clients
                 .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
-        public async Task<bool> CheckClientIdExistAsync(string clientId, Guid? expectedId = null, CancellationToken cancellationToken = default)
+        public virtual async Task<bool> CheckClientIdExistAsync(string clientId, Guid? expectedId = null, CancellationToken cancellationToken = default)
         {
             return await DbSet.AnyAsync(c => c.Id != expectedId && c.ClientId == clientId, cancellationToken: cancellationToken);
         }

modules/identityserver/src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/Devices/DeviceFlowCodesRepository.cs

@@ -19,7 +19,7 @@ namespace Volo.Abp.IdentityServer.Devices
 
         }
 
-        public async Task<DeviceFlowCodes> FindByUserCodeAsync(
+        public virtual async Task<DeviceFlowCodes> FindByUserCodeAsync(
             string userCode,
             CancellationToken cancellationToken = default)
         {
@@ -28,7 +28,7 @@ namespace Volo.Abp.IdentityServer.Devices
                 ;
         }
 
-        public async Task<DeviceFlowCodes> FindByDeviceCodeAsync(
+        public virtual async Task<DeviceFlowCodes> FindByDeviceCodeAsync(
             string deviceCode, 
             CancellationToken cancellationToken = default)
         {
@@ -36,7 +36,7 @@ namespace Volo.Abp.IdentityServer.Devices
                 .FirstOrDefaultAsync(d => d.DeviceCode == deviceCode, GetCancellationToken(cancellationToken));
         }
 
-        public async Task<List<DeviceFlowCodes>> GetListByExpirationAsync(DateTime maxExpirationDate, int maxResultCount,
+        public virtual async Task<List<DeviceFlowCodes>> GetListByExpirationAsync(DateTime maxExpirationDate, int maxResultCount,
             CancellationToken cancellationToken = default)
         {
             return await DbSet

modules/identityserver/src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/Grants/PersistedGrantRepository.cs

@@ -18,7 +18,7 @@ namespace Volo.Abp.IdentityServer.Grants
 
         }
 
-        public async Task<PersistedGrant> FindByKeyAsync(
+        public virtual async Task<PersistedGrant> FindByKeyAsync(
             string key,
             CancellationToken cancellationToken = default)
         {
@@ -27,7 +27,7 @@ namespace Volo.Abp.IdentityServer.Grants
                 ;
         }
 
-        public async Task<List<PersistedGrant>> GetListBySubjectIdAsync(
+        public virtual async Task<List<PersistedGrant>> GetListBySubjectIdAsync(
             string subjectId,
             CancellationToken cancellationToken = default)
         {
@@ -36,7 +36,7 @@ namespace Volo.Abp.IdentityServer.Grants
                 .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
-        public async Task<List<PersistedGrant>> GetListByExpirationAsync(
+        public virtual async Task<List<PersistedGrant>> GetListByExpirationAsync(
             DateTime maxExpirationDate, 
             int maxResultCount,
             CancellationToken cancellationToken = default)
@@ -48,7 +48,7 @@ namespace Volo.Abp.IdentityServer.Grants
                 .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
-        public async Task DeleteAsync(
+        public virtual async Task DeleteAsync(
             string subjectId, 
             string clientId,
             CancellationToken cancellationToken = default)
@@ -59,7 +59,7 @@ namespace Volo.Abp.IdentityServer.Grants
             );
         }
 
-        public async Task DeleteAsync(
+        public virtual async Task DeleteAsync(
             string subjectId, 
             string clientId, 
             string type,

modules/identityserver/src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/IdentityResources/IdentityResourceRepository.cs

@@ -46,7 +46,7 @@ namespace Volo.Abp.IdentityServer.IdentityResources
                 .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
-        public async Task<IdentityResource> FindByNameAsync(
+        public virtual async Task<IdentityResource> FindByNameAsync(
             string name, 
             bool includeDetails = true, 
             CancellationToken cancellationToken = default)
@@ -57,7 +57,7 @@ namespace Volo.Abp.IdentityServer.IdentityResources
                 .FirstOrDefaultAsync(GetCancellationToken(cancellationToken));
         }
 
-        public async Task<bool> CheckNameExistAsync(string name, Guid? expectedId = null, CancellationToken cancellationToken = default)
+        public virtual async Task<bool> CheckNameExistAsync(string name, Guid? expectedId = null, CancellationToken cancellationToken = default)
         {
             return await DbSet.AnyAsync(ir => ir.Id != expectedId && ir.Name == name, cancellationToken: cancellationToken);
         }

modules/identityserver/src/Volo.Abp.IdentityServer.MongoDB/Volo/Abp/IdentityServer/MongoDB/MongoApiResourceRepository.cs

@@ -48,7 +48,7 @@ namespace Volo.Abp.IdentityServer.MongoDB
             return await GetCountAsync();
         }
 
-        public async Task<bool> CheckNameExistAsync(string name, Guid? expectedId = null, CancellationToken cancellationToken = default)
+        public virtual async Task<bool> CheckNameExistAsync(string name, Guid? expectedId = null, CancellationToken cancellationToken = default)
         {
             return await GetMongoQueryable().AnyAsync(ar => ar.Id != expectedId && ar.Name == name, cancellationToken: cancellationToken);
         }

modules/identityserver/src/Volo.Abp.IdentityServer.MongoDB/Volo/Abp/IdentityServer/MongoDB/MongoClientRepository.cs

@@ -43,7 +43,7 @@ namespace Volo.Abp.IdentityServer.MongoDB
                 .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
-        public async Task<List<string>> GetAllDistinctAllowedCorsOriginsAsync(
+        public virtual async Task<List<string>> GetAllDistinctAllowedCorsOriginsAsync(
             CancellationToken cancellationToken = default)
         {
             return await GetMongoQueryable()
@@ -53,7 +53,7 @@ namespace Volo.Abp.IdentityServer.MongoDB
                 .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
-        public async Task<bool> CheckClientIdExistAsync(string clientId, Guid? expectedId = null, CancellationToken cancellationToken = default)
+        public virtual async Task<bool> CheckClientIdExistAsync(string clientId, Guid? expectedId = null, CancellationToken cancellationToken = default)
         {
             return await GetMongoQueryable().AnyAsync(c => c.Id != expectedId && c.ClientId == clientId, cancellationToken: cancellationToken);
         }

modules/identityserver/src/Volo.Abp.IdentityServer.MongoDB/Volo/Abp/IdentityServer/MongoDB/MongoDeviceFlowCodesRepository.cs

@@ -19,7 +19,7 @@ namespace Volo.Abp.IdentityServer.MongoDB
 
         }
 
-        public async Task<DeviceFlowCodes> FindByUserCodeAsync(
+        public virtual async Task<DeviceFlowCodes> FindByUserCodeAsync(
             string userCode,
             CancellationToken cancellationToken = default)
         {
@@ -28,13 +28,13 @@ namespace Volo.Abp.IdentityServer.MongoDB
                 ;
         }
 
-        public async Task<DeviceFlowCodes> FindByDeviceCodeAsync(string deviceCode, CancellationToken cancellationToken = default)
+        public virtual async Task<DeviceFlowCodes> FindByDeviceCodeAsync(string deviceCode, CancellationToken cancellationToken = default)
         {
             return await GetMongoQueryable()
                 .FirstOrDefaultAsync(d => d.DeviceCode == deviceCode, GetCancellationToken(cancellationToken));
         }
 
-        public async Task<List<DeviceFlowCodes>> GetListByExpirationAsync(
+        public virtual async Task<List<DeviceFlowCodes>> GetListByExpirationAsync(
             DateTime maxExpirationDate, 
             int maxResultCount,
             CancellationToken cancellationToken = default)

modules/identityserver/src/Volo.Abp.IdentityServer.MongoDB/Volo/Abp/IdentityServer/MongoDB/MongoIdentityResourceRepository.cs

@@ -27,7 +27,7 @@ namespace Volo.Abp.IdentityServer.MongoDB
                 .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
-        public async Task<IdentityResource> FindByNameAsync(
+        public virtual async Task<IdentityResource> FindByNameAsync(
             string name,
             bool includeDetails = true,
             CancellationToken cancellationToken = default)
@@ -37,7 +37,7 @@ namespace Volo.Abp.IdentityServer.MongoDB
                 .FirstOrDefaultAsync(GetCancellationToken(cancellationToken));
         }
 
-        public async Task<List<IdentityResource>> GetListByScopesAsync(string[] scopeNames, bool includeDetails = false,
+        public virtual async Task<List<IdentityResource>> GetListByScopesAsync(string[] scopeNames, bool includeDetails = false,
             CancellationToken cancellationToken = default)
         {
             return await GetMongoQueryable()
@@ -50,7 +50,7 @@ namespace Volo.Abp.IdentityServer.MongoDB
             return await GetCountAsync();
         }
 
-        public async Task<bool> CheckNameExistAsync(string name, Guid? expectedId = null, CancellationToken cancellationToken = default)
+        public virtual async Task<bool> CheckNameExistAsync(string name, Guid? expectedId = null, CancellationToken cancellationToken = default)
         {
             return await GetMongoQueryable().AnyAsync(ir => ir.Id != expectedId && ir.Name == name, cancellationToken: cancellationToken);
         }

modules/identityserver/src/Volo.Abp.IdentityServer.MongoDB/Volo/Abp/IdentityServer/MongoDB/MongoPersistedGrantRepository.cs

@@ -16,14 +16,14 @@ namespace Volo.Abp.IdentityServer.MongoDB
         {
         }
 
-        public async Task<PersistedGrant> FindByKeyAsync(string key, CancellationToken cancellationToken = default)
+        public virtual async Task<PersistedGrant> FindByKeyAsync(string key, CancellationToken cancellationToken = default)
         {
 
             return await GetMongoQueryable()
                 .FirstOrDefaultAsync(x => x.Key == key, GetCancellationToken(cancellationToken));
         }
 
-        public async Task<List<PersistedGrant>> GetListBySubjectIdAsync(string subjectId, CancellationToken cancellationToken = default)
+        public virtual async Task<List<PersistedGrant>> GetListBySubjectIdAsync(string subjectId, CancellationToken cancellationToken = default)
         {
             return await GetMongoQueryable()
                 .Where(x => x.SubjectId == subjectId)
@@ -31,7 +31,7 @@ namespace Volo.Abp.IdentityServer.MongoDB
                 ;
         }
 
-        public async Task<List<PersistedGrant>> GetListByExpirationAsync(DateTime maxExpirationDate, int maxResultCount,
+        public virtual async Task<List<PersistedGrant>> GetListByExpirationAsync(DateTime maxExpirationDate, int maxResultCount,
             CancellationToken cancellationToken = default)
         {
             return await GetMongoQueryable()
@@ -41,7 +41,7 @@ namespace Volo.Abp.IdentityServer.MongoDB
                 .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
-        public async Task DeleteAsync(string subjectId, string clientId, CancellationToken cancellationToken = default)
+        public virtual async Task DeleteAsync(string subjectId, string clientId, CancellationToken cancellationToken = default)
         {
             await DeleteAsync(
                 x => x.SubjectId == subjectId && x.ClientId == clientId,
@@ -49,7 +49,7 @@ namespace Volo.Abp.IdentityServer.MongoDB
             );
         }
 
-        public async Task DeleteAsync(string subjectId, string clientId, string type, CancellationToken cancellationToken = default)
+        public virtual async Task DeleteAsync(string subjectId, string clientId, string type, CancellationToken cancellationToken = default)
         {
             await DeleteAsync(
                 x => x.SubjectId == subjectId && x.ClientId == clientId && x.Type == type,

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

@@ -16,20 +16,17 @@ namespace Volo.Abp.PermissionManagement
     {
         protected PermissionManagementOptions Options { get; }
 
-        private readonly IPermissionManager _permissionManager;
-        private readonly IPermissionDefinitionManager _permissionDefinitionManager;
-        private readonly IStringLocalizerFactory _stringLocalizerFactory;
+        protected IPermissionManager PermissionManager { get; }
+        protected IPermissionDefinitionManager PermissionDefinitionManager { get; }
 
         public PermissionAppService(
             IPermissionManager permissionManager, 
             IPermissionDefinitionManager permissionDefinitionManager,
-            IStringLocalizerFactory stringLocalizerFactory,
             IOptions<PermissionManagementOptions> options)
         {
             Options = options.Value;
-            _permissionManager = permissionManager;
-            _permissionDefinitionManager = permissionDefinitionManager;
-            _stringLocalizerFactory = stringLocalizerFactory;
+            PermissionManager = permissionManager;
+            PermissionDefinitionManager = permissionDefinitionManager;
         }
 
         public virtual async Task<GetPermissionListResultDto> GetAsync(string providerName, string providerKey)
@@ -44,12 +41,12 @@ namespace Volo.Abp.PermissionManagement
 
             var multiTenancySide = CurrentTenant.GetMultiTenancySide();
 
-            foreach (var group in _permissionDefinitionManager.GetGroups())
+            foreach (var group in PermissionDefinitionManager.GetGroups())
             {
                 var groupDto = new PermissionGroupDto
                 {
                     Name = group.Name,
-                    DisplayName = group.DisplayName.Localize(_stringLocalizerFactory),
+                    DisplayName = group.DisplayName.Localize(StringLocalizerFactory),
                     Permissions = new List<PermissionGrantInfoDto>()
                 };
 
@@ -68,13 +65,13 @@ namespace Volo.Abp.PermissionManagement
                     var grantInfoDto = new PermissionGrantInfoDto
                     {
                         Name = permission.Name,
-                        DisplayName = permission.DisplayName.Localize(_stringLocalizerFactory),
+                        DisplayName = permission.DisplayName.Localize(StringLocalizerFactory),
                         ParentName = permission.Parent?.Name,
                         AllowedProviders = permission.Providers,
                         GrantedProviders = new List<ProviderInfoDto>()
                     };
 
-                    var grantInfo = await _permissionManager.GetAsync(permission.Name, providerName, providerKey);
+                    var grantInfo = await PermissionManager.GetAsync(permission.Name, providerName, providerKey);
 
                     grantInfoDto.IsGranted = grantInfo.IsGranted;
 
@@ -105,7 +102,7 @@ namespace Volo.Abp.PermissionManagement
 
             foreach (var permissionDto in input.Permissions)
             {
-                await _permissionManager.SetAsync(permissionDto.Name, providerName, providerKey, permissionDto.IsGranted);
+                await PermissionManager.SetAsync(permissionDto.Name, providerName, providerKey, permissionDto.IsGranted);
             }
         }
 

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

@@ -19,7 +19,7 @@ namespace Volo.Abp.PermissionManagement
             GuidGenerator = guidGenerator;
         }
 
-        public async Task SeedAsync(
+        public virtual async Task SeedAsync(
             string providerName, 
             string providerKey,
             IEnumerable<string> grantedPermissions,

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

@@ -50,12 +50,12 @@ namespace Volo.Abp.PermissionManagement
             );
         }
 
-        public async Task<PermissionWithGrantedProviders> GetAsync(string permissionName, string providerName, string providerKey)
+        public virtual async Task<PermissionWithGrantedProviders> GetAsync(string permissionName, string providerName, string providerKey)
         {
             return await GetInternalAsync(PermissionDefinitionManager.Get(permissionName), providerName, providerKey);
         }
 
-        public async Task<List<PermissionWithGrantedProviders>> GetAllAsync(string providerName, string providerKey)
+        public virtual async Task<List<PermissionWithGrantedProviders>> GetAllAsync(string providerName, string providerKey)
         {
             var results = new List<PermissionWithGrantedProviders>();
 
@@ -67,7 +67,7 @@ namespace Volo.Abp.PermissionManagement
             return results;
         }
 
-        public async Task SetAsync(string permissionName, string providerName, string providerKey, bool isGranted)
+        public virtual async Task SetAsync(string permissionName, string providerName, string providerKey, bool isGranted)
         {
             var permission = PermissionDefinitionManager.Get(permissionName);
 
@@ -99,7 +99,7 @@ namespace Volo.Abp.PermissionManagement
             await provider.SetAsync(permissionName, providerKey, isGranted);
         }
 
-        public async Task<PermissionGrant> UpdateProviderKeyAsync(PermissionGrant permissionGrant, string providerKey)
+        public virtual async Task<PermissionGrant> UpdateProviderKeyAsync(PermissionGrant permissionGrant, string providerKey)
         {
             permissionGrant.ProviderKey = providerKey;
             return await PermissionGrantRepository.UpdateAsync(permissionGrant);

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

@@ -24,7 +24,7 @@ namespace Volo.Abp.PermissionManagement
             Logger = NullLogger<PermissionStore>.Instance;
         }
 
-        public async Task<bool> IsGrantedAsync(string name, string providerName, string providerKey)
+        public virtual async Task<bool> IsGrantedAsync(string name, string providerName, string providerKey)
         {
             return (await GetCacheItemAsync(name, providerName, providerKey)).IsGranted;
         }

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

@@ -18,7 +18,7 @@ namespace Volo.Abp.PermissionManagement.EntityFrameworkCore
 
         }
 
-        public async Task<PermissionGrant> FindAsync(
+        public virtual async Task<PermissionGrant> FindAsync(
             string name, 
             string providerName, 
             string providerKey,
@@ -33,7 +33,7 @@ namespace Volo.Abp.PermissionManagement.EntityFrameworkCore
                 );
         }
 
-        public async Task<List<PermissionGrant>> GetListAsync(
+        public virtual async Task<List<PermissionGrant>> GetListAsync(
             string providerName,
             string providerKey,
             CancellationToken cancellationToken = default)

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

@@ -8,21 +8,21 @@ namespace Volo.Abp.PermissionManagement
     [Area("abp")]
     public class PermissionsController : AbpController, IPermissionAppService
     {
-        private readonly IPermissionAppService _permissionAppService;
+        protected IPermissionAppService PermissionAppService { get; }
 
         public PermissionsController(IPermissionAppService permissionAppService)
         {
-            _permissionAppService = permissionAppService;
+            PermissionAppService = permissionAppService;
         }
 
-        public Task<GetPermissionListResultDto> GetAsync(string providerName, string providerKey)
+        public virtual Task<GetPermissionListResultDto> GetAsync(string providerName, string providerKey)
         {
-            return _permissionAppService.GetAsync(providerName, providerKey);
+            return PermissionAppService.GetAsync(providerName, providerKey);
         }
 
-        public Task UpdateAsync(string providerName, string providerKey, UpdatePermissionsDto input)
+        public virtual Task UpdateAsync(string providerName, string providerKey, UpdatePermissionsDto input)
         {
-            return _permissionAppService.UpdateAsync(providerName, providerKey, input);
+            return PermissionAppService.UpdateAsync(providerName, providerKey, input);
         }
     }
 }

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

@@ -17,7 +17,7 @@ namespace Volo.Abp.PermissionManagement.MongoDB
 
         }
 
-        public async Task<PermissionGrant> FindAsync(
+        public virtual async Task<PermissionGrant> FindAsync(
             string name, 
             string providerName, 
             string providerKey,
@@ -32,7 +32,7 @@ namespace Volo.Abp.PermissionManagement.MongoDB
                 );
         }
 
-        public async Task<List<PermissionGrant>> GetListAsync(
+        public virtual async Task<List<PermissionGrant>> GetListAsync(
             string providerName, 
             string providerKey,
             CancellationToken cancellationToken = default)

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

@@ -29,20 +29,20 @@ namespace Volo.Abp.PermissionManagement.Web.Pages.AbpPermissionManagement
 
         public bool SelectAllInAllTabs { get; set; }
 
-        private readonly IPermissionAppService _permissionAppService;
+        protected IPermissionAppService PermissionAppService { get; }
 
         public PermissionManagementModal(IPermissionAppService permissionAppService)
         {
             ObjectMapperContext = typeof(AbpPermissionManagementWebModule);
 
-            _permissionAppService = permissionAppService;
+            PermissionAppService = permissionAppService;
         }
 
-        public async Task OnGetAsync()
+        public virtual async Task OnGetAsync()
         {
             ValidateModel();
 
-            var result = await _permissionAppService.GetAsync(ProviderName, ProviderKey);
+            var result = await PermissionAppService.GetAsync(ProviderName, ProviderKey);
 
             EntityDisplayName = result.EntityDisplayName;
 
@@ -64,7 +64,7 @@ namespace Volo.Abp.PermissionManagement.Web.Pages.AbpPermissionManagement
             SelectAllInAllTabs = Groups.All(g => g.IsAllPermissionsGranted);
         }
 
-        public async Task<IActionResult> OnPostAsync()
+        public virtual async Task<IActionResult> OnPostAsync()
         {
             ValidateModel();
 
@@ -77,7 +77,7 @@ namespace Volo.Abp.PermissionManagement.Web.Pages.AbpPermissionManagement
                 })
                 .ToArray();
 
-            await _permissionAppService.UpdateAsync(
+            await PermissionAppService.UpdateAsync(
                 ProviderName,
                 ProviderKey,
                 new UpdatePermissionsDto

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

@@ -5,7 +5,7 @@ namespace Volo.Abp.PermissionManagement.Web.Utils
     public class FlatTreeDepthFinder<T>
         where T : class, IFlatTreeItem
     {
-        public void SetDepths(List<T> items)
+        public virtual void SetDepths(List<T> items)
         {
             SetDepths(items, null, 0);
         }

modules/setting-management/src/Volo.Abp.SettingManagement.Domain/Volo/Abp/SettingManagement/ConfigurationSettingManagementProvider.cs

@@ -16,17 +16,17 @@ namespace Volo.Abp.SettingManagement
             Configuration = configuration;
         }
 
-        public Task<string> GetOrNullAsync(SettingDefinition setting, string providerKey)
+        public virtual Task<string> GetOrNullAsync(SettingDefinition setting, string providerKey)
         {
             return Task.FromResult(Configuration[ConfigurationSettingValueProvider.ConfigurationNamePrefix + setting.Name]);
         }
 
-        public Task SetAsync(SettingDefinition setting, string value, string providerKey)
+        public virtual Task SetAsync(SettingDefinition setting, string value, string providerKey)
         {
             throw new AbpException($"Can not set a setting value to the application configuration.");
         }
 
-        public Task ClearAsync(SettingDefinition setting, string providerKey)
+        public virtual Task ClearAsync(SettingDefinition setting, string providerKey)
         {
             throw new AbpException($"Can not set a setting value to the application configuration.");
         }

modules/setting-management/src/Volo.Abp.SettingManagement.Domain/Volo/Abp/SettingManagement/DefaultValueSettingManagementProvider.cs

@@ -8,17 +8,17 @@ namespace Volo.Abp.SettingManagement
     {
         public string Name => DefaultValueSettingValueProvider.ProviderName;
 
-        public Task<string> GetOrNullAsync(SettingDefinition setting, string providerKey)
+        public virtual Task<string> GetOrNullAsync(SettingDefinition setting, string providerKey)
         {
             return Task.FromResult(setting.DefaultValue);
         }
 
-        public Task SetAsync(SettingDefinition setting, string value, string providerKey)
+        public virtual Task SetAsync(SettingDefinition setting, string value, string providerKey)
         {
             throw new AbpException($"Can not set default value of a setting. It is only possible while defining the setting in a {typeof(ISettingDefinitionProvider)} implementation.");
         }
 
-        public Task ClearAsync(SettingDefinition setting, string providerKey)
+        public virtual Task ClearAsync(SettingDefinition setting, string providerKey)
         {
             throw new AbpException($"Can not clear default value of a setting. It is only possible while defining the setting in a {typeof(ISettingDefinitionProvider)} implementation.");
         }

modules/setting-management/src/Volo.Abp.SettingManagement.Domain/Volo/Abp/SettingManagement/SettingManagementProvider.cs

@@ -15,7 +15,7 @@ namespace Volo.Abp.SettingManagement
             SettingManagementStore = settingManagementStore;
         }
 
-        public async Task<string> GetOrNullAsync(SettingDefinition setting, string providerKey)
+        public virtual async Task<string> GetOrNullAsync(SettingDefinition setting, string providerKey)
         {
             return await SettingManagementStore.GetOrNullAsync(setting.Name, Name, NormalizeProviderKey(providerKey));
         }

modules/setting-management/src/Volo.Abp.SettingManagement.Domain/Volo/Abp/SettingManagement/SettingManagementStore.cs

@@ -24,13 +24,13 @@ namespace Volo.Abp.SettingManagement
             Cache = cache;
         }
 
-        public async Task<string> GetOrNullAsync(string name, string providerName, string providerKey)
+        public virtual async Task<string> GetOrNullAsync(string name, string providerName, string providerKey)
         {
             var cacheItem = await GetCacheItemAsync(name, providerName, providerKey);
             return cacheItem.Value;
         }
 
-        public async Task SetAsync(string name, string value, string providerName, string providerKey)
+        public virtual async Task SetAsync(string name, string value, string providerName, string providerKey)
         {
             var setting = await SettingRepository.FindAsync(name, providerName, providerKey);
             if (setting == null)
@@ -45,13 +45,13 @@ namespace Volo.Abp.SettingManagement
             }
         }
 
-        public async Task<List<SettingValue>> GetListAsync(string providerName, string providerKey)
+        public virtual async Task<List<SettingValue>> GetListAsync(string providerName, string providerKey)
         {
             var settings = await SettingRepository.GetListAsync(providerName, providerKey);
             return settings.Select(s => new SettingValue(s.Name, s.Value)).ToList();
         }
 
-        public async Task DeleteAsync(string name, string providerName, string providerKey)
+        public virtual async Task DeleteAsync(string name, string providerName, string providerKey)
         {
             var setting = await SettingRepository.FindAsync(name, providerName, providerKey);
             if (setting != null)

modules/setting-management/src/Volo.Abp.SettingManagement.Domain/Volo/Abp/SettingManagement/SettingStore.cs

@@ -13,7 +13,7 @@ namespace Volo.Abp.SettingManagement
             ManagementStore = managementStore;
         }
 
-        public Task<string> GetOrNullAsync(string name, string providerName, string providerKey)
+        public virtual Task<string> GetOrNullAsync(string name, string providerName, string providerKey)
         {
             return ManagementStore.GetOrNullAsync(name, providerName, providerKey);
         }

modules/setting-management/src/Volo.Abp.SettingManagement.EntityFrameworkCore/Volo/Abp/SettingManagement/EntityFrameworkCore/EfCoreSettingRepository.cs

@@ -15,7 +15,7 @@ namespace Volo.Abp.SettingManagement.EntityFrameworkCore
         {
         }
 
-        public async Task<Setting> FindAsync(string name, string providerName, string providerKey)
+        public virtual async Task<Setting> FindAsync(string name, string providerName, string providerKey)
         {
             return await DbSet
                 .FirstOrDefaultAsync(
@@ -23,7 +23,7 @@ namespace Volo.Abp.SettingManagement.EntityFrameworkCore
                 );
         }
 
-        public async Task<List<Setting>> GetListAsync(string providerName, string providerKey)
+        public virtual async Task<List<Setting>> GetListAsync(string providerName, string providerKey)
         {
             return await DbSet
                 .Where(

modules/setting-management/src/Volo.Abp.SettingManagement.MongoDB/Volo/Abp/SettingManagement/MongoDB/MongoSettingRepository.cs

@@ -16,12 +16,12 @@ namespace Volo.Abp.SettingManagement.MongoDB
 
         }
 
-        public async Task<Setting> FindAsync(string name, string providerName, string providerKey)
+        public virtual async Task<Setting> FindAsync(string name, string providerName, string providerKey)
         {
             return await GetMongoQueryable().FirstOrDefaultAsync(s => s.Name == name && s.ProviderName == providerName && s.ProviderKey == providerKey);
         }
 
-        public async Task<List<Setting>> GetListAsync(string providerName, string providerKey)
+        public virtual async Task<List<Setting>> GetListAsync(string providerName, string providerKey)
         {
             return await GetMongoQueryable().Where(s => s.ProviderName == providerName && s.ProviderKey == providerKey).ToListAsync();
         }

modules/setting-management/src/Volo.Abp.SettingManagement.Web/Navigation/SettingManagementMainMenuContributor.cs

@@ -12,7 +12,7 @@ namespace Volo.Abp.SettingManagement.Web.Navigation
 {
     public class SettingManagementMainMenuContributor : IMenuContributor
     {
-        public async Task ConfigureMenuAsync(MenuConfigurationContext context)
+        public virtual async Task ConfigureMenuAsync(MenuConfigurationContext context)
         {
             if (context.Menu.Name != StandardMenus.Main)
             {
@@ -43,7 +43,7 @@ namespace Volo.Abp.SettingManagement.Web.Navigation
                 );
         }
 
-        private async Task<bool> CheckAnyOfPagePermissionsGranted(
+        protected virtual async Task<bool> CheckAnyOfPagePermissionsGranted(
             SettingManagementPageOptions settingManagementPageOptions,
             SettingPageCreationContext settingPageCreationContext)
         {

modules/setting-management/src/Volo.Abp.SettingManagement.Web/Pages/SettingManagement/Index.cshtml.cs

@@ -9,25 +9,26 @@ namespace Volo.Abp.SettingManagement.Web.Pages.SettingManagement
     {
         public SettingPageCreationContext SettingPageCreationContext { get; private set; }
 
-        private readonly SettingManagementPageOptions _options;
-        private readonly IServiceProvider _serviceProvider;
+        protected SettingManagementPageOptions Options { get; }
 
-        public IndexModel(
-            IOptions<SettingManagementPageOptions> options, 
-            IServiceProvider serviceProvider)
+        public IndexModel(IOptions<SettingManagementPageOptions> options)
         {
-            _serviceProvider = serviceProvider;
-            _options = options.Value;
+            Options = options.Value;
         }
 
-        public async Task OnGetAsync()
+        public virtual async Task OnGetAsync()
         {
-            SettingPageCreationContext = new SettingPageCreationContext(_serviceProvider);
+            SettingPageCreationContext = new SettingPageCreationContext(ServiceProvider);
 
-            foreach (var contributor in _options.Contributors)
+            foreach (var contributor in Options.Contributors)
             {
                 await contributor.ConfigureAsync(SettingPageCreationContext);
             }
         }
+
+        public virtual Task OnPostAsync()
+        {
+            return Task.CompletedTask;
+        }
     }
 }

modules/tenant-management/src/Volo.Abp.TenantManagement.Domain/Volo/Abp/TenantManagement/Tenant.cs

@@ -72,7 +72,7 @@ namespace Volo.Abp.TenantManagement
             }
         }
 
-        internal void SetName([NotNull] string name)
+        protected internal virtual void SetName([NotNull] string name)
         {
             Name = Check.NotNullOrWhiteSpace(name, nameof(name), TenantConsts.MaxNameLength);
         }

modules/tenant-management/src/Volo.Abp.TenantManagement.Domain/Volo/Abp/TenantManagement/TenantManager.cs

@@ -7,15 +7,15 @@ namespace Volo.Abp.TenantManagement
 {
     public class TenantManager : DomainService, ITenantManager
     {
-        private readonly ITenantRepository _tenantRepository;
+        protected ITenantRepository TenantRepository { get; }
 
         public TenantManager(ITenantRepository tenantRepository)
         {
-            _tenantRepository = tenantRepository;
+            TenantRepository = tenantRepository;
 
         }
 
-        public async Task<Tenant> CreateAsync(string name)
+        public virtual async Task<Tenant> CreateAsync(string name)
         {
             Check.NotNull(name, nameof(name));
 
@@ -23,7 +23,7 @@ namespace Volo.Abp.TenantManagement
             return new Tenant(GuidGenerator.Create(), name);
         }
 
-        public async Task ChangeNameAsync(Tenant tenant, string name)
+        public virtual async Task ChangeNameAsync(Tenant tenant, string name)
         {
             Check.NotNull(tenant, nameof(tenant));
             Check.NotNull(name, nameof(name));
@@ -34,7 +34,7 @@ namespace Volo.Abp.TenantManagement
 
         protected virtual async Task ValidateNameAsync(string name, Guid? expectedId = null)
         {
-            var tenant = await _tenantRepository.FindByNameAsync(name);
+            var tenant = await TenantRepository.FindByNameAsync(name);
             if (tenant != null && tenant.Id != expectedId)
             {
                 throw new UserFriendlyException("Duplicate tenancy name: " + name); //TODO: A domain exception would be better..?

modules/tenant-management/src/Volo.Abp.TenantManagement.Domain/Volo/Abp/TenantManagement/TenantStore.cs

@@ -10,73 +10,73 @@ namespace Volo.Abp.TenantManagement
 
     public class TenantStore : ITenantStore, ITransientDependency
     {
-        private readonly ITenantRepository _tenantRepository;
-        private readonly IObjectMapper<AbpTenantManagementDomainModule> _objectMapper;
-        private readonly ICurrentTenant _currentTenant;
+        protected ITenantRepository TenantRepository { get; }
+        protected IObjectMapper<AbpTenantManagementDomainModule> ObjectMapper { get; }
+        protected ICurrentTenant CurrentTenant { get; }
 
         public TenantStore(
             ITenantRepository tenantRepository, 
             IObjectMapper<AbpTenantManagementDomainModule> objectMapper,
             ICurrentTenant currentTenant)
         {
-            _tenantRepository = tenantRepository;
-            _objectMapper = objectMapper;
-            _currentTenant = currentTenant;
+            TenantRepository = tenantRepository;
+            ObjectMapper = objectMapper;
+            CurrentTenant = currentTenant;
         }
 
-        public async Task<TenantConfiguration> FindAsync(string name)
+        public virtual async Task<TenantConfiguration> FindAsync(string name)
         {
-            using (_currentTenant.Change(null)) //TODO: No need this if we can implement to define host side (or tenant-independent) entities!
+            using (CurrentTenant.Change(null)) //TODO: No need this if we can implement to define host side (or tenant-independent) entities!
             {
-                var tenant = await _tenantRepository.FindByNameAsync(name);
+                var tenant = await TenantRepository.FindByNameAsync(name);
                 if (tenant == null)
                 {
                     return null;
                 }
 
-                return _objectMapper.Map<Tenant, TenantConfiguration>(tenant);
+                return ObjectMapper.Map<Tenant, TenantConfiguration>(tenant);
             }
         }
 
-        public async Task<TenantConfiguration> FindAsync(Guid id)
+        public virtual async Task<TenantConfiguration> FindAsync(Guid id)
         {
-            using (_currentTenant.Change(null)) //TODO: No need this if we can implement to define host side (or tenant-independent) entities!
+            using (CurrentTenant.Change(null)) //TODO: No need this if we can implement to define host side (or tenant-independent) entities!
             {
-                var tenant = await _tenantRepository.FindAsync(id);
+                var tenant = await TenantRepository.FindAsync(id);
                 if (tenant == null)
                 {
                     return null;
                 }
 
-                return _objectMapper.Map<Tenant, TenantConfiguration>(tenant);
+                return ObjectMapper.Map<Tenant, TenantConfiguration>(tenant);
             }
         }
 
-        public TenantConfiguration Find(string name)
+        public virtual TenantConfiguration Find(string name)
         {
-            using (_currentTenant.Change(null)) //TODO: No need this if we can implement to define host side (or tenant-independent) entities!
+            using (CurrentTenant.Change(null)) //TODO: No need this if we can implement to define host side (or tenant-independent) entities!
             {
-                var tenant = _tenantRepository.FindByName(name);
+                var tenant = TenantRepository.FindByName(name);
                 if (tenant == null)
                 {
                     return null;
                 }
 
-                return _objectMapper.Map<Tenant, TenantConfiguration>(tenant);
+                return ObjectMapper.Map<Tenant, TenantConfiguration>(tenant);
             }
         }
 
-        public TenantConfiguration Find(Guid id)
+        public virtual TenantConfiguration Find(Guid id)
         {
-            using (_currentTenant.Change(null)) //TODO: No need this if we can implement to define host side (or tenant-independent) entities!
+            using (CurrentTenant.Change(null)) //TODO: No need this if we can implement to define host side (or tenant-independent) entities!
             {
-                var tenant = _tenantRepository.FindById(id);
+                var tenant = TenantRepository.FindById(id);
                 if (tenant == null)
                 {
                     return null;
                 }
 
-                return _objectMapper.Map<Tenant, TenantConfiguration>(tenant);
+                return ObjectMapper.Map<Tenant, TenantConfiguration>(tenant);
             }
         }
     }

modules/tenant-management/src/Volo.Abp.TenantManagement.EntityFrameworkCore/Volo/Abp/TenantManagement/EntityFrameworkCore/EfCoreTenantRepository.cs

@@ -28,14 +28,14 @@ namespace Volo.Abp.TenantManagement.EntityFrameworkCore
                 .FirstOrDefaultAsync(t => t.Name == name, GetCancellationToken(cancellationToken));
         }
 
-        public Tenant FindByName(string name, bool includeDetails = true)
+        public virtual Tenant FindByName(string name, bool includeDetails = true)
         {
             return DbSet
                 .IncludeDetails(includeDetails)
                 .FirstOrDefault(t => t.Name == name);
         }
 
-        public Tenant FindById(Guid id, bool includeDetails = true)
+        public virtual Tenant FindById(Guid id, bool includeDetails = true)
         {
             return DbSet
                 .IncludeDetails(includeDetails)
@@ -62,7 +62,7 @@ namespace Volo.Abp.TenantManagement.EntityFrameworkCore
                 .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
-        public async Task<long> GetCountAsync(string filter = null, CancellationToken cancellationToken = default)
+        public virtual async Task<long> GetCountAsync(string filter = null, CancellationToken cancellationToken = default)
         {
             return await this
                 .WhereIf(

modules/tenant-management/src/Volo.Abp.TenantManagement.HttpApi/Volo/Abp/TenantManagement/TenantController.cs

@@ -12,66 +12,66 @@ namespace Volo.Abp.TenantManagement
     [Route("api/multi-tenancy/tenants")]
     public class TenantController : AbpController, ITenantAppService //TODO: Throws exception on validation if we inherit from Controller
     {
-        private readonly ITenantAppService _service;
+        protected ITenantAppService TenantAppService { get; }
 
-        public TenantController(ITenantAppService service)
+        public TenantController(ITenantAppService tenantAppService)
         {
-            _service = service;
+            TenantAppService = tenantAppService;
         }
 
         [HttpGet]
         [Route("{id}")]
         public virtual Task<TenantDto> GetAsync(Guid id)
         {
-            return _service.GetAsync(id);
+            return TenantAppService.GetAsync(id);
         }
 
         [HttpGet]
         public virtual Task<PagedResultDto<TenantDto>> GetListAsync(GetTenantsInput input)
         {
-            return _service.GetListAsync(input);
+            return TenantAppService.GetListAsync(input);
         }
 
         [HttpPost]
         public virtual Task<TenantDto> CreateAsync(TenantCreateDto input)
         {
             ValidateModel();
-            return _service.CreateAsync(input);
+            return TenantAppService.CreateAsync(input);
         }
 
         [HttpPut]
         [Route("{id}")]
         public virtual Task<TenantDto> UpdateAsync(Guid id, TenantUpdateDto input)
         {
-            return _service.UpdateAsync(id, input);
+            return TenantAppService.UpdateAsync(id, input);
         }
 
         [HttpDelete]
         [Route("{id}")]
         public virtual Task DeleteAsync(Guid id)
         {
-            return _service.DeleteAsync(id);
+            return TenantAppService.DeleteAsync(id);
         }
 
         [HttpGet]
         [Route("{id}/default-connection-string")]
-        public Task<string> GetDefaultConnectionStringAsync(Guid id)
+        public virtual Task<string> GetDefaultConnectionStringAsync(Guid id)
         {
-            return _service.GetDefaultConnectionStringAsync(id);
+            return TenantAppService.GetDefaultConnectionStringAsync(id);
         }
 
         [HttpPut]
         [Route("{id}/default-connection-string")]
-        public Task UpdateDefaultConnectionStringAsync(Guid id, string defaultConnectionString)
+        public virtual Task UpdateDefaultConnectionStringAsync(Guid id, string defaultConnectionString)
         {
-            return _service.UpdateDefaultConnectionStringAsync(id, defaultConnectionString);
+            return TenantAppService.UpdateDefaultConnectionStringAsync(id, defaultConnectionString);
         }
 
         [HttpDelete]
         [Route("{id}/default-connection-string")]
-        public Task DeleteDefaultConnectionStringAsync(Guid id)
+        public virtual Task DeleteDefaultConnectionStringAsync(Guid id)
         {
-            return _service.DeleteDefaultConnectionStringAsync(id);
+            return TenantAppService.DeleteDefaultConnectionStringAsync(id);
         }
     }
 }

modules/tenant-management/src/Volo.Abp.TenantManagement.MongoDB/Volo/Abp/TenantManagement/MongoDb/MongoTenantRepository.cs

@@ -28,13 +28,13 @@ namespace Volo.Abp.TenantManagement.MongoDB
                 .FirstOrDefaultAsync(t => t.Name == name, GetCancellationToken(cancellationToken));
         }
 
-        public Tenant FindByName(string name, bool includeDetails = true)
+        public virtual Tenant FindByName(string name, bool includeDetails = true)
         {
             return GetMongoQueryable()
                 .FirstOrDefault(t => t.Name == name);
         }
 
-        public Tenant FindById(Guid id, bool includeDetails = true)
+        public virtual Tenant FindById(Guid id, bool includeDetails = true)
         {
             return GetMongoQueryable()
                 .FirstOrDefault(t => t.Id == id);
@@ -60,7 +60,7 @@ namespace Volo.Abp.TenantManagement.MongoDB
                 .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
-        public async Task<long> GetCountAsync(string filter = null, CancellationToken cancellationToken = default)
+        public virtual async Task<long> GetCountAsync(string filter = null, CancellationToken cancellationToken = default)
         {
             return await GetMongoQueryable()
                 .WhereIf<Tenant, IMongoQueryable<Tenant>>(

modules/tenant-management/src/Volo.Abp.TenantManagement.Web/AbpTenantManagementWebAutoMapperProfile.cs

@@ -10,7 +10,7 @@ namespace Volo.Abp.TenantManagement.Web
             CreateRoleMappings();
         }
 
-        private void CreateRoleMappings()
+        protected virtual void CreateRoleMappings()
         {
             //List
             CreateMap<TenantDto, EditModalModel.TenantInfoModel>();

modules/tenant-management/src/Volo.Abp.TenantManagement.Web/Navigation/AbpTenantManagementWebMainMenuContributor.cs

@@ -9,7 +9,7 @@ namespace Volo.Abp.TenantManagement.Web.Navigation
 {
     public class AbpTenantManagementWebMainMenuContributor : IMenuContributor
     {
-        public async Task ConfigureMenuAsync(MenuConfigurationContext context)
+        public virtual async Task ConfigureMenuAsync(MenuConfigurationContext context)
         {
             if (context.Menu.Name != StandardMenus.Main)
             {

modules/tenant-management/src/Volo.Abp.TenantManagement.Web/Pages/TenantManagement/Tenants/ConnectionStringsModal.cshtml.cs

@@ -11,16 +11,16 @@ namespace Volo.Abp.TenantManagement.Web.Pages.TenantManagement.Tenants
         [BindProperty]
         public TenantInfoModel Tenant { get; set; }
 
-        private readonly ITenantAppService _tenantAppService;
+        protected ITenantAppService TenantAppService { get; }
 
         public ConnectionStringsModal(ITenantAppService tenantAppService)
         {
-            _tenantAppService = tenantAppService;
+            TenantAppService = tenantAppService;
         }
 
-        public async Task OnGetAsync(Guid id)
+        public virtual async Task OnGetAsync(Guid id)
         {
-            var defaultConnectionString = await _tenantAppService.GetDefaultConnectionStringAsync(id);
+            var defaultConnectionString = await TenantAppService.GetDefaultConnectionStringAsync(id);
             Tenant = new TenantInfoModel
             {
                 Id = id,
@@ -29,17 +29,17 @@ namespace Volo.Abp.TenantManagement.Web.Pages.TenantManagement.Tenants
             };
         }
 
-        public async Task<IActionResult> OnPostAsync()
+        public virtual async Task<IActionResult> OnPostAsync()
         {
             ValidateModel();
 
             if (Tenant.UseSharedDatabase || Tenant.DefaultConnectionString.IsNullOrWhiteSpace())
             {
-                await _tenantAppService.DeleteDefaultConnectionStringAsync(Tenant.Id);
+                await TenantAppService.DeleteDefaultConnectionStringAsync(Tenant.Id);
             }
             else
             {
-                await _tenantAppService.UpdateDefaultConnectionStringAsync(Tenant.Id, Tenant.DefaultConnectionString);
+                await TenantAppService.UpdateDefaultConnectionStringAsync(Tenant.Id, Tenant.DefaultConnectionString);
             }
 
             return NoContent();

modules/tenant-management/src/Volo.Abp.TenantManagement.Web/Pages/TenantManagement/Tenants/CreateModal.cshtml.cs

@@ -10,19 +10,24 @@ namespace Volo.Abp.TenantManagement.Web.Pages.TenantManagement.Tenants
         [BindProperty]
         public TenantInfoModel Tenant { get; set; }
 
-        private readonly ITenantAppService _tenantAppService;
+        protected ITenantAppService TenantAppService { get; }
 
         public CreateModalModel(ITenantAppService tenantAppService)
         {
-            _tenantAppService = tenantAppService;
+            TenantAppService = tenantAppService;
         }
 
-        public async Task<IActionResult> OnPostAsync()
+        public virtual Task OnGetAsync()
+        {
+            return Task.CompletedTask;
+        }
+
+        public virtual async Task<IActionResult> OnPostAsync()
         {
             ValidateModel();
 
             var input = ObjectMapper.Map<TenantInfoModel, TenantCreateDto>(Tenant);
-            await _tenantAppService.CreateAsync(input);
+            await TenantAppService.CreateAsync(input);
 
             return NoContent();
         }

modules/tenant-management/src/Volo.Abp.TenantManagement.Web/Pages/TenantManagement/Tenants/EditModal.cshtml.cs

@@ -11,26 +11,26 @@ namespace Volo.Abp.TenantManagement.Web.Pages.TenantManagement.Tenants
         [BindProperty]
         public TenantInfoModel Tenant { get; set; }
 
-        private readonly ITenantAppService _tenantAppService;
+        protected ITenantAppService TenantAppService { get; }
 
         public EditModalModel(ITenantAppService tenantAppService)
         {
-            _tenantAppService = tenantAppService;
+            TenantAppService = tenantAppService;
         }
 
-        public async Task OnGetAsync(Guid id)
+        public virtual async Task OnGetAsync(Guid id)
         {
             Tenant = ObjectMapper.Map<TenantDto, TenantInfoModel>(
-                await _tenantAppService.GetAsync(id)
+                await TenantAppService.GetAsync(id)
             );
         }
 
-        public async Task<IActionResult> OnPostAsync()
+        public virtual async Task<IActionResult> OnPostAsync()
         {
             ValidateModel();
 
             var input = ObjectMapper.Map<TenantInfoModel, TenantUpdateDto>(Tenant);
-            await _tenantAppService.UpdateAsync(Tenant.Id, input);
+            await TenantAppService.UpdateAsync(Tenant.Id, input);
 
             return NoContent();
         }

modules/tenant-management/src/Volo.Abp.TenantManagement.Web/Pages/TenantManagement/Tenants/Index.cshtml.cs

@@ -1,12 +1,18 @@
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc.RazorPages;
 
 namespace Volo.Abp.TenantManagement.Web.Pages.TenantManagement.Tenants
 {
     public class IndexModel : TenantManagementPageModel
     {
-        public void OnGet()
+        public virtual Task OnGetAsync()
         {
+            return Task.CompletedTask;
+        }
 
+        public virtual Task OnPostAsync()
+        {
+            return Task.CompletedTask;
         }
     }
 }