Sansa组件

诉求

　　仿照admin组件，实现对表的URL分配管理。

实现思路

　　1.在settings.py文件中注册APP，注册示例为：

'app01.apps.App01Config',
'app02.apps.App02Config',
‘stark_demo.apps.StarkDemoConfig',

　　2. 在每一个APP中的apps.py 文件中添加

from django.apps import AppConfig
2 from django.utils.module_loading import autodiscover_modules

class App01Config(AppConfig):
    name = 'app01'

7     def ready(self):
8         autodiscover_modules('stark',)

实现在Django项目启动时，扫描每个APP项目下的stark.py文件的文件，执行其中的代码，注册每个APP下的model，为每一个model生成增删改查四条URL。

来一张流程图进行说明。

Starksite类和Modelstark类的创建

from django.conf.urls import url
from django.shortcuts import HttpResponse, render, reverse,redirect
from django.utils.safestring import mark_safe
from django.forms import ModelForm
from app01.models import *
from app02.models import *

# 针对使用stark组件的默认样式类


class Modelstark(object):
    list_display = ["__str__"]
    list_display_link = ["__str__"]
    model_form = None
    # init 方法在实例化类的时候执行

    def __init__(self, model, site):
        self.model = model
        self.site = site
        self.label_model = (self.model._meta.app_label, self.model._meta.model_name)
    '''
    功能：
        将显示、编辑、删除、增加页面的url 封装到函数中。
    函数名:
        def get_add_url(self)
        def get_del_url(self,obj)
        def get_edit_url(self,obj)
        def get_list_url(self)
    '''
    def get_add_url(self):
        add_url = reverse("%s_%s_add" % self.label_model, )
        return add_url

    def get_del_url(self,obj):
        del_url = reverse("%s_%s_del" % self.label_model, args=(obj.pk,))
        return del_url

    def get_edit_url(self,obj):
        edit_url = reverse("%s_%s_edit"% self.label_model,args=(obj.pk,))
        return edit_url

    def get_list_url(self):
        list_url = reverse("%s_%s_show"%self.label_model,)
        return list_url
    '''
    功能:
        为显示页面右侧的添加按钮生成动态的URL
    函数名:
        def add_btn(self,obj=None,header=False)
    '''
    def add_btn(self,obj=None,header=False):
        if header:
            pass
        return mark_safe("<a href='%s' type='button' class='btn btn-success btn-lg pull-right'>添加</a>"%self.get_add_url())
    '''
    功能：
        为显示页面生成编辑、删除和复选框的标签
    函数名:
        def edit(self,obj=None,header=False)
        def delete(self,obj=None,header=False)
         def checkbox(self,obj=None,header=False)
    '''
    def edit(self,obj=None,header=False):
        if header:
            return "操作"
        return mark_safe("<a href='%s''>编辑</a>"%self.get_edit_url(obj))

    def delete(self,obj=None,header=False):
        if header:
            return "操作"
        return mark_safe("<a href='%s''>删除</a>" %self.get_del_url(obj))

    def checkbox(self,obj=None,header=False):
        if header:
            return mark_safe("<input type='checkbox' id='action-toggle'>")
        pass

        return mark_safe("<input type='checkbox' value='%s'>"%obj.pk)

        pass
    '''
    功能:
        为每一个类生成modelform,用于渲染标签
        判断用户是否定义了model_form，如果定义了则用用户自己的类，没有则用默认的modelForm
        备注：
            显示中文错误提示信息的解决思想是：
                在样式类中定义一个 model_form = None 的静态变量，在 def default_modelform(self) 函数中判断 model_form = None的bool值，若为False，
                则表明用户没有自定义 model_form ,因此走默认的modelForm.
                若model_form 为True，则表明用户对要注册的表定义了modelForm，因此用户会在自己的 XXXConfig类中声明 model_form = 自定义的modelForm，
                此时用用户自定义的 modelForm
    函数名:
        def mdelform(self)
    '''
    def default_modelform(self):
        class modelForm(ModelForm):
            class Meta:
                model = self.model
                fields = "__all__"
        if not self.model_form:
            return modelForm
        else:
            return self.model_form
    '''
       功能:
            显示、编辑、增加、删除4个视图函数
       函数名:
            def show_list(self, request)
            def add_list(self, request)
            def edit_list(self, request,id)
             def del_list(self, request,id)
       '''
    def show_list(self, request):
        data_list = self.model.objects.all()
        # 显示表头名称
        header_list = []
        for i in self.real_list_display():
            if callable(i):
                # 获取函数名：函数名.__name__
                # header_list.append(i.__name__) -----> low版
                header_list.append(i(self, header=True))
            else:
                if i == "__str__":
                    header_list.append(self.model._meta.model_name.upper())
                else:
                    header_list.append(self.model._meta.get_field(i).verbose_name)

        # print(self.list_display)
        # 首先循环每一条记录
        """
        需要构建的样式为：
        [
            ["id1","name1"],
            ["id2","name2"],
            ["id3","name3"],
        ]
        """
        # 显示数据
        ret_data_list = []
        for obj in data_list:
            tmp_list = []
            # 遍历显示的字段，i 指的是字段名称
            for i in self.real_list_display():
                if callable(i):
                    val = i(self, obj)
                else:
                    # val 为反射后的value
                    val = getattr(obj, i)
                    # 判断当前的 字段名称 是否在 list_display_link 中，在的话让该字段对应的值作为a标签
                    if i in self.list_display_link:
                        val = mark_safe("<a href='%s'>%s</a>"%(self.get_edit_url(obj),val))
                tmp_list.append(val)
            ret_data_list.append(tmp_list)
        # 显示添加按钮
        btn_list = []
        # 使用类.函数 的方式需要传self，但是使用类的对象.方法的方式不需要传self
        val = Modelstark.add_btn(self)
        btn_list.append(val)

        return render(request, "show_list.html", locals())

    def add_list(self, request):
        modelForm = self.default_modelform()
        errors = {}
        if request.method == "POST":
            form = modelForm(request.POST)
            if form.is_valid():
                form.save()
                return redirect(self.get_list_url())
            else:
                return render(request,"add.html",locals())
        form = modelForm()
        return render(request,"add.html",locals())

    def edit_list(self, request,id):
        obj = self.model.objects.filter(id=id).first()
        modelForm = self.default_modelform()
        if request.method == "POST":
            form = modelForm(request.POST,instance=obj)
            if form.is_valid():
                form.save()
                return redirect(self.get_list_url())
            else:
                pass
        form = modelForm(instance=obj)
        return render(request,"edit.html",locals())

    def del_list(self, request,id):
        if request.method == "POST":
            self.model.objects.filter(id=id).delete()
            return redirect(self.get_list_url())
        list_url = self.get_list_url()
        return render(request,"delete.html",locals())
    '''
    功能：
        在显示页面要真正显示的字段，对list_display进行扩展
    函数名：
        def real_list_display(self)
    '''
    def real_list_display(self):
        new_list_display = []
        new_list_display.extend(self.list_display)
        new_list_display.append(Modelstark.edit)
        new_list_display.append(Modelstark.delete)
        new_list_display.insert(0,Modelstark.checkbox)
        return new_list_display
    '''
    功能：
        为没一个注册的model生成增删改查四条URL
    函数名:
        def get_url_func(self)
    '''
    def get_url_func(self):
        tmp = []
        app_name = self.model._meta.app_label
        model_name = self.model._meta.model_name
        ret = (app_name, model_name)
        tmp.append(url("^$", self.show_list, name="%s_%s_show" %ret))
        tmp.append(url("^add/$", self.add_list, name="%s_%s_add" %ret))
        tmp.append(url("^edit/(\d+)/$", self.edit_list, name="%s_%s_edit" %ret))
        tmp.append(url("^del/(\d+)/$", self.del_list, name="%s_%s_del" %ret))
        '''
        在访问URL之前就已经分别为每张表创建了4条URL
        '''
        return tmp


# 创建stark类，实例化Starksite，用于注册model



class Starksite(object):

    def __init__(self):
        # 保存表的注册信息，保存的格式为:以model类为键，以该model实例化样式对象为值
        self._registry = {}

    # 类的注册函数
    def register(self, model, modelconfig=None):
        '''
        实现model的注册
        :param model: 要注册的类
        :param modelconfig: 该注册类的样式对象
        :return: None
        '''
        
        '''
        判断用户是否自己定义了样式类，如果没有，此时的modelconfig为None，则用默认的ModelStark样式类进行实例化注册；
        若用户自定义了注册类的样式对象，则使用用于自定的样式对象
        '''
        if not modelconfig:
            modelconfig = Modelstark
        # model是每次循环注册的表，self是实例化的Startksite类的实例化对象
        '''
        在对注册的model进行样式实例化的时候，modelconfig类实际上是Modelstark类的实例化，实例化要执行类的__init__函数，init函数的定义为：
            def __init__(self, model, site):
                self.model = model
                self.site = site
                self.label_model = (self.model._meta.app_label, self.model._meta.model_name)
            此时实例化的方式为：类名.__init__() 方式，因此需要传self。
            另外需要注意的是modelconfig(model,self)中的self是哪个类的实例化对象
            当在注册类的时候没有传入制定的样式类，那么这里的self是Modelstark类的实例化，
            但是，当用户传入定制的样式类时，此时的self是modelconfig类的实例化
        '''
        self._registry[model] = modelconfig(model, self)

    def get_urls(self):   
        '''
        生成表的一级和二级URL
        :return: tmp 
        '''
        tmp = []
        '''
        item():使字典中的键值对以元组的形式显示
        model: 注册的model类
        model_config:该类对应的样式类对象
        app_label:以字符串形式获取类所在的APP
        model_name:以字符串的获取类名
        '''
        for model, model_config in self._registry.items():
            app_label = model._meta.app_label
            model_name = model._meta.model_name
            #  为什么不能去掉None
            u = url("^%s/%s/" % (app_label, model_name), (model_config.get_url_func(), None, None))
            tmp.append(u)
        return tmp
    '''
    把urls函数做成静态方法，urls.py 中执行urls函数不需要加()
    '''
    @property
    def urls(self):
        return self.get_urls(), None, None


# 创建单例对象，在每一个app中的stark文件中调用
site = Starksite()

各功能的实现思路

一级与二级URL的设计思路

　　在注册完表后，执行urls.py文件，执行

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^stark/', site.urls),
]

　　site为类Starksite的单例实例化对象，site.urls 调用类下的urls方法，而urls方法实际上是执行get_urls(self) 方法，为每一个model首先生成一级URL，其次调用类的样式对象下的get_url_func(self)

函数，生成二级URL，同时为每一个增删改查URL创建别名，用于反向解析。

显示页面的数据显示

　　1.数据显示的思路

　　　　首先类中定义一个 list_display = ["__str__"]的静态变量，此静态变量在用于没有重写该变量时，则默认显示该对象的 def __str__(self) 方法的返回值。 

　　　　将显示的数据以 [ [1,"python",12,"<a>编辑</a>"],[2,"java",23,"<a>编辑</a>"],[3,"php",111,"<a>编辑</a>"],]的形式在后后台处理成功后，循环判断要显示的数据是一个字符串还是可执行函数，若是可执行函数则执行函数后追加保存到列表中，若是字符串则直接追加保存在列表中。

　　　　PS:

　　　　　1.getattr(obj,str) 函数用于反射，实现通过对象的字段名名称找到该字段对应的值。

　　　　　2.要循环的字段实际上是new_list_display, 即对list_display进行扩展，是默认显示的字段有复选框、对象名称、编辑、删除

    def real_list_display(self):
        new_list_display = []
        new_list_display.extend(self.list_display)
        new_list_display.append(Modelstark.edit)
        new_list_display.append(Modelstark.delete)
        new_list_display.insert(0,Modelstark.checkbox)
        return new_list_display

 

　　2.编辑和删除a标签的实现

　　　　把编辑和删除的a标签分别作为一个函数，使该函数的返回值为 mark_safe("<a>编辑</a>")，在循环要显示的字段对象的数据时，执行该函数。

　　　　PS:

　　　　　　mark_safe()函数实现前端safe相同的功能，使django不转移标签对象。

　　3.表头的实现

　　　　根据list_display 循环显示表头，当遇到“__str__”时，找到该该对象的“__str__“”方法的返回值，当遇到制定的字段名称，如public时，则使用 self.model._meta.get_field(i).verbose_name获取该字段的verbose_name,追加到列表中。

　　　　PS:

　　　　　get_field(arg) 可以获取到model表中该arg字段对象，该对象可以调用字段的属性，如verbose_name。

　　4.让字段作为a标签，实现跳转到编辑页面的实现

　　　　在循环显示数据的时候, 判断通过getattr()方法获取的字段值是否在list_display_link中，如果在，则使用mark_safe()使该value成为a标签。

　　5. ModelForm 组件实现页面的增删改查

　　　　只需要为要进行form渲染的类继承ModelForm，即可。

　　6.使用ModelForm实现显示中文错误信息

　　　　　在样式类中创建一个model_form = None的静态变量，在创建 ModelForm 类的函数 def default_modelform(self)中判断model_form的值，值为None，则使用默认的modelform，如果为True，则使用用户stark.py中定义的样式类。

在每个APP中stark.py文件的创建

from .models import *
# 对单例对象的调用
from stark_demo.service.sites import site,Modelstark
from django.forms import ModelForm


class BookModelForm(ModelForm):
    '''
    重写model的modelform类
    '''
    class Meta:
        model = Book
        fields = "__all__"
        error_messages = {
            "title":{"required":"不能为空"},
            "public":{"required":"不能为空"}
        }


class BookConfig(Modelstark):

    list_display = ["id","title","public"]
    list_display_link = ["id","title",]
    model_form = BookModelForm


site.register(Book,BookConfig)