昨日内容回顾
1. 权限系统的流程？ 2. 权限的表有几个？ 3. 技术点
中间件
session
orm
- 去重
- 去空
inclusion_tag
filter
有序字典
settings配置
引入静态文件
url别名
namespace
路由分发
构造数据结构
ModelForm
组件应用
admin
icon爬虫
mark_safe
下载文件
一、客户管理之 编辑权限(二)
下载代码：
链接：https://pan.baidu.com/s/1xYkyWFwmOZIFK4cqWWUizg 密码：zzs9
效果如下：
上面的权限管理，需要构造一个字典
构造字典
权限管理数据结构如下：
"": {
"title": "客户列表",
"url": "/customer/list/",
"name": "customer_list",
"children": [
{"title": "添加客户","url": "/customer/add/","name": "customer_add"}
{"title": "编辑客户","url": "/customer/edit/","name": "customer_edit"}
],
},
这里的1指的是权限id。也就Permission表的主键
修改 rbac-->urls.py，增加路径test，用来做测试。
from django.conf.urls import url
from rbac.views import role,menu,permission urlpatterns = [
url(r'^role/list/$', role.role_list,name='role_list'),
url(r'^role/add/$', role.role_add,name='role_add'),
url(r'^role/edit/(?P<rid>\d+)/$', role.role_edit,name='role_edit'), url(r'^menu/list/$', menu.menu_list,name='menu_list'),
url(r'^menu/add/$', menu.menu_add,name='menu_add'),
url(r'^menu/edit/(?P<pk>\d+)/$', menu.menu_edit,name='menu_edit'),
url(r'^menu/del/(?P<pk>\d+)/$', menu.menu_del,name='menu_del'), url(r'^permission/edit/(?P<pk>\d+)/$', menu.permission_edit, name='permission_edit'),
url(r'^permission/del/(?P<pk>\d+)/$', menu.permission_del, name='permission_del'), url(r'^permission/test/$', permission.test,name='test'),
]
进入目录 rbac-->views，创建文件permission.py
from django.shortcuts import render, redirect,HttpResponse
from rbac import models def test(request):
permission_queryset = models.Permission.objects.all().values("id","title","url","name","parent_id")
root_permission_dict = {}
for item in permission_queryset:
print(item['parent_id'])
# 判断parent_id不为空时,也就是能做菜单的url
if not item['parent_id']:
# 以id为key
root_permission_dict[item['id']] = {
'title':item['title'],
'url': item['url'],
'name': item['name'],
'children':[] # 子列表默认为空
} return HttpResponse('ok')
访问测试页面： http://127.0.0.1:8000/rbac/permission/test/，效果如下：
查看Pycharm控制台输出：
None
1
1
1
1
None
7
7
7
None
再筛选不能做菜单的url，也就是parent_id不能为空的
from django.shortcuts import render, redirect,HttpResponse
from rbac import models def test(request):
permission_queryset = models.Permission.objects.all().values("id","title","url","name","parent_id")
root_permission_dict = {} # 先添加二级菜单
for item in permission_queryset:
# print(item['parent_id'])
# 判断parent_id不为空时,也就是能做菜单的url
if not item['parent_id']:
# 以id为key
root_permission_dict[item['id']] = {
'title':item['title'],
'url': item['url'],
'name': item['name'],
'children':[] # 子列表默认为空
} # 再添加非菜单的url
for item in permission_queryset:
# 获取pid
parent_id = item['parent_id']
if parent_id: # 判断pid是否存在
# 追加到parent_id对应的children中
root_permission_dict[parent_id]['children'].append({
'title': item['title'],
'url': item['url'],
'name': item['name'],
}) # 查看最终数据
for root in root_permission_dict.values():
print(root['title'],root['name'],root['url'])
for node in root['children']:
print('--->',node['title'],node['name'],node['url']) return HttpResponse('ok')
刷新页面，查看Pycharm控制台输出：
客户列表 customer_list /customer/list/
---> 添加客户1 customer_add /customer/add/
---> 编辑客户 customer_edit /customer/edit/(?P<cid>\d+)/
---> 删除客户 customer_del /customer/del/(?P<cid>\d+)/
---> 批量导入客户 customer_import /customer/import/
角色列表 role /role/
账单列表 payment_list /payment/list/
---> 添加账单 payment_add /payment/add/
---> 编辑账单 payment_edit /payment/edit/(?P<pid>\d+)/
---> 删除账单 payment_del /payment/del/(?P<pid>\d+)/
点击菜单里面的超链接，url会有mid
这个时候，需要修改ORM查询语句
修改 rbac-->views-->menu.py
from django.shortcuts import render, redirect,HttpResponse
from django.urls import reverse
from rbac import models
from django import forms
from django.utils.safestring import mark_safe ICON_LIST = [
['fa-address-book', '<i aria-hidden="true" class="fa fa-address-book"></i>'],
['fa-address-book-o', '<i aria-hidden="true" class="fa fa-address-book-o"></i>'],
['fa-address-card', '<i aria-hidden="true" class="fa fa-address-card"></i>'],
['fa-address-card-o', '<i aria-hidden="true" class="fa fa-address-card-o"></i>'],
['fa-adjust', '<i aria-hidden="true" class="fa fa-adjust"></i>'],
]
for item in ICON_LIST:
item[1] = mark_safe(item[1]) def menu_list(request):
"""
权限管理和分配
:param request:
:return:
"""
menus = models.Menu.objects.all() mid = request.GET.get('mid')
root_permission_list = []
if mid:
# 找到可以成为菜单的权限 + 某个菜单下的
permissions = models.Permission.objects.filter(menu_id=mid).order_by('-id')
else:
# 找到可以成为菜单的权限
permissions = models.Permission.objects.filter(menu__isnull=False).order_by('-id') root_permission_queryset = permissions.values('id', 'title', 'url', 'name', 'menu__title')
root_permission_dict = {}
for item in root_permission_queryset:
item['children'] = []
root_permission_list.append(item)
root_permission_dict[item['id']] = item # 找到可以成为菜单的权限的所有子权限
node_permission_list = models.Permission.objects.filter(parent_id__in=permissions).order_by('-id').values('id',
'title',
'url',
'name',
'parent_id')
for node in node_permission_list:
pid = node['parent_id']
root_permission_dict[pid]['children'].append(node) return render(
request,
'rbac/menu_list.html',
{
'menu_list': menus,
'root_permission_list': root_permission_list,
'mid': mid
}
) class MenuModelForm(forms.ModelForm):
class Meta:
model = models.Menu
fields = ['title','icon']
widgets = {
# title字段添加class
'title': forms.TextInput(attrs={'class': 'form-control'}),
'icon': forms.RadioSelect(
choices=ICON_LIST
)
}
error_messages = {
'title': {
'required': '菜单名称不能为空'
},
'icon': {
'required': '请选择图标'
}
} def menu_add(request):
if request.method == "GET":
form = MenuModelForm()
else:
form = MenuModelForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse('rbac:menu_list'))
return render(request,"rbac/menu_add.html",{'form':form}) def menu_edit(request,pk):
obj = models.Menu.objects.filter(id=pk).first()
if request.method =='GET':
# instance参数，如果存在那么save()方法会更新这个实例，否则会创建一个新的实例
form = MenuModelForm(instance=obj)
return render(request,'rbac/menu_edit.html',{'form':form})
else:
form = MenuModelForm(data=request.POST,instance=obj)
if form.is_valid():
form.save()
return redirect(reverse('rbac:menu_list'))
else:
return render(request, 'rbac/menu_edit.html', {'form': form}) def menu_del(request, pk):
"""
删除菜单
:param request:
:param pk:
:return:
"""
obj = models.Menu.objects.filter(id=pk).delete()
# print(obj)
return redirect(reverse('rbac:menu_list')) class PermissionModelForm(forms.ModelForm):
class Meta:
model = models.Permission
fields = '__all__'
help_texts = {
'pid': '父级权限，无法作为菜单的权限才需要选择。',
'menu': "选中，表示该权限可以作为菜单；否则，不可做菜单。" }
widgets = {
'title': forms.TextInput(attrs={'class': "form-control", 'placeholder': '请输入权限名称'}),
'url': forms.TextInput(attrs={'class': "form-control", 'placeholder': '请输入URL'}),
'name': forms.TextInput(attrs={'class': "form-control", 'placeholder': '请输入URL别名'}),
'pid': forms.Select(attrs={'class': "form-control", 'placeholder': '请选择父级权限'}),
'menu': forms.Select(attrs={'class': "form-control", 'placeholder': '请选择菜单'}),
} def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs) def clean(self):
menu = self.cleaned_data.get('menu')
pid = self.cleaned_data.get('pid')
if menu and pid:
self.add_error('menu', '菜单和根权限同时只能选择一个') def permission_edit(request, pk):
"""
编辑权限
:param request:
:return:
"""
obj = models.Permission.objects.filter(id=pk).first()
if not obj:
return HttpResponse('权限不存在') if request.method == 'GET':
form = PermissionModelForm(instance=obj)
else:
form = PermissionModelForm(request.POST, instance=obj)
if form.is_valid():
form.save()
return redirect(reverse('rbac:menu_list'))
return render(request, 'rbac/permission_edit.html', {'form': form}) def permission_del(request, pk):
"""
删除权限
:param request:
:return:
"""
models.Permission.objects.filter(id=pk).delete()
return redirect(request.META['HTTP_REFERER'])
修改 rbac-->templates-->rbac-->menu_list.html
{% extends 'layout.html' %}
{% block css %}
<style>
tr.root {
background-color: #f1f7fd;
}
.menu-area tr.active {
background-color: #f1f7fd;
border-left: 3px solid #fdc00f;
}
#menuBody td[mid], #permissionBody > .root .title {
cursor: pointer;
}
#permissionBody tr.root {
background-color: #f1f7fd;
}
td a {
margin: 0 2px;
cursor: pointer;
}
table {
font-size: 12px;
}
.panel-body {
font-size: 12px;
}
.panel-body .form-control {
font-size: 12px;
}
</style>
{% endblock %}
{% block content %}
<div style="padding: 10px">
<h1>菜单管理</h1>
<div class="col-sm-3 menu-area">
<div class="panel panel-default">
<!-- Default panel contents -->
<div class="panel-heading">
<i class="fa fa-book" aria-hidden="true"></i>
菜单管理
<a href="{% url 'rbac:menu_add' %}" class="btn btn-xs btn-success right"
style="padding: 2px 8px;margin: -3px;">
<i class="fa fa-plus-circle" aria-hidden="true"></i>
新建
</a>
</div>
<!-- Table -->
<table class="table">
<th>名称</th>
<th>图标</th>
<th>选项</th>
<tbody id="menuBody">
{% for row in menu_list %}
{% if row.id|safe == mid %}
<tr class="active">
{% else %}
<tr>
{% endif %}
<td>
<a href="?mid={{ row.id }}">{{ row.title }}</a>
</td>
<td>
<!-- 展示图标 -->
<i class="fa {{ row.icon }}" aria-hidden="true"></i>
</td>
<td>
<!-- 编辑和删除 -->
<a href="{% url 'rbac:menu_edit' pk=row.id %}"><i class="fa fa-edit"
aria-hidden="true"></i></a>
<span style="padding: 0 5px;display: inline-block">|</span>
<a href="{% url 'rbac:menu_del' pk=row.id %}"><i class="fa fa-trash-o"
aria-hidden="true"></i></a>
</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
<div class="col-sm-9">
<div class="panel panel-default">
<!-- Default panel contents -->
<div class="panel-heading">
<i class="fa fa-cubes" aria-hidden="true"></i>
权限管理
<a href="{% url 'rbac:menu_add' %}" class="btn btn-xs btn-success right"
style="padding: 2px 8px;margin: -3px;">
<i class="fa fa-plus-circle" aria-hidden="true"></i>
新建
</a>
</div>
<!-- Table -->
<table class="table">
<th>名称</th>
<th>URL</th>
<th>CODE</th>
<th>菜单</th>
<th>所属菜单</th>
<th>选项</th>
<tbody>
{% for row in root_permission_list %}
{# 判断菜单id是否为空 #}
{% if row.menu__title %}
<tr class="root">
{% else %}
<tr style="display: none">
{% endif %}
<td>
<i class="fa fa-caret-down" aria-hidden="true"></i>
{{ row.title }}
</td>
<td>{{ row.url }}</td>
<td>{{ row.name }}</td>
<td>
{# 判断菜单id是否为空 #}
{% if row.menu__title %}
是
{% endif %}
</td>
<td>
{# 判断菜单id是否为空 #}
{% if row.menu__title %}
{{ row.menu__title }}
{% endif %}
</td>
<td>
<!-- 编辑和删除 -->
<a href="{% url 'rbac:permission_edit' pk=row.id %}"><i class="fa fa-edit"
aria-hidden="true"></i></a>
<span style="padding: 0 5px;display: inline-block">|</span>
<a href="{% url 'rbac:permission_del' pk=row.id %}"><i class="fa fa-trash-o"
aria-hidden="true"></i></a>
</td>
</tr>
<tbody class="two">
{% for child in row.children %}
<tr pid="{{ row.id }}">
<td class="title">{{ child.title }}</td>
<td>{{ child.url }}</td>
<td>{{ child.name }}</td>
<td></td>
<td>
{% if child.menu__title %}
{{ row.menu__title }}
{% endif %}
</td>
<td>
<a href="{% url 'rbac:permission_edit' pk=row.id %}" style="color:#333333;">
<i class="fa fa-edit" aria-hidden="true"></i></a>
<a href="{% url 'rbac:permission_del' pk=row.id %}" style="color:#d9534f;">
<i class="fa fa-trash-o" aria-hidden="true"></i>
</a>
</td>
</tr>
{% endfor %}
</tbody>
{% endfor %}
</tbody>
</table>
</div>
</div>
</div>
{% endblock %}
{% block js %}
<script>
//默认隐藏
{#$('.aa').prev().next().hide();#}
$('.two').prev().click(function () {
console.log('点击了');
//卷帘门切换
$(this).next().slideToggle(300);
})
</script>
{% endblock %}
访问页面：http://127.0.0.1:8000/rbac/menu/list，效果如下：
点击左边的信息管理，效果如下：
二、Django表单集合Formset
什么是Formset
Formset(表单集)是多个表单的集合。Formset在Web开发中应用很普遍，它可以让用户在同一个页面上提交多张表单，一键添加多个数据，比如一个页面上添加多个用户信息
为什么要使用Django Formset
我们先来下看下Django中不使用Formset情况下是如何在同一页面上一键提交2张或多张表单的。我们在模板中给每个表单取不同的名字，如form1和form2（如下面代码所示)。注: form1和form2分别对应forms.py里的Form1()和Form2()。
<form >
{{ form1.as_p }}
{{ form2.as_p }}
</form>
用户点击提交后，我们就可以在视图里了对用户提交的数据分别处理。
if request.method == 'POST':
form1 = Form1( request.POST,prefix="form1")
form2 = Form2( request.POST,prefix="form2") if form1.is_valid() or form2.is_valid():
pass
else:
form1 = Form1(prefix="form1")
form2 = Form2(prefix="form2")
这段代码看似并不复杂，然而当表单数量很多或不确定时，这个代码会非常冗长。我们希望能控制表单的数量，这是我们就可以用Formset了。
Formset的分类
Django针对不同的formset提供了3种方法: formset_factory, modelformset_factory和inlineformset_factory。我们接下来分别看下如何使用它们。
如何使用formset_factory
对于继承forms.Form的自定义表单，我们可以使用formset_factory。我们可以通过设置extra和max_num属性来确定我们想要展示的表单数量。注意: max_num优先级高于extra。比如下例中，我们想要显示3个空表单(extra=3)，但最后只会显示2个空表单，因为max_num=2。
from django import forms class BookForm(forms.Form):
name = forms.CharField(max_length=100)
title = forms.CharField()
pub_date = forms.DateField(required=False) # forms.py - build a formset of books from django.forms import formset_factory
from .forms import BookForm # extra: 想要显示空表单的数量
# max_num: 表单显示最大数量，可选，默认1000 BookFormSet = formset_factory(BookForm, extra=3, max_num=2)
在视图文件views.py里，我们可以像使用form一样使用formset。
# views.py - formsets example.
from .forms import BookFormSet
from django.shortcuts import render def manage_books(request):
if request.method == 'POST':
formset = BookFormSet(request.POST, request.FILES)
if formset.is_valid():
# do something with the formset.cleaned_data
pass
else:
formset = BookFormSet()
return render(request, 'manage_books.html', {'formset': formset})
模板里可以这样使用formset
<form action=”.” method=”POST”>
{{ formset }}
</form>
也可以这样使用
<form method="post">
{{ formset.management_form }}
<table>
{% for form in formset %}
{{ form }}
{% endfor %}
</table>
</form>
关于其他更多信息，请参考链接：
https://blog.csdn.net/weixin_42134789/article/details/81505983
举例
新建一个django项目，注意：django版本为1.11
修改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'^$', views.index),
url(r'^index/', views.index),
]
修改views.py
from django.shortcuts import render # Create your views here.
def index(request):
return render(request,"index.html")
在templates目录下创建文件index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<style>
.hide{
display: none;
}
</style>
</head>
<body>
<form method="post">
{{ formset.management_form }}
{% csrf_token %}
<table border="">
<tr>
<th>用户名</th>
<th>密码</th>
<th>邮箱</th>
</tr>
<tr>
<td><input type="text" name="user" placeholder="请输入用户名"></td>
<td><input type="text" name="pwd" placeholder="请输入密码"></td>
<td><input type="text" name="email" placeholder="请输入邮箱"></td>
</tr>
<tr>
<td><input type="text" name="user" placeholder="请输入用户名"></td>
<td><input type="text" name="pwd" placeholder="请输入密码"></td>
<td><input type="text" name="email" placeholder="请输入邮箱"></td>
</tr>
<tr>
<td><input type="text" name="user" placeholder="请输入用户名"></td>
<td><input type="text" name="pwd" placeholder="请输入密码"></td>
<td><input type="text" name="email" placeholder="请输入邮箱"></td>
</tr>
</table>
<input type="submit" value="提交">
</form>
</body>
</html>
启动项目，访问页面： http://127.0.0.1:8000/
点击提交按钮，需要一次性写入3条信息到数据库中
如果使用post提交，那么后台需要做form表单验证。之前学习的form组件，一次验证一行数据。
使用form
修改views.py
from django.shortcuts import render
from django import forms # Create your views here.
class UserForm(forms.Form):
user = forms.CharField()
pwd = forms.CharField()
email = forms.CharField() def index(request):
if request.method == 'GET':
form = UserForm()
return render(request,"index.html",{'form':form})
修改index.html
由于一个form对象，只能生成一行。那么3行，得需要复制3次
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<style>
.hide{
display: none;
}
</style>
</head>
<body>
<form method="post">
{{ formset.management_form }}
{% csrf_token %}
<table border="">
<tr>
<th>用户名</th>
<th>密码</th>
<th>邮箱</th>
</tr>
<tr>
{% for field in form %}
<td>{{ field }}</td>
{% endfor %}
</tr>
<tr>
{% for field in form %}
<td>{{ field }}</td>
{% endfor %}
</tr>
<tr>
{% for field in form %}
<td>{{ field }}</td>
{% endfor %}
</tr>
</table>
<input type="submit" value="提交">
</form>
</body>
</html>
刷新页面，效果如下：
假设不知道有多少条数据呢？得使用formset
使用formset
修改views.py
extra设置展示的表单数量，如果是0，则不会生成！
min_num=1，第一个form表单，必须是完整的。否则提示This field is required
from django.shortcuts import render
from django import forms # Create your views here.
class UserForm(forms.Form):
user = forms.CharField()
pwd = forms.CharField()
email = forms.CharField() def index(request):
# 生成一个类,它是form集合。extra设置展示的表单数量
# min_num至少提交一个完整的form表单
UserFormSet = forms.formset_factory(UserForm,extra=2,min_num=1)
if request.method == 'GET':
formset = UserFormSet()
return render(request,"index.html",{'formset':formset}) formset = UserFormSet(request.POST)
if formset.is_valid():
print(formset.cleaned_data) # 验证通过的数据
print('验证成功') return render(request, "index.html", {'formset': formset})
修改index.html
它必须使用2层for循环。第一次是fromset，它是一个集合，集合每一个元素都是form对象。
第二次是form对象
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<style>
.hide{
display: none;
}
</style>
</head>
<body>
<form method="post">
{{ formset.management_form }}
{% csrf_token %}
<table border="">
<tr>
<th>用户名</th>
<th>密码</th>
<th>邮箱</th>
</tr>
{% for form in formset %}
<tr>
{% for field in form %}
<td>{{ field }}{{ field.errors.0 }}</td>
{% endfor %}
</tr>
{% endfor %}
</table>
<input type="submit" value="提交">
</form>
</body>
</html>
关闭网页，重新访问，效果如下：
它有3个form对象，分别是extra和min_num设置的总和。min_num就是第一个！
直接提交一个空的表单，它会提示This field is required
提交数据
查看Pycharm控制台输出：
[{'pwd': '', 'email': '', 'user': ''}, {'pwd': '', 'email': '', 'user': ''}, {}]
验证成功
可以看出formset.cleaned_data是一个列表，列表的每一个元素，都是字典。
由于第3行没有填写，它是一个空字典
批量保存数据
修改models.py
from django.db import models # Create your models here.
class User(models.Model):
"""
用户表
"""
username = models.CharField(verbose_name='用户名', max_length=32)
password = models.CharField(verbose_name='密码', max_length=32)
email = models.EmailField(verbose_name='邮箱', max_length=32) def __str__(self):
return self.username
使用2个命令生成表
python manage.py makemigrations
python manage.py migrate
修改views.py，使用ModelForm做添加，并且对数据做校验
from django.shortcuts import render,HttpResponse
from django import forms
from app01 import models # Create your views here.
class UserForm(forms.ModelForm):
class Meta:
model = models.User # user表
fields = '__all__' # 所有字段 def index(request):
# 生成一个类,它是form集合。extra设置展示的表单数量
# min_num至少提交一个完整的form表单
UserFormSet = forms.formset_factory(UserForm,extra=2,min_num=1)
if request.method == 'GET':
formset = UserFormSet()
return render(request,"index.html",{'formset':formset}) formset = UserFormSet(request.POST)
if formset.is_valid():
# print(formset.cleaned_data) # 验证通过的数据
flag = False # 标志位
for row in formset.cleaned_data:
if row: # 判断数据不为空
# print(row) # 它是一个字典
# **表示将字典扩展为关键字参数
res = models.User.objects.create(**row)
if res: # 判断返回信息
flag = True if flag:
return HttpResponse('添加成功')
else:
return HttpResponse('添加失败') return render(request, "index.html", {'formset': formset})
注意：**表示将字典扩展为关键字参数
问题来了，为什么要用**呢？
先来看一下，使用create的添加示例
models.User.objects.create(username='xiao',password='',email='123@qq.com')
由于row是一个字典，而create需要关键字参数。那么**就可以完美解决这个问题！论Python基础的重要性！
重启django，刷新页面。
如果添加不合法的数据，会有提示！
输入2条正确的值
提示添加成功
查看用户表，发现有2条数据了！
批量修改数据
修改urls.py，增加路径
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^$', views.index),
url(r'^index/', views.index),
url(r'^batch_update/', views.batch_update),
]
修改views.py，增加视图函数
from django.shortcuts import render,HttpResponse
from django import forms
from app01 import models # Create your views here.
class UserForm(forms.ModelForm):
id = forms.IntegerField()
class Meta:
model = models.User # user表
fields = '__all__' # 所有字段 def index(request):
# 生成一个类,它是form集合。extra设置展示的表单数量
# min_num至少提交一个完整的form表单
UserFormSet = forms.formset_factory(UserForm,extra=2,min_num=1)
if request.method == 'GET':
formset = UserFormSet()
return render(request,"index.html",{'formset':formset}) formset = UserFormSet(request.POST)
if formset.is_valid():
# print(formset.cleaned_data) # 验证通过的数据
flag = False # 标志位
for row in formset.cleaned_data:
if row: # 判断数据不为空
# print(row) # 它是一个字典
# **表示将字典扩展为关键字参数
res = models.User.objects.create(**row)
if res: # 判断返回信息
flag = True if flag:
return HttpResponse('添加成功')
else:
return HttpResponse('添加失败') return render(request, "index.html", {'formset': formset}) def batch_update(request):
"""
批量更新
:param request:
:return:
"""
queryset = models.User.objects.all().values() # 查询表的所有记录
# extra=0表示不渲染form表单。如果指定为0,页面会多一个空的form表单。强迫症者表示不爽！
UserFormSet = forms.formset_factory(UserForm, extra=0)
if request.method =='GET':
# initial 参数用来给 ModelForm 定义初始值。注意:同名 Field 会覆盖 instance 的值
formset = UserFormSet(initial=queryset)
# print(queryset)
return render(request,'batch_update.html',{'formset':formset})
else:
formset = UserFormSet(request.POST)
# print(request.POST)
if formset.is_valid(): # 判断数据
flag = False # 标志位
for row in formset.cleaned_data:
# pop() 方法删除字典给定键 key 及对应的值，返回值为被删除的值
id = row.pop('id') # 获取id
if id: # 判断数据不为空
# print(row) # 它是一个字典
# **表示将字典扩展为关键字参数
res = models.User.objects.filter(id=id).update(**row)
if res: # 判断返回信息
flag = True if flag:
return HttpResponse('修改成功')
else:
return HttpResponse('修改失败')
else:
return render(request, "batch_update.html", {'formset': formset})
在templates目录新建文件batch_update.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<style>
.hide{
display: none;
}
</style>
</head>
<body>
<form method="post">
{{ formset.management_form }}
{% csrf_token %}
<table border="">
<tr>
<th>用户名</th>
<th>密码</th>
<th>邮箱</th>
</tr>
{% for form in formset %}
<tr>
{% for field in form %}
{#判断最后一个字段,也就是id#}
{% if forloop.last %}
{#隐藏id#}
<td class="hide">{{ field }}</td>
{% else %}
{#显示其他字段#}
<td>{{ field }}{{ field.errors.0 }}</td>
{% endif %}
{% endfor %}
</tr>
{% endfor %}
</table>
<input type="submit" value="提交">
</form>
</body>
</html>
访问页面：http://127.0.0.1:8000/batch_update/
修改密码
点击提交，效果如下：
查看表记录
注释事项
在更新的时候，需要有一个id。由于id字段是AutoField，该 Field 不会出现在 ModelForm 表单中。
因此，在views.py里面的UserForm中，定义了一个id字段。
那么在batch_update.html渲染时，就会显示这个id字段。但是更新时，这个id是主键，是不允许更改的。
所以用了一个很巧妙的办法，使用css样式，来隐藏它。
使用ModelForm渲染表单时，自定义的字段它是排在最后面的。所以使用forloop.last就可以定位到ID！
最后点击提交时，request.POST就带有id数据。那么后端，就可以通过id进行更新了！
关于其他更多的ModelForm信息，请参考链接：
https://blog.csdn.net/Leo062701/article/details/80963625
三、ORM之limit_choices_to
limit_choices_to介绍
它是在Admin或ModelForm中显示关联数据时，提供的条件
比如：
- limit_choices_to={'nid__gt': 5}
- limit_choices_to=lambda : {'nid__gt': 5}
from django.db.models import Q
- limit_choices_to=Q(nid__gt=10)
- limit_choices_to=Q(nid=8) | Q(nid__gt=10)
- limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
举例
打开权限管理项目，访问url： http://127.0.0.1:8000/rbac/menu/list/
点击删除账单后面的编辑按钮，进入之后，点击父权限
注意：这里的父权限，展示不对。为什么？因为它必须是能作为菜单权限的！
而这里却展示了所有url。
怎么解决呢？有2个办法
第一：页面渲染时，对数据做判断。
第二：使用limit_choices_to(推荐)
修改 rbac-->models.py，找到字段
parent = models.ForeignKey(verbose_name='父权限',to='Permission',null=True,blank=True)
更改为
parent = models.ForeignKey(verbose_name='父权限',to='Permission',null=True,blank=True,limit_choices_to={'menu__isnull': False})
这个时候，不需要执行那2个命令
直接刷新页面，效果如下：
补充另外一个选项help_text，它是用来提示帮助信息
比如：
help_text="对于无法作为菜单的URL，可以为其选择一个可以作为菜单的权限，那么访问时，则默认选中此权限",
parent 字段完整信息如下：
parent = models.ForeignKey(verbose_name='父权限', to='Permission', null=True, blank=True,
limit_choices_to={'menu__isnull': False},
help_text="对于无法作为菜单的URL，可以为其选择一个可以作为菜单的权限，那么访问时，则默认选中此权限")
在输入框的右侧，就可以显示信息
在模板中，使用{{ field.help_text }}渲染，效果如下：
由于父权限和菜单是二选一的，前端无法做验证，需要在后端做验证。
使用全局钩子，来做判断！
def clean(self):
menu = self.cleaned_data.get('menu_id')
pid = self.cleaned_data.get('pid_id')
if menu and pid:
self.add_error('menu','菜单和根权限同时只能选择一个')
四、构造家族结构
先来看一下Laravel官网的评论区，这是一个评论树形结构
其中可以针对任何一个人进行回复．说白一点就是多叉树，类似的结构如下：
文章的id就是根节点，每一个子节点都保存着上一级节点的id，同级节点之间使用根据创建时间进行先后排序。
评论数型结构
根评论
comment_list = [
{'id':1, 'title':'写的不错', 'pid':None}
]
子评论
comment_list = [
{'id':1, 'title':'写的不错', 'pid':None},
{'id':2, 'title':'还不错', 'pid':1}
]
三级评论
comment_list = [
{'id':1, 'title':'写的不错', 'pid':None},
{'id':2, 'title':'还不错', 'pid':1},
{'id':3, 'title':'什么玩意', 'pid':2}
]
后面的层级，依次类推。
最终数据如下：
comment_list = [
{'id':1, 'title':'写的不错', 'pid':None},
{'id':2, 'title':'还不错', 'pid':1},
{'id':3, 'title':'什么玩意', 'pid':2},
{'id':4, 'title':'q1', 'pid':2},
{'id':5, 'title':'', 'pid':1},
{'id':6, 'title':'去你的吧', 'pid':3},
]
层级关系应该是这个样子的
{'id':1, 'title':'写的不错', 'pid':None},
{'id':2, 'title':'还不错', 'pid':1},
{'id':3, 'title':'什么玩意', 'pid':2}
{'id':6, 'title':'去你的吧', 'pid':3},
{'id':4, 'title':'q1', 'pid':2}
{'id':5, 'title':'', 'pid':1},
如何构造
转换字典
先将数据转换成字典
comment_dict = {}
for item in comment_list:
comment_dict[item['id']] = item
执行之后，结果是一个大字典
comment_dict = {
1: {'title': '写的不错', 'id': 1, 'pid': None},
2: {'title': '还不错', 'id': 2, 'pid': 1},
3: {'title': '什么玩意', 'id': 3, 'pid': 2},
4: {'title': 'q1', 'id': 4, 'pid': 2},
5: {'title': '', 'id': 5, 'pid': 1},
6: {'title': '去你的吧', 'id': 6, 'pid': 3}
}
注意：这里面的每一个小字典，和comment_list里面的字典，用的是同一个内存地址。
证明一下，改个数据
comment_list = [
{'id':1, 'title':'写的不错', 'pid':None},
{'id':2, 'title':'还不错', 'pid':1},
{'id':3, 'title':'什么玩意', 'pid':2},
{'id':4, 'title':'q1', 'pid':2},
{'id':5, 'title':'', 'pid':1},
{'id':6, 'title':'去你的吧', 'pid':3},
] comment_dict = {}
for item in comment_list:
comment_dict[item['id']] = item print('字典更改前',comment_dict[1])
comment_list[0]['title'] = '写的不错~~~'
print('字典更改后',comment_dict[1])
执行输出：
字典更改前 {'title': '写的不错', 'pid': None, 'id': 1}
字典更改后 {'title': '写的不错~~~', 'pid': None, 'id': 1}
发现了吧！明明更改的是大列表，但是大字典里面的数据，也随之变动！
加children
加children的目的，是为了存放除了根评论之外的，比如：二级和三级评论！
comment_list = [
{'id':1, 'title':'写的不错', 'pid':None},
{'id':2, 'title':'还不错', 'pid':1},
{'id':3, 'title':'什么玩意', 'pid':2},
{'id':4, 'title':'q1', 'pid':2},
{'id':5, 'title':'', 'pid':1},
{'id':6, 'title':'去你的吧', 'pid':3},
] comment_dict = {}
for item in comment_list:
# 增加新的key为children,值为空列表
item['children'] = []
comment_dict[item['id']] = item for row in comment_list:
if not row['pid']:
continue
执行之后，comment_dict结构如下：
comment_dict = {
1: {'title': '写的不错', 'id': 1, 'pid': None,'children':[]},
2: {'title': '还不错', 'id': 2, 'pid': 1,'children':[]},
3: {'title': '什么玩意', 'id': 3, 'pid': 2,'children':[]},
4: {'title': 'q1', 'id': 4, 'pid': 2,'children':[]},
5: {'title': '', 'id': 5, 'pid': 1,'children':[]},
6: {'title': '去你的吧', 'id': 6, 'pid': 3,'children':[]}
}
最加到children
判断是根评论，跳过循环。否则最加到children
comment_list = [
{'id':1, 'title':'写的不错', 'pid':None},
{'id':2, 'title':'还不错', 'pid':1},
{'id':3, 'title':'什么玩意', 'pid':2},
{'id':4, 'title':'q1', 'pid':2},
{'id':5, 'title':'', 'pid':1},
{'id':6, 'title':'去你的吧', 'pid':3},
] comment_dict = {}
for item in comment_list:
# 增加新的key为children,值为空列表
item['children'] = []
comment_dict[item['id']] = item for row in comment_list:
if not row['pid']: # 判断根评论
continue # 跳过此次循环
pid = row['pid'] # 获取pid
# 最加到children中
comment_dict[pid]['children'].append(row)
执行之后，comment_dict结构如下：
{
"": {
"pid": null,
"id": 1,
"title": "写的不错",
"children": [{
"pid": 1,
"id": 2,
"title": "还不错",
"children": [{
"pid": 2,
"id": 3,
"title": "什么玩意",
"children": [{
"pid": 3,
"id": 6,
"title": "去你的吧",
"children": []
}]
}, {
"pid": 2,
"id": 4,
"title": "q1",
"children": []
}]
}, {
"pid": 1,
"id": 5,
"title": "",
"children": []
}]
},
"": {
"pid": 1,
"id": 2,
"title": "还不错",
"children": [{
"pid": 2,
"id": 3,
"title": "什么玩意",
"children": [{
"pid": 3,
"id": 6,
"title": "去你的吧",
"children": []
}]
}, {
"pid": 2,
"id": 4,
"title": "q1",
"children": []
}]
},
"": {
"pid": 2,
"id": 3,
"title": "什么玩意",
"children": [{
"pid": 3,
"id": 6,
"title": "去你的吧",
"children": []
}]
},
"": {
"pid": 2,
"id": 4,
"title": "q1",
"children": []
},
"": {
"pid": 1,
"id": 5,
"title": "",
"children": []
},
"": {
"pid": 3,
"id": 6,
"title": "去你的吧",
"children": []
}
}
上面的结构，是用json格式化工具之后的！
这里面的字典，虽然有重复的，但是它们是同一个内存地址！
可以看到children的数据，都加上了
终极版
import json
comment_list = [
{'id': 1, 'title': '写的不错', 'pid': None},
{'id': 2, 'title': '还不错', 'pid': 1},
{'id': 3, 'title': '什么玩意', 'pid': 2},
{'id': 4, 'title': 'q1', 'pid': 2},
{'id': 5, 'title': '', 'pid': 1},
{'id': 6, 'title': '去你的吧', 'pid': 3},
] comment_dict = {}
for item in comment_list:
# 增加新的key为children,值为空列表
item['children'] = []
comment_dict[item['id']] = item result = [] # 空列表
for row in comment_list:
if not row['pid']: # 判断根评论
result.append(row) # 添加到列表
else:
pid = row['pid'] # 获取pid
# 最加到children中
comment_dict[pid]['children'].append(row) print(json.dumps(result))
执行输出：
注意：这个是使用网页版json工具，进行排版的！！！
[{
"id": 1,
"children": [{
"id": 2,
"children": [{
"id": 3,
"children": [{
"id": 6,
"children": [],
"pid": 3,
"title": "去你的吧"
}],
"pid": 2,
"title": "什么玩意"
}, {
"id": 4,
"children": [],
"pid": 2,
"title": "q1"
}],
"pid": 1,
"title": "还不错"
}, {
"id": 5,
"children": [],
"pid": 1,
"title": ""
}],
"pid": null,
"title": "写的不错"
}]
关于客户权限管理系统，详细步骤没有时间写了，附上终极版本
链接：https://pan.baidu.com/s/1uVM5iAl4lCqAhdPZSSyd_A 密码：yj4z
未完待续...