24.stark组件全部

admin组件

admin参考:https://www.cnblogs.com/yuanchenqi/articles/8323452.html

model参考:https://www.cnblogs.com/yuanchenqi/articles/8963244.html

# 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

直接给出参考博客网址：https://www.cnblogs.com/smallmars/p/8657094.html

看不懂的话这里有视频：https://www.bilibili.com/video/av58974459?from=search&seid=4711332916584502531

这篇博客开始部分不好开头，我把开头整理一下，关于老男孩的项目有了规律，就是你发现你现在看的项目没有视频，那么可能是前几期教的，直接去B站搜这个项目名称相关的视频，就可以找，我是直接看博客，看到多级过滤的时候看不下去了才发现的，第九期的视频里面有很多好的项目可以看。

基础版本：

第一步：创建一个项目，去包里面最少有两个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 *

自定义配置类

class BookStark(ModelStark):

pass

list_display = ["nid", "title", "price", edit, delete]

site.register(Book, BookStark) # 初始的你只需要把BookStark类定义了，使用我们site注册了就行，里面的内容可以直接pass

```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类中将，那些函数补全你可以删除和编辑了。

现在我感觉前面缺少选择框：
# 自定义配置类
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的包放进去就好了，目录结构是这样子的。

然后再添加分页的时候返现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（我直接把项目代码弄上去了，但是外面的目录没传上去）