可快速生成增删curd改查功能的插件

仿造Django中的admin自己实现增删改查、模糊搜索、批量操作、条件筛选、popup功能的插件

1.创建组件

　　首先创建一个app，这里取名为stark，在settings.py中将其进行注册

INSTALLED_APPS = [

    'django.contrib.admin',

    'django.contrib.auth',

    'django.contrib.contenttypes',

    'django.contrib.sessions',

    'django.contrib.messages',

    'django.contrib.staticfiles',

    'stark.apps.StarkConfig',

]

settings.py

2.启动项

　　在stark的apps中写入启动项

#在apps.py中：

from django.apps import AppConfig

#必须写的内容，是Django启动的时候会自动加载

class StarkConfig(AppConfig):

    name = 'stark'

    def ready(self):

        from django.utils.module_loading import autodiscover_modules

        autodiscover_modules('stark')

apps.py

3.创建插件文件

　　在stark下创建一个叫service的包，包中创建一个文件，这里取名为v1.py。在v1中创建类似于AdminSite ModelAdmin的类，用于自己封装组件

class StarkConfig(object):

    """

        用于为每个类（即每张表）生成url对应关系，并处理用户请求的基类

        日后会封装很多功能

    """

    def __init__(self,model_class,site):

        self.model_class = model_class

        self.site = site

class StarkSite(object):

    '''

    单例模式创建的对象的类,是一个容器，用于放置处理请求对应关系

    {model.UserInfo:StarkConfig(model.UserInfo,self)}

    '''

    def __init__(self):

        self._registey = {}

    def register(self,model_class,stark_config_class=None):

        if not stark_config_class:

#stark_config_class，没写派生类时默认给予StarkConfig

            stark_config_class = StarkConfig

        self._registey[model_class] = stark_config_class(model_class,self)

#字典{表名：stark_config_class（表名，self）}

site = StarkSite()#单例模式

StarkConfig和 StarkSite

4.自动生成url

　　在全局的ulrs.py 中

from django.conf.urls import url

from stark.service import v1

urlpatterns = [

    url(r'^stark/', v1.site.urls),#自己创建的类似admin的功能，需在app里有相应的注册

]

　　在v1.py中，为每行需要操作的表生成增删改查4个url

class StarkConfig(object):

        def __init__(self,model_class,site):

            self.model_class = model_class

            self.site = site

#装饰器，为了传参数request

        def wrap(self,view_func):

            def inner(request,*args,**kwargs):

                self.request=request

                return view_func(request,*args,**kwargs)

            return inner

        def get_urls(self):#第五步

            app_model_name=(self.model_class._meta.app_label,self.model_class._meta.model_name,)#元祖（app名，表名）

            url_patterns=[

            url(r'^$',self.wrap(self.changelist_view),name='%s_%s_changelist'%app_model_name),

            url(r'^add/$',self.wrap(self.add_view),name='%s_%s_add'%app_model_name),

            url(r'^(\d+)/delete/$',self.wrap(self.delete_view),name='%s_%s_delete'%app_model_name),

            url(r'^(\d+)/change/$',self.wrap(self.change_view),name='%s_%s_change'%app_model_name),

        ]

            url_patterns.extend(self.extra_url())#除增删改查外，想要自定义的新增的url

            return url_patterns#最后就得到了需要用到的一堆url

        def extra_url(self):

            return []

########################################

        @property

        def urls(self):#第四步

            return self.get_urls()

        def urls(self):

            return self.get_urls()

#########反向生成url#####################

        def get_change_url(self, nid):

            name = 'stark:%s_%s_change' % (self.model_class._meta.app_label, self.model_class._meta.model_name)

            edit_url = reverse(name, args=(nid,))

            return edit_url

        def get_list_url(self):

            name = 'stark:%s_%s_changelist' % (self.model_class._meta.app_label, self.model_class._meta.model_name)

            edit_url = reverse(name)

            return edit_url

        def get_add_url(self):

            name = 'stark:%s_%s_add' % (self.model_class._meta.app_label, self.model_class._meta.model_name)

            edit_url = reverse(name)

            return edit_url

        def get_delete_url(self, nid):

            name = 'stark:%s_%s_delete' % (self.model_class._meta.app_label, self.model_class._meta.model_name)

            edit_url = reverse(name, args=(nid,))

            return edit_url

######视图函数（之后会具体扩展）####

        def changelist_view(self,request,*args,**kwargs):

            return HttpResponse('列表')

        def add_view(self,request,*args,**kwargs):

            return HttpResponse('添加')

        def delete_view(self,request,nid,*args,**kwargs):

            return HttpResponse('删除')

        def change_view(self,request,nid,*args,**kwargs):

            return HttpResponse('修改')

class StarkSite(object):

    '''

    单例模式创建的对象的类,是一个容器，用于放置处理请求对应关系

    {model.UserInfo:StarkConfig(model.UserInfo,self)}

    '''

    def __init__(self):

        self._registry = {}

    def register(self,model_class,stark_config_class=None):

        if not stark_config_class:

            #stark_config_class即29，没写那个派生类的时候默认给予StarkConfig

            stark_config_class=StarkConfig

        self._registry[model_class]=stark_config_class(model_class,self)

        #表名：stark_config_class（表名，self）

    def get_urls(self):#第三步，给url

        url_pattern=[]

        for model_class,stark_config_obj in self._registry.items():#去字典里取值

            app_name=model_class._meta.app_label#app名

            model_name=model_class._meta.model_name#表名

            curd_url=url(r'^%s/%s/'%(app_name,model_name),(stark_config_obj.urls,None,None))

            #拼接生成url，需执行stark_config_obj.urls———第四步

            url_pattern.append(curd_url)

        return url_pattern

    @property

    def urls(self):#第二步，要url

        return (self.get_urls(),None,'stark')

site=StarkSite()#第一步，单例模式

对 StarkConfig 和 StarkSite 进行扩展

5.定制功能

　　定制每一个列表页面（查）都会有的功能，若不具备该功能可在派生类中修改。

　　这里用了分页功能，可在全局中创建文件夹utils，将自己写的分页器page.py放入其中，之后在v1.py中导入即可使用。

class StarkConfig(object):

    """

        用于为每个类（即每张表）生成url对应关系，并处理用户请求的基类

    """

    def __init__(self,model_class,site):

        self.model_class=model_class

        self.site=site

        self.request=None

############定制功能####################

#########1 默认每个tr都会拥有的td

    def checkbox(self,obj=None,is_header=False):

        if is_header:

            return '选择'

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

    def edit(self,obj=None,is_header=False):

        if is_header:

            return '编辑操作'

        #url地址栏的搜索条件

        query_str=self.request.GET.urlencode()

        if query_str:

            #重新构造<button class="btn btn-primary"></button>

            params=QueryDict(mutable=True)

            params[self._query_param_key]=query_str

            return mark_safe('<button class="btn btn-primary"><a href="%s?%s" style="color:white;">编辑</a></button>' %(self.get_change_url(obj.id),params.urlencode(),))

        return mark_safe('<button class="btn btn-primary"><a href="%s" style="color:white;">编辑</a></button>' %(self.get_change_url(obj.id),))

    def delete(self,obj=None,is_header=False):

        if is_header:

            return '删除操作'

        query_str = self.request.GET.urlencode()

        if query_str:

            # 重新构造

            params = QueryDict(mutable=True)

            params[self._query_param_key] = query_str

            return mark_safe('<button class="btn btn-danger"><a href="%s?%s" style="color:white;">删除</a></button>' % (self.get_delete_url(obj.id), params.urlencode(),))

        return mark_safe('<button class="btn btn-danger"><a href="%s" style="color:white;">删除</a></button>'%(self.get_delete_url(obj.id),) )

    list_display=[]

    #得到派生类中自定义的list_display

    def get_list_display(self):

        data=[]

        if self.list_display:#派生类中定义的要显示的字段

            data.extend(self.list_display)#加入到data中

            data.append(StarkConfig.edit)#加入编辑td

            data.append(StarkConfig.delete)#加入删除td

            data.insert(0,StarkConfig.checkbox)#在最前面插一个td

        return data

    edit_link=[]

    def get_edit_link(self):

        result=[]

        if self.edit_link:

            result.extend(self.edit_link)

        return result

######### 2是否显示add按钮

    show_add_btn = True  # 默认显示

    def get_show_add_btn(self):

        return self.show_add_btn

#########3 关键字搜索

    show_search_form = False#默认不显示

    def get_show_search_form(self):

        return self.show_search_form

    search_fields = []#关键字默认为空

    def get_search_fields(self):

        result = []

        if self.search_fields:

            result.extend(self.search_fields)#派生类中自定义的关键字

        return result

    def get_search_condition(self):

        key_word = self.request.GET.get(self.search_key)#'_q'

        search_fields = self.get_search_fields()#关键字

        condition = Q()#创建Q对象用于与或

        condition.connector = 'or'#搜索条件之间用或连接

        if key_word and self.get_show_search_form():

            for field_name in search_fields:

                condition.children.append((field_name, key_word))

        return condition

#############4 actions，批量功能，需拥有权限才可拥有此功能

    show_actions = False#默认不显示

    def get_show_actions(self):

        return self.show_actions

    actions = []#默认批量操作内容为空

    def get_actions(self):

        result = []

        if self.actions:

            result.extend(self.actions)#加入派生类中自定制的批量操作

        return result

#############5 组合搜索

    show_comb_filter = False

    def get_show_comb_filter(self):

        return self.show_comb_filter

    comb_filter=[]#默认为空

    def get_comb_filter(self):

        result=[]

        if self.comb_filter:

            result.extend(self.comb_filter)#得到派生类中的条件删选

        return result

#############6排序

    order_by = []

    def get_order_by(self):

        result = []

        result.extend(self.order_by)

        return result

StarkConfig类中扩展

6.ChangeList

　　因为列表展示页面（查）需要后端向前端传很多的参数，所以我们这里讲所有需要传的参数封装到一个额外的类中，这样我们在视图函数中只需要将这个类实例化，只用向前端传这个类，在前端只要 ChangeList.方法或字段就可以了

class ChangeList(object):

    '''

    很牛逼的一个类，封装了所有视图函数想要往前端传的内容

    功能：使视图函数中的代码变的简洁

    '''

    def __init__(self,config,queryset):

        self.config=config#stark.py中写了派生类的话就是那个类，没写的话默认就是StarkConfig

        self.list_display=config.get_list_display()

        self.edit_link = config.get_edit_link()

        self.model_class=config.model_class#数据库的表

        self.request=config.request#StarkConfig中默认是None，不过程序运行后就会有

        self.show_add_btn=config.get_show_add_btn()

        # 搜索框

        self.show_search_form = config.get_show_search_form()

        self.search_form_val = config.request.GET.get(config.search_key, '')#搜索关键字“_q”,首次访问网页默认是空

        # 批量操作

        self.actions=config.get_actions()#得到派生类中写的actions的内容[]

        self.show_actions=config.get_show_actions()#操作框

        #组合搜索

        self.show_comb_filter=config.get_show_comb_filter()

        self.comb_filter=config.get_comb_filter()

        from utils.pager import Pagination

        #分页器

        current_page = self.request.GET.get('page', 1)#得到传入的page，没有默认为第一页

        total_count = queryset.count()#要显示的数据的量，queryset在视图函数中有数据库操作的赋值

        page_obj = Pagination(current_page, total_count, self.request.path_info, self.request.GET, per_page_count=5)

                            #当前页         数据量        当前url不带问号         ？后面的条件内容      设定的每页显示的数据量条数

        self.page_obj = page_obj#得到最终生成的分页器对象

        self.data_list = queryset[page_obj.start:page_obj.end]#得到分页后的数据，用于页面展示

    #批量操作

    def modify_actions(self):

        result = []#批量操作内容，默认为空，去派生类中定义

        for func in self.actions:#self.actions=config.get_actions()，默认为空

            temp = {'name':func.__name__,'text':func.short_desc}#name是函数名，text是自加的描述

            result.append(temp)

        return result

    def add_url(self):#添加操作的url

        query_str = self.request.GET.urlencode()

        if query_str:

            # 重新构造,用于跳转

            params = QueryDict(mutable=True)

            params[self.config._query_param_key] = query_str

            return self.config.get_add_url()+'?'+params.urlencode()

        return self.config.get_add_url()

    def head_list(self):

        #构造表头

        result = []

        # [checkbox,'id','name',edit,del]

        for field_name in self.list_display:

            if isinstance(field_name, str):

                # 根据类和字段名称，获取字段对象的verbose_name

                verbose_name = self.model_class._meta.get_field(field_name).verbose_name

            else:

                verbose_name = field_name(self.config, is_header=True)# 去派生类中执行

            result.append(verbose_name)

        return result

    def body_list(self):

        # 处理表中的数据

        data_list = self.data_list#self.data_list = queryset[page_obj.start:page_obj.end]

        new_data_list = []

        for row in data_list:

            # row是 每一条数据对象UserInfo(id=2,name='alex2',age=181)

            temp = []

            for field_name in self.list_display:

                if isinstance(field_name,str):#派生类中定义的显示字段

                    val = getattr(row,field_name)

                else:#每个td都拥有的功能，checkbox、edit、delete、

                    val = field_name(self.config,row)

                # 用于定制编辑列

                if field_name in self.edit_link:

                    val = self.edit_link_tag(row.pk, val)

                temp.append(val)

            new_data_list.append(temp)

        return new_data_list

    def gen_comb_filter(self):

        #生成器函数

        """

        [

             FilterRow(((1,'男'),(2,'女'),)),

             FilterRow([obj,obj,obj,obj ]),

             FilterRow([obj,obj,obj,obj ]),

        ]

        """

        '''

                comb_filter = [

                v1.FilterOption('gender', is_choice=True),#关键字传参，代表是choice

                v1.FilterOption('depart'),#, 筛选只显示id大于三的部门condition={'id__gt': 3}

                v1.FilterOption('roles', True),#True传入，代表是多选

            ]

                '''

        from django.db.models import ForeignKey,ManyToManyField

        for option in self.comb_filter:

            _field = self.model_class._meta.get_field(option.field_name)#字段

            if isinstance(_field,ForeignKey):

                # 获取当前字段depart，关联的表 Department表并获取其所有数据

                # print(field_name,_field.rel.to.objects.all())

                row = FilterRow(option, option.get_queryset(_field), self.request)

            elif isinstance(_field,ManyToManyField):

                # print(field_name, _field.rel.to.objects.all())

                # data_list.append(  FilterRow(_field.rel.to.objects.all()) )

                row = FilterRow(option,option.get_queryset(_field), self.request)

            else:

                # print(field_name,_field.choices)

                # data_list.append(  FilterRow(_field.choices) )

                row = FilterRow(option,option.get_choices(_field),self.request)

            # 可迭代对象，迭代详细在FilterRow的__iter__中

            yield row

    def edit_link_tag(self,pk,text):

        query_str = self.request.GET.urlencode()  # page=2&nid=1

        params = QueryDict(mutable=True)

        params[self.config._query_param_key] = query_str

        return mark_safe('<a href="%s?%s">%s</a>' % (self.config.get_change_url(pk), params.urlencode(),text,))  # /stark/app01/userinfo/

v1.py中的ChangeList类

7.组合搜索（筛选）

　　组合搜索（筛选功能）是一大难点，这里还需定义两个类FilterOption和FilterRow

　　FilterOption：用于封装筛选条件的配置信息。FilterOption的实例化由派生类决定

　　FilterRow：可迭代对象，封装了筛选中的每一行数据。

class FilterOption(object):

    def __init__(self, field_name, multi=False, condition=None, is_choice=False,text_func_name=None, val_func_name=None):

        """

        :param field_name: 字段

        :param multi:  是否多选

        :param condition: 显示数据的筛选条件

        :param is_choice: 是否是choice

        """

        self.field_name = field_name

        self.multi = multi

        self.condition = condition

        self.is_choice = is_choice

        self.text_func_name = text_func_name#组合搜索时，页面上生成显示的文本的函数

        self.val_func_name = val_func_name#组合搜索时，页面上生成的a标签中的值的函数

    def get_queryset(self, _field):

        if self.condition:#是数据的筛选条件

            return _field.rel.to.objects.filter(**self.condition)#拿到筛选后的对象

        return _field.rel.to.objects.all()#默认“全部”按钮被选中，给出所有对象

    def get_choices(self, _field):#是choices

        return _field.choices

#可迭代对象，封装了筛选中的每一行数据。

class FilterRow(object):

    def __init__(self, option, data, request):

        self.option = option

        self.data = data#关联字段所关联的表的所有有关联的数据

        # request.GET

        self.request = request

    def __iter__(self):

        params = copy.deepcopy(self.request.GET)#深拷贝？后面的内容，得到QueryDict

        params._mutable = True#可修改

        current_id = params.get(self.option.field_name)  #params.get（字段），得到的是值

        current_id_list = params.getlist(self.option.field_name)  # [1,2,3]

        if self.option.field_name in params:#地址栏已存在筛选条件

            # del params[self.option.field_name]，先删除

            origin_list = params.pop(self.option.field_name)#删除，并得到删除内容

            url = "{0}?{1}".format(self.request.path_info, params.urlencode())

            yield mark_safe('<a href="{0}">全部</a>'.format(url))#“全部按钮”不被选中

            params.setlist(self.option.field_name, origin_list)#将本身已存在的筛选条件放入params中

        else:

            url = "{0}?{1}".format(self.request.path_info, params.urlencode())#地址栏不存在筛选条件

            yield mark_safe('<a class="active" href="{0}">全部</a>'.format(url))#默认“全部”按钮被选中

        for val in self.data:

            if self.option.is_choice:# ( (1,男),(2,女)  )

                pk, text = str(val[0]), val[1]

            else:#每个val都是对象

                # pk, text = str(val.pk), str(val)

                text = self.option.text_func_name(val) if self.option.text_func_name else str(val)

                pk = str(self.option.val_func_name(val)) if self.option.val_func_name else str(val.pk)

            # 当前URL？option.field_name

            # 当前URL？gender=pk

            #制定url的显示规则：

            # self.request.path_info # http://127.0.0.1:8005/arya/crm/customer/?gender=1&id=2

            # self.request.GET['gender'] = 1 # &id=2gender=1

            if not self.option.multi:

                # 单选

                params[self.option.field_name] = pk#1,2

                url = "{0}?{1}".format(self.request.path_info, params.urlencode())

                if current_id == pk:#当前url筛选条件中的值

                    yield mark_safe("<a class='active' href='{0}'>{1}</a>".format(url, text))#该筛选按钮被选中

                else:

                    yield mark_safe("<a href='{0}'>{1}</a>".format(url, text))#其余按钮，没被选中

            else:

                # 多选 current_id_list = ["1","2"]

                _params = copy.deepcopy(params)

                id_list = _params.getlist(self.option.field_name)#["1","2","3","4"]

                if pk in current_id_list:#值已存在，表示该按钮已被选中

                    id_list.remove(pk)#将该值从id_list中去除

                    _params.setlist(self.option.field_name, id_list)#["2","3","4"]

                    url = "{0}?{1}".format(self.request.path_info, _params.urlencode())

                    #该按钮被选中，但其a标签的href中跳转的链接即当前url去除本身按钮id的状态，即该按钮，被再次点击时，就会恢复未选中状态

                    yield mark_safe("<a class='active' href='{0}'>{1}</a>".format(url, text))

                else:#值未存在

                    id_list.append(pk)

                    # params中被重新赋值

                    _params.setlist(self.option.field_name, id_list)

                    # 创建URL，赋予其被点时，使其产生被选中

                    url = "{0}?{1}".format(self.request.path_info, _params.urlencode())

                    yield mark_safe("<a href='{0}'>{1}</a>".format(url, text))

FilterOption和FilterRow

8.popup功能

　　popup功能用于添加和编辑页面，在操作时选择外键关联的select框，可临时添加一个对象的功能

添加和编辑的视图函数中需要有以下代码：

    def xxx_view(self,request):

        _popbackid = request.GET.get('_popbackid')#临时需要添加的外键字段所对应的输入框的id

        if request.method == 'POST':

            form = model_form_class(request.POST)

            if form.is_valid():

                new_obj=form.save()

                if _popbackid:

                    # 判断是否是来源于popup请求

                    # render一个页面，写自执行函数

                    # popUp('/stark/crm/userinfo/add/?_popbackid=id_consultant&model_name=customer&related_name=consultant')

                    from django.db.models.fields.reverse_related import ManyToOneRel, ManyToManyRel

                    result = {'status': False, 'id': None, 'text': None, 'popbackid': _popbackid}

                    model_name = request.GET.get('model_name')  # customer

                    related_name = request.GET.get('related_name')  # consultant, "None"

                    for related_object in new_obj._meta.related_objects:#关联表的对象

                        _model_name = related_object.field.model._meta.model_name

                        _related_name = related_object.related_name

                        # 判断外键关联字段是否是主键id

                        if (type(related_object) == ManyToOneRel):

                            _field_name = related_object.field_name

                        else:

                            _field_name = 'pk'

                        _limit_choices_to = related_object.limit_choices_to

                        if model_name == _model_name and related_name == str(_related_name):

                            is_exists = self.model_class.objects.filter(**_limit_choices_to, pk=new_obj.pk).exists()

                            if is_exists:

                                # 如果新创建的用户是可查看的人，页面才增加

                                # 分门别类做判断：

                                result['status'] = True

                                result['text'] = str(new_obj)

                                result['id'] = getattr(new_obj, _field_name)

                                return render(request, 'stark/popup_response.html',

                                              {'json_result': json.dumps(result, ensure_ascii=False)})

                    return render(request, 'stark/popup_response.html',

                                  {'json_result': json.dumps(result, ensure_ascii=False)})

                else:

                    list_query_str = request.GET.get(self._query_param_key)

                    list_url = '%s?%s' % (self.get_list_url(), list_query_str,)

                    return redirect(list_url)

                    # return redirect(self.get_list_url())

        return render(request, 'stark/add_view.html', {'form': form, 'config': self})

视图函数

　　因为编辑和添加的前端页面代码大量冲重合，所以这里引入form.html和templatetags。

templatetages下创建change_form.py

from django.template import Library

from django.urls import reverse

from stark.service.v1 import site

register = Library()

# 自定义标签

@register.inclusion_tag('stark/form.html')

def new_form(config,model_form_obj):

    new_form = []

    for bfield in model_form_obj:#model_form_obj是每一条记录

        temp = {'is_popup': False, 'item': bfield}

        # bfield.field是ModelForm读取对应的models.类，然后根据每一个数据库字段，生成Form的字段

        from django.forms.boundfield import BoundField

        from django.db.models.query import QuerySet

        from django.forms.models import ModelChoiceField

        if isinstance(bfield.field, ModelChoiceField):#是单选和多选————>外键字段

            related_class_name = bfield.field.queryset.model#得到字段的field

            if related_class_name in site._registry:#已注册

                app_model_name = related_class_name._meta.app_label, related_class_name._meta.model_name

                # FK，One,M2M： 当前字段所在的类名和related_name

                model_name = config.model_class._meta.model_name

                related_name = config.model_class._meta.get_field(bfield.name).rel.related_name

                # print(model_name,related_name)

                base_url = reverse("stark:%s_%s_add" % app_model_name)#应用名_类名_add，反向生成url

                #bfield.auto_id是内置方法，得到该input框的id

                # 带有回调参数的url

                popurl = "%s?_popbackid=%s&model_name=%s&related_name=%s" % (base_url, bfield.auto_id,model_name,related_name)

                temp['is_popup'] = True

                temp['popup_url'] = popurl

        new_form.append(temp)#{'is_popup': True, 'item': bfield,'popup_url':popurl}

    return {'new_form':new_form}

change_form.py

templates下的form.html（内含jQuery，处理popup回调）

<form method="post"  class="form-horizontal" novalidate>

    {% csrf_token %}

{#    dic={'is_popup': True, 'item': bfield,'popup_url':popurl}#}

    {% for dic in new_form %}

        <div class="col-sm-4 col-sm-offset-4">

            <div class="form-group">

                <label for="" class="col-sm-2 control-label">{{ dic.item.field.label }}:</label>

                <div class="col-sm-9" style="position: relative">

                    {# modelform自动形成input#}

                    {{ dic.item }}

                    {% if dic.is_popup %}{# 单选或多选#}

                        <div style="position: absolute;top: 10px;left: 330px;">

                            <a href="" onclick="popUp('{{ dic.popup_url }}')"><i class="fa fa-arrows" aria-hidden="true"></i></a>

                        </div>

                    {% endif %}

                    <div style="position: absolute;font-size: 12px;top: 18px;right: 20px;color: #e4393c;background: #FFEBEB;">{{ dic.item.errors.0 }}</div>

                </div>

            </div>

        </div>

    {% endfor %}

    <div class="col-sm-offset-7 col-sm-3">

        <input type="submit" class="btn btn-primary" value="提交">

    </div>

</form>

<script>

    function popUp(url) {

        var popupPage = window.open(url, url, "status=1, height:500, width:600, toolbar=0, resizeable=0");

    }

    function popupCallback(dic) {

        if (dic.status) {

            var op = document.createElement('option');

            op.value = dic.id;

            op.text = dic.text;

            op.setAttribute('selected', 'selected');

            document.getElementById(dic.popbackid).appendChild(op);

        }

    }

</script>

form.html

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>正在关闭</title>

</head>

<body>

    <script>

        (function () {

            var dic = {{ json_result|safe }};

{#            发起popup请求的页面执行该回调函数#}

            opener.popupCallback(dic);

            window.close();

        })()

    </script>

</body>

</html>

popup_response.html

添加和修改的html页面将会在之后给出

9.视图函数

9.1 静态文件

　　创建一个static文件夹，用于存放静态文件。这里用到了bootstrap、font-awesome和jQuery

9.2 基板

　　因为增删改查的前端页面代码重复量较多，所以我们设置一个基板，用于减少代码冗余。

{% load staticfiles %}

<!DOCTYPE html>

<html lang="en">

<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>{% block title %}{% endblock %}</title>

    <link rel="stylesheet" href="{% static 'bootstrap-3.3.7-dist/css/bootstrap.css' %}">

    <link rel="stylesheet" href="{% static "mycss/stark-form.css" %}" />

    <link rel="stylesheet" href="{% static 'font-awesome/css/font-awesome.min.css' %}">

    {% block css %}

    {% endblock %}

</head>

<body>

{% block body %}

{% endblock %}

{% block js %}

{% endblock %}

</body>

</html>

基板base_temp

9.3 查

　　注意组合搜索功能和批量功能

    # 默认列表页面

    def changelist_view(self, request,*args, **kwargs):

        #分页，已改写到ChangeList类中

        # from utils.pager import Pagination

        # current_page=request.GET.get('page',1)

        # total_count=self.model_class.objects.all().count()

        # page_obj=Pagination(current_page,total_count,request.path_info,request.GET,per_page_count=4)

        if request.method=='GET':

            comb_condition = {}#筛选条件默认为空

            option_list = self.get_comb_filter()#拿到派生类中定制的筛选条件

            for key in request.GET.keys():#？后面的键

                value_list = request.GET.getlist(key)#拿到键对应的值[1,2,3]

                flag = False

                for option in option_list:#option是每一个删选条件

                    if option.field_name == key:#该条件已存在于地址栏

                        flag = True

                        break

                if flag:

                    #comb_condition = {"id__in":[1,2,3].......}

                    comb_condition["%s__in" % key] = value_list

            # 带搜索条件的数据，没有搜索条件的话就是全部数据。有筛选条件的话，还得处理成筛选后的数据

            queryset=self.model_class.objects.filter(self.get_search_condition()).filter(**comb_condition).distinct()

            the_list=ChangeList(self,queryset)#封装好要向前端传的值

            return render(request, 'stark/changelist.html', {'the_list':the_list})

        elif request.method=='POST' and self.get_show_actions():#批量操作

            func_name_str = request.POST.get('list_action')#前端传的操作name

            action_func = getattr(self, func_name_str)#反射，得到处理的方式

            ret = action_func(request)

            if ret:

                return ret

查页面（后端）

{% extends 'stark/base_temp.html' %}

{% block title %}列表页面{% endblock %}

{% block css %}

<style>

        h1 {

            margin-bottom: 50px;

        }

        td, th {

            text-align: center;

        }

        .list-filter a {

            display: inline-block;

            padding: 3px 6px;

            border: 1px solid #2e6da4;

            margin: 3px 0;

        }

        .list-filter a.active {

            background-color: #2e6da4;

            color: white;

        }

    </style>

{% endblock %}

{% block body %}

    <div class="container">

    <div class="row">

        <div class="col-md-10 col-md-offset-1">

            <h1 class="text-center">列表页面</h1>

            {#        筛选栏#}

        {% if the_list.show_comb_filter %}

            <div class="list-filter">

                {% for item in the_list.gen_comb_filter %}

                    <div>

                        {% for foo in item %}

                            {{ foo }}

                        {% endfor %}

                    </div>

                {% endfor %}

            </div>

        {% endif %}

            {#        搜索栏#}

            {% if the_list.show_search_form %}

                <div class="form-group pull-right">

                    <form method="get">

                        <input name="{{ the_list.config.search_key }}" value="{{ the_list.search_form_val }}"

                               class="form-control"

                               placeholder="请输入搜索条件" type="text" style="display:inline-block;width: 200px;"/>

                        <button class="btn btn-primary"><span class="glyphicon glyphicon-search"></span></button>

                    </form>

                </div>

            {% endif %}

            {#        带有批量执行操作的表格#}

            <form method="post">

                {% csrf_token %}

                {% if the_list.show_actions %}

                    <div class="form-group">

                        <select name="list_action" class="form-control" style="display:inline-block;width: 200px;">

                            {% for item in the_list.modify_actions %}

                                <option value="{{ item.name }}">{{ item.text }}</option>

                            {% endfor %}

                        </select>

                        <button class="btn btn-danger">执行</button>

                    </div>

                {% endif %}

                <table class="table table-bordered table-striped">

                    <thead>

                    <tr>

                        <th>编号</th>

                        {% for item in the_list.head_list %}

                            <th>{{ item }}</th>

                        {% endfor %}

                    </tr>

                    </thead>

                    <tbody>

                    {% for obj in the_list.body_list %}

                        <tr>

                            <td><b>（{{ forloop.counter }}）</b></td>

                            {% for col in obj %}

                                <td>{{ col }}</td>

                            {% endfor %}

                        </tr>

                    {% endfor %}

                    </tbody>

                </table>

            </form>

            {#        添加按钮#}

            <div class="pull-left">

                {% if the_list.show_add_btn %}

                    <a href="{{ the_list.add_url }}" class="btn btn-info">&nbsp;&nbsp;&nbsp;&nbsp;添加&nbsp;&nbsp;&nbsp;&nbsp;</a>

                {% endif %}

            </div>

            {#        分页器#}

            <div class="pager">

                <nav aria-label="Page navigation">

                    <ul class="pagination">

                        {{ the_list.page_obj.page_html|safe }}

                    </ul>

                </nav>

            </div>

        </div>

    </div>

</div>

{% endblock %}

查页面（前端）

9.4 modelform

　　modelform有两种写法

model_form_class = None

    def get_model_form_class(self):

        if self.model_form_class:

            return self.model_form_class

        from django.forms import ModelForm

    #方式一：

        # class TestModelForm(ModelForm):

        #     class Meta:

        #         model = self.model_class

        #         fields = "__all__"

        #

        #         error_messages = {

        #             "__all__":{

        #

        #                   },

        #         'email': {

        #         'required': '',

        #         'invalid': '邮箱格式错误..',

        #         }

        #         }

      #方式二： type创建TestModelForm类

        meta = type('Meta', (object,), {'model': self.model_class, 'fields': '__all__'})

        TestModelForm = type('TestModelForm', (ModelForm,), {'Meta': meta})

        return TestModelForm

modelform

9.5 增页面（含popup功能）

class StarkConfig(object):

 #增

    def add_view(self, request, *args, **kwargs):

        # 添加页面

        model_form_class = self.get_model_form_class()#根据modelform生成input

        _popbackid = request.GET.get('_popbackid')#临时需要添加的外键字段所对应的输入框的id

        if request.method == 'GET':

            form = model_form_class()

        else:

            form = model_form_class(request.POST)

            if form.is_valid():

                new_obj=form.save()

                if _popbackid:

                    # 判断是否是来源于popup请求

                    # render一个页面，写自执行函数

                    # popUp('/stark/crm/userinfo/add/?_popbackid=id_consultant&model_name=customer&related_name=consultant')

                    from django.db.models.fields.reverse_related import ManyToOneRel, ManyToManyRel

                    result = {'status': False, 'id': None, 'text': None, 'popbackid': _popbackid}

                    model_name = request.GET.get('model_name')  # customer

                    related_name = request.GET.get('related_name')  # consultant, "None"

                    for related_object in new_obj._meta.related_objects:#关联表的对象

                        _model_name = related_object.field.model._meta.model_name

                        _related_name = related_object.related_name

                        # 判断外键关联字段是否是主键id

                        if (type(related_object) == ManyToOneRel):

                            _field_name = related_object.field_name

                        else:

                            _field_name = 'pk'

                        _limit_choices_to = related_object.limit_choices_to

                        if model_name == _model_name and related_name == str(_related_name):

                            is_exists = self.model_class.objects.filter(**_limit_choices_to, pk=new_obj.pk).exists()

                            if is_exists:

                                # 如果新创建的用户是可查看的人，页面才增加

                                # 分门别类做判断：

                                result['status'] = True

                                result['text'] = str(new_obj)

                                result['id'] = getattr(new_obj, _field_name)

                                return render(request, 'stark/popup_response.html',

                                              {'json_result': json.dumps(result, ensure_ascii=False)})

                    return render(request, 'stark/popup_response.html',

                                  {'json_result': json.dumps(result, ensure_ascii=False)})

                else:

                    list_query_str = request.GET.get(self._query_param_key)

                    list_url = '%s?%s' % (self.get_list_url(), list_query_str,)

                    return redirect(list_url)

                    # return redirect(self.get_list_url())

        return render(request, 'stark/add_view.html', {'form': form, 'config': self})

StarkConfig类中的add_view

{% extends 'stark/base_temp.html' %}

{% load change_form %}

{% block title %}添加页面{% endblock %}

{% block css %}{% endblock %}

{% block body %}

    <h1 class="text-center">添加页面</h1>

    <form method="post"  novalidate>

        {% csrf_token %}

    {#    {% include 'stark/form.html' %}#}

        {% new_form config form  %}{#    def new_form(model_form_obj):#}

    </form>

{% endblock %}

add_view.html

9.6 改页面（含popup功能）

class StarkConfig(object):

    def change_view(self, request, nid,*args, **kwargs):

        # self.model_class.objects.filter(id=nid)

        obj = self.model_class.objects.filter(pk=nid).first()

        print(obj)

        if not obj:

            return redirect(self.get_list_url())

        model_form_class = self.get_model_form_class()

        _popbackid = request.GET.get('_popbackid')#临时需要添加的外键字段所对应的输入框的id

        # GET,显示标签+默认值

        if request.method == 'GET':

            form = model_form_class(instance=obj)

            return render(request, 'stark/change_view.html', {'form': form,'config': self})

        else:

            form = model_form_class(instance=obj, data=request.POST)

            if form.is_valid():

                form.save()

                list_query_str=request.GET.get(self._query_param_key)

                list_url='%s?%s'%(self.get_list_url(),list_query_str,)

                return redirect(list_url)

            return render(request, 'stark/change_view.html', {'form': form})

StarkConfig类中的add_view

{% extends 'stark/base_temp.html' %}

{% load change_form %}

{% block title %}添加页面{% endblock %}

{% block css %}{% endblock %}

{% block body %}

    <h1 class="text-center">修改页面</h1>

        <form method="post" novalidate>

{#        {% include 'stark/form.html' %}#}

            {% new_form config form  %}{#    def new_form(model_form_obj):#}

        </form>

{% endblock %}

change_view.html

9.7 删页面

　　删页面最为简单，但也要注意跳转功能，总不能在第三页点删除键后跳到了第一页吧

class StarkConfig(object):

    def delete_view(self, request, nid,*args, **kwargs):

        self.model_class.objects.filter(pk=nid).delete()

        list_query_str = request.GET.get(self._query_param_key)

        list_url = '%s?%s' % (self.get_list_url(), list_query_str,)

        return redirect(list_url)

StarkConfig类中的delete_view

end

　　至此，插件v1就已全部完成。在使用时，需要在app中导入这个文件，即创建一个stark.py文件，在文件中进行注册。

　　在stark.py中，只注册的话就执行默认功能，即只具备查、删、改功能。若想要拥有更多功能，需在stark.py中自己写一个派生类，利用钩子函数进行扩展。

举例说明：

　　这里进行对插件的使用的举例说明

　　我们创建一个新的app并建表，然后在app下创建stark.py，无需写路由和视图函数即可得到增删改查以及模糊搜索、批量操作、条件筛选、popup等功能。具体是否拥有该功能，由权限决定。

from django.db import models

# Create your models here.

class UserInfo(models.Model):

    name=models.CharField(max_length=32)

    pwd=models.CharField(max_length=32)

    email=models.EmailField(max_length=32)

    tp=models.ForeignKey('Type')

    class Meta:

        verbose_name_plural = "用户表"

    def __str__(self):

        return self.name

class Type(models.Model):

    name=models.CharField(max_length=32)

    role=models.ManyToManyField('Role')

    class Meta:

        verbose_name_plural = "类型表"

    def __str__(self):

        return self.name

class Role(models.Model):

    name=models.CharField(max_length=32)

    salary=models.IntegerField(default=0)

    class Meta:

        verbose_name_plural = "角色表"

    def __str__(self):

        return self.name

class Host(models.Model):

    hostname = models.CharField(verbose_name='主机名',max_length=32)

    ip = models.GenericIPAddressField(verbose_name="IP",protocol='ipv4')

    port = models.IntegerField(verbose_name='端口')

models.py

print('我是stark')

from django.shortcuts import HttpResponse,render,redirect

from django.utils.safestring import mark_safe

from django.conf.urls import url

from stark.service import v1

from app01 import models

from django.forms import ModelForm

class UserInfoModelForm(ModelForm):

    class Meta:

        model = models.UserInfo

        fields = '__all__'

        error_messages = {

            'name':{

                'required':'用户名不能为空'

            }

        }

class UserinfoConfig(v1.StarkConfig):

    '''

    自己定义的派生类，可以有29种额外的显示方式，效果与admin相同

    '''

    list_display=['id','name','pwd','email']

    def extra_url(self):

        url_list=[

            #除增删改查外，想要新增的url

        ]

        return url_list

    show_add_btn = True

    model_form_class = UserInfoModelForm

    show_search_form = True#搜索框

    search_fields = ['name__contains', 'email__contains']#模糊搜索

    show_actions = True#批量操作框

    #批量删除

    def multi_del(self,request):

        pk_list = request.POST.getlist('pk')#得到所有的勾选的项

        self.model_class.objects.filter(id__in=pk_list).delete()

        return HttpResponse('删除成功')

        # return redirect("http://www.baidu.com")

    multi_del.desc_text = "批量删除"#给函数内部加一个字段

    def multi_init(self,request):

        pk_list = request.POST.getlist('pk')

        #self.model_class.objects.filter(id__in=pk_list).delete()

        # return HttpResponse('删除成功')

        #return redirect("http://www.baidu.com")

    multi_init.desc_text = "初始化"

    actions = [multi_del, multi_init]#给actions加入定制的功能

class HostModelForm(ModelForm):

    class Meta:

        model = models.Host

        fields = ['id','hostname','ip','port']

        error_messages = {

            'hostname':{

                'required':'主机名不能为空',

            },

            'ip':{

                'required': 'IP不能为空',

                'invalid': 'IP格式错误',

            }

        }

class HostConfig(v1.StarkConfig):

    def ip_port(self,obj=None,is_header=False):

        if is_header:

            return '自定义列'

        return "%s:%s" %(obj.ip,obj.port,)

    list_display = ['id','hostname','ip','port',ip_port]

    # get_list_display

    show_add_btn = True

    # get_show_add_btn

    model_form_class = HostModelForm

    # get_model_form_class

    def extra_url(self):

        urls = [

            url('^report/$',self.report_view)

        ]

        return urls

    def report_view(self,request):

        return HttpResponse('自定义报表')

    def delete_view(self,request,nid,*args,**kwargs):

        if request.method == "GET":

            return render(request,'my_delete.html')

        else:

            self.model_class.objects.filter(pk=nid).delete()

            return redirect(self.get_list_url())

#相应的注册

#第二个参数传入自己写的类时，可以拥有自己写的类中的额外的方法

v1.site.register(models.UserInfo,UserinfoConfig)

v1.site.register(models.Role)

v1.site.register(models.Type)

v1.site.register(models.Host,HostConfig)

stark.py

附：

import copy

import json

from django.shortcuts import HttpResponse,render,redirect

from django.urls import reverse

from django.conf.urls import url, include

from django.utils.safestring import mark_safe

from django.http import QueryDict

from django.db.models import Q

#用于封装筛选条件的配置信息

class FilterOption(object):

    def __init__(self, field_name, multi=False, condition=None, is_choice=False,text_func_name=None, val_func_name=None):

        """

        :param field_name: 字段

        :param multi:  是否多选

        :param condition: 显示数据的筛选条件

        :param is_choice: 是否是choice

        """

        self.field_name = field_name

        self.multi = multi

        self.condition = condition

        self.is_choice = is_choice

        self.text_func_name = text_func_name#组合搜索时，页面上生成显示的文本的函数

        self.val_func_name = val_func_name#组合搜索时，页面上生成的a标签中的值的函数

    def get_queryset(self, _field):

        if self.condition:#是数据的筛选条件

            return _field.rel.to.objects.filter(**self.condition)#拿到筛选后的对象

        return _field.rel.to.objects.all()#默认“全部”按钮被选中，给出所有对象

    def get_choices(self, _field):#是choices

        return _field.choices

#可迭代对象，封装了筛选中的每一行数据。

class FilterRow(object):

    def __init__(self, option, data, request):

        self.option = option

        self.data = data#关联字段所关联的表的所有有关联的数据

        # request.GET

        self.request = request

    def __iter__(self):

        params = copy.deepcopy(self.request.GET)#深拷贝？后面的内容，得到QueryDict

        params._mutable = True#可修改

        current_id = params.get(self.option.field_name)  #params.get（字段），得到的是值

        current_id_list = params.getlist(self.option.field_name)  # [1,2,3]

        if self.option.field_name in params:#地址栏已存在筛选条件

            # del params[self.option.field_name]，先删除

            origin_list = params.pop(self.option.field_name)#删除，并得到删除内容

            url = "{0}?{1}".format(self.request.path_info, params.urlencode())

            yield mark_safe('<a href="{0}">全部</a>'.format(url))#“全部按钮”不被选中

            params.setlist(self.option.field_name, origin_list)#将本身已存在的筛选条件放入params中

        else:

            url = "{0}?{1}".format(self.request.path_info, params.urlencode())#地址栏不存在筛选条件

            yield mark_safe('<a class="active" href="{0}">全部</a>'.format(url))#默认“全部”按钮被选中

        for val in self.data:

            if self.option.is_choice:# ( (1,男),(2,女)  )

                pk, text = str(val[0]), val[1]

            else:#每个val都是对象

                # pk, text = str(val.pk), str(val)

                text = self.option.text_func_name(val) if self.option.text_func_name else str(val)

                pk = str(self.option.val_func_name(val)) if self.option.val_func_name else str(val.pk)

            # 当前URL？option.field_name

            # 当前URL？gender=pk

            #制定url的显示规则：

            # self.request.path_info # http://127.0.0.1:8005/arya/crm/customer/?gender=1&id=2

            # self.request.GET['gender'] = 1 # &id=2gender=1

            if not self.option.multi:

                # 单选

                params[self.option.field_name] = pk#1,2

                url = "{0}?{1}".format(self.request.path_info, params.urlencode())

                if current_id == pk:#当前url筛选条件中的值

                    yield mark_safe("<a class='active' href='{0}'>{1}</a>".format(url, text))#该筛选按钮被选中

                else:

                    yield mark_safe("<a href='{0}'>{1}</a>".format(url, text))#其余按钮，没被选中

            else:

                # 多选 current_id_list = ["1","2"]

                _params = copy.deepcopy(params)

                id_list = _params.getlist(self.option.field_name)#["1","2","3","4"]

                if pk in current_id_list:#值已存在，表示该按钮已被选中

                    id_list.remove(pk)#将该值从id_list中去除

                    _params.setlist(self.option.field_name, id_list)#["2","3","4"]

                    url = "{0}?{1}".format(self.request.path_info, _params.urlencode())

                    #该按钮被选中，但其a标签的href中跳转的链接即当前url去除本身按钮id的状态，即该按钮，被再次点击时，就会恢复未选中状态

                    yield mark_safe("<a class='active' href='{0}'>{1}</a>".format(url, text))

                else:#值未存在

                    id_list.append(pk)

                    # params中被重新赋值

                    _params.setlist(self.option.field_name, id_list)

                    # 创建URL，赋予其被点时，使其产生被选中

                    url = "{0}?{1}".format(self.request.path_info, _params.urlencode())

                    yield mark_safe("<a href='{0}'>{1}</a>".format(url, text))

class ChangeList(object):

    '''

    很牛逼的一个类，封装了所有视图函数想要往前端传的内容

    功能：使视图函数中的代码变的简洁

    '''

    def __init__(self,config,queryset):

        self.config=config#stark.py中写了派生类的话就是那个类，没写的话默认就是StarkConfig

        self.list_display=config.get_list_display()

        self.edit_link = config.get_edit_link()

        self.model_class=config.model_class#数据库的表

        self.request=config.request#StarkConfig中默认是None，不过程序运行后就会有

        self.show_add_btn=config.get_show_add_btn()

        # 搜索框

        self.show_search_form = config.get_show_search_form()

        self.search_form_val = config.request.GET.get(config.search_key, '')#搜索关键字“_q”,首次访问网页默认是空

        # 批量操作

        self.actions=config.get_actions()#得到派生类中写的actions的内容[]

        self.show_actions=config.get_show_actions()#操作框

        #组合搜索

        self.show_comb_filter=config.get_show_comb_filter()

        self.comb_filter=config.get_comb_filter()

        from utils.pager import Pagination

        #分页器

        current_page = self.request.GET.get('page', 1)#得到传入的page，没有默认为第一页

        total_count = queryset.count()#要显示的数据的量，queryset在视图函数中有数据库操作的赋值

        page_obj = Pagination(current_page, total_count, self.request.path_info, self.request.GET, per_page_count=5)

                            #当前页         数据量        当前url不带问号         ？后面的条件内容      设定的每页显示的数据量条数

        self.page_obj = page_obj#得到最终生成的分页器对象

        self.data_list = queryset[page_obj.start:page_obj.end]#得到分页后的数据，用于页面展示

    #批量操作

    def modify_actions(self):

        result = []#批量操作内容，默认为空，去派生类中定义

        for func in self.actions:#self.actions=config.get_actions()，默认为空

            temp = {'name':func.__name__,'text':func.short_desc}#name是函数名，text是自加的描述

            result.append(temp)

        return result

    def add_url(self):#添加操作的url

        query_str = self.request.GET.urlencode()

        if query_str:

            # 重新构造,用于跳转

            params = QueryDict(mutable=True)

            params[self.config._query_param_key] = query_str

            return self.config.get_add_url()+'?'+params.urlencode()

        return self.config.get_add_url()

    def head_list(self):

        #构造表头

        result = []

        # [checkbox,'id','name',edit,del]

        for field_name in self.list_display:

            if isinstance(field_name, str):

                # 根据类和字段名称，获取字段对象的verbose_name

                verbose_name = self.model_class._meta.get_field(field_name).verbose_name

            else:

                verbose_name = field_name(self.config, is_header=True)# 去派生类中执行

            result.append(verbose_name)

        return result

    def body_list(self):

        # 处理表中的数据

        data_list = self.data_list#self.data_list = queryset[page_obj.start:page_obj.end]

        new_data_list = []

        for row in data_list:

            # row是 每一条数据对象UserInfo(id=2,name='alex2',age=181)

            temp = []

            for field_name in self.list_display:

                if isinstance(field_name,str):#派生类中定义的显示字段

                    val = getattr(row,field_name)

                else:#每个td都拥有的功能，checkbox、edit、delete、

                    val = field_name(self.config,row)

                # 用于定制编辑列

                if field_name in self.edit_link:

                    val = self.edit_link_tag(row.pk, val)

                temp.append(val)

            new_data_list.append(temp)

        return new_data_list

    def gen_comb_filter(self):

        #生成器函数

        """

        [

             FilterRow(((1,'男'),(2,'女'),)),

             FilterRow([obj,obj,obj,obj ]),

             FilterRow([obj,obj,obj,obj ]),

        ]

        """

        '''

                comb_filter = [

                v1.FilterOption('gender', is_choice=True),#关键字传参，代表是choice

                v1.FilterOption('depart'),#, 筛选只显示id大于三的部门condition={'id__gt': 3}

                v1.FilterOption('roles', True),#True传入，代表是多选

            ]

                '''

        from django.db.models import ForeignKey,ManyToManyField

        for option in self.comb_filter:

            _field = self.model_class._meta.get_field(option.field_name)#字段

            if isinstance(_field,ForeignKey):

                # 获取当前字段depart，关联的表 Department表并获取其所有数据

                # print(field_name,_field.rel.to.objects.all())

                row = FilterRow(option, option.get_queryset(_field), self.request)

            elif isinstance(_field,ManyToManyField):

                # print(field_name, _field.rel.to.objects.all())

                # data_list.append(  FilterRow(_field.rel.to.objects.all()) )

                row = FilterRow(option,option.get_queryset(_field), self.request)

            else:

                # print(field_name,_field.choices)

                # data_list.append(  FilterRow(_field.choices) )

                row = FilterRow(option,option.get_choices(_field),self.request)

            # 可迭代对象，迭代详细在FilterRow的__iter__中

            yield row

    def edit_link_tag(self,pk,text):

        query_str = self.request.GET.urlencode()  # page=2&nid=1

        params = QueryDict(mutable=True)

        params[self.config._query_param_key] = query_str

        return mark_safe('<a href="%s?%s">%s</a>' % (self.config.get_change_url(pk), params.urlencode(),text,))  # /stark/app01/userinfo/

class StarkConfig(object):

    """

        用于为每个类（即每张表）生成url对应关系，并处理用户请求的基类

    """

    def __init__(self,model_class,site):

        self.model_class=model_class

        self.site=site

        self.request=None

        self._query_param_key='_listfilter'#？后面的条件内容

        self.search_key='_q'#搜索关键字

#####################################定制功能######################################

#########1 默认每个tr都会拥有的td

    def checkbox(self,obj=None,is_header=False):

        if is_header:

            return '选择'

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

    def edit(self,obj=None,is_header=False):

        if is_header:

            return '编辑操作'

        #url地址栏的搜索条件

        query_str=self.request.GET.urlencode()

        if query_str:

            #重新构造<button class="btn btn-primary"></button>

            params=QueryDict(mutable=True)

            params[self._query_param_key]=query_str

            return mark_safe('<button class="btn btn-primary"><a href="%s?%s" style="color:white;">编辑</a></button>' %(self.get_change_url(obj.id),params.urlencode(),))

        return mark_safe('<button class="btn btn-primary"><a href="%s" style="color:white;">编辑</a></button>' %(self.get_change_url(obj.id),))

    def delete(self,obj=None,is_header=False):

        if is_header:

            return '删除操作'

        query_str = self.request.GET.urlencode()

        if query_str:

            # 重新构造

            params = QueryDict(mutable=True)

            params[self._query_param_key] = query_str

            return mark_safe('<button class="btn btn-danger"><a href="%s?%s" style="color:white;">删除</a></button>' % (self.get_delete_url(obj.id), params.urlencode(),))

        return mark_safe('<button class="btn btn-danger"><a href="%s" style="color:white;">删除</a></button>'%(self.get_delete_url(obj.id),) )

    list_display=[]

    #得到派生类中自定义的list_display

    def get_list_display(self):

        data=[]

        if self.list_display:#派生类中定义的要显示的字段

            data.extend(self.list_display)#加入到data中

            data.append(StarkConfig.edit)#加入编辑td

            data.append(StarkConfig.delete)#加入删除td

            data.insert(0,StarkConfig.checkbox)#在最前面插一个td

        return data

    edit_link=[]

    def get_edit_link(self):

        result=[]

        if self.edit_link:

            result.extend(self.edit_link)

        return result

######### 2是否显示add按钮

    show_add_btn = True  # 默认显示

    def get_show_add_btn(self):

        return self.show_add_btn

#########3 关键字搜索

    show_search_form = False#默认不显示

    def get_show_search_form(self):

        return self.show_search_form

    search_fields = []#关键字默认为空

    def get_search_fields(self):

        result = []

        if self.search_fields:

            result.extend(self.search_fields)#派生类中自定义的关键字

        return result

    def get_search_condition(self):

        key_word = self.request.GET.get(self.search_key)#'_q'

        search_fields = self.get_search_fields()#关键字

        condition = Q()#创建Q对象用于与或

        condition.connector = 'or'#搜索条件之间用或连接

        if key_word and self.get_show_search_form():

            for field_name in search_fields:

                condition.children.append((field_name, key_word))

        return condition

#############4 actions

    show_actions = False#默认不显示

    def get_show_actions(self):

        return self.show_actions

    actions = []#默认批量操作内容为空

    def get_actions(self):

        result = []

        if self.actions:

            result.extend(self.actions)#加入派生类中自定制的批量操作

        return result

#############5 组合搜索

    show_comb_filter = False

    def get_show_comb_filter(self):

        return self.show_comb_filter

    comb_filter=[]#默认为空

    def get_comb_filter(self):

        result=[]

        if self.comb_filter:

            result.extend(self.comb_filter)#得到派生类中的条件删选

        return result

#############6排序

    order_by = []

    def get_order_by(self):

        result = []

        result.extend(self.order_by)

        return result

##################################访问相应网址时需要作数据处理的视图函数##########################

    # 默认列表页面

    def changelist_view(self, request,*args, **kwargs):

        #分页，已改写到ChangeList类中

        # from utils.pager import Pagination

        # current_page=request.GET.get('page',1)

        # total_count=self.model_class.objects.all().count()

        # page_obj=Pagination(current_page,total_count,request.path_info,request.GET,per_page_count=4)

        if request.method=='GET':

            comb_condition = {}#筛选条件默认为空

            option_list = self.get_comb_filter()#拿到派生类中定制的筛选条件

            for key in request.GET.keys():#？后面的键

                value_list = request.GET.getlist(key)#拿到键对应的值[1,2,3]

                flag = False

                for option in option_list:#option是每一个删选条件

                    if option.field_name == key:#该条件已存在于地址栏

                        flag = True

                        break

                if flag:

                    #comb_condition = {"id__in":[1,2,3].......}

                    comb_condition["%s__in" % key] = value_list

            # 带搜索条件的数据，没有搜索条件的话就是全部数据。有筛选条件的话，还得处理成筛选后的数据

            queryset=self.model_class.objects.filter(self.get_search_condition()).filter(**comb_condition).distinct()

            the_list=ChangeList(self,queryset)#封装好要向前端传的值

            return render(request, 'stark/changelist.html', {'the_list':the_list})

        elif request.method=='POST' and self.get_show_actions():#批量操作

            func_name_str = request.POST.get('list_action')#前端传的操作name

            action_func = getattr(self, func_name_str)#反射，得到处理的方式

            ret = action_func(request)

            if ret:

                return ret

    # 一劳永逸的modelform

    model_form_class = None

    def get_model_form_class(self):

        if self.model_form_class:

            return self.model_form_class

        from django.forms import ModelForm

        # class TestModelForm(ModelForm):

        #     class Meta:

        #         model = self.model_class

        #         fields = "__all__"

        #

        #         error_messages = {

        #             "__all__":{

        #

        #                   },

        #         'email': {

        #         'required': '',

        #         'invalid': '邮箱格式错误..',

        #         }

        #         }

        # type创建TestModelForm类

        meta = type('Meta', (object,), {'model': self.model_class, 'fields': '__all__'})

        TestModelForm = type('TestModelForm', (ModelForm,), {'Meta': meta})

        return TestModelForm

    #增

    def add_view(self, request, *args, **kwargs):

        # 添加页面

        model_form_class = self.get_model_form_class()#根据modelform生成input

        _popbackid = request.GET.get('_popbackid')#临时需要添加的外键字段所对应的输入框的id

        if request.method == 'GET':

            form = model_form_class()

        else:

            form = model_form_class(request.POST)

            if form.is_valid():

                new_obj=form.save()

                if _popbackid:

                    # 判断是否是来源于popup请求

                    # render一个页面，写自执行函数

                    # popUp('/stark/crm/userinfo/add/?_popbackid=id_consultant&model_name=customer&related_name=consultant')

                    from django.db.models.fields.reverse_related import ManyToOneRel, ManyToManyRel

                    result = {'status': False, 'id': None, 'text': None, 'popbackid': _popbackid}

                    model_name = request.GET.get('model_name')  # customer

                    related_name = request.GET.get('related_name')  # consultant, "None"

                    for related_object in new_obj._meta.related_objects:#关联表的对象

                        _model_name = related_object.field.model._meta.model_name

                        _related_name = related_object.related_name

                        # 判断外键关联字段是否是主键id

                        if (type(related_object) == ManyToOneRel):

                            _field_name = related_object.field_name

                        else:

                            _field_name = 'pk'

                        _limit_choices_to = related_object.limit_choices_to

                        if model_name == _model_name and related_name == str(_related_name):

                            is_exists = self.model_class.objects.filter(**_limit_choices_to, pk=new_obj.pk).exists()

                            if is_exists:

                                # 如果新创建的用户是可查看的人，页面才增加

                                # 分门别类做判断：

                                result['status'] = True

                                result['text'] = str(new_obj)

                                result['id'] = getattr(new_obj, _field_name)

                                return render(request, 'stark/popup_response.html',

                                              {'json_result': json.dumps(result, ensure_ascii=False)})

                    return render(request, 'stark/popup_response.html',

                                  {'json_result': json.dumps(result, ensure_ascii=False)})

                else:

                    list_query_str = request.GET.get(self._query_param_key)

                    list_url = '%s?%s' % (self.get_list_url(), list_query_str,)

                    return redirect(list_url)

                    # return redirect(self.get_list_url())

        return render(request, 'stark/add_view.html', {'form': form, 'config': self})

    #删

    def delete_view(self, request, nid,*args, **kwargs):

        self.model_class.objects.filter(pk=nid).delete()

        list_query_str = request.GET.get(self._query_param_key)

        list_url = '%s?%s' % (self.get_list_url(), list_query_str,)

        return redirect(list_url)

    #改

    def change_view(self, request, nid,*args, **kwargs):

        # self.model_class.objects.filter(id=nid)

        obj = self.model_class.objects.filter(pk=nid).first()

        print(obj)

        if not obj:

            return redirect(self.get_list_url())

        model_form_class = self.get_model_form_class()

        _popbackid = request.GET.get('_popbackid')#临时需要添加的外键字段所对应的输入框的id

        # GET,显示标签+默认值

        if request.method == 'GET':

            form = model_form_class(instance=obj)

            return render(request, 'stark/change_view.html', {'form': form,'config': self})

        else:

            form = model_form_class(instance=obj, data=request.POST)

            if form.is_valid():

                form.save()

                list_query_str=request.GET.get(self._query_param_key)

                list_url='%s?%s'%(self.get_list_url(),list_query_str,)

                return redirect(list_url)

            return render(request, 'stark/change_view.html', {'form': form})

############################反向生成url##########################################

    def get_change_url(self, nid):

        name = 'stark:%s_%s_change' % (self.model_class._meta.app_label, self.model_class._meta.model_name)

        edit_url = reverse(name, args=(nid,))

        return edit_url

    def get_list_url(self):

        name = 'stark:%s_%s_changelist' % (self.model_class._meta.app_label, self.model_class._meta.model_name)

        edit_url = reverse(name)

        return edit_url

    def get_add_url(self):

        name = 'stark:%s_%s_add' % (self.model_class._meta.app_label, self.model_class._meta.model_name)

        edit_url = reverse(name)

        return edit_url

    def get_delete_url(self, nid):

        name = 'stark:%s_%s_delete' % (self.model_class._meta.app_label, self.model_class._meta.model_name)

        edit_url = reverse(name, args=(nid,))

        return edit_url

##########################################################################################################

    #装饰器，为了传参数request

    def wrap(self,view_func):

        def inner(request,*args,**kwargs):

            self.request=request

            return view_func(request,*args,**kwargs)

        return inner

    def get_urls(self):#第五步

        app_model_name=(self.model_class._meta.app_label,self.model_class._meta.model_name,)#元祖（app名，表名）

        url_patterns=[

            url(r'^$',self.wrap(self.changelist_view),name='%s_%s_changelist'%app_model_name),

            url(r'^add/$',self.wrap(self.add_view),name='%s_%s_add'%app_model_name),

            url(r'^(\d+)/delete/$',self.wrap(self.delete_view),name='%s_%s_delete'%app_model_name),

            url(r'^(\d+)/change/$',self.wrap(self.change_view),name='%s_%s_change'%app_model_name),

        ]

        url_patterns.extend(self.extra_url())#除增删改查外，想要自定义的新增的url

        return url_patterns#最后就得到了需要用到的一堆url

    def extra_url(self):

        return []

#############################################################################################

    @property

    def urls(self):#第四步

        return self.get_urls()

########传说中类与类之间的分界线############################################################################

class StarkSite(object):

    '''

    单例模式创建的对象的类,是一个容器，用于放置处理请求对应关系

    {model.UserInfo:StarkConfig(model.UserInfo,self)}

    '''

    def __init__(self):

        self._registry = {}

    def register(self,model_class,stark_config_class=None):

        if not stark_config_class:

            #stark_config_class即29，没写那个派生类的时候默认给予StarkConfig

            stark_config_class=StarkConfig

        self._registry[model_class]=stark_config_class(model_class,self)

        #表名：stark_config_class（表名，self）

    def get_urls(self):#第三步，给url

        url_pattern=[]

        for model_class,stark_config_obj in self._registry.items():#去字典里取值

            app_name=model_class._meta.app_label#app名

            model_name=model_class._meta.model_name#表名

            curd_url=url(r'^%s/%s/'%(app_name,model_name),(stark_config_obj.urls,None,None))

            #拼接生成url，需执行stark_config_obj.urls———第四步

            url_pattern.append(curd_url)

        return url_pattern

    @property

    def urls(self):#第二步，要url

        return (self.get_urls(),None,'stark')

site=StarkSite()#第一步，单例模式

v1.py

巴特西