24.stark组件所有
admin组件
admin参考:https://www.cnblogs.com/yuanchenqi/articles/8323452.htmljavascript
model参考:https://www.cnblogs.com/yuanchenqi/articles/8963244.htmlcss
# admin的参数，以及自定义显示
from django.contrib import admin
from app01.models import *
class BookConfig(admin.ModelAdmin):
list_display = ["nid", "title", "price", "publishDate"] # 定制显示那些列，不能放多对多
list_display_links = ["title"] # 查看连接
# list_filter = ["title", "publishDate", "authors"] # 过滤
list_editable = ["price"] # 编辑
search_fields = ["title", "price"] # 搜索字段
# date_hierarchy = "publishDate"
fields = ("title",) # 限定现实的字段
exclude = ("",) # 不显示哪些字段，和fields相反
ordering = ("nid",) # 排序
def patch_action(self, request, queryset):
queryset.update(publishDate="2019-11-22")
patch_action.short_description = "批量初始化"
actions = [patch_action]
admin.site.register(Book, BookConfig)
admin.site.register(Author)
admin.site.register(AuthorDetail)
admin.site.register(Publish)
url使用：
# url的嵌套
from django.contrib import admin
from django.http import HttpResponse
from django.urls import path
def yuan(request):
return HttpResponse("ok")
def test01(request):
return HttpResponse("test01")
from starkapp.service.stark import site
urlpatterns = [
path('admin/', admin.site.urls),
url(r"^stark/", site.urls),
url("^yuan/", ([
url(r"^test01/", ([
url(r"^test001/", test01),
url(r"^test002/", test01),
], None, None),
url(r"^test02/", test01),
url(r"^test03/", test01),
], None, None)) # 第一个是namespace， 第二个是app_name,
]
单例模式：
# 单例模式 （设计模式全部语言都有）
单例类：就是只容许类生成一个对象，全部的修改对这一个对象的修改，保证数据的统一性
class Singleton(object):
_instance = None
def __new__(cls, *args, **kwargs):
if not cls._instance:
cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
return cls._instance
class MyClass(Singleton):
a = 1
one = MyClass()
one.a = 2
two = MyClass()
print(two.a)
python天生就只吃单例模式的，为何？
写一个类，实例化一个对象，将其放入一个包中，其余地方使用的时候直接从这个里面导入（这个时候会生成一个.pyc,以后的每次使用这个对象都是从这个.pyc中取，能够理解为缓存），每次导入到的都是同一个对象，（内存地址相同）。
### admin源码：
# 使用
path('admin/', admin.site.urls),
admin.site.register(Book, BookConfig)
def register(self, model_or_iterable, admin_class=None, **options)：
admin_class = admin_class or ModelAdmin
if isinstance(model_or_iterable, ModelBase):
model_or_iterable = [model_or_iterable]
self._registry[model] = admin_class(model, self)
1.注册admin.py
admin.site.register(Book, BookConfig)
def register(self, model_or_iterable, admin_class=None, **options)：
if not admin_class:
return admin_class=ModelAdmin
self._registry[model] = admin_class(model, self)
2.url设计
如何获取app名称和model名称
model._meta.app_label, model._meta.model_name
一次分发
def get_urls():
temp = []
for model, admin_class in admin.site._registry.items():
# url(r"app01/book/", )
temp.append(url(r"^%s/%s" %(model._meta.app_label, model._meta.model_name), yuan))
return temp
urlpatterns = [
path('admin/', admin.site.urls),
url(r"^stark/", site.urls),
url("^yuan/", (get_urls(), None, None))
]
二次分发：
def add(request,):
return HttpResponse("add")
def delete(request,id):
return HttpResponse("delete")
def change(request,id):
return HttpResponse("change")
def list_view(request,):
return HttpResponse("list_view")
def get_urls_2():
temp = []
temp.append(url(r"^add/", add))
temp.append(url(r"^(\d+)/delete/", delete)) # 函数本身定义
temp.append(url(r"^(\d+)/change/", change))
temp.append(url(r"^", list_view))
return temp
def get_urls():
temp = []
for model, admin_class in admin.site._registry.items():
temp.append(url(r"^%s/%s/" %(model._meta.app_label, model._meta.model_name), (get_urls_2(), None, None)))
return temp
urlpatterns = [
path('admin/', admin.site.urls),
url(r"^stark/", site.urls),
url("^yuan/", (get_urls(), None, None))
]
stark组件：
查看页面： 表头 表数据 search action
直接给出参考博客网址：http://www.javashuo.com/article/p-tufkhsym-hr.htmlhtml
看不懂的话这里有视频：https://www.bilibili.com/video/av58974459?from=search&seid=4711332916584502531java
这篇博客开始部分很差开头，我把开头整理一下，关于老男孩的项目有了规律，就是你发现你如今看的项目没有视频，那么多是前几期教的，直接去B站搜这个项目名称相关的视频，就能够找，我是直接看博客，看到多级过滤的时候看不下去了才发现的，第九期的视频里面有不少好的项目能够看。python
基础版本：
第一步：建立一个项目，去包里面最少有两个app（一个是stark组件的，一个是其余用来测试的stark组件是否产生工做的），我建立了app01和stark组件的app(starkapp)名字能够任意起只要你能找到就行
第二步：首先settings中注册：
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'starkapp.apps.StarkappConfig',
'app01.apps.App01Config',
]
第三步：
starkapp下面建立一个service的包，记住是包，不是的话可能出现问题。同时建立一个stark.py文件
第四步：
在stark.py中写咱们的程序
from django.conf.urls import url
from django.http import HttpResponse
from django.shortcuts import render
class ModelStark(object):
list_display = []
def __init__(self, model, site):
self.model = model # 当前用户访问的模型表
self.site = site
# 记住这个视图函数，若是下面的get_url_2中你没有添加它的话，你根本看不到只记得页面
def change_list(self, request):
ret = self.model.objects.all()
return render(request, "index.html", locals())
def add(self, request):
return HttpResponse("add")
def delete(self, request, id):
return HttpResponse("delete")
def change(self, request, id):
return HttpResponse("change")
# def list_view(self, request):
# return HttpResponse("list_view")
def get_urls_2(self):
temp = []
model_name = self.model._meta.model_name # 当前模型表
app_label = self.model._meta.app_label # 当前app
temp.append(url(r"^add/$", self.add, name="%s_%s_add" % (app_label, model_name)))
temp.append(url(r"^(\d+)/delete/$", self.delete, name="%s_%s_delete" % (app_label, model_name)))
temp.append(url(r"^(\d+)/change/$", self.change, name="%s_%s_change" % (app_label, model_name)))
temp.append(url(r"^$", self.change_list, name="%s_%s_list" % (app_label, model_name)))
return temp
@property
def urls_2(self):
return self.get_urls_2(), None, None # [], None, None
class StarkSite(object):
def __init__(self):
self._registry = {}
def register(self, model, stark_class=None, **options):
if not stark_class:
# 若是注册的时候没有自定义配置类，执行
stark_class = ModelStark # 配置类
# 降配置类对象加到_registry字典中，创建模型类
self._registry[model] = stark_class(model, self) # _registry={'model':stark_class(model)}
def get_urls(self):
"""构造一层url"""
temp = []
for model, stark_class_obj in self._registry.items():
# model:一个模型表
# stark_class_obj:当前模型表相应的配置类对象
model_name = model._meta.model_name
app_label = model._meta.app_label
# 分发增删改查url
temp.append(url(r"^%s/%s/" % (app_label, model_name), stark_class_obj.urls_2))
"""
path('app01/user/',UserConfig(User,site).urls2),
path('app01/book/',ModelStark(Book,site).urls2),
"""
return temp
@property
def urls(self):
return self.get_urls(), None, None
site = StarkSite() # 生成一个单例模式的对象
第五步：
有没有发现本身的项目中urls没配stark app的路由，如今就去
from django.conf.urls import url
from django.contrib import admin
from django.urls import path
from starkapp.service.stark import site
urlpatterns = [
path('admin/', admin.site.urls),
url(r"^stark/", site.urls), # 有没有发现这个site是咱们本身写的呢个单例模式的对象，没错就是它
]
第六步： 咱们要是用stark组件为咱们的模型，建立增删改查页面，咱们是否是应该去本身的项目app01了
```python 要是用这个模块咱们就须要建立一个stark1.py（这个名字能够改，看完你就知道咋改了）在本身得项目里面，内容是这样的：
from starkapp.service.stark import site, ModelStark
from django.utils.safestring import mark_safe
from django.urls import reverse
from .models import *jquery
自定义配置类
class BookStark(ModelStark):
passgit
list_display = ["nid", "title", "price", edit, delete]
site.register(Book, BookStark) # 初始的你只须要把BookStark类定义了，使用咱们site注册了就行，里面的内容能够直接passgithub
```html
第七步：
前段的页面也给你：
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta http-equiv="x-ua-compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Title</title>
<link rel="stylesheet" href="/static/bootstrap-3.3.4/css/bootstrap.min.css">
</head>
<body>
<h3>数据展现</h3>
<div class="container">
<div class="row">
<div class="col-md-8">
<table class="table table-striped table-hover">
<heade>
<tr>
<td>id</td>
<td>标题</td>
<td>价格</td>
</tr>
</heade>
{% for obj in ret %}
<tr>
<td>{{ obj.nid }}</td>
<td>{{ obj.title }}</td>
<td>{{ obj.price }}</td>
</tr>
{% endfor %}
</table>
</div>
</div>
</div>
</body>
</html>
第八步：
有没有发现，咱们什么都写了，可是咋么让django找到我第六步建立的stark1.py呢？
如今回到stark组件app下面，在apps.py里面写下面的代码：
from django.apps import AppConfig
from django.utils.module_loading import autodiscover_modules
class StarkappConfig(AppConfig):
name = 'starkapp'
# 程序启动时，扫描app下得指定文件（stark1.py）并执行
def ready(self):
autodiscover_modules('stark1') # 这句的做用就是让django找到咱们的stark1。py模块，执行里面的site.register()方法，进行初始化路由。简化版的在这里完成了，已经能够看到页面了，我须要下次的写高级一点的。
中级版本：
能够将app01.stark1.py改为
# 自定义配置类
class BookStark(ModelStark):
def edit(self, obj=None, is_header=False):
if is_header:
return "操做"
return mark_safe("<a href='/stark/app01/book/%s/change'>编辑</a>" % obj.pk)
def delete(self, obj=None, is_header=False):
if is_header:
return "操做"
return mark_safe("<a href='/stark/app01/book/%s/delete'>删除</a>" % obj.pk)
list_display = ["nid", "title", "price", edit, delete]
# 补充
field_obj = Book._meta.get_field("title") #就是一个charField字段的对象
field_obj.max_length # 最大长度
starkapp.service.stark.py改为这样，你只须要改着一个函数的内容
def change_list(self, request):
header_list = []
for field in self.list_display:
if callable(field):
val = field(self, is_header=True)
header_list.append(val)
else:
field_obj = self.model._meta.get_field(field)
header_list.append(field_obj.verbose_name)
data_list = self.model.objects.all()
new_data_list = []
for obj in data_list:
temp = []
for field in self.list_display:
if callable(field):
val = field(self, obj)
else:
val = getattr(obj, field)
temp.append(val)
new_data_list.append(temp)
return render(request, "index.html", locals())
index.html改为这样
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta http-equiv="x-ua-compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Title</title>
<link rel="stylesheet" href="/static/bootstrap-3.3.4/css/bootstrap.min.css">
</head>
<body>
<h3>数据展现</h3>
<div class="container">
<div class="row">
<div class="col-md-8">
<table class="table table-striped table-hover">
<thead>
<tr>
{% for foo in header_list %}
<td>{{ foo }}</td>
{% endfor %}
</tr>
</thead>
<tbody>
{% for data in new_data_list %}
<tr>
{% for item in data %}
<td>{{ item }}</td>
{% endfor %}
</tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
</div>
</body>
</html>
而后你的页面就变成了下面这同样：接下来你也想到只要在starkapp.service.satrk下的modelstark类中将，那些函数补全你能够删除和编辑了。
web
如今我感受前面缺乏选择框：
# 自定义配置类
class BookStark(ModelStark):
def edit(self, obj=None, is_header=False):
if is_header:
return "操做"
return mark_safe("<a href='/stark/app01/book/%s/change'>编辑</a>" % obj.pk)
def delete(self, obj=None, is_header=False):
if is_header:
return "操做"
return mark_safe("<a href='/stark/app01/book/%s/delete'>删除</a>" % obj.pk)
# 加了这么一行
def select(self, obj=None, is_header=None):
if is_header:
return mark_safe("<input id='mutPut' type='checkbox'>")
return mark_safe("<input type='checkbox' value=%s>" % obj.pk)
list_display = [select, "nid", "title", "price", edit, delete]
而后加上是加上了，可是没有事件： index页面引入jquery，加上下面一句就有了
<script>
$("#mutPut").click(function () {
if ($(this).prop("checked")){
$("tbody [type='checkbox']").prop("checked", true)
}else{
$("tbody [type='checkbox']").prop("checked", false)
}
})
</script>
# 可是如今我感受，编辑删除以及选择的函数中的href中的url都是写死的，其余的模型使用不了，因此咱们是用反向解析,这样就能够适用全部的模型了，同时为了每一个模型都须要这三个方法，因此将这三个方法移入modelstark中。
# 展现编辑链接
def edit_link(self, obj=None, is_header=False):
if is_header:
return "操做"
name = "{}_{}_change".format(self.app_label, self.model_name)
return mark_safe("<a href=%s>编辑</a>" % reverse(name, args=(obj.pk,)))
# 本来都是在用户本身的配置类中写，可是如今写入modelStark中是由于，是由于每一个表可能都能用到，减小代码重复
def delete_link(self, obj=None, is_header=False):
if is_header:
return "操做"
name = "{}_{}_delete".format(self.app_label, self.model_name)
return mark_safe("<a href=%s>删除</a>" % reverse(name, args=(obj.pk,)))
def select_btn(self, obj=None, is_header=None):
if is_header:
return mark_safe("<input id='mutPut' type='checkbox'>")
return mark_safe("<input type='checkbox' value=%s name='_selected_action'>" % obj.pk)
# 组成新的list_display
@property
def get_list_display(self):
new_list_display = []
new_list_display.extend(self.list_display)
if not self.list_display_link:
new_list_display.append(ModelStark.edit_link)
new_list_display.append(ModelStark.delete_link)
new_list_display.insert(0, ModelStark.select_btn)
return new_list_display
# 相应的下面的路由也须要加上别名，咱们是用app_name和mdoel——name,以及要执行的操做三者放一块儿组成每一个模型惟一的别名
def get_urls_2(self):
temp = []
model_name = self.model._meta.model_name # 当前模型表
app_label = self.model._meta.app_label # 当前app
temp.append(url(r"^add/$", self.add, name="%s_%s_add" % (app_label, model_name)))
temp.append(url(r"^(\d+)/delete/$", self.delete, name="%s_%s_delete" % (app_label, model_name)))
temp.append(url(r"^(\d+)/change/$", self.change, name="%s_%s_change" % (app_label, model_name)))
temp.append(url(r"^$", self.change_list, name="%s_%s_list" % (app_label, model_name)))
return temp
def change_list(self, request):
中list_display = self.get_list_display() 记得改
list_display_link:
# django中的admin有list_display咱们已经实现了，如今咱们来实现list_display_link
BookStrak中加一句
class BookStark(ModelStark):
list_display = ["nid", "title", "price"]
list_display_link = ["nid", "title"]
# 以后修改modelStark中的
@property
def get_list_display(self):
new_list_display = []
new_list_display.extend(self.list_display)
# 若是设置了list_display_link就把编辑删除
if not self.list_display_link:
new_list_display.append(ModelStark.edit_link)
new_list_display.append(ModelStark.delete_link)
new_list_display.insert(0, ModelStark.select_btn)
return new_list_display
# 最后将chang_list中的获取数据的代码改动一下
data_list = self.data_list
new_data_list = []
# 这里才是咱们数据库中的数据
for obj in data_list:
temp = []
for field in self.config.get_list_display:
if callable(field):
val = field(self.config, obj)
else:
val = getattr(obj, field)
# 若是有list_display_link，就把他编程a标签
if field in self.config.list_display_link:
val = mark_safe("<a href=%s>%s</a>" % (self.config.get_edit_url(obj), val))
temp.append(val)
new_data_list.append(temp)
add:
# 发现admin还有添加数据的操做，咱们也须要实现,使用modelForm
# 其余的组件咱们慢慢实现
- ModelStark中加一个函数
# 使用modelform组件
def get_modelfrom_class(self):
class ModelFormClass(ModelForm):
class Meta:
model = self.model
fields = "__all__"
if not self.get_modelfrom_class:
return ModelFormClass
else:
return self.model_form_class
- 完善add添加函数的逻辑
def add(self, request):
form = self.model_form_class
if request.method == "GET":
return render(request, "add_index.html", locals())
else:
data = request.POST
form = form(data=data)
if form.is_valid():
form.save()
return redirect(self.get_list_url())
else:
return render(request, "add_index.html", locals())
# add_index.html页面
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta http-equiv="x-ua-compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Title</title>
<link rel="stylesheet" href="/static/bootstrap-3.3.4/css/bootstrap.min.css">
<script type="application/javascript" src="/static/jquery.js"></script>
<style>
.form-group input{
display: block;
width: 100%;
height: 34px;
padding: 6px 12px;
font-size: 14px;
line-height: 1.42857143;
color: #555;
background-color: #fff;
background-image: none;
border: 1px solid #ccc;
border-radius: 4px;
-webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.075);
box-shadow: inset 0 1px 1px rgba(0,0,0,.075);
-webkit-transition: border-color ease-in-out .15s,-webkit-box-shadow ease-in-out .15s;
-o-transition: border-color ease-in-out .15s,box-shadow ease-in-out .15s;
transition: border-color ease-in-out .15s,box-shadow ease-in-out .15s;
}
.error{
color: red;
}
</style>
</head>
<body>
<h3>添加数据</h3>
{% include "add_conponent.html" %}
</body>
</html>
# 使用模板循环使用
<div class="container">
<div class="row">
<div class="col-md-6">
<form action="" method="post" novalidate>
{% csrf_token %}
{% for field in form %}
<div class="form-group">
<label for="">{{ field.label }}:</label>
<div>
{{ field }}
<span class="error pull-right">
{{ field.errors.0 }}
</span>
</div>
</div>
{% endfor %}
<p><input type="submit" class="btn btn-primary"></p>
</form>
</div>
</div>
</div>
### delete&chanage:
# 添加页面写完了，下来再咱们继续完成编辑和删除页面的逻辑，视图中的函数modelStark中
def get_delete_url(self, obj):
delete_url = "{}_{}_delete".format(self.app_label, self.model_name)
return delete_url
def get_add_url(self):
add_url = "{}_{}_add".format(self.app_label, self.model_name)
return add_url
def get_list_url(self):
list_url = "{}_{}_list".format(self.app_label, self.model_name)
return list_url
# 上面三个就是为了获取反向解析的name名称
def delete(self, request, id):
del_obj = self.model.objects.filter(nid=id).first()
if request.method == "GET":
list_url = self.get_list_url()
# 为何要确认页面，是由于重要数据须要二次确认，防止误删
return render(request, "del_index.html", locals())
else:
del_obj.delete()
return redirect(self.get_list_url())
# 编辑页面
def change(self, request, id):
form = self.get_modelfrom_class()
obj = self.model.objects.filter(pk=id).first()
if request.method == "GET":
form = form(instance=obj)
return render(request, "change_index.html", locals())
else:
form = form(data=request.POST, instance=obj)
if form.is_valid():
form.save()
return redirect(self.get_list_url())
else:
return render(request, "change_index.html", locals())
# 编辑的html页面代码：
# 由于代码和添加页面相似，因此讲代码整合，弄一个子组件
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta http-equiv="x-ua-compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Title</title>
<link rel="stylesheet" href="/static/bootstrap-3.3.4/css/bootstrap.min.css">
<script type="application/javascript" src="/static/jquery.js"></script>
<style>
.form-group input{
display: block;
width: 100%;
height: 34px;
padding: 6px 12px;
font-size: 14px;
line-height: 1.42857143;
color: #555;
background-color: #fff;
background-image: none;
border: 1px solid #ccc;
border-radius: 4px;
-webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.075);
box-shadow: inset 0 1px 1px rgba(0,0,0,.075);
-webkit-transition: border-color ease-in-out .15s,-webkit-box-shadow ease-in-out .15s;
-o-transition: border-color ease-in-out .15s,box-shadow ease-in-out .15s;
transition: border-color ease-in-out .15s,box-shadow ease-in-out .15s;
}
.error{
color: red;
}
</style>
</head>
<body>
<h3>编辑数据</h3>
{% include "add_conponent.html" %}
</body>
</html>
# add_conponent.html
<div class="container">
<div class="row">
<div class="col-md-6">
<form action="" method="post" novalidate>
{% csrf_token %}
{% for field in form %}
<div class="form-group">
<label for="">{{ field.label }}:</label>
<div>
{{ field }}
<span class="error pull-right">
{{ field.errors.0 }}
</span>
</div>
</div>
{% endfor %}
<p><input type="submit" class="btn btn-primary"></p>
</form>
</div>
</div>
</div>
# 刪除页面比较简单delete_index.html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta http-equiv="x-ua-compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>删除</title>
<link rel="stylesheet" href="/static/bootstrap-3.3.7/css/bootstrap.min.css">
<script src="/static/jquery-3.2.1.min.js"></script>
</head>
<body>
<h3>删除页面</h3>
<div>
<p>{{ del_obj }}</p>
</div>
<form action="" method="post">
{% csrf_token %}
<input type="submit" value="确认删除" class="btn btn-danger">
<a href="{% url list_url %}" class="btn btn-primary">取消</a>
</form>
</body>
</html>
分页：
# 这是本身写的一个分页器类，其中咱们有添加了一些参数
# params self.request.GET信息 主要是为了保存，请求的参数信息，好比你选了一堆的过滤条件,好比：
# http://localhost:8000/stark/app01/book/page=1&title=django，可是你的分页器中的路径是这样子的 http://localhost:8000/stark/app01/book/page=1，用户的条件title=django没有保留，那么问题来了，用户发现这样咱们次都要选择，你这网站很差用我不玩了，因此为了提升用户体验，咱们须要保留用户的筛选过滤条件，那么咱们就须要加一个参数params
class Pagination(object):
def __init__(self, current_page, all_count, base_url, params, per_page_num=4, pager_count=11):
"""
封装分页相关数据
:param current_page: 当前页
:param all_count: 数据库中的数据总条数
:param per_page_num: 每页显示的数据条数
:param base_url: 分页中显示的URL前缀
:param pager_count: 最多显示的页码个数
:param params: self.request.GET信息
"""
try:
current_page = int(current_page)
except Exception as e:
current_page = 1
if current_page <1:
current_page = 1
self.current_page = current_page
self.all_count = all_count
self.per_page_num = per_page_num
self.base_url = base_url
import copy
params = copy.deepcopy(params)
params._mutable = True
self.params = params
# 总页码
all_pager, tmp = divmod(all_count, per_page_num)
if tmp:
all_pager += 1
self.all_pager = all_pager
self.pager_count = pager_count
self.pager_count_half = int((pager_count - 1) / 2)
@property
def start(self):
return (self.current_page - 1) * self.per_page_num
@property
def end(self):
return self.current_page * self.per_page_num
def page_html(self):
# 若是总页码 < 11个：
if self.all_pager <= self.pager_count:
pager_start = 1
pager_end = self.all_pager + 1
# 总页码 > 11
else:
# 当前页若是<=页面上最多显示11/2个页码
if self.current_page <= self.pager_count_half:
pager_start = 1
pager_end = self.pager_count + 1
# 当前页大于5
else:
# 页码翻到最后
if (self.current_page + self.pager_count_half) > self.all_pager:
pager_end = self.all_pager + 1
pager_start = self.all_pager - self.pager_count + 1
else:
pager_start = self.current_page - self.pager_count_half
pager_end = self.current_page + self.pager_count_half + 1
page_html_list = []
# 这个地方就用到了，每次咱们把保留的参数所有拼接进入url中那么就没有问题了 # self.base_url:http://localhost:8000/stark/app01/book/
# self.params.urlencode(): ?page=1&title=django
self.params["page"] = 1
first_page = '<li><a href="%s?%s">首页</a></li>' % (self.base_url, self.params.urlencode(),)
page_html_list.append(first_page)
if self.current_page <= 1:
prev_page = '<li class="disabled"><a href="#">上一页</a></li>'
else:
self.params["page"] = self.current_page - 1
prev_page = '<li><a href="%s?%s">上一页</a></li>' % (self.base_url, self.params.urlencode(),)
page_html_list.append(prev_page)
for i in range(pager_start, pager_end):
self.params["page"] = i
if i == self.current_page:
temp = '<li class="active"><a href="%s?%s">%s</a></li>' % (self.base_url, self.params.urlencode(), i,)
else:
temp = '<li><a href="%s?%s">%s</a></li>' % (self.base_url, self.params.urlencode(), i,)
page_html_list.append(temp)
if self.current_page >= self.all_pager:
next_page = '<li class="disabled"><a href="#">下一页</a></li>'
else:
self.params["page"] = self.current_page + 1
next_page = '<li><a href="%s?%s">下一页</a></li>' % (self.base_url, self.params.urlencode(),)
page_html_list.append(next_page)
self.params["page"] = self.all_pager
last_page = '<li><a href="%s?%s">尾页</a></li>' % (self.base_url, self.params.urlencode(),)
page_html_list.append(last_page)
return ''.join(page_html_list)
分页组件直接在starkapp下面建一个util的包放进去就行了，目录结构是这样子的。
shell
而后再添加分页的时候返现modelstark组建中change_list函数下的代码是在是太多了，并且后面还须要继续添加，咱们整合一下。用一个类ChangeList来封装一下，其中的咱们主要是须要获取表头和表体的数据，因此将这两个代码各写一个函数。同时咱们将分页组件引入。
class ChangeList(object):
def __init__(self, config, request, queryset):
self.config = config
self.request = request
self.queryset = queryset
from starkapp.util.paginator import Pagination
current_page = request.GET.get("page")
all_count = self.queryset.count()
base_url = self.request.path_info
params = self.request.GET
paginator = Pagination(current_page, all_count, base_url, params)
data_list = self.queryset[paginator.start: paginator.end]
self.paginator = paginator
self.data_list = data_list
def get_header(self):
header_list = []
# 这里的代码是处理表头数据的
for field in self.config.get_list_display:
if callable(field):
val = field(self.config, is_header=True)
header_list.append(val)
else:
if field == "__str__":
header_list.append(self.config.model._meta.model_name.upper())
else:
field_obj = self.config.model._meta.get_field(field)
header_list.append(field_obj.verbose_name)
return header_list
def get_body(self):
data_list = self.data_list
new_data_list = []
# 这里才是咱们数据库中的数据
for obj in data_list:
temp = []
for field in self.config.get_list_display:
if callable(field):
val = field(self.config, obj)
else:
val = getattr(obj, field)
# 若是有list_display_link，就把他编程a标签
if field in self.config.list_display_link:
val = mark_safe("<a href=%s>%s</a>" % (reverse(self.config.get_edit_url(obj), args=(obj.pk,)), val))
temp.append(val)
new_data_list.append(temp)
return new_data_list
# modelstark类中的change_list函数进行简化， 这下是否是很简洁了，并且解耦也作好了
# 首页展现页面
def change_list(self, request):
self.request = request
queryset = self.model.objects.all（）
# 至于为何将self传过去，是由于changeList类中使用到了
cl = ChangeList(self, request, queryset)
return render(request, "index.html", locals())
search:
# modelstark中添加
@property
def get_search_condition(self):
from django.db.models import Q
search_condition = Q()
search_condition.connector = "or" # 设置关系为或
if self.search_fields: # ["title", "price"]
key_word = self.request.GET.get("q", None)
# 若是有值才添加，没有纸就直接返回空的Q()
self.key_word = key_word
if key_word:
for search_field in self.search_fields:
# 由于条件设置得是or因此这里才能够成立，若是是and，所有遍历加进去查询可能会出错
search_condition.children.append((search_field + "__contains", key_word))
return search_condition
# change_list改
# 首页展现页面
def change_list(self, request)：
self.request = request
add_url = self.get_add_url()
# search模糊查询
queryset = self.model.objects.filter(self.get_search_condition)
# filter模糊查询
queryset = queryset.filter(self.get_filter_condition)
cl = ChangeList(self, request, queryset)
return render(request, "index.html", locals())
# index.html改
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta http-equiv="x-ua-compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Title</title>
<link rel="stylesheet" href="/static/bootstrap-3.3.4/css/bootstrap.min.css">
<script type="application/javascript" src="/static/jquery.js"></script>
</head>
<body>
<h3>数据展现</h3>
<div class="container">
<div class="row">
<div class="col-md-8">
<!-添加-->
<a href="{% url add_url %}"><button class="btn btn-primary">添加</button></a>
<!-搜索-->
{% if cl.config.search_fields %}
<div class="pull-right form-group">
<form action="" method="get" class="form-inline">
<input type="text" class="form-control" name="q" value="{{ cl.config.key_word }}">
<input type="submit" class="btn btn-primary" value="search">
</form>
</div>
{% endif %}
<!-主题内容-->
<form action="" method="post">
{% csrf_token %}
<!-批量操做下拉框-->
<div>
<select class="form-control" name="action" id="" style="width: 200px;
margin: 5px 0; display: inline-block; vertical-align: -1px">
<option value="">------------</option>
{% for item in cl.handler_action %}
<option value="{{ item.name }}">{{ item.desc }}</option>
{% endfor %}
</select>
<button type="submit" class="btn btn-primary">Go</button>
</div>
<!-展现-->
<table class="table table-striped table-hover">
<thead>
<tr>
{% for foo in cl.get_header %}
<td>{{ foo }}</td>
{% endfor %}
</tr>
</thead>
<tbody>
{% for data in cl.get_body %}
<tr>
{% for item in data %}
<td>{{ item }}</td>
{% endfor %}
</tr>
{% endfor %}
</tbody>
</table>
</form>
<!-分页-->
<nav aria-label="Page navigation" class="pull-right">
<ul class="pagination">
{{ cl.paginator.page_html|safe }}
</ul>
</nav>
</div>
</div>
</div>
<script>
$("#mutPut").click(function () {
if ($(this).prop("checked")){
$("tbody [type='checkbox']").prop("checked", true)
}else{
$("tbody [type='checkbox']").prop("checked", false)
}
})
</script>
</body>
</html>
actions:
# modelstark中添加
@property
def get_filter_condition(self):
from django.db.models import Q
filter_condition = Q()
for field, val in self.request.GET.items():
if field in self.list_filter:
filter_condition.children.append((field, val))
return filter_condition
# 修改 加上name属性
def select_btn(self, obj=None, is_header=None):
if is_header:
return mark_safe("<input id='mutPut' type='checkbox'>")
return mark_safe("<input type='checkbox' value=%s name='_selected_action'>" % obj.pk)
# 更改change_list函数，前段页面就是上面的呢个
# 首页展现页面
def change_list(self, request):
if request.method == "POST":
func_name = request.POST.get("action")
# getlist多个值处理
pk_list = request.POST.getlist("_selected_action")
queryset = self.model.objects.filter(pk__in=pk_list)
func = getattr(self, func_name)
func(queryset=queryset)
self.request = request
add_url = self.get_add_url()
# search模糊查询
queryset = self.model.objects.filter(self.get_search_condition)
# filter模糊查询
queryset = queryset.filter(self.get_filter_condition)
cl = ChangeList(self, request, queryset)
return render(request, "index.html", locals())
# modelstark类中加上
def get_actions(self):
temp = []
temp.extend(self.actions)
temp.append(ModelStark.patch_delete)
return temp
# changeList类中加上
class ChangeList(object):
def __init__(self, config, request, queryset):
self.config = config
self.request = request
self.queryset = queryset
from starkapp.util.paginator import Pagination
current_page = request.GET.get("page")
all_count = self.queryset.count()
base_url = self.request.path_info
params = self.request.GET
paginator = Pagination(current_page, all_count, base_url, params)
data_list = self.queryset[paginator.start: paginator.end]
self.paginator = paginator
self.data_list = data_list
# actions 批量操做的动做
self.actions = self.config.get_actions() # 这里的获取actions是modelstark类中的
def handler_action(self):
temp = []
for action in self.actions:
temp.append({"name": action.__name__, "desc": action.desc if getattr(action, "desc", None) else action.__name__})
return temp
### filter: 难
补充必看： # self.config.model._meta.get_field(filter_field_name）给你看一下拿的是什么吧（下面第一张图），能够看到拿到的关联的对多字段的实例，其中个人django是2.0版本以上的，你能够经过related_model拿到对应的模型，以后经过模型管理器拿到对应的数据。（2.0版本已一下的试一试rel.to.objects.all(),这个我也没试，拿不到本身搜一搜吧。） filter_field_obj = self.config.model._meta.get_field(filter_field_name) # filter_field = FilterField(filter_field_name, filter_field_obj, self) print(type(filter_field_obj)) print(filter_field_obj.related_model.objects.all()) from django.db.models.fields.related import ManyToManyField from django.db.models.fields.related import ForeignKey
# 更爱changeList类
class ChangeList(object):
def __init__(self, config, request, queryset):
self.config = config
self.request = request
self.queryset = queryset
from starkapp.util.paginator import Pagination
current_page = request.GET.get("page")
all_count = self.queryset.count()
base_url = self.request.path_info
params = self.request.GET
paginator = Pagination(current_page, all_count, base_url, params)
data_list = self.queryset[paginator.start: paginator.end]
self.paginator = paginator
self.data_list = data_list
# actions 批量操做的动做
self.actions = self.config.get_actions()
# filter 过滤的字段
self.list_filter = self.config.list_filter
def get_filter_link_tag(self):
link_list = {}
data = self.request.GET
import copy
params = copy.deepcopy(data)
for filter_field_name in self.config.list_filter:
# 为何放里面而不是放外面
data = self.request.GET
import copy
params = copy.deepcopy(data)
current_id = self.request.GET.get(filter_field_name, 0)
filter_field_obj = self.config.model._meta.get_field(filter_field_name)
# filter_field = FilterField(filter_field_name, filter_field_obj, self)
if isinstance(filter_field_obj, ManyToManyField) or isinstance(filter_field_obj, ForeignKey):
data_list = filter_field_obj.related_model.objects.all()
else:
data_list = self.config.model.objects.values_list("pk", filter_field_name)
temp = []
# 处理所有标签
if params.get(filter_field_name, None):
del params[filter_field_name]
temp.append("<a href='?%s'>所有</a>" % (params.urlencode()))
else:
temp.append("<a class='active' href='?%s'>所有</a>" % (params.urlencode()))
# 处理数据标签
for obj in data_list:
if isinstance(filter_field_obj, ManyToManyField) or isinstance(filter_field_obj, ForeignKey):
pk, text = obj.pk, str(obj)
params[filter_field_name] = pk
else:
pk, text = obj
params[filter_field_name] = text
_url = params.urlencode()
if current_id == str(pk) or current_id == text:
link_tag = "<a class='active' href='?%s'>%s</a>" % (_url, text) # %s/%s/
else:
link_tag = "<a href='?%s'>%s</a>" % (_url, text) # %s/%s/
temp.append(link_tag)
link_list[filter_field_name] = temp
# 在下面我本身封装的类，能够本身玩玩，只须要将这个函数中的代码所有注释，保留这两句就能够了
# ff = FilterField(self.config, self.request)
# link_list = ff.get_filter_link()
return link_list
# 因为发现上面的呢个函数是在太长，因此我本身试试能不能将它分红一个类，能够练习一下，其实咱们写代码的时候固然是都写在一个函数中看起来方便，可是为了装逼吧，因此将每一个功能分开，让每一个函数变得简单一些，我的感受这种方式其实不方便阅读代码。
# 为每个过滤的字段封装成总体类
class FilterField(object):
def __init__(self, config, request):
self.config = config
self.request = request
def get_data(self):
if isinstance(self.filter_field_obj, ForeignKey) or isinstance(self.filter_field_obj, ManyToManyField):
return self.filter_field_obj.related_model.objects.all()
elif self.filter_field_obj.choices:
return self.filter_field_obj.choices
else:
return self.config.model.objects.values_list("pk", self.filter_field_name)
def get_params(self):
data = self.request.GET
import copy
params = copy.deepcopy(data)
return params
def get_filter_link(self):
link_list = {}
for filter_field_name in self.config.list_filter:
self.filter_field_name = filter_field_name
# 为何放里面而不是放外面
params = self.get_params()
current_id = self.get_current_id()
self.get_filter_field_obj()
temp = self.get_link_list(params, current_id)
link_list[filter_field_name] = temp
return link_list
def get_current_id(self):
current_id = self.request.GET.get(self.filter_field_name, 0)
return current_id
def get_filter_field_obj(self):
filter_field_obj = self.config.model._meta.get_field(self.filter_field_name)
self.filter_field_obj = filter_field_obj
def get_link_list(self, params, current_id):
data_list = self.get_data()
temp = []
temp = self.deal_all_tag(params, temp)
temp = self.deal_data_tag(params, data_list, current_id, temp)
return temp
def deal_data_tag(self, params, data_list, current_id, temp):
for obj in data_list:
pk, text, params = self.get_pk_text(params, obj)
_url = params.urlencode()
if current_id == str(pk) or current_id == text:
link_tag = "<a class='active' href='?%s'>%s</a>" % (_url, text) # %s/%s/
else:
link_tag = "<a href='?%s'>%s</a>" % (_url, text) # %s/%s/
temp.append(link_tag)
return temp
def get_pk_text(self, params, obj):
if isinstance(self.filter_field_obj, ManyToManyField) or isinstance(self.filter_field_obj, ForeignKey):
pk, text = obj.pk, str(obj)
params[self.filter_field_name] = pk
else:
pk, text = obj
params[self.filter_field_name] = text
return pk, text, params
def deal_all_tag(self, params, temp):
if params.get(self.filter_field_name, None):
del params[self.filter_field_name]
temp.append("<a href='?%s'>所有</a>" % (params.urlencode()))
else:
temp.append("<a class='active' href='?%s'>所有</a>" % (params.urlencode()))
return temp
pop页面：
1.若是在一对多和多对多后面显示加号 2. +对应跳转路由 3. 保存记录的同时，将原页面中的下拉菜单中天骄新纪录 知识点： window.opener当前窗口的打开窗口
最后一个也就是下面这幅图中的+号的实现，点击加号直接跳到建立页面，其中的难点就是上面列出的三条，咱们一个一个解决。
# 1.如何在一对多和多对多后面显示加号（咱们发先这个是在添加页面的时候才显示的因此咱们找到add函数），跳到add_index.html页面发现。全部的字段都是经过form组件渲染出来的，那么有没有什么解决的办法。先来一个简易版的直接加。
```python # 这个时候发现，每一个后面都有咋办，咱们只想在多对因此及一对多字段添加，这个时候我想到了model，可是发现好想联系不上。而后忽然想到使用form组件渲染的，咱们打印一下每一个字段的类型，发现是一个boundField类型。进入看看 ```
它有这么多的属性，咱们一个一个打印试试，最后发现field就是咱们的字段。
``` 这个时候操做性就来了，咱们能够判断这个字段是否是，一对多的类型（多对多继承一对多），而后给他加一个属性。 ```
# modelstark的add函数中
def add(self, request):
modelform = self.get_modelfrom_class()
from django.forms.boundfield import BoundField
form = modelform()
for field in form:
print(type(field.field))
if isinstance(field.field, ModelChoiceField):
field.is_pop = True
related_model_name = field.field.queryset.model._meta.model_name
related_app_name = field.field.queryset.model._meta.app_label
_url = reverse("{}_{}_add".format(related_app_name, related_model_name)) + \
"?pop_res_id=id_{}".format(field.name)
field.url = _url
if request.method == "GET":
return render(request, "add_index.html", locals())
else:
data = request.POST
form = modelform(data=data)
if form.is_valid():
obj = form.save()
pop_res_id = request.GET.get("pop_res_id")
if pop_res_id:
res = {"pk": obj.pk, "text": str(obj), "pop_res_id": pop_res_id}
return render(request, "pop.html", {"res": res})
else:
return redirect(self.get_list_url())
else:
return render(request, "add_index.html", locals())
<div class="container">
<div class="row">
<div class="col-md-6 col-xs-6 col-md-offset-3">
<form action="" method="post" novalidate>
{% csrf_token %}
{% for field in form %}
<div class="form-group">
<label for="">{{ field.label }}:</label>
<div style="position: relative">
{{ field }}
<span class="error pull-right">
{{ field.errors.0 }}
</span>
{% if field.is_pop %} # 而后这里加上判断就能够了
<a onclick="pop('{{ field.url }}')" style="color: blue; font-size: 30px; position: absolute;top: -10px;">+</a>
{% endif %}
</div>
</div>
{% endfor %}
<p><input type="submit" class="btn btn-primary"></p>
</form>
</div>
</div>
</div>
2. +对应跳转路由
加号对应的跳转路由咱们能够直接看django自带的admin路由是什么样？
http://localhost:8000/stark/app01/publish/add/?pop_res_id=id_publish可是是动态的因此咱们想第一步中。给每一个外键属性的字段加上一个url
for field in form:
print(type(field.field))
if isinstance(field.field, ModelChoiceField):
field.is_pop = True
related_model_name = field.field.queryset.model._meta.model_name
related_app_name = field.field.queryset.model._meta.app_label
# 就是这句
_url = reverse("{}_{}_add".format(related_app_name, related_model_name)) + \
"?pop_res_id=id_{}".format(field.name)
field.url = _url
这个时候还要解决的时候打开一个新页面
添加到添加页面的组件中，也就是下面的图。
<script>
function pop(url) {
window.open(url,"","width=600,height=400,top=100,left=200")
}
</script>
可是又如何作到，在点击保存以后关闭页面的呢。看到下面红框中的判断没有，返回了一个pop.html页面。
3. 保存记录的同时，将原页面中的下拉菜单中添加新纪录
# pop.html页面就这几句代码，加注释
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<script>
# 这句话是将，数据传入打开它的父window，pop_response是父window的一个函数，本身定义就行了。
window.opener.pop_response('{{ res.pk }}', '{{ res.text }}', '{{ res.pop_res_id }}');
# 他才是关闭窗口，直接在js中将窗口关闭
window.close()
</script>
</body>
</html>
# add_index.html若是处理呢？看到里面的函数你就明白了，就是生成一个option标签，绑定数据和属性给，插入下拉框中。
而后到这里就完了。不习惯使用git的可是又怕代码没地方保存哎？
地址：https://github.com/maxhope8/stark.git（我直接把项目代码弄上去了，可是外面的目录没传上去）
相关文章
- 1. Django——stark组件
- 2. stark组件
- 3. stark组件03
- 4. 开发stark组件
- 5. 【django之stark组件】
- 6. 开发stark组件2
- 7. stark组件分页开发
- 8. CRM【第二篇】: stark组件
- 9. stark组件5_扩展url
- 10. Django之stark组件1
- 更多相关文章...
- • Rust 所有权 - RUST 教程
- • ASP AdRotator 组件 - ASP 教程
- • IDEA下SpringBoot工程配置文件没有提示
- • 再有人问你分布式事务，把这篇扔给他
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 在windows下的虚拟机中,安装华为电脑的deepin操作系统
- 2. 强烈推荐款下载不限速解析神器
- 3. 【区块链技术】孙宇晨：区块链技术带来金融服务的信任变革
- 4. 搜索引起的链接分析-计算网页的重要性
- 5. TiDB x 微众银行 | 耗时降低 58%，分布式架构助力实现普惠金融
- 6. 《数字孪生体技术白皮书》重磅发布（附完整版下载）
- 7. 双十一“避坑”指南：区块链电子合同为电商交易保驾护航！
- 8. 区块链产业，怎样“链”住未来？
- 9. OpenglRipper使用教程
- 10. springcloud请求一次好用一次不好用zuul Name or service not known
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Django——stark组件
- 2. stark组件
- 3. stark组件03
- 4. 开发stark组件
- 5. 【django之stark组件】
- 6. 开发stark组件2
- 7. stark组件分页开发
- 8. CRM【第二篇】: stark组件
- 9. stark组件5_扩展url
- 10. Django之stark组件1