RBAC 基于角色的权限控制

其他 2019-05-01 19:41:23 阅读次数: 0

RBAC 基于角色的权限控制

​ (Role-Based Access Control)

  1. 为什么要有权限:

    区分用户的 功能

    在web开发中 url代表权限

表结构:

from django.db import models


class Permission(models.Model):

    url = models.CharField(max_length=32, verbose_name='权限')
    title = models.CharField(max_length=32, verbose_name='标题')

    class Meta:
        verbose_name_plural = '权限'
        verbose_name = '权限'

    def __str__(self):
        return self.title


class Role(models.Model):
    """
    角色表
    """
    name = models.CharField(max_length=32, verbose_name='名称')
    permissions = models.ManyToManyField('Permission', verbose_name='角色拥有的权限', blank=True)

    def __str__(self):
        return self.name


class User(models.Model):
    """
    用户表
    """
    name = models.CharField(max_length=32, verbose_name='名称')
    password = models.CharField(max_length=32, verbose_name='密码')
    roles = models.ManyToManyField('Role', verbose_name='用户拥有的角色', blank=True)

    def __str__(self):
        return self.name

流程

  1. 录入权限信息到数据库

  2. 登录成功后保存用户的权限到session中

    def login(request):
    if request.method == 'POST':
        user = request.POST.get('user')
        pwd = request.POST.get('pwd')
        obj = models.User.objects.filter(name=user, password=pwd).first()
        if not obj:
            return render(request, 'login.html', {'error_msg': '用户名或密码错误'})
        # 登陆成果  保存权限的信息
        ret = obj.roles.all().filter(permissions__url__isnull=False).values('permissions__url',
                                                                            'permissions__title').distinct()

        # 保存权限信息
        request.session[settings.PERMISSION_SESSION_KEY] = list(ret)

        return redirect(reverse('customer_list'))

    return render(request, 'login.html')

    在setting 配置中 配置

    # ################################ 权限的配置 ################################
# 权限的key
PERMISSION_SESSION_KEY = 'permissions'
# 菜单的key
PERMISSION_MENU_KEY = 'menus'
WHITE_LIST = [
    r'^/login/$',
    r'^/reg/$',
    r'^/admin/.*',
]

  3. 中间件中对权限进行检验（白名单）

    class RbacMiddleware(MiddlewareMixin):

    def process_request(self, request):
        # 1. 获取当前访问的URL
        url = request.path_info

        # 白名单   
        for i in settings.WHITE_LIST:
            if re.match(i, url):
                return

        # 2. 获取当前用户的权限信息   无权限的 跳转 login
        permission_list = request.session.get(settings.PERMISSION_SESSION_KEY) 

        if not permission_list:
            return redirect(reverse('login'))

        # 3. 权限的校验
        for i in permission_list:
            if re.match(r"^{}$".format(i['url']), url):
                return
        # 拒绝访问
        return HttpResponse('没有访问权限')

一级菜单

动态生成一级菜单

  • 表结构

    • 权限表 角色表 用户表
    • 权限和角色的多对多关系表 用户和角色的多对多关系表
    from django.db import models


class Permission(models.Model):
    """
    权限表
    可做菜单的权限    is_menu=True
    不可做菜单的权限  is_menu=False
    """
    url = models.CharField(max_length=32, verbose_name='权限')
    title = models.CharField(max_length=32, verbose_name='标题')
    is_menu = models.BooleanField(default=False, verbose_name='是否是菜单')
    icon = models.CharField(max_length=64, null=True, blank=True, verbose_name='图标')

    class Meta:
        verbose_name_plural = '权限'
        verbose_name = '权限'

    def __str__(self):
        return self.title


class Role(models.Model):
    """
    角色表
    """
    name = models.CharField(max_length=32, verbose_name='名称')
    permissions = models.ManyToManyField('Permission', verbose_name='角色拥有的权限', blank=True)

    def __str__(self):
        return self.name


class User(models.Model):
    """
    用户表
    """
    name = models.CharField(max_length=32, verbose_name='名称')
    password = models.CharField(max_length=32, verbose_name='密码')
    roles = models.ManyToManyField('Role', verbose_name='用户拥有的角色', blank=True)

    def __str__(self):
        return self.name

  • 流程:

    1. 保存菜单的信息到 session 中
    # 在 rbac app中 定义 一个文件 处理 信息的 录入

def init_permisson(request, obj):
    """
    权限信息的初识化
    保存权限和菜单的信息
    :param request:
    :param obj:
    :return:
    """
    ret = obj.roles.all().filter(permissions__url__isnull=False).values('permissions__url',
                                                                        'permissions__title',
                                                                        'permissions__is_menu',
                                                                        'permissions__icon',
                                                                        ).distinct()
    # 存放权限信息
    permission_list = []
    # 存放菜单信息
    menu_list = []
    for item in ret:
        # 将所有的权限信息添加到permission_list
        permission_list.append({'url': item['permissions__url']})

        # 把是菜单的权限信息放入到menu_list
        if item.get('permissions__is_menu'):
            menu_list.append({'url': item['permissions__url'], 'title': item['permissions__title'],
                              'icon': item['permissions__icon']})

    # 保存权限信息
    request.session[settings.PERMISSION_SESSION_KEY] = permission_list

    # 保存菜单信息
    request.session[settings.PERMISSION_MENU_KEY] = menu_list

    1. 定义 菜单的 heml 代码块 使用 inclusion_tag

      html 代码 menu.html

      <div class="static-menu">
    {#                <a href="/customer/list/" class="active">#}
    {#                    <span class="icon-wrap"><i class="fa fa-connectdevelop"></i></span> 客户管理</a>#}
    {#                <a href="/payment/list/">#}
    {#                    <span class="icon-wrap"><i class="fa fa-code-fork"></i></span> 账单管理</a>#}

    {% for item in menu_list %}
        <a href="{{ item.url }}" class="{{ item.class }}">
            <span class="icon-wrap"><i class="fa {{ item.icon }}"></i></span> {{ item.title }}</a>
    {% endfor %}

</div>

      inclusion_tag

      from django import template
from django.conf import settings
import re

register = template.Library()


@register.inclusion_tag('rbac/menu.html')
def menu(request):
    menu_list = request.session.get(settings.PERMISSION_MENU_KEY)

    for item in menu_list:
        if re.match("^{}$".format(item['url']), request.path_info):
            item['class'] = 'active'
            break
    return {'menu_list': menu_list}

    2. 定义 代码块的css 样式 menu.css

      .static-menu .icon-wrap {
    width: 20px;
    display: inline-block;
    text-align: center;
}

.static-menu a {
    text-decoration: none;
    padding: 8px 15px;
    border-bottom: 1px solid #ccc;
    color: #333;
    display: block;
    background: #efefef;
    background: -webkit-gradient(linear, left bottom, left top, color-stop(0, #efefef), color-stop(1, #fafafa));
    background: -ms-linear-gradient(bottom, #efefef, #fafafa);
    background: -moz-linear-gradient(center bottom, #efefef 0%, #fafafa 100%);
    background: -o-linear-gradient(bottom, #efefef, #fafafa);
    filter: progid:dximagetransform.microsoft.gradient(startColorStr='#e3e3e3', EndColorStr='#ffffff');
    -ms-filter: "progid:DXImageTransform.Microsoft.gradient(startColorStr='#fafafa',EndColorStr='#efefef')";
    box-shadow: inset 0px 1px 1px white;
}

.static-menu a:hover {
    color: #2F72AB;
    border-left: 2px solid #2F72AB;
}

.static-menu a.active {
    color: #2F72AB;
    border-left: 2px solid #2F72AB;
}

    3. 在 母版中 导入 css 样式 以及使用 inclusion_tag 返回菜单列表

      <link rel="stylesheet" href="{% static 'css/menu.css' %} "/>
          {% load rbac %}
          {% menu request %}

二级菜单

动态生成二级菜单

表结构:

from django.db import models

# Create your models here.

class Menu(models.Model):
    ''' 一级菜单 '''
    title = models.CharField(max_length=32)
    icon = models.CharField(max_length=64, null=True, blank=True, verbose_name='图标')

    def __str__(self):
        return self.title


class Permission(models.Model):
    '''
    权限表
    可以做二级菜单的权限   menu 关联 菜单表
    不可以做菜单的权限   menu=null
    '''
    url = models.CharField(max_length=32, verbose_name='路径')
    title = models.CharField(max_length=32, verbose_name='描述')
    menu = models.ForeignKey('Menu', null=True, blank=True)

    def __str__(self):
        return self.title


class Role(models.Model):
    '''
    角色表 部门
    '''
    name = models.CharField(max_length=32, verbose_name='角色')
    permissions = models.ManyToManyField('Permission', verbose_name='角色拥有的权限', blank=True)

    def __str__(self):
        return self.name


class User(models.Model):
    '''
    用户表
    '''
    name = models.CharField(max_length=32, verbose_name='用户名')
    password = models.CharField(max_length=32, verbose_name='密码')
    roles = models.ManyToManyField('Role', blank=True, verbose_name='用户拥有的角色')

    def __str__(self):
        return self.name

    class Meta:
        verbose_name_plural = '用户'
        verbose_name = '用户表'

二级菜单的 数据结构

data = [{
    'permissions__url': '/customer/list/',
    'permissions__title': '客户列表',
    'permissions__menu__title': '信息列表',
    'permissions__menu__icon': 'fa-code-fork',
    'permissions__menu_id': 1
},
    {
    'permissions__url': '/customer/list/',
    'permissions__title': '用户列表',
    'permissions__menu__title': '信息列表',
    'permissions__menu__icon': 'fa-code-fork',
    'permissions__menu_id': 1
},{
    'permissions__url': '/customer/add/',
    'permissions__title': '增加客户',
    'permissions__menu__title': None,
    'permissions__menu__icon': None,
    'permissions__menu_id': None
}, {
    'permissions__url': '/customer/edit/(\\d+)/',
    'permissions__title': '编辑客户',
    'permissions__menu__title': None,
    'permissions__menu__icon': None,
    'permissions__menu_id': None
}]

"""
{
  1:{
    'title':'信息列表',
    'icnon':'fa-code-fork',
    'children': [
        {'title': '客户列表','url':'/customer/list/ },
        {'title': '用户列表','url':'/customer/list/ }
    ]
  }
}

"""

流程：

  1. 保存菜单的信息到 session 中
# 在 rbac app中 定义 一个文件 处理 信息的 录入

def init_permisson(request, obj):
    """
    权限信息的初识化
    保存权限和菜单的信息
    :param request:
    :param obj:
    :return:
    """
    ret = obj.roles.all().filter(permissions__url__isnull=False).values('permissions__url',
                                                                        'permissions__title',                                                               'permissions__menu__title',
                                                                      'permissions__menu__icon',
                                                                        'permissions__menu_id',
                                                                        ).distinct()
    print(ret)

    # 存放权限信息
    permission_list = []
    # 存放菜单信息
    menu_dict = {}  VGB M,K.L/;['}.+
*6654=-908877                                }0']
    for item in ret:
        # 将所有的权限信息添加到permission_list
        permission_list.append({'url': item['permissions__url']})

        # 构造菜单的数据结构
        menu_id = item.get('permissions__menu_id')

        # 表示当前的权限是不做菜单的权限
        if not menu_id:
            continue

        # 可以做菜单的权限
        if menu_id not in menu_dict:
            menu_dict[menu_id] = {
                'title': item['permissions__menu__title'],  # 一级菜单标题
                'icon': item['permissions__menu__icon'],
                'children': [{'title': item['permissions__title'], 'url': item['permissions__url']}]
            }
        else:
            menu_dict[menu_id]['children'].append(
                {'title': item['permissions__title'], 'url': item['permissions__url']})

    print(menu_dict)


    # 保存权限信息
    request.session[settings.PERMISSION_SESSION_KEY] = permission_list

    # 保存菜单信息
    request.session[settings.PERMISSION_MENU_KEY] = menu_dict

  1. 定义html代码块 及 inclusion_tag

    html代码块

<div class="multi-menu">

    {% for item in menu_list %}
        <div class="item">
            <div class="title"><i class="fa {{ item.icon }}"></i> {{ item.title }} </div>
            <div class="body">

                {% for child in item.children %}
                    <a href="{{ child.url }}">{{ child.title }}</a>
                {% endfor %}
            </div>
        </div>
    {% endfor %}

</div>

​ inclusion_tag rbac.py

from django import template
from django.conf import settings
import re

register = template.Library()


@register.inclusion_tag('rbac/menu.html')
def menu(request):
    menu_dict = request.session.get(settings.PERMISSION_MENU_KEY)

    return {'menu_list': menu_dict.values()}
  1. Css样式 css/menu.css
.multi-menu .item {
    background-color: white;
}

.multi-menu .item > .title {
    padding: 10px 5px;
    border-bottom: 1px solid #dddddd;
    cursor: pointer;
    color: #333;
    display: block;
    background: #efefef;
    background: -webkit-gradient(linear, left bottom, left top, color-stop(0, #efefef), color-stop(1, #fafafa));
    background: -ms-linear-gradient(bottom, #efefef, #fafafa);
    background: -o-linear-gradient(bottom, #efefef, #fafafa);
    filter: progid:dximagetransform.microsoft.gradient(startColorStr='#e3e3e3', EndColorStr='#ffffff');
    -ms-filter: "progid:DXImageTransform.Microsoft.gradient(startColorStr='#fafafa',EndColorStr='#efefef')";
    box-shadow: inset 0 1px 1px white;
}

.multi-menu .item > .body {
    border-bottom: 1px solid #dddddd;
}

.multi-menu .item > .body a {
    display: block;
    padding: 5px 20px;
    text-decoration: none;
    border-left: 2px solid transparent;
    font-size: 13px;

}

.multi-menu .item > .body a:hover {
    border-left: 2px solid #2F72AB;
}

.multi-menu .item > .body a.active {
    border-left: 2px solid #2F72AB;
}

使用:

在 母版中  导入  css 样式   以及使用   inclusion_tag  返回菜单列表

    <link rel="stylesheet" href="{% static 'css/menu.css' %} "/>
              {% load rbac %}
              {% menu request %}

二级菜单的 点击动画


$(function () {
    $('.item .title').click(function () {
        {#$(this).next().toggleClass('hide')#}
        $('.item .title').siblings($(this)).slideUp(100);

         $(this).next().slideDown(100);

         {#展开当前 一级菜单 下的 二级菜单#}
         {#$(this).next().removeClass('hide');#}
         {# 关闭其他菜单 下的 二级菜单#}
         {#$(this).parent().siblings().find('.body').addClass('hide');#}
    })
})

菜单的排序

给一级菜单进行排序

在model 中 添加 权重 字段

# 1.model 中  的权限表 添加 权重字段 
weight = models.IntegerField(default=1, verbose_name='权重')

# 2.查询出权重 将其加入到 menu_dict 的一级菜单中 

# 3. 在  inclusion_tag 中 给菜单进行排序
    # 导入 OrderedDict 有序字典   因为字典是无序的  查询出的顺序不一定  
    from collections import OrderedDict
    ordered_dict = OrderedDict()
                     # 给菜单进行排序
    for i in sorted(menu_dict, key=lambda a: menu_dict[a]['weight'], reverse=True):
        # 将  menu_dict  循环添加到 实例化的  OrderedDict() 中
        ordered_dict[i] = menu_dict[i]

非菜单权限的归属问题

  • 信息列表 # 一级菜单

    ​ 客户列表 # 二级菜单

         添加客户    #  非菜单权限

     编辑客户    #  非菜单权限

  • 财务列表

    缴费列表

  • 权限表中

    menu_id ： 关联的菜单

    parent_id： 外键关联自己 三级菜单 ‘self’ 判断从属于那个权限

    id url title menu_id parent_id

    1 /list/ 客户列表 1 null

    2 /add/ 添加客户 null 1

  1. 给权限表中 加入 paren 外键的字段 可以为空

    paren = models.ForeignKey('self', null=True, blank=True)

  2. 获取 paren 关联的 id 也就是 父id 从属于那个权限 以及 本权限的id

        permission = obj.roles.all().filter(permissions__url__isnull=False)
    .values('permissions__url',
            'permissions__title',                                                                           'permissions__menu__title',                                                                     'permissions__menu__font',
            'permissions__menu__weight',  # 权重
            'permissions__menu_id',
            #'permissions__weight',
            'permissions__paren_id',  # 关联的 归属id
            'permissions__id',  # 本权限的 id
            ).distinct()

  3. 將 id pid 存放到 permissions_list 中的每个字典中

    permissions_list.append({'url': item['permissions__url'],
                         'id': item['permissions__id'],
                         'pid': item['permissions__paren_id'], })   #paren  括弧

  4. 存放 权限id 到 二级菜单的 children中

                    'children': [{'title': item['permissions__title'],
                              'url': item['permissions__url'],
                              'id': item['permissions__id'],
                              }]}

  5. 从 中间件中获取到 两个id 做判断 將 从属的 id 存放到 request 对象中

    # 记录 paren 的 id 到 request 中
id, pid = i['id'], i['pid']
if pid:
    #  有PID表示当前访问的权限是子权限   它有父权限 要让这个父权限展开
    request.xxx = pid
else:
    # 表示当前访问的权限是父权限  要让自己展开
    request.xxx = id

  6. 从 inclusion_tag 中 取到 没个菜单的 children 循环 判断 从属的 id 是不是 本 权限的 id

     给从属的 权限加上 显示  及 active 
item['class'] = 'hide'
        for child in item['children']:

            # if re.match("^{}$".format(child['url']), request.path_info):
            if request.xxx == child['id']:
                child['class'] = 'active'
                item['class'] = ''

路径导航

面包屑 导航

注意 :

​ 权限信息放入到session中。进行json序列化

​ 字段的key 如果是数字化，会变成数字字符串

  1. 將 权限 dict 中加入 title 描述

    字典中 本身就有 路径 以及 描述

    permissions_dict[item['permissions__id']] = ({'url': item['permissions__url'],
                                             'id': item['permissions__id'],
                                             'pid': item['permissions__paren_id'],
                                             'title': item['permissions__title']})

  2. 在 中间件中 创建 一个 面包屑的列表 存到 request 中

    # 创建列表   使用 反射  添加到 request 中   名字在 settings 中配置
setattr(request, setting.BREADCRUMB, [ {'url': reverse('index'), 'title': '首页'},])

# 其他导航路径的添加
if pid:
    #  有PID表示当前访问的权限是子权限   它有父权限 要让这个父权限展开
    request.xxx = pid

    # 获取 父 权限的 内容
    p_dict = permissions_dict[str(pid)]
    # 將父权限的内容 添加到 面包屑列表中
    getattr(request,setting.BREADCRUMB).append(
        {'url': p_dict['url'], 'title': p_dict['title']}
    )
    # 添加子 内容 到 列表中
    getattr(request,setting.BREADCRUMB).append(
        {'url': i['url'], 'title': i['title']}
    )

else:
    # 表示当前访问的权限是父权限  要让自己展开
    request.xxx = id
    getattr(request,setting.BREADCRUMB).append(
        {'url': i['url'], 'title': i['title']}
    )

  3. 信创建 inclusion_tag 获取 面包屑列表

    @register.inclusion_tag('rbac/breadcrumb.html')
def breadcrumb(request):
    breadcrumb_list = getattr(request,setting.BREADCRUMB)
    return {'breadcrumb_list': breadcrumb_list}

    HTML 页面 rbac/breadcrumb.html

    <ol class="breadcrumb no-radius no-margin" style="border-bottom: 1px solid #ddd;">
    {% for bread in breadcrumb_list %}
        {% if forloop.last %}
            <li>{{ bread.title }}</li>
        {% else %}
            <li><a href="{{ bread.url }}">{{ bread.title }}</a></li>
        {% endif %}
    {% endfor %}

</ol>

  4. 在 母版中使用

    {% breadcrumb request %}

    用到反射 （反射复习）

权限控制到按钮级别

同过 name 别名 来判断 路径 將name 存放在 权限中

name = models.CharField(max_length=32, verbose_name='url别名')

存放所有 权限的  别名

  1. 获取 自己的url别名 以及

                 'permissions__paren__name',  # 关联的 归属  权限 名字
         'permissions__name',  # url别名

  2. 用别名做 key 添加 关联字段的 名字

     # 添加所有的 权限 url   使用  url 别名 当做 Key
permissions_dict[item['permissions__name']] = (
            {'url': item['permissions__url'],
             'id': item['permissions__id'],
             'p_name': item['permissions__paren__name'],  # 添加 查询 当前关联的 权限的名字
             'pid': item['permissions__paren_id'],
         'title': item['permissions__title']})

    在中间件中 获取 p_name 的值

    通过 值 找到 父及菜单的所有内容

    id, pid, p_name = i['id'], i['pid'], i['p_name']
p_dict = permissions_dict[p_name]   查找 父及菜单内容

  3. 创建 filter 过滤器 反回 T or F 来判断 是否显示 标签

    @register.filter()
def has_permission(request, name):
    # 判断name是否在权限的字典中
    if name in request.session.get(settings.PERMISSION_SESSION_KEY):
        return True

  4. 在母版中 使用

    {% if request|has_permission:'customer_edit' and request|has_permission:'customer_del' %}

 {% if request|has_permission:'customer_del' %}

区分 一二级联动 菜单

  1. 获取所有的 一级 菜单 一级 权限 信息 做展示

  2. 修改 权限 信息的 数据结构 区分 二三级 菜单 循环进行展示

# 显示 一级菜单 联动 二及菜单
def menu_list(request):
    menu_obj = models.Menu.objects.all()
    # 获取 菜单的 id
    mid = request.GET.get('mid')

    if mid:
        # 如果有 条件 则对数据进行筛选
        permission_all = models.Permission.objects.filter(Q(menu_id=mid) | Q(paren__menu_id=mid))
    else:
        permission_all = models.Permission.objects.all()

# 实例化 有序字典  修改 数据结构  將 数据分为  二三级菜单 存入 有序字典中
    permission_dict = OrderedDict()
    for item in permission_query_dict:
        # 判断 二级菜单
        if item.get('menu_id'):
            permission_dict[item['id']] = item
            item['children'] = []
    for item in permission_query_dict:
        # 判断三级菜单
        pid = item.get('paren_id')
        if pid:
            permission_dict[pid]['children'].append(item)
            
    print(permission_dict)

html

{% extends 'layout.html' %}
{% block css %}
    <style>
        .permission-area tr.root {
            background-color: #dff0d8;
        }
        .menu-body tr.active {
            background-color: #f1f7fd;
            border-left: 3px solid #fdc00f;
        }
    </style>
{% endblock %}
{% block content %}
    <div class="col-sm-3">
        <div class="panel panel-info" style="margin: 20px;">
            <div class="panel-heading"><i class="fa fa-book"></i> 菜单管理
                <a href="{% url 'menu_add' %}" class="btn btn-sm btn-success pull-right"
                   style="margin-top: -2px; padding: 2px 7px">
                    <i class="fa fa-plus"></i> 新建</a>
            </div>
            <table class="table  table-hover">
                <thead>
                <tr>
                    <th>名称</th>
                    <th>图标</th>
                    <th>操作</th>
                </tr>
                </thead>
                <tbody class="menu-body">
                {% for field in menu_obj %}
                    {#         field.pk|safe    将数字转义为字符串  #}
                    <tr class="{% if field.pk|safe == mid %}active{% endif %}">
                        <td><a href="?mid={{ field.pk }}">{{ field.title }}</a></td>
                        <td><i class="fa {{ field.font }}"></i></td>
                        <td>
                            <a href="{% url 'menu_edit' field.pk %}" style=""><i class="fa fa-pencil-square-o"></i></a>
                            <a href="{% url 'menu_del' field.pk %}" style="color: red;"><i class="fa fa-trash"></i></a>
                        </td>
                    </tr>
                {% endfor %}

                </tbody>
            </table>
        </div>
    </div>

    <div class="col-sm-9">
        <div class="panel panel-info" style="margin: 20px;">
            <div class="panel-heading"><i class="fa fa-th"></i> 权限管理
                <a href="" class="btn btn-sm btn-warning pull-right" style="margin-top: -2px; padding: 2px 7px">
                    <i class="fa fa-mail-forward"></i> 批量操作</a>
                <a href="{% url 'permission_add' %}" class="btn btn-sm btn-success pull-right" style="margin-top: -2px; padding: 2px 7px">
                    <i class="fa fa-plus-circle"></i> 新建</a>
            </div>
            <table class="table  table-hover">
                <thead>
                <tr>
                    <th>描述</th>
                    <th>URR</th>
                    <th>URR别名</th>
                    <th>操作</th>
                </tr>
                </thead>
                <tbody class="permission-area">
                  
                {% for p_permission in permission_dict %}
{# 二级菜单的 展示 #}
                    <tr class="root" id="{{ p_permission.id }}">
                        <td class="title">
                            <i class="fa fa-caret-down"></i>
                            {{ p_permission.title }}</td>
                        <td>{{ p_permission.url }}</td>
                        <td>{{ p_permission.name }}</td>
                        <td>
                            <a href="{% url 'permission_edit' p_permission.id %}" style=""><i class="fa fa-pencil-square-o"></i></a>
                            <a href="" style="color: red;"><i class="fa fa-trash"></i></a>
                        </td>
                    </tr>
                    {% for c_permission in p_permission.children %}
三级菜单的展示
                        <tr pid="{{ p_permission.id }}">
                            <td>{{ c_permission.title }}</td>
                            <td>{{ c_permission.url }}</td>
                            <td>{{ c_permission.name }}</td>
                            <td>
                                <a href="{% url 'permission_edit' c_permission.id %}" style=""><i class="fa fa-pencil-square-o"></i></a>
                                <a href="" style="color: red;"><i class="fa fa-trash"></i></a>
                            </td>
                        </tr>
                    {% endfor %}
                {% endfor %}
                </tbody>
            </table>
        </div>
    </div>

{% endblock %}
{% block js %}
    <script>
        $('.permission-area').on('click', '.root .title', function () {
            var caret = $(this).find('i');
            var id = $(this).parent().attr('id');
            if (caret.hasClass('fa-caret-right')) {
                caret.removeClass('fa-caret-right').addClass('fa-caret-down');
                $(this).parent().nextAll('tr[pid="' + id + '"]').removeClass('hide');
            } else {
                caret.removeClass('fa-caret-down').addClass('fa-caret-right');
                $(this).parent().nextAll('tr[pid="' + id + '"]').addClass('hide');
            }
        })
    </script>
{% endblock %}

应用rbac权限组件

  1. 有一个要应用的项目

  2. 把rbac的app拷贝到新项目中，注册

  3. 生成rbac相关的表

    1. 删除rbac/migrations下的除init之外的py文件
    2. 执行数据库迁移的命令

  4. 使用admin录入权限信息

    1. 创建超级用户
    2. 登录admin录入权限信息
      1. 权限信息 url地址 不带^$
      2. 角色 给角色分配权限
      3. 用户 给用户分配角色

  5. 应用登录后权限信息的初始化

    from rbac.service.permission import init_permisson
from rbac.models import User

# 登录成功后
init_permisson(request,obj)

  6. 使用权限的中间件

MIDDLEWARE = [
    ...
    'rbac.middlewares.rbac.RbacMiddleware'
]

​ 在settings中进行配置

# ################################ 权限的配置 ################################
# 权限的key
PERMISSION_SESSION_KEY = 'permissions'
# 菜单的key
PERMISSION_MENU_KEY = 'menus'
WHITE_LIST = [
    r'^/login/$',
    r'^/reg/$',
    r'^/admin/.*',
]

7.应用动态生成一级菜单

  1. 使用menu 的inclusion_tag
  2. 应用css样式
<link rel="stylesheet" href="{% static 'css/menu.css' %} "/>
          {% load rbac %}
          {% menu request %}

2.动态生成二级菜单

信息列表 - 一级菜单

​ 客户列表 - 二级菜单

财务列表

​ 缴费列表

icon 图标库 爬虫

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from django.utils.safestring import mark_safe
import requests
from bs4 import BeautifulSoup

response = requests.get(
    url='http://fontawesome.dashgame.com/',
)
response.encoding = 'utf-8'

soup = BeautifulSoup(response.text, 'html.parser')
web = soup.find(attrs={'id': 'web-application'})

icon_list = []

for item in web.find_all(attrs={'class': 'fa-hover'}):
    tag = item.find('i')
    class_name = tag.get('class')[1]
    icon_list.append([class_name, str(tag)])

print(icon_list)

应用权限组件

  1. 拷贝rbac组件到新的项目中，注册app
  2. 修改用户表，继承rbac中的User
class User(models.Model):
    """
    用户表
    """
    # name = models.CharField(max_length=32, verbose_name='名称')
    # password = models.CharField(max_length=32, verbose_name='密码')
    roles = models.ManyToManyField(Role, verbose_name='用户拥有的角色', blank=True)

    # def __str__(self):
    #     return self.name
    class Meta:
        abstract = True  # 数据库迁移时候不会生成表，用来做基类

class UserProfile(User, models.Model):
  1. 执行数据库迁移的命令
    1. 删除rbac下migrations中的记录
    2. 注释掉admin中User表
    3. roles = models.ManyToManyField(Role, verbose_name='用户拥有的角色', blank=True) # 关联的字段不要写成字符串形式
  2. 设置rbac的url
url(r'rbac/', include('rbac.urls',namespace='rbac'))

  1. 菜单管理

  2. 权限的录入

    1. 所有的url要头name
    2. 不要忽略rbac namespace
    3. 注意url和别名的长度
    4. 构建层级结构

  3. 角色管理

  4. 分配权限

    1. 注意用新的用户表替换rbac中的User
    2. 给不同角色分配权限
    3. 给不同用户分配角色

  5. 应用上权限

    1. 应用中间件 在settings中写上权限的配置
    # 权限的key
PERMISSION_SESSION_KEY = 'permissions'
# 菜单的key
PERMISSION_MENU_KEY = 'menus'
WHITE_LIST = [
    r'^/login/$',
    r'^/reg/$',
    r'^/admin/.*',
]

NO_PERMISSION_LIST = [
    r'^/index/$',
    r'^/logout/$',
]

# 路径导航
BREADCRUMB = 'breadcrumb_list'
# 路径导航
CURRENT_MENU = 'current_parent_id'
    1. 登录成功后权限信息的初识化
    from rbac.service.permission import init_permisson
# 权限信息的初始化
init_permisson(request,obj)

  6. 动态生成二级菜单

    1. 在layout中使用
```
导入CSS js 
{% load rbac %}
{% menu request %}
```

  1. 应用路径导航

    {% breadcrumb request %}

  2. 权限控制到按钮级别

{% load rbac %}
{% if request|has_permission:"consult_add" %}
    <a href="{% url 'consult_add' %}" class="btn btn-primary btn-sm">添加</a>
{% endif %}

权限如何能不重新登录，就应用新的权限？

  • 用户表加字段 存 session_key

  • 通过session_key 拿到用户的session数据 更新权限

    from django.contrib.sessions.models import Session
from django.contrib.sessions.backends.db import SessionStore

decode   encode

权限如何控制到行级别？

加条件表

1554205394307

猜你喜欢

转载自www.cnblogs.com/zhang-zi-yi/p/10800426.html
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
Java基础复习_day13_Collection集合
2018.11.16 c语言学习经验
且看Java内置四大核心函数式接口
小程序云开发中数据库的数据分段和显示图片
python的函数
Web-JS进阶
【干货】C++常用代码积累笔记大全
Spring的ioc操作 与 IOC底层原理
构建之法20191121-11 Scrum立会报告+燃尽图 07
Spring boot之Hello World访问404
每日归档
更多
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022