1，分配权限到角色：Microsoft.AspNetCore.Identity.EntityFrameworkCore中提供了RoleManager类，类中提供了把权限分配到角色的方法：

　　Task<IdentityResult> AddClaimAsync(TRole role, Claim claim)

　　第一个参数表示对应的角色对象，第二个参数表示一个权限信息

2，分配权限到用户：Microsoft.AspNetCore.Identity.EntityFrameworkCore中提供了UserManager类，类中提供了把权限分配到用户的方法：

　　Task<IdentityResult> AddClaimAsync(TUser user, Claim claim)

　　第一个参数表示对应的用户对象，第二个参数表示一个权限信息

3，分配用户到角色：用到的同样是UserManager类，使用的方法：

　　AddToRoleAsync(TUser user, string role)

　　第一个参数表示的是用户对象，第二个是角色的名称

4，获取角色当前具有的权限列表：

　Task<IList<Claim>> RoleManager.GetClaimsAsync(TRole role)

5，获取用户当前具有的权限列表：

　Task<IList<Claim>> UserManager.GetClaimsAsync(TUser user)

 

 

通过这样的方式就可以完成权限分配全过程，再结合前面的权限控制方法，系统就实现了完成的权限控制逻辑。

那现在的问题来了，权限列表从什么地方来？一般来说，一个业务系统功能确定后，对应的权限列表也自然就确定了，再实现分配权限到角色，分配权限到用户的功能时，只需要在页面上把所有的权限列出来进行选择即可，效果图如下：asp.net core mvc权限控制：分配权限_asp

把选择的数据调用对应的方法保存即可。

这个问题解决了，但是新的问题又来了。如果说一个业务功能点特别多，自然会导致权限也会很多，如果完全通过手工的方式写到页面上，那自然工作量会很大很大，再者业务系统可能会不断地变化，这个时候也会去不断地修改权限分配页面，这自然不是一个好的方法，下面我给大家说一个我想的一个方法，不一定是最好的，但是能省很大的事。

首秀我们需要解决的问题是，如何快速生成这个权限配置列表。

思路就是改造AuthorizeAttribute，在这个特性基础上增加权限描述信息，用权限描述信息作为Policy。下面直接上代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited =true)]　　//类名称可以改，因为我把系统操作当作资源来管理
    public class ResourceAttribute:AuthorizeAttribute
    {
        private string _resouceName;
        private string _action;
        public ResourceAttribute(string name)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException(nameof(name));
            }
            _resouceName = name;
　　　　　　　//把资源名称设置成Policy名称
            Policy = _resouceName;
        }
 
        public string GetResource()
        {
            return _resouceName;
        }
        public string Action
        {
            get
            {
                return _action;
            }
            set
            {
                _action = value;
                if (!string.IsNullOrEmpty(value))
                {　　　　　　　　　　　　//把资源名称跟操作名称组装成Policy
                    Policy = _resouceName + "-" + value;
                }
            }
        }
    }

　　

 

类已经定义好了，那我们就看看如何使用，因为是特性定义，所以可以在控制器类或者方法上按照下面结构使用：

[Resource("组织架构", Action = "添加部门")]

到这里基础工作已经做完，下面还有两个问题需要解决：

1，Policy现在只是配置了名称，但是具体验证规则没有定义

2，如何获取所有的权限列表

 

先来看第一个问题，前面的文章介绍了，Policy需要提前在startup里通过AddAuthorization进行配置，但是现在我们并没有做这样的步骤,所以目前权限还不会起作用。框架在权限验证的时候，会依赖一个IAuthorizationPolicyProvider来根据Policy名称获取具体的规则，自然我们会想到自定义一个IAuthorizationPolicyProvider实现，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class ResourceAuthorizationPolicyProvider : IAuthorizationPolicyProvider
    {
        private  AuthorizationOptions _options;
        public ResourceAuthorizationPolicyProvider(IOptions<AuthorizationOptions> options)
        {
            if (options == null)
            {
                throw new ArgumentNullException(nameof(options));
            }
 
            _options = options.Value;
        }
        public Task<AuthorizationPolicy> GetDefaultPolicyAsync()
        {
            return Task.FromResult(_options.DefaultPolicy);
        }
　　
        public Task<AuthorizationPolicy> GetPolicyAsync(string policyName)
        {
            AuthorizationPolicy policy = _options.GetPolicy(policyName);　　　　　　　//因为我们policy的名称其实就是对应的权限名称，所以可以用下列逻辑返回需要的验证规则
            if (policy == null)
            {
                string[] resourceValues = policyName.Split(new char[] { '-' }, StringSplitOptions.None);
                if (resourceValues.Length == 1)
                {
                    _options.AddPolicy(policyName, builder =>
                    {
                        builder.AddRequirements(new ClaimsAuthorizationRequirement(resourceValues[0], null));
                    });
                }
                else
                {
                    _options.AddPolicy(policyName, builder =>
                    {
                        builder.AddRequirements(new ClaimsAuthorizationRequirement(resourceValues[0], new string[] { resourceValues[1] }));
                    });
                }
            }
            return Task.FromResult(_options.GetPolicy(policyName));
        }
    }

实现了IAuthorizationPolicyProvider，我们就需要在startup.cs的ConfigureServices(IServiceCollection services)方法中进行注册，操作如下：

1
services.TryAdd(ServiceDescriptor.Transient<IAuthorizationPolicyProvider, ResourceAuthorizationPolicyProvider>());

 

再来看第二个问题，我们已经在控制器或者方法上定义了权限信息，关键是我们如何从这些特性里获取到权限列表，将来用于权限分配的时候使用。在asp.net core mvc中提供了一个类解析机制，IApplicationModelProvider，这个依赖信息比较多，这里就不过多介绍，后续我会单独开一个系列，介绍asp.net core mvc的内部机制。

直接上代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public class ResourceApplicationModelProvider : IApplicationModelProvider
    {
        private readonly IAuthorizationPolicyProvider _policyProvider;
 
        public ResourceApplicationModelProvider(IAuthorizationPolicyProvider policyProvider)
        {
            _policyProvider = policyProvider;
        }
         
 
        public void OnProvidersExecuted(ApplicationModelProviderContext context)
        {
            
        }
 
        public void OnProvidersExecuting(ApplicationModelProviderContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }
 
            List<ResourceAttribute> attributeData = new List<ResourceAttribute>();　　　　　　　　//循环获取所有的控制器
            foreach (var controllerModel in context.Result.Controllers)
            {　　　　　　　　//得到ResourceAttribute
                var resourceData = controllerModel.Attributes.OfType<ResourceAttribute>().ToArray();
                if (resourceData.Length > 0)
                {
                    attributeData.AddRange(resourceData);
                }
　　　　　　　　　　//循环控制器方法
                foreach (var actionModel in controllerModel.Actions)
                {                   //得到方法的ResourceAttribute
                    var actionResourceData = actionModel.Attributes.OfType<ResourceAttribute>().ToArray();
                    if (actionResourceData.Length > 0)
                    {
                        attributeData.AddRange(actionResourceData);
                    }
                }
            }
　　　　　　　//把所有的resourceattribute的信息写到一个全局的resourcedata中，resourcedata就可以在其他地方进行使用，resourcedata定义后面补充　
            foreach (var item in attributeData)
            {
                ResourceData.AddResource(item.GetResource(), item.Action);
            }
        }
 
        public int Order { get { return -1000 + 11; } }
    }

resourcedata定义如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class ResourceData
    {
        static ResourceData()
        {
            Resources = new Dictionary<string, List<string>>();
        }
 
        public static void AddResource(string name)
        {
            AddResource(name, "");
        }
 
        public static void AddResource(string name,string action)
        {
            if (string.IsNullOrEmpty(name))
            {
                return;
            }
            if (!Resources.ContainsKey(name))
            {
                Resources.Add(name, new List<string>());
            }
 
            if (!string.IsNullOrEmpty(action) && !Resources[name].Contains(action))
            {
                Resources[name].Add(action);
            }
        }
 
        public static Dictionary<string, List<string>> Resources { get; set; }
    }

　然后在startup中注册我们刚刚定义的IApplicationModelProvider：

1
services.TryAddEnumerable(ServiceDescriptor.Transient<IApplicationModelProvider, ResourceApplicationModelProvider>());

　然后在权限分配页面通过ResourceData.Resources就获取到了所有的权限信息，然后通过循环的方式直接显示到页面上即可。