ABP权限认证

通过AOP+特性实现

ABP默认的权限验证过滤器 AbpAuthorizationFilter   可以通过继承AsyncAuthorizationFilter 自定义自己的权限过滤器

 权限数据存放表  [AbpPermissions]

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;
            }