通過AOP+特性實現

1.設定許可權的class需要需要派生自AuthorizationProvider類

    public class MyAuthorizationProvider : AuthorizationProvider
    {
        public override void SetPermissions(IPermissionDefinitionContext context)
        {
            var pages = context.CreatePermission(PermissionNames.Pages_Users, FL("
 
後臺頁面"));

            //物料管理
            var product = pages.CreateChildPermission(PermissionNames.Pages_Product, FL("物料管理"));
            product.CreateChildPermission(PermissionNames.Pages_Product_CreateOrEdit, FL("新增修改物料"));

2.ABP中Application層需要進行許可權驗證  在Module中註冊許可權

public override
 
 void PreInitialize()
        {
            Configuration.Authorization.Providers.Add<MyAuthorizationProvider>(); 
　　　　 }

3.在介面或方法上新增許可權

所有許可權都儲存在 PermissionDictionary Permissions物件中    這個PermissionDictionary型別繼承Dictionary<string, Permission> 

許可權就是一份存在記憶體中的資料字典   

protected readonly PermissionDictionary Permissions;

許可權物件(Permission)：用於定義一個Permission，一個permission可以包含多個子Permission.

    public class Permission
    {
        /// <summary>
        /// Parent of this permission if one exists.
        /// If set, this permission can be granted only if parent is granted.
        /// </summary>
        public Permission Parent { get; private set; }

        /// <summary>
        /// List of child permissions. A child permission can be granted only if parent is granted.
        /// </summary>
        public IReadOnlyList<Permission> Children => _children.ToImmutableList();
        private readonly List<Permission> _children;

驗證許可權的過程

找到當前請求需要執行的方法    找到當前方法繼承許可權的特性和當前方法所在的類繼承的許可權的特性  

如果都不存在 直接通過    

如果存在    迴圈存在的所有許可權特性中的許可權

去獲取當前使用者的許可權  跟當前需要的許可權進行匹配   全部匹配  就通過

可以自己注入 這個物件來檢查許可權

//檢查是否存在當前的許可權   

        public virtual async Task<bool> IsGrantedAsync(string permissionName)
        {
            return AbpSession.UserId.HasValue && await _userManager.IsGrantedAsync(AbpSession.UserId.Value, permissionName);
        }

        public virtual async Task<bool> IsGrantedAsync(long userId, string permissionName)
        {
            return await _userManager.IsGrantedAsync(userId, permissionName);
        }

//獲取當前使用者的所有許可權

        private async Task<UserPermissionCacheItem> GetUserPermissionCacheItemAsync(long userId)
        {
            var cacheKey = userId + "@" + (GetCurrentTenantId() ?? 0);
            return await _cacheManager.GetUserPermissionCache().GetAsync(cacheKey, async () =>
            {
                var user = await FindByIdAsync(userId);
                if (user == null)
                {
                    return null;
                }

                var newCacheItem = new UserPermissionCacheItem(userId);

                foreach (var roleName in await GetRolesAsync(userId))
                {
                    newCacheItem.RoleIds.Add((await RoleManager.GetRoleByNameAsync(roleName)).Id);
                }
                
                foreach (var permissionInfo in await UserPermissionStore.GetPermissionsAsync(userId))
                {
                    //當前許可權是否授予
                    if (permissionInfo.IsGranted)
                    {
                        //授予的許可權
                        newCacheItem.GrantedPermissions.Add(permissionInfo.Name);
                    }
                    else
                    {
                        //禁止的許可權
                        newCacheItem.ProhibitedPermissions.Add(permissionInfo.Name);
                    }
                }
                //當前使用者的所有許可權
                return newCacheItem;
            });
        }

//檢查是否有許可權

            //檢查當前方法的許可權是否在該使用者的授予許可權中
            if (cacheItem.GrantedPermissions.Contains(permission.Name))
            {
                return true;
            }
            //禁止許可權
            if (cacheItem.ProhibitedPermissions.Contains(permission.Name))
            {
                return false;
            }