权限管理rbac：基于角色的权限控制

权限管理rbac：基于角色的权限控制

 

 

        table相关

table的设计

from django.db import models

class UserInfo(models.Model):
    username = models.CharField(max_length=40)
    password = models.CharField(max_length=40)
    email = models.EmailField(null=True, blank=True)
    nickname = models.CharField(max_length=40, null=True, blank=True)
    role = models.ManyToManyField("Role")

    def __str__(self):
        return self.username


class Role(models.Model):
    name = models.CharField(max_length=32)
    authority = models.ManyToManyField("Authority")

    def __str__(self):
        return self.name


class Authority(models.Model):
    title = models.CharField(max_length=32)
    url = models.CharField(max_length=100)
    menu = models.ForeignKey("Menu", null=True, blank=True)

    def __str__(self):
        return self.title


class Menu(models.Model):
    title = models.CharField(max_length=32)
    pid = models.ForeignKey("self", null=True, blank=True)

    def __str__(self):
        menu_title_list = [self.title]
        pid = self.pid
        while pid:
            menu_title_list.insert(0, pid.title)
            pid = pid.pid
        return "-".join(menu_title_list)

主要使用以下几张表：

• UserInfo  
  • 用户名/密码/邮箱等基本信息
  • 与 Role 多对多的关系
• Role
  • 角色的名字（相当于用户组）
  • 与 Authority 多对多的关系
• Authority
  • 权限的名称 -- 用于显示
  • 权限的路径 -- 用于访问
  • 创建 Menu 的外键
• Menu
  • 菜单的名称
  • 菜单的父级 id
• role_authority
  • 由多对多创建，存放 Role 的id， Authority 的id
• userinfo_role
  • 由多对多创建， 存放Userinfo 的id， Role 的id

table注册

导入 admin 模块以及存放定义了表格的 类，通过 admin.site.register( )注册

from django.contrib import admin
from . import models

admin.site.register(models.UserInfo)
admin.site.register(models.Role)
admin.site.register(models.Authority)
admin.site.register(models.Menu)

 

 

        登陆后的设置

在登陆成功以后，该用户的权限路径/菜单等存入 request.session 中

from .. import models
from django.conf import settings          # django 中有默认的配置以及自定义的配置，会在这里拿到合并后的结果

def login_init(request, user_obj):        # 由于需要使用到 session 以及 登陆的对象，所以需要调用者传入
    authority_list = user_obj.role.values("authority__title",
                                          "authority__url",
                                          "authority__menu_id").distinct()
    url_list = []
    url_menu_list = []
    for item in authority_list:
        url_list.append(item["authority__url"])             # 将所有的权限 url 放入到 url_list，最后存入到 session 中；
        if item["authority__menu_id"]:                      # 将拥有 菜单id 的权限的这条记录放入到 url_menu_list，最后存入到 session 中；
            url_menu_list.append({
                "title": item["authority__title"],
                "url": item["authority__url"],
                "menu_id": item["authority__menu_id"],
            })
    menu_list = list(models.Menu.objects.values("id", "title", "pid"))         # 因为菜单相对的会比较小，所以将所有的菜单信息加入到 menu_list 中，最后存入到 session 中；

    request.session[settings.PERMISSION.get("session_persission_list")] = url_list
    request.session[settings.PERMISSION.get("session_persission_menu_list")] = {
        "url_menu_list": url_menu_list,
        "menu_list": menu_list,
    }

 

 

        中间件设置

在实际过程中，如果该用户访问的 url 不在自己的权限之内，那么应该直接返回，不需要进入到试图函数等流程中，所以，我们可以在中间件中的 request 中进行判断，由于需要使用到 session，所以，自定义的中间件应该放在最后的位置

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'rbac.middleware.filterPermission.FilterPermission',            # 自定义的中间件
]

中间件注册时，自定义的 class 应该继承与 MiddlewareMixin，导入方式为：from django.utils.deprecation import MiddlewareMixin 如果它不存在了，可以手写一个，然后继承，代码如下：

class MiddlewareMixin(object):
    def __init__(self, get_response=None):
        self.get_response = get_response
        super(MiddlewareMixin, self).__init__()

    def __call__(self, request):
        response = None
        if hasattr(self, 'process_request'):
            response = self.process_request(request)
        if not response:
            response = self.get_response(request)
        if hasattr(self, 'process_response'):
            response = self.process_response(request, response)
        return response

继承完成后，便可以进行自定义的中间件插件的编写了

import re
from django.utils.deprecation import MiddlewareMixin
from django.conf import settings
from django.shortcuts import redirect


class FilterPermission(MiddlewareMixin):
    """
    中间件，用来过滤权限，在
    setting 中设置
        rule：规定路径为开头结尾，用来拼接 url，格式为： "^{0}$"
        session_persission_list： 存放 session 中权限路径的 key
        safe_url：存放安全路径，登录前后都可以进入的列表，如：登录页面，注册页面等
    """
    def process_request(self, request):
        permission_url = request.session.get(settings.PERMISSION.get("session_persission_list"))
        current_url = request.path_info
        rule = settings.PERMISSION.get("rule")

        for url in settings.PERMISSION.get("safe_url"):
            if re.match(rule.format(url), current_url):
                return None

        for url in permission_url:
            if re.match(rule.format(url), current_url):
                return None

        return redirect("/login.html")

这样一来，我们便可以自动过滤/拦截没有权限的访问了

 

        自定义过滤器

 上面已经完成了中间件拦截非法路径的问题，下面我们需要对我们写的权限管理系统中的数据进行管理，那么，我们可以在页面做出一个菜单进行管理（多级菜单），这里我们通过 自定义过滤器 的方式实现

效果图，很粗糙

过滤器定义

1. 自定义的过滤器放到 templatetags 目录下

2. 引入 from django.template import Library

3. 实例化 register = Library( )

4. 在函数上加装饰器 (这里只用到了 simple_tag 一种) @register.simple_tag

import re
import os
from django.conf import settings
from django.template import Library
from django.utils.safestring import mark_safe

register = Library()




def get_menus_dict(request):
    url_menu_list = request.session[settings.PERMISSION["session_persission_menu_list"]]["url_menu_list"]
    menu_list = request.session[settings.PERMISSION["session_persission_menu_list"]]["menu_list"]

    ret = []
    menu_dict = {}
    current_path = request.path_info
    # url_menu_list = [{'menu_id': 4, 'url': '/rbac/user/', 'title': '用户管理'}]
    # menu_list = [{'id': 1, 'title': '用户管理', 'pid': None}]
    for item in menu_list:
        item["children"] = []
        item["open"] = False
        item["status"] = False
        menu_dict[item["id"]] = item

    for item in url_menu_list:
        flag = False

        pid = item["menu_id"]
        menu_dict[pid]["children"].append(item)
        if re.match(settings.PERMISSION['rule'].format(item["url"]), current_path):
            flag = True
            item["status"] = True
        else:
            item["status"] = False

        while pid:
            menu_dict[pid]["status"] = True
            if flag:
                menu_dict[pid]["open"] = True
            pid = menu_dict[pid]["pid"]

    for k, v in menu_dict.items():
        # {'status': True, 'children': [], 'id': 1, 'title': '用户管理', 'pid': None, 'open': False}
        if not v["pid"]:
            ret.append(v)
        else:
            menu_dict[v["pid"]]["children"].append(v)

    return ret


def get_menus_html(menu_list):
    tpl1 = """
            <div class='rbac-menu-item'>
                <div class='rbac-menu-header'>{0}</div>
                <div class='rbac-menu-body {2}'>{1}</div>
            </div>
        """             # 父级别标签， {0} 菜单名字  {1} 子菜单信息   {2} class名称，用来确当是否展开这个菜单


    tpl2 = """
                    <a href='{0}' class='{1}'>{2}</a>
        """             # 权限标签 {0} 权限路径   {2} 权限名称

    html = ''
    for item in menu_list:
        if item.get('url', None):
            html += tpl2.format(item['url'], 'rbac_active' if item.get('status') else '', item.get('title'))
        elif not item.get('status'):
            continue
        else:
            html += tpl1.format(item['title'], get_menus_html(item['children']), '' if item.get('open') else 'rbac-hide')

    return html


@register.simple_tag
def rbac_menus(request):
    # 将 request.session 中的数据取出来处理成列表中包含字典的形式
    # 用作构建 标签 发送给前端
    menu_dict = get_menus_dict(request)
    # 用上面的数据，用来构建标签
    html = get_menus_html(menu_dict)



    return mark_safe(html)


@register.simple_tag
def rbac_css():         # 读取css代码，放入到前端中
    file_path = os.path.join('rbac', 'theme', 'rbac.css')
    if os.path.exists(file_path):
        return mark_safe(open(file_path, 'r', encoding='utf-8').read())
    else:
        raise Exception('rbac主题CSS文件不存在')


@register.simple_tag
def rbac_js():         # 读取js代码，放入到前端中
    file_path = os.path.join('rbac', 'theme', 'rbac.js')
    if os.path.exists(file_path):
        return mark_safe(open(file_path, 'r', encoding='utf-8').read())
    else:
        raise Exception('rbac主题JavaScript文件不存在')

拼接后的字符串放入到前端以后，需要使用 safe 过滤器才能进行渲染，但是在自定义过滤器这里，似乎不太方便，这里使用一个新的方法

1. 引入 from django.utils.safestring import mark_safe

2. 使用 mark_safe(html)

from django.utils.safestring import mark_safe

mark_safe(html)

　　

前端使用

下面是使用上面过滤器的页面

{% load rbac %}
{% load static %}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Title</title>
    <style>
        .head{
            height: 44px;
            background-color: #369;
        }

        .left{
            float:left;
            width: 200px;
            background-color: azure;
        }

        .right{
            margin-left:200px;
            background-color: beige;
        }
    </style>
    <style>
        {% rbac_css %}
    </style>
    <script src="{% static 'rbac/js/jquery-1.12.4.js' %}"></script>
</head>
<body>
    <div class="head"></div>
    <div class="body">
        <div class="left">
            {% rbac_menus request %}
        </div>
        <div class="right"></div>
    </div>
    <div class="foot"></div>
</body>
<script>
    {% rbac_js %}
</script>
</html>

由于我在设置编辑的时候，左面的菜单是固定不变的，所以这里用到了一个 母版的继承

1. 定义 母版 的时候，需要自定义的位置使用 {% block 名字%}{% endblock %} 来定义

2. 使用的时候，在 html 文件的开头使用 {% extends "母版路径" %} 来申明，使用时重写  {% block 名字%}{% endblock %} 里面的内容

这里列出一个 人物信息 的前段代码来做例子

{% extends "rbac/base.html" %}

{% block head %}
    <style>
     .clearfix:after,.clearfix:before{
            content: "";
            display:block;
        }
        .clearfix:after{
            clear:both;
        }
        .clearfix{
            zoom:1;
        }

        .fl{
            float: left;
        }

        .fr{
            float: right;
        }
        ul li{
            float: left;
            list-style: none;
            text-indent: 0;
        }
        .id{
            width:8%
        }
        .username, .password, .email, .nickname{
            width: 20%;
        }
        .button{
            width:12%;
        }
        .body ul{
{#            padding: 20px 0;#}
            height:20px;
            border-bottom: 1px solid #ddd;
        }
{#        .add{#}
{#            position: relative;#}
{#            right:-100px;#}
{#            top:0;#}
{#        }#}

    </style>
{% endblock %}

{% block body %}
<div class="clearfix body">
    <a href="/rbac/user/add/" class="add"><input type="button" value="添加"></a>
    <ul>
        <li class="id">id</li>
        <li class="username">username</li>
        <li class="password">password</li>
        <li class="email">email</li>
        <li class="nickname">nickname</li>
        <li class="button">编辑</li>
    </ul>
    {% for user_obj in user_obj_list %}
        <ul>
            <li class="id">{{ user_obj.id }}</li>
            <li class="username">{{ user_obj.username }}</li>
            <li class="password">{{ user_obj.password }}</li>
            <li class="email">{{ user_obj.email }}</li>
            <li class="nickname">{{ user_obj.nickname }}</li>
            <li class="button">
                <a href="/rbac/user/edit/{{ user_obj.id }}/" class="edit"><input type="button" value="修改"></a>
                <a href="/rbac/user/delete/{{ user_obj.id }}/" class="delete"><input type="button" value="删除"></a>
            </li>
        </ul>
    {% endfor %}
</div>

{% endblock %}

 

下面是我这个目录的结构

 

相关的配置文件

STATIC_URL = '/static/'

PERMISSION = {
    "rule": "^{0}$",
    "session_persission_list": "session_persission_list",
    "session_persission_menu_list": "session_persission_menu_list",
    "safe_url": ["/login.html", "/register.html", "/admin/.*", "/rbac/.*"],
}

　　

        ModelForm