写在前面
之前在windows上写代码逻辑、搞前端等花了很长时间，跑通之后一直没往centos上部署，
昨天尝试部署下，结果发现静态文件找不到 ==‘‘
由于写了2个组件：
- arya model的增删改查，模拟django admin
- rbac 基于角色的访问控制
并且每个组件下都有自己的静态文件，层次结构如下：
[[email protected] crm_rbac_arya]# tree -I "statics|*pyc|migrations" . -L 3
.
├── arya
│ ├── admin.py
│ ├── apps.py
│ ├── __init__.py
│ ├── models.py
│ ├── __pycache__
│ ├── service
│ │ ├── arya.py
│ │ ├── arya_v1.py
│ │ └── __pycache__
│ ├── static
│ │ └── arya
│ ├── templates
│ │ └── arya
│ ├── tests.py
│ ├── utils
│ │ ├── pager.py
│ │ └── __pycache__
│ └── views.py
├── bin
│ ├── uwsgi.ini
│ ├── uwsgi.log
│ ├── uwsgi.pid
│ └── uwsgi.sock
├── crm
│ ├── admin.py
│ ├── apps.py
│ ├── arya.py
│ ├── __init__.py
│ ├── middleware
│ │ ├── login_required.py
│ │ └── __pycache__
│ ├── models.py
│ ├── __pycache__
│ ├── tests.py
│ └── views.py
├── crm_rbac_arya
│ ├── __init__.py
│ ├── __pycache__
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
├── db.sqlite3
├── manage.py
├── rbac
│ ├── admin.py
│ ├── apps.py
│ ├── arya.py
│ ├── __init__.py
│ ├── middleware
│ │ ├── __pycache__
│ │ └── rbac.py
│ ├── models.py
│ ├── __pycache__
│ ├── service
│ │ ├── init_permission.py
│ │ └── __pycache__
│ ├── static
│ │ └── rbac
│ ├── templates
│ │ └── rbac
│ ├── templatetags
│ │ ├── __init__.py
│ │ ├── menu_gennerator.py
│ │ └── __pycache__
│ ├── tests.py
│ └── views.py
└── templates
├── arya
│ ├── layout.html.simple
│ └── layout_old.html
├── index.html
└── login.html
31 directories, 42 files
[[email protected] crm_rbac_arya]#
开始纠结：
STATIC_URL = ‘/static/‘ STATIC_ROOT = os.path.join(BASE_DIR, ‘rbac/static‘) STATIC_ROOT = os.path.join(BASE_DIR, ‘arya/static‘)
之前这样写的，没有写 STATICFILES_DIRS ， 并且在urls.py里增加了如下几行：
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
url(r‘^arya/‘, arya.site.urls),
url(r‘^login/‘, views.login),
url(r‘^index/‘, views.index),
url(r‘^clear/‘, views.clear),
]
urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
这样是可以找到arya的静态文件，找不到rbac的静态文件。
后来想把多个app下的静态文件都移出来放一个目录下，但是又不想破坏每个组件的完整性。。。
看了官网Managing static files 苦逼了好一会，瞎搞了一会还是没搞定。
今早在地铁上，又上网查了下，突然灵机一动想起了 STATICFILES_DIRS ，必须有 django.contrib.staticfiles 这个app，然后
python manage.py collectstatic
最后在nginx和uwsgi上配置好路径即可！
环境：
Python 3.5.2 django 1.11.4 CentOS release 6.4 (Final) nginx/1.10.3
废话到此为止，上代码：
arya/service/arya.py
from django.shortcuts import HttpResponse,render,redirect
from django.conf.urls import url, include
from django.urls import reverse
from django.utils.safestring import mark_safe
from django.forms import ModelForm
from ..utils.pager import Paginator
from copy import deepcopy
from django.db.models import ForeignKey, ManyToManyField
import functools
from types import FunctionType
from django.db.models import Q
from django.http.request import QueryDict
class FilterRow(object):
"""
组合搜索项
"""
def __init__(self, option, change_list, data_list, param_dict=None, is_choices=None):
self.option = option
self.change_list = change_list
self.data_list = data_list
self.param_dict = deepcopy(param_dict)
self.param_dict._mutable = True
self.is_choices = is_choices
def __iter__(self):
base_url = self.change_list.config.reverse_list_url
tpl = "<a href=‘{0}‘ class=‘{1}‘>{2}</a>"
"""
点击 课程2 和 性别1 这两个条件进行筛选的情况下：
self.option.name 分别是 consultant course gender
self.param_dict 是 <QueryDict: {‘gender‘: [‘1‘], ‘course‘: [‘2‘]}>
"""
# 这里是给 全部btn 创建url链接
if self.option.name in self.param_dict:
# 注意这里需要先把option.name对应的item pop掉，再做 urlencode()操作！
pop_value = self.param_dict.pop(self.option.name)
url = "{0}?{1}".format(base_url, self.param_dict.urlencode())
val = tpl.format(url, ‘‘, ‘全部‘)
self.param_dict.setlist(self.option.name, pop_value)
else:
url = "{0}?{1}".format(base_url, self.param_dict.urlencode())
val = tpl.format(url, ‘active‘, ‘全部‘)
# self.param_dict
yield mark_safe("<div class=‘whole‘>")
yield mark_safe(val)
yield mark_safe("</div>")
yield mark_safe("<div class=‘others‘>")
for obj in self.data_list:
param_dict = deepcopy(self.param_dict)
if self.is_choices:
# ((1, ‘男‘), (2, ‘女‘))
pk = str(obj[0])
text = obj[1]
else:
# url上要传递的值
pk = self.option.val_func_name(obj) if self.option.val_func_name else obj.pk
pk = str(pk)
# a标签上显示的内容
text = self.option.text_func_name(obj) if self.option.text_func_name else str(obj)
exist = False
if pk in param_dict.getlist(self.option.name):
exist = True
if self.option.is_multi:
if exist:
values = param_dict.getlist(self.option.name)
values.remove(pk)
param_dict.setlist(self.option.name,values)
else:
param_dict.appendlist(self.option.name, pk)
else:
param_dict[self.option.name] = pk
url = "{0}?{1}".format(base_url, param_dict.urlencode())
val = tpl.format(url, ‘active‘ if exist else ‘‘, text)
yield mark_safe(val)
yield mark_safe("</div>")
class FilterOption(object):
def __init__(self, field_or_func, condition=None, is_multi=False, text_func_name=None, val_func_name=None):
"""
:param field: 字段名称或函数
:param is_multi: 是否支持多选
:param text_func_name: 在Model中定义函数，显示文本名称，默认使用 str(对象)
:param val_func_name: 在Model中定义函数，显示文本名称，默认使用 对象.pk
"""
self.field_or_func = field_or_func
self.condition = condition # 筛选条件
self.is_multi = is_multi # 是否允许多选
self.text_func_name = text_func_name
self.val_func_name = val_func_name
@property
def is_func(self):
if isinstance(self.field_or_func, FunctionType):
return True
@property
def name(self):
if self.is_func:
return self.field_or_func.__name__
else:
return self.field_or_func
@property
def get_condition(self):
if self.condition:
return self.condition
con = Q()
return con
class ChangeList(object):
"""
专门用来处理列表页面部分的代码逻辑，简化 AryaConfig.changelist_view()
"""
def __init__(self,config,queryset):
self.config = config
self.list_display = config.get_list_display()
self.show_add = config.get_show_add()
self.add_url = config.reverse_add_url
# 模糊搜索
self.search_list = config.get_search_list()
self.keyword = config.keyword
self.actions = config.get_actions()
# 分页相关
current_page = config.request.GET.get(‘page‘,1)
all_count = queryset.count()
base_url = config.reverse_list_url
per_page = config.per_page
per_page_count = config.per_page_count
# 用于首先模糊查找了下数据的情况下要保留原来的 ?keyword=xxx ，在这基础上再进行分页
# 但是如果在这里修改query_params则会影响 request.GET ，所以这里要进行深拷贝
# 注意：request.GET 不是字典类型，而是django自己的QueryDict类型
query_params = deepcopy(config.request.GET)
query_params._mutable = True
pager = Paginator(all_count,current_page,base_url,per_page,per_page_count,query_params)
self.queryset = queryset[pager.start:pager.end]
self.page_html = pager.page_html
# 组合筛选
self.list_filter = config.get_list_filter()
# 获取表头第一版
‘‘‘
header_data = []
for str_or_func in self.get_list_display():
if isinstance(str_or_func,str):
val = self.model._meta.get_field(str_or_func).verbose_name
else:
val = str_or_func(self, is_header=True)
header_data.append(val)
‘‘‘
# 获取表头改进版
def table_header(self):
for str_or_func in self.list_display:
if isinstance(str_or_func, str):
val = self.config.model._meta.get_field(str_or_func).verbose_name
else:
val = str_or_func(self.config, is_header=True)
yield val
# 获取表内容
# def table_body(self):
# table_data = []
# for row in self.queryset:
# if not self.list_display:
# # 用列表把对象做成列表集合是为了兼容有list_display的情况在前端展示（前端用2层循环展示）
# table_data.append([row, ])
# else:
# tmp = []
# for str_or_func in self.list_display:
# if isinstance(str_or_func, str):
# # 如果是字符串则通过反射取值
# tmp.append(getattr(row, str_or_func))
# else:
# # 否则就是函数，获取函数执行的结果
# tmp.append(str_or_func(self.config, row))
# table_data.append(tmp)
# return table_data
def table_body(self):
for row in self.queryset:
if not self.list_display:
# 用列表把对象做成列表集合是为了兼容有list_display的情况在前端展示（前端用2层循环展示）
yield [row, ]
else:
tmp = []
for str_or_func in self.list_display:
if isinstance(str_or_func, str):
# 如果是字符串则通过反射取值
tmp.append(getattr(row, str_or_func))
else:
# 否则就是函数，获取函数执行的结果
tmp.append(str_or_func(self.config, row))
yield tmp
# 定制批量操作的actions
def action_options(self):
options = []
for func in self.actions:
tmp = {‘value‘:func.__name__, ‘text‘:func.text}
options.append(tmp)
return options
# 定制组合筛选
def gen_list_filter(self):
for option in self.list_filter:
if option.is_func:
data_list = option.field_or_func(self.config, self, option)
else:
_field = self.config.model._meta.get_field(option.field_or_func)
"""
option.field_or_func course 咨询的课程
_field crm.Customer.course type <class ‘django.db.models.fields.related.ManyToManyField‘>
_field.rel <ManyToManyRel: crm.customer> type <class ‘django.db.models.fields.reverse_related.ManyToManyRel‘>
option.field_or_func consultant 课程顾问
_field crm.Customer.consultant type <class ‘django.db.models.fields.related.ForeignKey‘>
_field.rel <ManyToOneRel: crm.customer> type <class ‘django.db.models.fields.reverse_related.ManyToOneRel‘>
"""
if isinstance(_field, ForeignKey):
data_list = FilterRow(option, self, _field.rel.model.objects.filter(option.get_condition),
self.config.request.GET)
elif isinstance(_field, ManyToManyField):
data_list = FilterRow(option, self, _field.rel.model.objects.filter(option.get_condition),
self.config.request.GET)
else:
# print(_field.choices) # ((1, ‘男‘), (2, ‘女‘))
data_list = FilterRow(option, self, _field.choices, self.config.request.GET, is_choices=True)
yield data_list
def add_html(self):
"""
添加按钮
:return:
"""
add_html = mark_safe(‘<a class="btn btn-primary" href="%s">添加</a>‘ % (self.config.add_url_params,))
return add_html
def search_attr(self):
val = self.config.request.GET.get(self.keyword)
return {"value": val, ‘name‘: self.keyword}
class AryaConfig(object):
# 借助继承特性，实现定制列展示
list_display = []
# 定制是否显示添加按钮
show_add = False
def get_show_add(self):
return self.show_add
# 使用ModelForm
model_form_class = None
def get_model_form_class(self):
if self.model_form_class:
return self.model_form_class
class DynamicModelForm(ModelForm):
class Meta:
model = self.model
fields = ‘__all__‘
return DynamicModelForm
"""
也可以使用 type 来生成
def get_model_form_class(self):
model_form_cls = self.model_form
if not model_form_cls:
_meta = type(‘Meta‘, (object,), {‘model‘: self.model, "fields": "__all__"})
model_form_cls = type(‘DynamicModelForm‘, (ModelForm,), {‘Meta‘: _meta})
return model_form_cls
"""
# 分页相关配置
per_page = 10
per_page_count = 11
# 定制actions，即结合checkbox进行批量操作
actions = []
def get_actions(self):
result = []
result.extend(self.actions)
return result
# 模糊搜索字段列表 (默认不支持搜索)
search_list = []
def get_search_list(self):
result = []
result.extend(self.search_list)
return result
@property
def get_search_condition(self):
con = Q()
con.connector = "OR"
# 加入搜索关键字是 kk, 并且如果我们在search_list里规定的只有 qq 和 name 这俩字段可以提供搜索条件
# 那么 kk 这个关键字要么在 name里，要么在qq这个字段里，二者之间是 或 的关系
val = self.request.GET.get(self.keyword)
if not val:
return con
# [‘qq‘,‘name‘] 精确搜索
# [‘qq__contains‘,‘name__contains‘] 模糊搜索
field_list = self.get_search_list()
for field in field_list:
field = "{0}__contains".format(field)
con.children.append((field,val))
return con
@property
def get_search_condition2(self):
‘‘‘
search_list = [
{‘key‘: ‘qq‘, ‘type‘: None},
{‘key‘: ‘name‘, ‘type‘: None},
{‘key‘: ‘course__name‘, ‘type‘: None},
]
‘‘‘
# condition = {}
# keyword = request.GET.get(‘keyword‘)
# search_list = self.get_search_list()
# if keyword and search_list:
# # [‘username‘,‘email‘,‘ut‘,]
# for field in search_list:
# condition[field] = keyword
# condition = {
# ‘username‘:keyword,
# ‘email‘:keyword,
# ‘ut‘:keyword,
# }
# 这样去 filter(**condition) 过滤的时候是按照 且 关系过滤， 这样不太好，应该改成 或 关系过滤
# 即 Django里的 Q 查询 : from django.db.models import Q
# queryset = self.model.objects.all()
# queryset = self.model.objects.filter(**condition)
# 增加这个属性，用于在ChangeList类里获取到查询的关键字（即通过self参数把request传递给ChangeList）
condition = Q()
condition.connector = "OR"
keyword = self.request.GET.get(self.keyword)
if not keyword:
return condition
search_list = self.get_search_list()
for field_dict in search_list:
field = "{0}__contains".format(field_dict.get(‘key‘))
field_type = field_dict.get(‘type‘)
if field_type:
try:
keyword = field_type(keyword)
except Exception as e:
continue
condition.children.append((field, keyword))
return condition
"""定制查询组合条件"""
list_filter = []
def get_list_filter(self):
return self.list_filter
@property
def get_list_filter_condition(self):
# 获取model的字段，FK，choice，但是没有多对多的字段
# fields1 = [obj.name for obj in self.model._meta.fields]
# 只获取获取多对多的字段
# fields2 = [obj.name for obj in self.model._meta.many_to_many]
# 还包含了反向关联字段
fields3 = [obj.name for obj in self.model._meta._get_fields()]
"""
[‘internal_referral‘, ‘consultrecord‘, ‘paymentrecord‘, ‘student‘, ‘id‘, ‘qq‘, ‘name‘, ‘gender‘, ‘education‘, ‘graduation_school‘, ‘major‘, ‘experience‘, ‘work_status‘, ‘company‘, ‘salary‘, ‘source‘, ‘referral_from‘, ‘status‘, ‘consultant‘, ‘date‘, ‘last_consult_date‘, ‘course‘]
"""
# fields = dir(self.model._meta)
"""
[‘FORWARD_PROPERTIES‘, ‘REVERSE_PROPERTIES‘, ‘__class__‘, ‘__delattr__‘, ‘__dict__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__le__‘, ‘__lt__‘, ‘__module__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘__weakref__‘, ‘_expire_cache‘, ‘_forward_fields_map‘, ‘_get_fields‘, ‘_get_fields_cache‘, ‘_ordering_clash‘, ‘_populate_directed_relation_graph‘, ‘_prepare‘, ‘_property_names‘, ‘_relation_tree‘, ‘abstract‘, ‘add_field‘, ‘add_manager‘, ‘app_config‘, ‘app_label‘, ‘apps‘, ‘auto_created‘, ‘auto_field‘, ‘base_manager‘, ‘base_manager_name‘, ‘can_migrate‘, ‘concrete_fields‘, ‘concrete_model‘, ‘contribute_to_class‘, ‘db_table‘, ‘db_tablespace‘, ‘default_apps‘, ‘default_manager‘, ‘default_manager_name‘, ‘default_permissions‘, ‘default_related_name‘, ‘fields‘, ‘fields_map‘, ‘get_ancestor_link‘, ‘get_base_chain‘, ‘get_field‘, ‘get_fields‘, ‘get_latest_by‘, ‘get_parent_list‘, ‘get_path_from_parent‘, ‘get_path_to_parent‘, ‘has_auto_field‘, ‘index_together‘, ‘indexes‘, ‘installed‘, ‘label‘, ‘label_lower‘, ‘local_concrete_fields‘, ‘local_fields‘, ‘local_managers‘, ‘local_many_to_many‘, ‘managed‘, ‘manager_inheritance_from_future‘, ‘managers‘, ‘managers_map‘, ‘many_to_many‘, ‘model‘, ‘model_name‘, ‘object_name‘, ‘order_with_respect_to‘, ‘ordering‘, ‘original_attrs‘, ‘parents‘, ‘permissions‘, ‘pk‘, ‘private_fields‘, ‘proxy‘, ‘proxy_for_model‘, ‘related_fkey_lookups‘, ‘related_objects‘, ‘required_db_features‘, ‘required_db_vendor‘, ‘select_on_save‘, ‘setup_pk‘, ‘setup_proxy‘, ‘swappable‘, ‘swapped‘, ‘unique_together‘, ‘verbose_name‘, ‘verbose_name_plural‘, ‘verbose_name_raw‘, ‘virtual_fields‘]
"""
# 去请求URL中获取参数
# 根据参数生成条件
con = {}
params = self.request.GET
# self.request.GET <QueryDict: {‘gender‘: [‘1‘], ‘course‘: [‘1‘, ‘2‘]}>
for k in params:
# 判断k是否在数据库字段支持
if k not in fields3:
continue
v = params.getlist(k)
k = "{0}__in".format(k)
con[k] = v
"""
比如按照课程2和性别1这俩条件进行筛选的时候:
{‘gender__in‘: [‘1‘], ‘course__in‘: [‘2‘]}
并且课程可以多选
注意：这里课程之间是 或 的关系，即如果一个客户只咨询了课程1，但是筛选条件是 课程1和课程2，这种情况下，当前客户也会被筛选出来，
尽管该用户并没有咨询课程2
<QueryDict: {‘gender‘: [‘2‘], ‘course‘: [‘1‘, ‘2‘]}>
{‘course__in‘: [‘1‘, ‘2‘], ‘gender__in‘: [‘2‘]}
"""
return con
def __init__(self, model, arya_site):
self.model = model
self.arya_site = arya_site
self.app_label = model._meta.app_label
self.model_name = model._meta.model_name
self.change_filter_name = "_change_filter"
self.keyword = ‘keyword‘
self.request = None
# 定制 编辑 按钮
def row_edit(self, row=None, is_header=None):
if is_header:
return "编辑"
# 反向生成URL
edit_a = mark_safe("<a href=‘{0}?{1}‘>编辑</a>".format(self.reverse_edit_url(row.id), self.back_url_param))
return edit_a
# 定制 删除 按钮
def row_del(self, row=None, is_header=None):
if is_header:
return "删除"
# 反向生成URL
del_a = mark_safe("<a href=‘{0}?{1}‘>删除</a>".format(self.reverse_del_url(row.id), self.back_url_param))
return del_a
# 定制 checkbox
def check_box(self, row=None, is_header=None):
if is_header:
return "选项"
checkbox = mark_safe("<input type=‘checkbox‘ name=‘item_id‘ value=‘{0}‘ />".format(row.id))
return checkbox
def get_list_display(self):
result = []
result.extend(self.list_display)
# 如果有编辑权限
"""
注意这里的参数不是方法self.row_edit 而是函数AryaConfig.row_edit
class Foo(object):
def func(self):
print(‘方法‘)
方法和函数的区别：
# - 如果被对象调用，则self不用传值
# obj = Foo()
# obj.func()
# - 如果被类 调用，则self需要主动传值
# obj = Foo()
# Foo.func(obj)
"""
result.append(AryaConfig.row_edit)
# 如果有删除权限
result.append(AryaConfig.row_del)
# 加上checkbox
result.insert(0, AryaConfig.check_box)
return result
# 装饰器：给 changelist_view add_view delete_view change_view 增加 self.request = request
# 这样就不用在每个view里都写一遍 self.request = request
# 每次请求进来记录下这个request，这样就能拿到rbac请求验证中间里面的permission_code_list
def wrapper(self, func):
@functools.wraps(func)
def inner(request, *args, **kwargs):
self.request = request
return func(request, *args, **kwargs)
return inner
def get_urls(self):
app_model_name = self.model._meta.app_label,self.model._meta.model_name
urlpatterns = [
url(r‘^$‘, self.wrapper(self.changelist_view), name=‘%s_%s_list‘ % app_model_name),
url(r‘^add/$‘, self.wrapper(self.add_view), name=‘%s_%s_add‘ % app_model_name),
url(r‘^(.+)/delete/$‘, self.wrapper(self.delete_view), name=‘%s_%s_delete‘ % app_model_name),
url(r‘^(.+)/change/$‘, self.wrapper(self.change_view), name=‘%s_%s_change‘ % app_model_name)
]
urlpatterns += self.extra_urls()
return urlpatterns
def extra_urls(self):
"""
扩展URL预留的钩子函数
:return:
"""
return []
@property
def urls(self):
return self.get_urls(), None, None
def changelist_view(self, request):
"""
列表页面
:param request:
:return:
"""
# 执行批量actions，比如批量删除
if ‘POST‘ == request.method:
func_name = request.POST.get(‘select_action‘)
if func_name:
# 通过反射获取要批量执行的函数对象
func = getattr(self, func_name)
func(request)
‘‘‘先过滤组合搜索，然后过滤模糊搜索，最后去重拿到最后结果‘‘‘
queryset = self.model.objects.filter(**self.get_list_filter_condition).filter(self.get_search_condition2).distinct()
cl = ChangeList(self,queryset)
return render(request,‘arya/item_list.html‘,{‘cl‘:cl})
def add_view(self, request):
"""
添加页面
:param request:
:return:
"""
model_form_cls = self.get_model_form_class()
if ‘GET‘ == request.method:
# 返回对应的添加页面
form = model_form_cls()
return render(request,‘arya/add_view.html‘,{‘form‘:form})
else:
# 保存
form = model_form_cls(data=request.POST)
if form.is_valid():
form.save()
# 获取反向生成URL，跳转回列表页面
return redirect(self.list_url_with_params)
return render(request,‘arya/add_view.html‘,{‘form‘:form})
def delete_view(self, request, uid):
"""
删除页面
:param request:
:param uid:
:return:
"""
obj = self.model.objects.filter(id=uid).first()
if not obj:
return redirect(self.reverse_list_url)
if ‘GET‘ == request.method:
return render(request,‘arya/delete_view.html‘)
else:
obj.delete()
return redirect(self.list_url_with_params)
def change_view(self, request, uid):
"""
编辑页面
:param request:
:param uid:
:return:
"""
obj = self.model.objects.filter(id=uid).first()
if not obj:
return redirect(self.reverse_list_url)
model_form_cls = self.get_model_form_class()
if ‘GET‘ == request.method:
# 在input框里显示原来的值
form = model_form_cls(instance=obj)
return render(request,‘arya/change_view.html‘,{‘form‘:form})
else:
# 更新某个实例
form = model_form_cls(instance=obj,data=request.POST)
if form.is_valid():
form.save()
return redirect(self.list_url_with_params)
return render(request, ‘arya/change_view.html‘, {‘form‘: form})
# 反向生成url相关
@property
def back_url_param(self):
‘‘‘反向生成base_url之外的其他参数，用于保留之前的操作‘‘‘
query = QueryDict(mutable=True)
if self.request.GET:
"""
self.request.GET <QueryDict: {‘gender‘: [‘1‘], ‘course‘: [‘1‘, ‘2‘]}>
self.request.GET.urlencode() gender=1&course=1&course=2
query.urlencode() _change_filter=gender%3D1%26course%3D1%26course%3D2
对应的编辑按钮的地址： /arya/crm/customer/obj.id/change/?_change_filter=gender%3D1%26course%3D1%26course%3D2
"""
query[self.change_filter_name] = self.request.GET.urlencode() # gender=2&course=2&course=1
return query.urlencode()
def reverse_del_url(self, pk):
‘‘‘反向生成删除按钮对应的基础URL（不带额外参数的），需要传入obj的id‘‘‘
base_del_url = reverse(viewname=‘{0}:{1}_{2}_delete‘.format(self.arya_site.namespace, self.app_label, self.model_name),args=(pk,))
return base_del_url
def reverse_edit_url(self, pk):
‘‘‘反向生成编辑按钮对应的基础URL（不带额外参数的），需要传入obj的id‘‘‘
base_edit_url = reverse(viewname=‘{0}:{1}_{2}_change‘.format(self.arya_site.namespace, self.app_label, self.model_name),args=(pk,))
return base_edit_url
@property
def reverse_add_url(self):
‘‘‘反向生成添加按钮对应的基础URL（不带额外参数的）‘‘‘
base_add_url = reverse(viewname=‘{0}:{1}_{2}_add‘.format(self.arya_site.namespace, self.app_label, self.model_name))
return base_add_url
@property
def reverse_list_url(self):
‘‘‘反向生成列表页面对应的基础URL（不带额外参数的）‘‘‘
base_list_url = reverse(viewname=‘{0}:{1}_{2}_list‘.format(self.arya_site.namespace, self.app_label, self.model_name))
return base_list_url
@property
def list_url_with_params(self):
‘‘‘反向生成列表页面对应的URL（带了之前用户操作的一些参数）‘‘‘
base_url = self.reverse_list_url
query = self.request.GET.get(self.change_filter_name)
return "{0}?{1}".format(base_url, query if query else "")
@property
def add_url_params(self):
base_url = self.reverse_add_url
if self.request.GET:
return base_url
else:
query = QueryDict(mutable=True)
query[self.change_filter_name] = self.request.GET.urlencode()
return "{0}?{1}".format(base_url, query.urlencode())
class AryaSite(object):
def __init__(self, name=‘arya‘):
self.name = name
self.namespace = name
self._registy = {}
def register(self,class_name,config_class):
self._registy[class_name] = config_class(class_name,self)
def get_urls(self):
urlpatterns = [
url(r‘^login/$‘, self.login),
url(r‘^logout/$‘, self.logout),
]
for model, config_class in self._registy.items():
pattern = r‘^{0}/{1}/‘.format(model._meta.app_label, model._meta.model_name)
urlpatterns.append(url(pattern, config_class.urls))
# return urlpatterns,None,None
# 指定名称空间名字为 arya
return urlpatterns
@property
def urls(self):
return self.get_urls(),self.name,self.namespace
def login(self, request):
return HttpResponse("登录页面")
def logout(self, request):
return HttpResponse("登出页面")
# 基于Python文件导入特性实现的单例模式
site = AryaSite()
arya/apps.py
from django.apps import AppConfig
from django.utils.module_loading import autodiscover_modules
from django.contrib.admin.sites import site
class AryaConfig(AppConfig):
name = ‘arya‘
def ready(self):
autodiscover_modules(‘arya‘, register_to=site)
crm/models.py里的顾客model
class Customer(models.Model):
"""
客户表
"""
qq = models.CharField(verbose_name=‘qq‘, max_length=64, unique=True, help_text=‘QQ号必须唯一‘)
name = models.CharField(verbose_name=‘学生姓名‘, max_length=16)
gender_choices = ((1, ‘男‘), (2, ‘女‘))
gender = models.SmallIntegerField(verbose_name=‘性别‘, choices=gender_choices)
education_choices = (
(1, ‘重点大学‘),
(2, ‘普通本科‘),
(3, ‘独立院校‘),
(4, ‘民办本科‘),
(5, ‘大专‘),
(6, ‘民办专科‘),
(7, ‘高中‘),
(8, ‘其他‘)
)
education = models.IntegerField(verbose_name=‘学历‘, choices=education_choices, blank=True, null=True, )
graduation_school = models.CharField(verbose_name=‘毕业学校‘, max_length=64, blank=True, null=True)
major = models.CharField(verbose_name=‘所学专业‘, max_length=64, blank=True, null=True)
experience_choices = [
(1, ‘在校生‘),
(2, ‘应届毕业‘),
(3, ‘半年以内‘),
(4, ‘半年至一年‘),
(5, ‘一年至三年‘),
(6, ‘三年至五年‘),
(7, ‘五年以上‘),
]
experience = models.IntegerField(verbose_name=‘工作经验‘, blank=True, null=True, choices=experience_choices)
work_status_choices = [
(1, ‘在职‘),
(2, ‘无业‘)
]
work_status = models.IntegerField(verbose_name="职业状态", choices=work_status_choices, default=1, blank=True,
null=True)
company = models.CharField(verbose_name="目前就职公司", max_length=64, blank=True, null=True)
salary = models.CharField(verbose_name="当前薪资", max_length=64, blank=True, null=True)
source_choices = [
(1, "qq群"),
(2, "内部转介绍"),
(3, "官方网站"),
(4, "百度推广"),
(5, "360推广"),
(6, "搜狗推广"),
(7, "腾讯课堂"),
(8, "广点通"),
(9, "高校宣讲"),
(10, "渠道代理"),
(11, "51cto"),
(12, "智汇推"),
(13, "网盟"),
(14, "DSP"),
(15, "SEO"),
(16, "其它"),
]
source = models.SmallIntegerField(‘客户来源‘, choices=source_choices, default=1)
referral_from = models.ForeignKey(
‘self‘,
blank=True,
null=True,
verbose_name="转介绍自学员",
help_text="若此客户是转介绍自内部学员,请在此处选择内部学员姓名",
related_name="internal_referral"
)
course = models.ManyToManyField(verbose_name="咨询课程", to="Course")
status_choices = [
(1, "已报名"),
(2, "未报名")
]
status = models.IntegerField(
verbose_name="状态",
choices=status_choices,
default=2,
help_text=u"选择客户此时的状态"
)
consultant = models.ForeignKey(verbose_name="课程顾问", to=‘UserInfo‘, related_name=‘consultant‘)
date = models.DateField(verbose_name="咨询日期", auto_now_add=True)
last_consult_date = models.DateField(verbose_name="最后跟进日期", auto_now_add=True)
def __str__(self):
return "姓名:{0},QQ:{1}".format(self.name, self.qq, )
crm/arya.py里顾客部分
from arya.service import arya
from . import models
from django.forms import ModelForm,fields
from django.forms import widgets as form_widgets
from django.utils.safestring import mark_safe
from django.shortcuts import HttpResponse,render,redirect
from django.db.models import Q
class CustomerModelForm(ModelForm):
# 也可以自己在这里添加一个字段
# phone = fields.CharField()
# city = fields.ChoiceField(choices=[(1,"北京"),(2,"上海"),(3,"深圳")])
# 注意：这里扩展的字段名如果和 models.Customer 里面的字段名相同就会覆盖 models.Customer的字段，否则则会添加一个新的字段
class Meta:
model = models.Customer
fields = ‘__all__‘
error_messages = {
‘qq‘:{
‘required‘:‘qq不能为空！‘,
},
‘name‘: {
‘required‘: ‘客户姓名不能为空！‘,
},
‘gender‘: {
‘required‘: ‘性别不能为空！‘,
},
‘source‘: {
‘required‘: ‘客户来源不能为空！‘,
},
‘course‘: {
‘required‘: ‘咨询的课程不能为空！‘,
},
‘status‘: {
‘required‘: ‘客户状态不能为空！‘,
},
‘consultant‘:{
‘required‘: ‘课程顾问不能为空！‘,
}
}
class CustomerConfig(PermissionConfig, arya.AryaConfig):
def show_gender(self, row=None, is_header=None):
if is_header:
return "性别"
# gender_choices = ((1, ‘男‘), (2, ‘女‘))
# gender = models.SmallIntegerField(verbose_name=‘性别‘, choices=gender_choices)
# obj.get_字段_display() 这个方法可以拿到 数字在元组里对应的描述
return row.get_gender_display()
def show_education(self, row=None, is_header=None):
if is_header:
return "学历"
# obj.get_字段_display() 这个方法可以拿到 数字在元组里对应的描述
return row.get_education_display()
def show_work_status(self, row=None, is_header=None):
if is_header:
return "职业状态"
# obj.get_字段_display() 这个方法可以拿到 数字在元组里对应的描述
return row.get_work_status_display()
def show_experience(self, row=None, is_header=None):
if is_header:
return "工作经验"
# obj.get_字段_display() 这个方法可以拿到 数字在元组里对应的描述
return row.get_experience_display()
def show_course(self, row=None, is_header=None):
if is_header:
return "咨询的课程"
tpl = "<span style=‘display:inline-block;padding:3px;margin:2px;border:1px solid #ddd;‘>{0}</span>"
course_obj_list = row.course.all()
courses = [tpl.format(course.name) for course in course_obj_list]
return mark_safe(‘ ‘.join(courses))
def show_record(self, row=None, is_header=None):
if is_header:
return "跟进记录"
return mark_safe("<a href=‘xxx/{0}‘>查看跟进记录</a>".format(row.id))
list_display = [‘qq‘,‘name‘,show_gender,show_course,‘consultant‘,show_record]
model_form_class = CustomerModelForm
# 定制批量删除的actions
def multi_delete(self, request):
item_list = request.POST.getlist(‘item_id‘)
# 注意：filter(id__in=item_list) 这样写就不用使用for循环了
self.model.objects.filter(id__in=item_list).delete()
multi_delete.text = "批量删除" # 可以这样赋值
actions = [multi_delete,]
# search_list = [
# {‘key‘: ‘qq__contains‘, ‘type‘: None},
# {‘key‘: ‘name__contains‘, ‘type‘: None},
# {‘key‘: ‘course__name__contains‘, ‘type‘: None},
# ]
search_list = [
{‘key‘: ‘qq‘, ‘type‘: None},
{‘key‘: ‘name‘, ‘type‘: None},
{‘key‘: ‘course__name‘, ‘type‘: None},
]
list_filter = [
arya.FilterOption(‘consultant‘, condition=Q(depart_id=1)),
arya.FilterOption(‘course‘, is_multi=True),
arya.FilterOption(‘gender‘),
]
arya.site.register(models.Customer, CustomerConfig)
rbac/arya.py里权限部分
from arya.service import arya
from . import models
from django.forms import ModelForm,fields,widgets
from django.urls.resolvers import RegexURLPattern
from crm.arya import PermissionConfig as PermissionControl
# 获取全部url
def get_all_url(patterns,prev,is_first=False, result=[]):
if is_first:
result.clear()
for item in patterns:
v = item._regex.strip("^$")
if isinstance(item, RegexURLPattern):
val = prev + v
result.append((val,val,))
# result.append(val)
else:
get_all_url(item.urlconf_name, prev + v)
return result
class PermissionModelForm(ModelForm):
# 也可以自己在这里添加扩展字段
# phone = fields.CharField()
# city = fields.ChoiceField(choices=[(1,"北京"),(2,"上海"),(3,"深圳")])
# city = fields.MultipleChoiceField(choices=[(1,"北京"),(2,"上海"),(3,"深圳")])
# 注意：这里扩展的字段名如果和 models.Customer 里面的字段名相同就会覆盖 models.Customer的字段，否则则会添加一个新的字段
url = fields.ChoiceField()
class Meta:
model = models.Permission
fields = ‘__all__‘
# fields = [‘title‘,‘url‘]
# exclude = [‘title‘]
error_messages = {
‘title‘:{
‘required‘:‘用户名不能为空！‘,
},
‘url‘: {
‘required‘: ‘密码不能为空！‘,
},
‘code‘: {
‘required‘: ‘密码不能为空！‘,
},
‘group‘: {
‘invalid‘: ‘邮箱格式不正确！‘,
},
}
# 也可以自定义前端标签样式
# widgets = {
# ‘username‘: form_widgets.Textarea(attrs={‘class‘: ‘c1‘})
# ‘username‘: form_widgets.Input(attrs={‘class‘: ‘some_class‘})
# }
def __init__(self, *args, **kwargs):
super(PermissionModelForm,self).__init__(*args, **kwargs)
from crm_rbac_arya.urls import urlpatterns
# 获取全部url，并以下拉框的形式显示在前端
# 也可以进一步把未加入权限的url列出来，就需要查一遍数据库过滤下。
self.fields[‘url‘].choices = get_all_url(urlpatterns, ‘/‘, True)
"""
# 在用Form的时候遇到过这个问题，即用户关联部门（外键关联）的时候：
# depart = fields.ChoiceField(choices=models.Department.objects.values_list(‘id‘,‘title‘))
# 如果按照上面方式写，那么如果在部门表新添加数据后，则在用户关联的时候是无法显示新添加的部门信息的！！！只有程序重启才能获得新添加的数据！
# 因为 depart 在 UserInfoForm 类里属于静态字段，在程序刚启动的时候会从上到下执行一遍，把当前数据加载到内存。
# 所以采用了 __init__() 方法，每次都去数据库拿最新的数据
手动挡：
depart = fields.ChoiceField()
def __init__(self, *args, **kwargs):
super(UserInfoForm,self).__init__(*args, **kwargs)
self.fields[‘depart‘].choices = models.Department.objects.values_list(‘id‘,‘title‘)
自动挡：
from django.forms.models import ModelChoiceField
depart = ModelChoiceField(queryset=models.Department.objects.all())
# 这种方式虽然简单，但是在前端<option value=pk>object</option>，即显示的是object，还依赖model里的 __str__方法。
上面说的是Form的问题，而ModelForm是Form和Model的结合体，也存在这个问题，所以这里也采用 __init__() 的方式
"""
class PermissionConfig(PermissionControl, arya.AryaConfig):
list_display = [‘title‘,‘url‘,‘group‘,]
# 定制添加权限页面
model_form_class = PermissionModelForm
arya.site.register(models.Permission, PermissionConfig)
rbac/middleware/rbac.py权限验证中间件
# 这是页面权限验证的中间件
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)
# 如果没有登录过就直接跳转到登录页面
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):
# 获取当前用户所具有的权限的代号列表，用于之后控制是否展示相关操作
request.permission_code_list = values[‘codes‘]
flag = True
break
if flag:
break
if not flag:
return HttpResponse("无权访问")
settings.py
"""
Django settings for crm_rbac_arya project.
Generated by ‘django-admin startproject‘ using Django 1.11.4.
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 = ‘6-s)^[email protected]&&k7po_7rvqi%c8%=#&4(f‘
# 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‘,
‘rbac.apps.RbacConfig‘,
‘arya.apps.AryaConfig‘,
‘crm.apps.CrmConfig‘,
]
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‘,
‘crm.middleware.login_required.UserAuthMiddleware‘,
‘rbac.middleware.rbac.RbacMiddleware‘,
]
ROOT_URLCONF = ‘crm_rbac_arya.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 = ‘crm_rbac_arya.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/‘
STATIC_ROOT = os.path.join(BASE_DIR, ‘statics‘)
#STATIC_ROOT = os.path.join(BASE_DIR, ‘rbac/static‘)
#STATIC_ROOT = os.path.join(BASE_DIR, ‘arya/static‘)
#STATICFILES_DIRS = (
# os.path.join(BASE_DIR,"common_static"),
# ‘/data/www/crm_rbac_arya/arya/static/‘,
#)
########################## Private config ##################################
PERMISSION_DICT = "permission_dict"
PERMISSION_MENU_LIST = "permission_menu_list"
URL_FORMAT = "^{0}$"
RBAC_LOGIN_URL = "/login/"
LOGIN_SESSION_KEY = "user_info"
VALID_URL_LIST = [
"^/login/$",
"^/admin.*",
"^/clear/$",
"^/static/*",
]
主模板
{% load static %}
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>新起点</title>
<link rel="Shortcut Icon" href="{% static ‘arya/img/header.png‘ %}"/>
<link rel="stylesheet" href="{% static ‘arya/plugin/layui/css/layui.css‘ %}">
{% block css %} {% endblock %}
</head>
<body class="layui-layout-body">
<div class="layui-layout layui-layout-admin">
<div class="layui-header">
<div class="layui-logo">在线教育CRM</div>
<!-- 头部区域（可配合layui已有的水平导航） -->
<ul class="layui-nav layui-layout-left">
<li class="layui-nav-item"><a href="">虚拟化</a></li>
<li class="layui-nav-item"><a href="">大数据</a></li>
<li class="layui-nav-item"><a href="">图像识别</a></li>
<li class="layui-nav-item">
<a href="javascript:;">其它方向</a>
<dl class="layui-nav-child">
<dd><a href="">邮件管理</a></dd>
<dd><a href="">消息管理</a></dd>
<dd><a href="">授权管理</a></dd>
</dl>
</li>
</ul>
<ul class="layui-nav layui-layout-right">
<li class="layui-nav-item">
<a href="javascript:;">
<img src="{% static ‘arya/img/avatar.jpg‘ %}" class="layui-nav-img">
standby
</a>
<dl class="layui-nav-child">
<dd><a href="">基本资料</a></dd>
<dd><a href="">安全设置</a></dd>
</dl>
</li>
<li class="layui-nav-item"><a href="/clear/">退出</a></li>
</ul>
</div>
{% load menu_gennerator %}
<div class="layui-side layui-bg-black">
<div class="layui-side-scroll">
<!-- 左侧导航区域（可配合layui已有的垂直导航） -->
<div class="left_menu">
{% menu_show request %}
</div>
</div>
</div>
<div class="layui-body">
<!-- 内容主体区域 -->
<div style="padding: 15px;">
{% block content %} {% endblock %}
</div>
</div>
<div class="layui-footer" style="text-align: center;">
<!-- 底部固定区域 -->
[email protected]<a href="http://www.cnblogs.com/standby/" target="_blank">71standby</a>
</div>
</div>
<script src="{% static ‘arya/plugin/jquery/js/jquery-3.2.1.js‘ %}"></script>
<script src="{% static ‘arya/plugin/layui/layui.all.js‘ %}"></script>
<script src="{% static ‘rbac/js/rbac_layui.js‘ %}"></script>
{% block js %} {% endblock %}
<script>
;!function () {
//无需再执行layui.use()方法加载模块，直接使用即可
var form = layui.form
, layer = layui.layer;
//…
}();
</script>
</body>
</html>
列表页面模板
{% extends "arya/layout.html" %}
{% load static %}
{% block css %}
<link rel="stylesheet" href="{% static ‘arya/plugin/bootstrap/css/bootstrap.css‘ %}">
<link rel="stylesheet" href="{% static ‘arya/css/filter.css‘ %}">
<link rel="stylesheet" href="{% static ‘arya/css/option.css‘ %}">
{% endblock %}
{% block content %}
<div class="breadcrumb">
<span class="layui-breadcrumb">
<a href="/index/">首页</a>
<a href="" class="breadcrumb_menu_title"></a>
<a href="" class="breadcrumb_menu_item"><cite></cite></a>
</span>
</div>
<div>
<!-- 组合筛选 -->
{% if cl.list_filter %}
<div class="comb-search">
{% for row in cl.gen_list_filter %}
<div class="row">
{% for col in row %}
{{ col }}
{% endfor %}
</div>
{% endfor %}
</div>
{% endif %}
<!-- 模糊搜索 -->
{% if cl.search_list %}
<div class="search_option">
<form action="" method="get">
<input class="form-control" id="key_input" name="{{ cl.search_attr.name }}" value="{{ cl.search_attr.value }}" type="text" placeholder="请输入关键字..." />
<button class="btn btn-success">
<span class="glyphicon glyphicon-search"></span>
</button>
</form>
</div>
{% endif %}
<!-- 模糊搜索方式2 -->
{# <div class="search_option">#}
{# {% if cl.search_list %}#}
{# <form method="get">#}
{# <input type="text" name="keyword" id="key_input" class="form-control" placeholder="请输入搜索关键字..." value="{{ cl.keyword }}">#}
{# <input type="submit" value="搜索" class="btn btn-primary">#}
{# </form>#}
{# {% endif %}#}
{# </div>#}
<!-- 添加button -->
{# {% if cl.show_add %}#}
{# {{ cl.add_html }}#}
{# {% endif %}#}
<!-- 定制Action和表格数据 -->
<form method="post">
{% csrf_token %}
{% if cl.actions %}
<div class="multi_option">
<select name="select_action" class="form-control" style="width: 300px; display: inline-block">
{% for action in cl.action_options %}
<option value="{{ action.value }}">{{ action.text }}</option>
{% endfor %}
</select>
<input type="submit" value="执行" class="btn btn-success">
</div>
{% endif %}
<table class="table table-striped table-hover">
<thead>
<tr>
{% for val in cl.table_header %}
<th>{{ val }}</th>
{% endfor %}
</tr>
</thead>
<tbody>
{% for item in cl.table_body %}
<tr>
{% for col in item %}
<td>{{ col }}</td>
{% endfor %}
</tr>
{% endfor %}
</tbody>
</table>
</form>
<div style="text-align: right">
<ul class="pagination">
{{ cl.page_html|safe }}
</ul>
</div>
</div>
{% endblock %}
{% block js %}
<script src="{% static ‘arya/plugin/bootstrap/js/bootstrap.js‘ %}"></script>
<script src="{% static ‘arya/js/breadcrumb.js‘ %}"></script>
{% endblock %}
uwsgi.ini
# uwsig使用配置文件启动 [uwsgi] # 项目目录 chdir=/data/www/crm_rbac_arya/ # 指定项目的application module=crm_rbac_arya.wsgi:application # 指定sock的文件路径 socket=/data/www/crm_rbac_arya/bin/uwsgi.sock # 进程个数 workers=6 pidfile=/data/www/crm_rbac_arya/bin/uwsgi.pid # 指定IP端口 http=ip:port # 指定静态文件 static-map=/static=/data/www/crm_rbac_arya/statics # 启动uwsgi的用户名和用户组 uid=root gid=root # 启用主进程 master=true # 自动移除unix Socket和pid文件当服务停止的时候 vacuum=true # 序列化接受的内容，如果可能的话 thunder-lock=true # 启用线程 enable-threads=true # 设置自中断时间 harakiri=30 # 设置缓冲 post-buffering=4096 # 设置日志目录 daemonize=/data/www/crm_rbac_arya/bin/uwsgi.log
crm.conf
server {
listen 80;
access_log logs/crm.log main;
root /data/www/crm_rbac_arya;
location /static {
alias /data/www/crm_rbac_arya/statics;
}
location / {
include uwsgi_params;
# uwsgi_pass 127.0.0.1:80;
uwsgi_pass unix:/data/www/crm_rbac_arya/bin/uwsgi.sock;
}
}
成果截图：
并且针对修改和删除操作，使用QueryDict(mutable=True)对象实例记录操作前的参数，保留了之前的操作步骤。
扩展
QueryDict的mutable参数 ：
更多请参考官方文档：Django的Request 对象和Response 对象
遗留的bug
如果先按照关键字搜索， 然后翻页， 然后再做组合筛选的话，由于page参数停留在翻页之后所以会导致组合筛选的时候可能会搜索不到。
项目源码已托管至 Github
原文地址：https://www.cnblogs.com/standby/p/8443212.html
时间： 2024-11-11 20:44:37