写在前面
世间安得双全法 不负如来不负卿
s17day26 CRM项目 项目概要：XX公司CRM
- 权限管理，公共组件，app *****
- 熟悉增删改查，Low ***
- 增删改查组件，公共组件，app **** 内容回顾：
. .all,values,values_list
models.xx.objects.all()
---> [obj,obj,obj,]
models.xx.objects.values('id','name')
---> [{"id":,'name':'兴普'},{"id":,'name':'兴普1'},]
models.xx.objects.values_list('id','name')
---> [(,'兴普'),(,'记不住就别来了')] . 中间件是什么？有什么作用？ class Md1: def process_request(self,request):
pass class process_response(self,request,response):
return response class Md2: def process_request(self,request):
pass class process_response(self,request,response):
return response MIDDLEWARE = [ "xxxxx.xxxx.Md1",
"xxxxx.xxxx.Md2"
] . ORM创建表 FK常用操作
class A(Model):
name = models.CharField(...) class B(Model):
name = models.CharField(...)
fk = models.FK(A) a. B表中有几列
id
name
fk_id b. 跨表操作
b_list = models.B.objects.all()
for item in b_list:
item.id
item.name
item.fk_id
item.fk
item.fk.name
item.fk.id
c. 跨表操作
b_list = models.B.objects.values('id','name','fk_id','fk__name')
for item in b_list:
item['id']
item['name']
item['fk_id']
item['fk__name'] d. 跨表操作
b_list = models.B.objects.vlaues_list('id','name','fk_id','fk__name')
for item in b_list:
item[]
item[]
item[']
item[]
e. 找A名称=“吴一飞”所有B表中的数据
models.B.objects.filter(fk__name='吴一飞') M2M常用操作： class A(Model):
name = models.CharField(...) class B(Model):
name = models.CharField(...)
m = models.M2M(A) a. B表中有几列
id
name PS: 自动生成一个第三张表；m用于间接的对第三张表进行操作 b. 在B表中插入三条数据；A表中插入2条数据
models.A.objects.create(name='赵峰分')
models.A.objects.create(name='王勇')
models.A.objects.create(name='刘宏伟') models.B.objects.create(name='兴普')
models.B.objects.create(name='香姐')
models.B.objects.create(name='名扬') c. 兴普和【赵峰分，王勇，刘宏伟】创建关系 obj = models.B.objects.create(name='兴普')
obj.m.add()
obj.m.add()
obj.m.add()
obj.m.add(*[,,]) d. 查找和兴普有关系的男人？
obj = models.B.objects.create(name='兴普')
obj.m.all() [A—obj,A—obj,A—obj] . Session是什么？和Cookie有什么区别？ . 正则表达式 re.match() ^ $ 示例程序：pro_crm
员工模块：
权限，根据含有正则表达式URL进行分配
操作，通过配置文件进行定制
学生模块：
问卷 今日内容： 权限：授权 s17crm
- app01
- rbac
- models.py 第一版：
. 权限表（含有正则表达式），permission id url title
/userinfo/ 用户列表
/userinfo/(\d+)/delete/ 删除用户
/userinfo/(\d+)/change/ 修改用户
/userinfo/add/ 添加用户 . 用户表,userinfo
id username password
yql
wxp
zmx
ll . 用户和权限关系表
id 用户ID 权限ID 问题：用户分配权限时，麻烦 第二版： . 权限组,group
id title
用户组
订单组 . 权限表（含有正则表达式），permission id url title code group_i1 is_menu
/userinfo/ 用户列表 list true
/userinfo/(\d+)/delete/ 删除用户 del false
/userinfo/(\d+)/change/ 修改用户 edit false
/userinfo/add/ 添加用户 add true
/order/add/ ... add true
/order/(\d+)/delete/ del false
/order/(\d+)/change/ edit false
/order/ list true . 用户表,userinfo
id username password
yql
wxp
zmx
ll . 角色表，role
id title
销售员
销售经理
市场专员
市场经理
IT
CTO
销售市场总监
CEO . 用户角色关系表
用户ID 角色ID . 角色和权限关系表
角色ID 权限ID 注意：根据用户找权限
- 用户具有的所有角色
- 再根据角色找所有权限（去重） 中午作业：
- 填充数据
- id=1的用户，
- 找具有所有角色
- 找到所有权限
- 找到所有权限（去重） 填充数据：
基于Django Admin数据填充 补充：不要相信你的眼睛 分配权限：
销售员：用户列表
孟祥杰
王勇 销售经理：用户列表，添加用户
银秋良 总监： 用户列表，添加用户，订单列表
兴普 CEO：....
刘磊 注意：Djang Admin进行添加权限或授权 权限： 自动生成菜单 . 获取数据 [
{'menu_id': , 'menu_title': '用户管理菜单', 'title': '用户列表', 'url': '/userinfo/'},
{'opened':True,'menu_id': , 'menu_title': '用户管理菜单', 'title': '订单列表', 'url': '/order/'}, {'menu_id': , 'menu_title': '权限管理菜单', 'title': 'xxx列表', 'url': '/order/add/'}
{'menu_id': , 'menu_title': '权限管理菜单', 'title': 'xx列表', 'url': '/order/add/'}
] . 根据数据创建两级菜单
用户管理菜单
用户列表！
订单列表
权限管理菜单
xxx列表
xx列表 思路：
page_menu = {
:{'menu_id':,'menu_title':'用户管理菜单','children': [{ 'title': '用户列表', 'url': '/userinfo/'},{'title': '订单列表', 'url': '/order/'} ]}
: {'menu_id':,'menu_title':'权限管理菜单','children': [{ 'title': '用户列表', 'url': '/userinfo/'},{'title': '订单列表', 'url': '/order/'} ]}
} current_url = request.path_info for item in permission_menu_list:
url = item['url']
regex = xxx.format(url)
if re.match(regex,current_url):
item['opened'] = True menu_id = item['menu_id']
opened = "active" if item.get('opened') else "" child = {'title':item['title'],'url':item['url'],'opened': opened}
if menu_id in page_menu:
page_menu[menu_id]['children'].append(child)
if opened:
page_menu[menu_id]['opened'] = opened
else:
page_menu[menu_id] = {'opened':opened, 'menu_title': item['menu_title'], 'children': [child, ]} 总结： . 表结构设计 . 录入数据 . 用户登录：
- 获取角色
- 获取权限
- 对权限去重 . 结构，权限信息
{
: {
'urls': ['/userinfo/', '/userinfo/add/', '/userinfo/(\\d+)/delete/', '/userinfo/(\\d+)/change/'],
'codes': ['list', 'add', 'del', 'edit']
},
: {
'urls': ['/order/', '/order/add/', '/order/(\\d+)/delete/', '/order/(\\d+)/change/'],
'codes': ['list', 'add', 'del', 'edit']
} }
放入session中
. 中间件
白名单
request.path_info
session获取权限，进行验证 . 自动生成菜单
- inclusion_tag
- 母版 . Django Admin 权限app中写代码：
- 中间件
- init_permission
- models
- admin
- templatetags 依赖配置文件：
XX = "permission_dict"
OO = "permission_menu_list"
RBAC_LOGIN_URL = "/login/"
URL_FORMAT = "^{0}$" VALID_URL_LIST = [
"^/login/$",
"^/admin.*",
] 使用权限管理：
. 创建cmdb project
. rbac拷贝到项目中
. 在settings.APP中将 rbac 注册
. 在settings中设置
XX = "permission_dict"
OO = "permission_menu_list"
RBAC_LOGIN_URL = "/login/"
URL_FORMAT = "^{0}$" VALID_URL_LIST = [
"^/login/$",
"^/admin.*",
]
. 开发CMDB完成 . 中间件中注册
. 利用temaplatetags和母版获取动态菜单 . 在Django Admin中操作权限信息 作业：
. 权限系统：4天
. 自己创建一个主机管理系统：
- 主机
- 主机组
- 部门
- 机房
. 使用 权限系统[10天]
武Sir - 笔记
一、内容回顾
- .all .values .values_list
models.xxx.objects.all() --> [obj,obj,obj,...]
models.xxx.objects.values('id','name') --> [{'id':1,'name':'alex'},{'id':2,'name':'standby'},...]
models.xxx.objects.values_list('id','name') --> [(1,'alex'),(2,'standby',....)] - 中间件是什么？有什么用？
可以拦截所有的请求和响应，进行一些处理
中间件执行时有序的，从上到下执行，如果当前中间件不允许过，那么就不会再执行后面的中间件
比如说：对用户的请求做下黑名单 process_request() 默认没有返回值，即返回None； 则继续往下执行
但是如果有返回值，则不再继续往下执行，直接返回； 每个中间件就是一个类：
class Md1:
def process_request(self,request):
pass
def process_response(self,request,response):
return response
class Md2:
def process_request(self,request):
pass
def process_response(self,request,response):
return response settings.py里配置 MIDDLEWARE = [
"XXXXXX.XXXXX.Md1",
"XXXXXX.XXXXX.Md2",
] - ORM创建表 - ForeignKey常用操作
class A(Model):
name = models.CharField(...) class B(Model):
name = models.CharField(...)
fk = models.ForeignKey(A) a. B表中有几列：
id
name
fk_id b. 跨表操作
b_list = models.B.objects.all()
for item in b_list:
item.id
item.name
item.fk
item.fk_id
item.fk.id
item.fk.name c. 跨表操作
b_list = models.B.objects.values('id','name','fk_id','fk__name')
for item in b_list:
item['id']
item['name']
item['fk_id']
item['fk__name'] d. 跨表操作
b_list = models.B.objects.vlaues_list('id','name','fk_id','fk__name')
for item in b_list:
item[0]
item[1]
item[2]
item[3] e. 找A表名称等于"alex"的所有B表中的数据 *****
models.B.objects.filter(fk__name="alex") good models.B.objects.filter(fk.name="alex") 这个是不可以，需要验证！！！！！！ - M2M常用操作
class A(Model):
name = models.CharField(...) class B(Model):
name = models.CharField(...)
m = models.ManyToMany(A) a. B表中有几列？
id
name PS：ManyToMany 会自动生成第三张表，字段m用于间接的对第三张表进行操作 b. 在B表中插入3条数据，A表中插入2条数据 models.A.objects.create(name='alex1')
models.A.objects.create(name='alex2') models.B.objects.create(name='egon1')
models.B.objects.create(name='egon2')
models.B.objects.create(name='egon3') c. 让 egon1 和 [alex1,alex2] 创建关系
obj = models.B.objects.filter('name'='egon1')
obj.m.add(*[1,2]) d. 查找和egon1有关系的人
obj = models.B.objects.filter('name'='egon1')
obj.m.all() # 拿到了queryset对象集合，都是A表的对象 - Session是什么？ 和cookie有什么区别？
- session依赖cookie而存在
- session是存储在服务端的键值对
- cookie是存储在客户端浏览器里的键值对 - 用户第一次来访问主页，服务端生成一个随机字符串通过cookie返回给客户端
同时服务端把这个字符串当做key存储在数据库表里（也可以存在其他地方），值可以为空 - 用户第二次发起登录请求则带上刚才的cookie和用户信息
服务端则把用户信息（比如用户名密码）用某种方式存储在刚才随机字符串对应的值里
这样就表示用户登录过了
二、CRM项目介绍
- CRM简介
xxx公司的CRM项目
- 权限管理 (写成一个公共的组件/app，适用于Django项目) *****
- low的增删改查 ***
- 增删改查的组件 (写成公共组件/app) **** - 员工模块
- 权限：根据 含有正则表达式的url 进行分配的
- 操作：通过配置文件进行定制
- 学生模块
- 问卷
- RBAC简介
RBAC（Role-Based Access Control，基于角色的权限控制）
就是用户通过角色与权限进行关联。 简单地说，一个用户拥有若干角色，每一个角色拥有若干权限。
这样，就构造成“用户-角色-权限”的授权模型。 在这种模型中，用户与角色之间，角色与权限之间，一般者是多对多的关系。
三、表结构设计
- 第一版
- permission权限表（含有正则表达式的url）
id url title
1 /userinfo/ 用户列表
2 /userinfo/(\d+)/delete/ 删除用户
3 /userinfo/(\d+)/change/ 修改用户
4 /userinfo/add/ 添加用户 - userinfo用户表
id username password
1 alex 123
2 egon 123
3 standby 123 - 用户和权限的关系表
id user_id permission_id
1 1 1
2 1 2
3 2 1
4 3 1
5 3 2
6 3 3 问题：用户分配权限时，很麻烦，不方便后面的维护 - 第二版
- permission权限表（含有正则表达式的url）
id url title
1 /userinfo/ 用户列表
2 /userinfo/(\d+)/delete/ 删除用户
3 /userinfo/(\d+)/change/ 修改用户
4 /userinfo/add/ 添加用户 - userinfo用户表
id username password
1 alex 123
2 egon 123
3 standby 123 - role 角色表
id title
1 销售员
2 销售经理
3 市场专员
4 市场经理
5 IT
6 CTO
7 CEO - 用户和角色关系表
id user_id role_id
1 1 1
2 2 1
3 2 2
4 3 1
5 3 2
6 3 7 - 角色和权限的关系表
id role_id permission_id
1 1 1
2 2 1
3 2 4
4 6 1
5 6 3
6 6 4
7 7 1
8 7 2
9 7 3
10 7 4 列出standby所具有的所有权限，可能会重复，所以需要去重；
注意：根据用户找权限
- 根据用户找角色
- 根据角色找权限 - 增加权限组表group
id title
1 用户组
2 订单组 - permission权限表 增加一个代号code字段、权限组字段以及 是否是菜单字段(涉及到在前端页面展示):
- permission权限表（含有正则表达式的url）
id url title code group_id is_menu
1 /userinfo/ 用户列表 list 1 true
2 /userinfo/(\d+)/delete/ 删除用户 del 1 false
3 /userinfo/(\d+)/change/ 修改用户 edit 1 false
4 /userinfo/add/ 添加用户 add 1 true
5 /order/ 订单列表 list 2 true
6 /order/(\d+)/delete/ 删除订单 del 2 false
7 /order/(\d+)/change/ 修改订单 edit 2 false
8 /order/add/ 添加订单 add 2 true
class Group(models.Model):
"""
权限组表
"""
title = models.CharField(max_length=32) class Meta:
verbose_name_plural = "权限组表"
def __str__(self):
return self.title
class Permission(models.Model):
"""
权限表
"""
title = models.CharField(verbose_name='标题',max_length=32)
url = models.CharField(verbose_name="含正则的URL",max_length=128)
code = models.CharField(verbose_name="权限代号",max_length=16)
group = models.ForeignKey(verbose_name="权限组",to="Group") # 把具体的权限分组管理，类似省市县
is_menu = models.BooleanField(verbose_name="是否是菜单") # 用来筛选出可以在左侧菜单展示的选项
class Meta:
verbose_name_plural = "权限表" def __str__(self):
return self.title class UserInfo(models.Model):
"""
用户表
"""
username = models.CharField(verbose_name="用户名",max_length=32)
password = models.CharField(verbose_name='密码',max_length=64)
roles = models.ManyToManyField(verbose_name='具有所有角色',to="Role",blank=True) class Meta:
verbose_name_plural = "用户表" def __str__(self):
return self.username class Role(models.Model):
"""
角色表
"""
title = models.CharField(verbose_name='角色名称',max_length=32)
permissions = models.ManyToManyField(verbose_name="具有所有权限",to='Permission',blank=True) class Meta:
verbose_name_plural = "角色表" def __str__(self):
return self.title
让组和菜单创建关系 页面显示的时候是不显示组的
组的存在只是为了在分配权限的时候方便一些：一个组下面的增删改查
但是菜单的信息存储在哪呢？
- 可以把菜单和组都存储在 Group表里
- 增加parent字段，让某些组属于某个菜单（ORM里就是自关联，需要related_name字段）
- 然后再增加一个is_group字段用来区分组和菜单
补充：
- 具体的权限只能在 组 下面，不能直接挂载菜单下面
class Permission(models.Model):
"""
权限表
"""
title = models.CharField(verbose_name='标题',max_length=32)
url = models.CharField(verbose_name="含正则的URL",max_length=128)
code = models.CharField(verbose_name="权限代号",max_length=16)
# group = models.ForeignKey(verbose_name="权限组",to="Group") # 把具体的权限分组管理，类似省市县
group = models.ForeignKey(verbose_name="权限组",to="Group",limit_choices_to={'is_group':True})
is_menu = models.BooleanField(verbose_name="是否是菜单") # 用来筛选出可以在左侧菜单展示的选项
class Meta:
verbose_name_plural = "权限表" def __str__(self):
return self.title
group = models.ForeignKey(verbose_name="权限组",to="Group")
group = models.ForeignKey(verbose_name="权限组",to="Group",limit_choices_to={'is_group':True})
就是说：只有是组的时候才能做 Permission表的外键
最终的表结构如下：
class Group(models.Model):
"""
权限组表
"""
title = models.CharField(max_length=32)
parent = models.ForeignKey(to="Group",related_name="xxx",null=True,blank=True)
is_group = models.BooleanField(verbose_name="是否是组",default=True) class Meta:
verbose_name_plural = "权限组表"
def __str__(self):
return self.title class Permission(models.Model):
"""
权限表
"""
title = models.CharField(verbose_name='标题',max_length=32)
url = models.CharField(verbose_name="含正则的URL",max_length=128)
code = models.CharField(verbose_name="权限代号",max_length=16)
# group = models.ForeignKey(verbose_name="权限组",to="Group") # 把具体的权限分组管理，类似省市县
group = models.ForeignKey(verbose_name="权限组",to="Group",limit_choices_to={'is_group':True})
is_menu = models.BooleanField(verbose_name="是否是菜单") # 用来筛选出可以在左侧菜单展示的选项 class Meta:
verbose_name_plural = "权限表" def __str__(self):
return self.title class UserInfo(models.Model):
"""
用户表
"""
username = models.CharField(verbose_name="用户名",max_length=32)
password = models.CharField(verbose_name='密码',max_length=64)
roles = models.ManyToManyField(verbose_name='具有所有角色',to="Role",blank=True) class Meta:
verbose_name_plural = "用户表" def __str__(self):
return self.username class Role(models.Model):
"""
角色表
"""
title = models.CharField(verbose_name='角色名称',max_length=32)
permissions = models.ManyToManyField(verbose_name="具有所有权限",to='Permission',blank=True) class Meta:
verbose_name_plural = "角色表" def __str__(self):
return self.title
四、需求分析
# 几点注意事项 - 双下划线跨表取值
- 外键和多对多 都可以用 __(双下划线) 跨表获取对应字段
- user -> 多个角色roles -> 根据角色的permissions字段加 '__' 跨到权限表 ```
permission_list = user.roles.filter(permissions__id__isnull=False).values(
'permissions__id',
'permissions__title',
'permissions__url',
'permissions__code',
'permissions__group',
'permissions__is_menu'
).distinct()
``` - 列表distinct()去重
- [].distinct() 进行去重 - 自定义配置
- 在settings.py里定义好 （变量名一定要大写）
- 在代码里引入
Django的所有配置（既包含自定义的也包含Django内置的）：
from django.conf import settings - 找到某个用户所具有的权限
- 先查找所具有的角色
- 再查找所具有的权限
- 最后把权限去重 - 自动生成权限菜单
- 获取数据
- 创建两级菜单
- 两级菜单生成
- 在视图函数中拼接好返回给前端
- @register.simple_tag()
- @register.inclusion_rag("menu_tpl.html") - 请求url验证中间件
- 要在settings.py里维护一份白名单
- 请求验证中间件依赖于session，所以自定义中间件的位置应该放在session中间件(SessionMiddleware)之后
- 对用户请求的url和该用户所具有的权限要做正则匹配：re.match(patten, current_request_url)
# 1/2/3 是组ID
{
1: {
'urls': ['/userinfo/', '/userinfo/add/'],
'codes': ['list', 'add']
},
2: {
'urls': ['/order/'],
'codes': ['list']
},
3: {
'urls': ['/index/'],
'codes': ['index']
}
} [
{'menu_id': 4, 'menu_title': '用户管理菜单', 'permission_url': '/userinfo/', 'permission_title': '用户列表'},
{'menu_id': 4, 'menu_title': '用户管理菜单', 'permission_url': '/userinfo/add/', 'permission_title': '添加用户'},
{'menu_id': 6, 'menu_title': '权限管理菜单', 'permission_url': '/permissioninfo/', 'permission_title': '权限列表'},
{'menu_id': 6, 'menu_title': '权限管理菜单', 'permission_url': '/permissioninfo/add', 'permission_title': '添加权限'}
] # 4/6 是菜单ID
# 菜单和组都在同一张表里，有父子关系，最后的目的是构造菜单和is_menu=True的权限item的两级菜单
{
4:{
'opened':False,
'menu_title':'用户管理菜单',
'children': [
{'title': '用户列表', 'url': '/userinfo/', 'opened':False},
{'title': '订单列表', 'url': '/order/', 'opened':False,}
]
},
6: {
'opened':False,
'menu_title':'权限管理菜单',
'children': [
{'title': '权限列表', 'url': '/userinfo/', 'opened':False},
{'title': '添加权限', 'url': '/order/', 'opened':False,}
]
}
}
总结：
- 表的设计（很重要）
4个类 6张表 - Django admin 录入数据 - 用户登录处理
- 获取角色
- 获取权限
- 对权限去重
- 然后把权限数据存储到session - 登录中间件
- 白名单
- request.path_info
- 从session获取权限，进行验证 - 自动生成菜单
- 跨表取出相关数据，转换字典结构
- 视图中生成好字典返回给前端
- 前端模板渲染 - simple_tag
- inclusion_rag
- 模板layout.html - 权限app包含哪些内容
- 中间件
- init_permission
- models
- admin
- templatetags 依赖配置文件 PERMISSION_DICT = "permission_dict"
URL_FORMAT = "^{0}$"
RBAC_LOGIN_URL = "/login/"
VALID_URL_LIST = [
"^/login/$",
"^/admin.*",
] - 使用rbac权限管理
- 创建CMDB项目
- 把rbac拷贝到项目中
- 在settings.APP中注册 rbac
- 在settings中配置相关变量：
PERMISSION_DICT = "permission_dict"
URL_FORMAT = "^{0}$"
RBAC_LOGIN_URL = "/login/"
VALID_URL_LIST = [
"^/login/$",
"^/admin.*",
]
- 开发CMDB
- 开启中间件验证
- 利用tmplatetags和模板动态生成菜单
- 在Django admin中操作权限信息 练习
- 权限系统补充完整，搞清楚每一行代码 [4天]
- 自己创建project，比如主机管理系统
- 主机
- 主机组
- 部门
- 机房
- ...
- 使用rbac权限系统 [10天]
五、代码实现
表结构如上所述，此处略过...
# 项目结构 D:\soft\work\Python_17\day26\homework\s17crm>tree /F
卷 NewDisk 的文件夹 PATH 列表
卷序列号为 2E8B-8205
D:.
│ db.sqlite3
│ manage.py
│
│
├─app01
│ │ admin.py
│ │ apps.py
│ │ models.py
│ │ tests.py
│ │ views.py
│ └─ __init__.py
│
│
├─rbac
│ │ admin.py
│ │ apps.py
│ │ models.py
│ │ tests.py
│ │ views.py
│ │ __init__.py
│ │
│ ├─middleware
│ │ └─ rbac.py
│ │
│ │
│ ├─service
│ │ │ init_permission.py
│ │ │
│ │ └─__pycache__
│ │ init_permission.cpython-35.pyc
│ │
│ ├─templatetags
│ │ menu_gennerator.py
│ └─ __init__.py
│
│
├─s17crm
│ │ settings.py
│ │ urls.py
│ │ wsgi.py
│ └─ __init__.py
│
├─statics
│ ├─css
│ │ bbs.css
│ │ bootstrap-select.min.css
│ │ bootstrap-theme.css
│ │ bootstrap-theme.css.map
│ │ bootstrap-theme.min.css
│ │ bootstrap-theme.min.css.map
│ │ bootstrap.css
│ │ bootstrap.css.map
│ │ bootstrap.min.css
│ │ bootstrap.min.css.map
│ │ bootstrapValidator.min.css
│ │
│ ├─image
│ │ header.png
│ │
│ └─js
│ bootstrap-select.js.map
│ bootstrap-select.min.js
│ bootstrap.js
│ bootstrap.min.js
│ bootstrapValidator.min.js
│ city_info.js
│ jquery-3.2.1.js
│ jquery-3.2.1.min.js
│ jquery.cookie.js
│ npm.js
│
└─templates
index.html
login.html
menu_tpl.html
order.html
order_add.html
tpl.html
user.html
user_add.html D:\soft\work\Python_17\day26\homework\s17crm>
# s17crm/app01/views.py from django.shortcuts import render,HttpResponse,redirect
from django.forms import Form
from django.forms import fields
from django.forms import widgets
from rbac import models
from rbac.service.init_permission import init_permission
from django.conf import settings class LoginForm(Form):
username = fields.CharField(required=True,error_messages={'required':"用户名不能为空"})
password = fields.CharField(required=True,error_messages={'required':"密码不能为空"}) def login(request):
if "GET" == request.method:
form = LoginForm()
return render(request,'login.html',{'form':form})
else:
form = LoginForm(data=request.POST)
if form.is_valid():
# 格式验证通过
# 注意：只有当 LoginForm 里面变量名称和models表字段名称一致才能使用 **form.cleaned_data
user = models.UserInfo.objects.filter(**form.cleaned_data).first()
if user:
# 获取当前用户的权限信息做格式化然后存储到session中
init_permission(request,user)
print(request.session.get(settings.PERMISSION_DICT))
print(request.session.get(settings.PERMISSION_MENU_LIST))
return redirect('/index/')
else:
from django.core.exceptions import ValidationError
form.add_error('password',ValidationError("用户名或密码错误!!!")) return render(request,'login.html',{'form':form}) def index(request):
# 通过 @register.inclusion_tag('menu_tpl.html') 构造菜单结构并渲染
# 所以这里不用做处理
return render(request,'index.html') def clear(request):
# 手动清空session
request.session.clear()
return HttpResponse("已清除") def order(request):
return render(request,'order.html') def order_add(request):
return render(request,'order_add.html') def user(request):
return render(request,'user.html') def user_add(request):
return render(request,'user_add.html')
# s17crm\rbac\middleware\rbac.py
# 用户访问鉴权中间件 #!/usr/bin/python
# -*- coding:utf-8 -*-
# 这是页面权限验证的中间件 from django.shortcuts import HttpResponse,redirect
from django.conf import settings
import re 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 class RbacMiddleware(MiddlewareMixin):
def process_request(self,request): # 1. 获取当前请求的 uri
current_request_url = request.path_info # 2. 判断是否在白名单里，在则不进行验证，直接放行
for url in settings.VALID_URL_LIST:
if re.match(url, current_request_url):
return None # 3. 验证用户是否有访问权限
flag = False
permission_dict = request.session.get(settings.PERMISSION_DICT) print(permission_dict) # 如果没有登录过就直接跳转到登录页面
if not permission_dict:
return redirect(settings.RBAC_LOGIN_URL)
"""
{
1: {
'codes': ['list', 'add'],
'urls': ['/userinfo/', '/userinfo/add/']
},
2: {
'codes': ['list'],
'urls': ['/order/']
}
}
"""
for group_id, values in permission_dict.items():
for url in values['urls']:
# 必须精确匹配 URL ： "^{0}$"
patten = settings.URL_FORMAT.format(url)
if re.match(patten, current_request_url):
flag = True
break
if flag:
break
if not flag:
return HttpResponse("无权访问")
# s17crm\rbac\service\init_permission.py
# 这是用户登录后初始化用户权限信息的模块 #!/usr/bin/python
# -*- coding:utf-8 -*- from django.conf import settings def init_permission(request,user):
# 获取当前用户的权限信息
"""
外键和多对多 都可以用 __(双下划线) 跨表获取对应字段
[].distinct() 进行去重
"""
permission_list = user.roles.filter(permissions__id__isnull=False).values(
'permissions__id',
'permissions__title',
'permissions__url',
'permissions__code',
'permissions__group',
'permissions__is_menu',
'permissions__group__parent_id', # 即：当前权限所在组的所属菜单ID
'permissions__group__parent__title', # 即：当前权限所在组的所属菜单名称
).distinct() # 格式化当前用户的权限信息
"""
{
1: {
'codes': ['list', 'add'],
'urls': ['/userinfo/', '/userinfo/add/']
},
2: {
'codes': ['list'],
'urls': ['/order/']
}
}
"""
permission_dict = {}
for item in permission_list:
url = item.get('permissions__url')
code = item.get('permissions__code')
group_id = item.get('permissions__group')
if group_id in permission_dict:
permission_dict[group_id]['urls'].append(url)
permission_dict[group_id]['codes'].append(code)
else:
permission_dict[group_id] = {'codes': [code, ], 'urls': [url, ]}
# 把当前用户权限信息存储到session中
request.session[settings.PERMISSION_DICT] = permission_dict # 格式化当前用户的菜单列表信息
# 最终的目的就是要把菜单和具体的is_menu=True的权限item关联起来并在前端构成 两级菜单
'''
[
{'menu_id': 4, 'menu_title': '用户管理菜单', 'permission_url': '/userinfo/', 'permission_title': '用户列表'},
{'menu_id': 4, 'menu_title': '用户管理菜单', 'permission_url': '/userinfo/add/', 'permission_title': '添加用户'},
{'menu_id': 4, 'menu_title': '用户管理菜单', 'permission_url': '/order/', 'permission_title': '订单列表'}
]
'''
permission_menu_list = []
for item in permission_list:
if item['permissions__is_menu']:
tmp = {
'menu_title':item['permissions__group__parent__title'],
'menu_id':item['permissions__group__parent_id'],
'permission_url':item['permissions__url'],
'permission_title':item['permissions__title'],
}
permission_menu_list.append(tmp)
# 把当前用户菜单信息存储到session中
request.session[settings.PERMISSION_MENU_LIST] = permission_menu_list # 设置session的超时时间：30min
request.session.set_expiry(1800) # 为了要在前端构造出两级菜单，还需要对上面拿到的菜单列表做一下格式转换
'''
{
4:{
'opened':False,
'menu_title':'用户管理菜单',
'children': [
{'title': '用户列表', 'url': '/userinfo/', 'opened':False},
{'title': '订单列表', 'url': '/order/', 'opened':False,}
]
},
6: {
'opened':False,
'menu_title':'权限管理菜单',
'children': [
{'title': '权限列表', 'url': '/xxxinfo/', 'opened':False},
{'title': '分类列表', 'url': '/xxxxxxxx/', 'opened':False,}
]
}
}
'''
# s17crm\rbac\templatetags\menu_gennerator.py
# 使用inclusion_tag渲染菜单显示在前端页面 #!/usr/bin/python
# -*- coding:utf-8 -*- from django import template
register = template.Library() import re
from django.conf import settings '''
[
{'menu_id': 4, 'menu_title': '用户管理菜单', 'permission_url': '/userinfo/', 'permission_title': '用户列表'},
{'menu_id': 4, 'menu_title': '用户管理菜单', 'permission_url': '/userinfo/add/', 'permission_title': '添加用户'},
{'menu_id': 4, 'menu_title': '用户管理菜单', 'permission_url': '/order/', 'permission_title': '订单列表'},
...
] 转换成下面的结构，然后再前端进行展示 {
4:{
'opened':False,
'menu_title':'用户管理菜单',
'children': [
{'title': '用户列表', 'url': '/userinfo/', 'opened':False},
{'title': '订单列表', 'url': '/order/', 'opened':False,}
]
},
6: {
'opened':False,
'menu_title':'权限管理菜单',
'children': [
{'title': '权限列表', 'url': '/xxxinfo/', 'opened':False},
{'title': '分类列表', 'url': '/xxxxxxxx/', 'opened':False,}
]
},
...
}
''' @register.inclusion_tag('menu_tpl.html')
def menu_show(request):
permission_menu_dict = {}
current_request_url = request.path_info
permission_menu_list = request.session.get(settings.PERMISSION_MENU_LIST) for item in permission_menu_list:
url = item['permission_url']
patten = settings.URL_FORMAT.format(url)
# 首先遍历所有的具体权限，与当前请求url做比较，匹配则把 opened置为 active，用于配合前端的 .active 属性
opened = "active" if re.match(patten, current_request_url) else "" menu_id = item['menu_id']
child = {'opened': opened, 'title': item['permission_title'], 'url': item['permission_url']}
if menu_id in permission_menu_dict:
# 更新已有menu
permission_menu_dict[menu_id]['children'].append(child)
if opened:
permission_menu_dict[menu_id]['opened'] = opened
else:
# 初始化一个menu
permission_menu_dict[menu_id] = {
'opened': opened,
'menu_title': item['menu_title'],
'children': [child,]
}
return {'permission_menu_dict':permission_menu_dict} # s17crm\templates\menu_tpl.html {% for menu_id,item_dict in permission_menu_dict.items %}
<div class="item">
<div class="menu_title">
<a href="#" class="{{ item_dict.opened }}">{{ item_dict.menu_title }}</a>
</div>
<div class="menu_items {{ item_dict.opened }}">
{% for permission in item_dict.children %}
<a href={{ permission.url }} class="{{ permission.opened }}">{{ permission.title }}</a>
{% endfor %}
</div>
</div>
{% endfor %}
# s17crm\templates\login.html <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body> <form method="post" novalidate>
{% csrf_token %}
<P>
{{ form.username }} {{ form.errors.username.0 }}
</P>
<p>
{{ form.password }} {{ form.errors.password.0 }}
</p> <input type="submit" value="提交">
</form> </body>
</html>
# s17crm\templates\tpl.html
{% load staticfiles %}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>###CRM</title>
<link rel="Shortcut Icon" href="{% static "image/header.png" %}">
<link rel="stylesheet" href="{% static "css/bootstrap.css" %}">
<script src="{% static "js/jquery-3.2.1.min.js" %}"></script>
<script src="{% static "js/bootstrap.js" %}"></script>
<style>
body {
margin: 0;
padding: 0;
}
.header {
height: 40px;
background-color: lightgreen;
text-align: center;
line-height: 40px;
}
.menu {
float: left;
width: 16%;
background-color: wheat;
min-height: 500px
}
.right_body {
float: left;
width: 84%;
min-height: 500px;
}
.item .menu_title {
font-size: 20px;
}
.item .menu_title a.active {
color: green;
}
.item .menu_items {
display: none;
}
.item .menu_items.active {
display: block !important;
}
.item .menu_items a {
font-size: 15px;
display: block;
padding-left: 20px;
}
.item .menu_items a.active {
color: red;
}
</style>
</head>
<body>
<div class="header">
<h2>头部文字水平垂直居中显示...</h2>
</div>
{% load menu_gennerator %}
<div class="content">
<div class="menu">
{% menu_show request %}
</div>
{% block content %}
<h1>这个是模板页面...</h1>
{% endblock %}
</div>
</body>
<script>
$(function () {
menu_swith();
});
function menu_swith() {
$(".menu_title").click(function () {
if($(this).children().hasClass("active")) {
$(this).next().removeClass("active");
$(this).children().removeClass("active");
}else {
$(this).children().addClass("active");
$(this).next().addClass("active");
}
})
}
</script>
</html>
# s17crm\templates\index.html
{% extends "tpl.html" %}
{% block content %}
<div class="right_body">
<h1>这是首页...</h1>
</div>
{% endblock %}
# s17crm\templates\order.html
{% extends "tpl.html" %}
{% block content %}
<div class="right_body">
<h1>订单列表...</h1>
</div>
{% endblock %}
# s17crm\templates\order_add.html
{% extends "tpl.html" %}
{% block content %}
<div class="right_body">
<h1>新增订单...</h1>
</div>
{% endblock %}
...
# s17crm\s17crm\urls.py from django.conf.urls import url
from django.contrib import admin
from app01 import views urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^login/', views.login),
url(r'^index/', views.index),
url(r'^clear/', views.clear),
url(r'^userinfo/$', views.user),
url(r'^userinfo/add/$', views.user_add),
url(r'^order/$', views.order),
url(r'^order/add/$', views.order_add),
]
# \s17crm\s17crm\settings.py """
Django settings for s17crm project. Generated by 'django-admin startproject' using Django 1.11.3. For more information on this file, see
https://docs.djangoproject.com/en/1.11/topics/settings/ For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.11/ref/settings/
""" import os # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '-dulev94(7c=_e_s!@ww937pu3rqiiszw1y(eyl3*mp$&5h_e2' # SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True ALLOWED_HOSTS = [] # Application definition INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'app01',
'rbac',
] 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.rbac.RbacMiddleware'
] ROOT_URLCONF = 's17crm.urls' TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR, 'templates')]
,
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
] WSGI_APPLICATION = 's17crm.wsgi.application' # Database
# https://docs.djangoproject.com/en/1.11/ref/settings/#databases DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
} # Password validation
# https://docs.djangoproject.com/en/1.11/ref/settings/#auth-password-validators AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
] # Internationalization
# https://docs.djangoproject.com/en/1.11/topics/i18n/ LANGUAGE_CODE = 'en-us' TIME_ZONE = 'UTC' USE_I18N = True USE_L10N = True USE_TZ = True # Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.11/howto/static-files/ STATIC_URL = '/static/' #引用名
# 配置STATICFILES_DIRS，指定额外的静态文件存储位置
STATICFILES_DIRS = (
os.path.join(BASE_DIR,"statics"), #实际名 ,即实际文件夹的名字
) ########################## 自定义权限相关配置 ################################## PERMISSION_DICT = "permission_dict"
PERMISSION_MENU_LIST = "permission_menu_list"
URL_FORMAT = "^{0}$"
RBAC_LOGIN_URL = "/login/"
VALID_URL_LIST = [
"^/login/$",
"^/admin.*",
"^/clear/$",
]