stark组件之过滤操作【模仿Django的admin】

一、先看下django的admin是如何实现过滤操作

首先在配置类中顶一个list_filter的列表，把要过滤的字段作为元素写i进去就可以了

class testbook(admin.ModelAdmin):
 
    # 第一步，定义一个函数，必须要接受三个参数
    def test_action(self,request,queryset):
        """
 
        :param request:
        :param queryset:这个就是需要批量操作的queryset对象
        :return:
        """
        print(queryset)
 
    # 第二步,为这个函数对象赋值一个新的属性
    test_action.short_description = "测试批量操作的函数"
 
    # 第三步，将函数对象添加到actions这个列表中
    actions = [test_action]
 
    list_filter = ["auther","publish"]

　　

重点是这里

最后我们看下页面的效果

下面我们重点看下点击过滤的元素的url

先点击一下作者2

然后在点击一下出版社2

二、下面在我们自己是如何实现类似Django的admin的过滤操作

1、先把用到的知识点梳理一下

        .active{
            color: #2b542c!important;
        }

　　

如果一个class的属性优先级不够，可以用上面的方式来实现

2、从request.GET中拿到参数，然后把这个参数中的一些数值改一下，然后在渲染回到GET方式在url中传参的样式，用urlencode方法

import copy
parms = copy.deepcopy(self.request.GET)
parms[filter_str] = obj.id
_url = "?{url}".format(url = parms.urlencode())

　　

3、通过字段的字符串去获取对应的字段对象，然后在通过字段对象获取这个字段对象的表对象的方法，这里注意，只有一对多，一对一，外键的字段可以这样操作

filter_obj = self.config.model._meta.get_field(filter_str)
# 通过字符串拿到这个字符串对应的字段对象
 
            # filter_obj
            # app1.book.auther <
            #
            # class 'django.db.models.fields.related.ManyToManyField'>
            #
            # filter_obj
            # app1.book.publish <
            #
            # class 'django.db.models.fields.related.ForeignKey'>
            #
            # filter_obj
            # app1.book.price <
            #
            # class 'django.db.models.fields.DecimalField'>
 
data_list = filter_obj.rel.to.objects.all()
 
            # <QuerySet [<auther: 作者1>, <auther: 作者2>, <auther: 作者3>, <auther: 作者4>, <auther: 作者5>]>
            # < QuerySet[ < publist: 出版社1 >, < publist: 出版社2 >, < publist: 出版社3 >, < publist: 出版社4 >, < publist: 出版社5 >] >

　　

3、判断字典中是否有某个k，这里直接用get方法

                if parms.get("p",None):
                    del parms["p"]
                # 这                if parms.get("p",None):
                    del parms["p"]
                # 这里做一个处理，点击过滤，把page的参数干掉里做一个处理，点击过滤，把page的参数干掉

　　

4、判断某个实例是否为某个类的实例，下面这个例子是判断i_obj这个对象是否为一个多对多这个类的实例的，这个类必须要用元组传递进去

                            from django.db.models.fields.related import ManyToManyField
                            i_obj = obj._meta.get_field(i)
                            if isinstance(i_obj,(ManyToManyField,)):
                                many = getattr(obj, i)
                                many_query_set = many.all()
                                temp = ""
                                for o in many_query_set:
                                    temp = temp + str(o) + "--"

　

先导入类，然后在判断　

下面我们看下我们的过滤是如何实现的

1、先看下页面的效果，右边就是我们实现的效果

2、首先在模型表的配置类里定了一个我们要支持的过滤的字段

class bookclass(stark.Starkclass):
 
    list_display = ["id","title","price","auther","publish"]
    list_display_links = ["id","price","auther"]
    search_fields = ["title","price"]
    def test_action(self,request,queryset):
        print(queryset,)
 
    actions = [test_action]
    # test_action.__name__ = "测试批量操作的函数"
    test_action.short_description = "测试批量操作的函数"
 
    modelformclass = mybookmodelform
 
    list_filter = ["title","auther", "publish",]

　　

当然我们也需要在父类中定义了一个同样的字段，这个是我们的常规套路

class Starkclass(object):
    list_display = ['__str__']
    list_display_links = []
    search_fields = []
    modelformclass = None
    actions = []
 
    list_filter = []

　　

3、然后我们看下前端的代码的实现

        <div class="col-md-4">
            <div class="filter">
                {% for k,v in get_filter.items %}
                    <div class="well">
                        <p>{{ k }}</p>
                        {% for tag in v %}
                            <p>{{ tag|safe }}</p>
                        {% endfor %}
                    </div>
                {% endfor %}
            </div>

　　

这里我们在截图看下前端的效果

这里其实一个面板，我们使用了bootstrap的well的样式，我们后端传递给前端的其实是一个字段,字典的k值是我们的要过滤的字段，字典的v值是我们这个字段对应的所有的值的a标签

4、下面我们看下具体的视图函数，首先因为这个和显示相关，我们还是把主要代码放在showlist这个类中来实现

        get_filter = showlist.get_filter_link_tag()
 
        return render(request,"list_view.html",{"data_list":data_list,"title_list":title_list,"page_str":page_str,"search_fields":self.search_fields,"action_str":action_str,
                                                "get_filter":get_filter
                                                })

　　

调用showlist类的get_filter_link_tag这个函数，然后将返回值渲染到前端

5、下面我们看下get_filter_link_tag这个函数的代码

  def get_filter_link_tag(self):
        link_dict = {}
        import copy
        for filter_str in self.config.list_filter:
            parms = copy.deepcopy(self.request.GET)
            # 通过字符串拿到这个字符串对应的字段对象
            filter_obj = self.config.model._meta.get_field(filter_str)
            print("filter_obj",filter_obj,type(filter_obj))
 
            # filter_obj
            # app1.book.auther <
            #
            # class 'django.db.models.fields.related.ManyToManyField'>
            #
            # filter_obj
            # app1.book.publish <
            #
            # class 'django.db.models.fields.related.ForeignKey'>
            #
            # filter_obj
            # app1.book.price <
            #
            # class 'django.db.models.fields.DecimalField'>
 
            # 获取当前的参数值，主要是为了吧选中的a标签加一个active的属性
            cid = int(self.request.GET.get(filter_str,0))
 
            from django.db.models.fields.related import ManyToManyField
            from django.db.models.fields.related import ForeignKey
            if isinstance(filter_obj,(ManyToManyField,ForeignKey)):
                print(filter_obj.rel.to.objects.all())
                # 通过字段对象跨表查询，必须是ManyToManyField或者ForeignKey的字段,
 
                # <QuerySet [<auther: 作者1>, <auther: 作者2>, <auther: 作者3>, <auther: 作者4>, <auther: 作者5>]>
                # < QuerySet[ < publist: 出版社1 >, < publist: 出版社2 >, < publist: 出版社3 >, < publist: 出版社4 >, < publist: 出版社5 >] >
                data_list = filter_obj.rel.to.objects.all()
            else:
                data_list = self.config.model.objects.all()
 
            temp = []
 
            # 这里要加一个全选的a标签,如果点出版社的是全部，则把参数中的出版社的标签全部去掉，如果点的是作者的全部，则把参数中作者的标签全部去掉
            all_dict = copy.deepcopy(parms)
            if all_dict:
                if all_dict.get(filter_str,None):
                    del all_dict[filter_str]
 
            print(parms,"parms",filter_str)
            _url = "?{url}".format(url=all_dict.urlencode())
            all_label = "<a href='{url}'>全部</a>".format(url = _url)
            temp.append(all_label)
            # 处理全部的a标签的的代码
            # --------------------------------------------------------------------
 
            for obj in data_list:
                parms[filter_str] = obj.id
                if parms.get("p",None):
                    del parms["p"]
                # 这里做一个处理，点击过滤，把page的参数干掉
 
                _url = "?{url}".format(url = parms.urlencode())
                # print(cid,obj.id,"------------------------------")
 
                # 这里做一下判断，如果当前的id和现在循环的id一样，则需要给这个a标签加一个属性，用以区分
                if int(cid) == obj.id:
                    a_str = "<a class='active' href='{url}'>{obj}</a>".format(obj=str(obj), url=_url)
                else:
                    a_str = "<a href='{url}'>{obj}</a>".format(obj=str(obj),url = _url)
                temp.append(a_str)
            link_dict[filter_str] = temp
        return link_dict

　　

首先循环我们定义的过滤的字典，通过字符串拿到这个字符串对应的字段对象

然后拿到GET方式传递过来的参数，这个参数主要是判断当然是否有我这个字段的过滤规则，有的话，则把当前过滤规则对应的a标签用active标记出来

            # 获取当前的参数值，主要是为了吧选中的a标签加一个active的属性
            cid = int(self.request.GET.get(filter_str,0))

　　

这里主要分别对多对多，一对多和普通字段做过滤，因为多对多字段和一对多可以做跨表查询，而普通字段是不能做跨表查询

            from django.db.models.fields.related import ManyToManyField
            from django.db.models.fields.related import ForeignKey
            if isinstance(filter_obj,(ManyToManyField,ForeignKey)):
                print(filter_obj.rel.to.objects.all())
                # 通过字段对象跨表查询，必须是ManyToManyField或者ForeignKey的字段,
 
                # <QuerySet [<auther: 作者1>, <auther: 作者2>, <auther: 作者3>, <auther: 作者4>, <auther: 作者5>]>
                # < QuerySet[ < publist: 出版社1 >, < publist: 出版社2 >, < publist: 出版社3 >, < publist: 出版社4 >, < publist: 出版社5 >] >
                data_list = filter_obj.rel.to.objects.all()
            else:
                data_list = self.config.model.objects.all()

　　

下面这段代码主要是为了处理all标签的，点击一下all，会把自己这个面板的字段对应的过滤参数去掉

            # 这里要加一个全选的a标签,如果点出版社的是全部，则把参数中的出版社的标签全部去掉，如果点的是作者的全部，则把参数中作者的标签全部去掉
            all_dict = copy.deepcopy(parms)
            if all_dict:
                if all_dict.get(filter_str,None):
                    del all_dict[filter_str]

　　

            print(parms,"parms",filter_str)
            _url = "?{url}".format(url=all_dict.urlencode())
            all_label = "<a href='{url}'>全部</a>".format(url = _url)
            temp.append(all_label)

　　

这里的代码主要是把参数中的页码相关参数去掉，我们点击一下过滤会有问题

  for obj in data_list:
                parms[filter_str] = obj.id
                if parms.get("p",None):
                    del parms["p"]
                # 这里做一个处理，点击过滤，把page的参数干掉
 
                _url = "?{url}".format(url = parms.urlencode())

　　

下面的代码就是返回一个a标签了的字典，也就是渲染在前端的字典

                # 这里做一下判断，如果当前的id和现在循环的id一样，则需要给这个a标签加一个属性，用以区分
                if int(cid) == obj.id:
                    a_str = "<a class='active' href='{url}'>{obj}</a>".format(obj=str(obj), url=_url)
                else:
                    a_str = "<a href='{url}'>{obj}</a>".format(obj=str(obj),url = _url)
                temp.append(a_str)
            link_dict[filter_str] = temp
        return link_dict

　　

还有一个就是显示数据相关，我们页面显示的数据应该是过滤后的数据

        q_obj = self.get_search(request)
        q_filter_obj = self.get_filter(request)
 
        if q_obj and q_filter_obj:
            new_data_list = self.model.objects.all().filter(q_obj).filter(q_filter_obj)
        elif q_obj and not q_filter_obj:
            new_data_list = self.model.objects.all().filter(q_obj)
        elif not q_obj and q_filter_obj:
            new_data_list = self.model.objects.all().filter(q_filter_obj)
        else:
            new_data_list = self.model.objects.all()

　　

我们看到这里把获取过滤字段重新写在一个函数中了

下面我们看下这个函数，这里同样用到了Q对象，不过这里的Q对象是and的关系，之前我们做的search是or的关系

    def get_filter(self,request):
        from django.db.models import Q
        q_filter_obj = Q()
        q_filter_obj.connector = "and"
        for k in self.list_filter:
            if request.GET.get(k,None):
                temp = (k,request.GET.get(k))
                q_filter_obj.children.append(temp)
        print(q_filter_obj,"q_filter_obj")
        return q_filter_obj

　　

最后我们把filter相关的所有的代码粘贴来，供大家学习

    def get_filter_link_tag(self):
        link_dict = {}
        import copy
        for filter_str in self.config.list_filter:
            parms = copy.deepcopy(self.request.GET)
            # 通过字符串拿到这个字符串对应的字段对象
            filter_obj = self.config.model._meta.get_field(filter_str)
            print("filter_obj",filter_obj,type(filter_obj))
 
            # filter_obj
            # app1.book.auther <
            #
            # class 'django.db.models.fields.related.ManyToManyField'>
            #
            # filter_obj
            # app1.book.publish <
            #
            # class 'django.db.models.fields.related.ForeignKey'>
            #
            # filter_obj
            # app1.book.price <
            #
            # class 'django.db.models.fields.DecimalField'>
 
            # 获取当前的参数值，主要是为了吧选中的a标签加一个active的属性
            cid = int(self.request.GET.get(filter_str,0))
 
            from django.db.models.fields.related import ManyToManyField
            from django.db.models.fields.related import ForeignKey
            if isinstance(filter_obj,(ManyToManyField,ForeignKey)):
                print(filter_obj.rel.to.objects.all())
                # 通过字段对象跨表查询，必须是ManyToManyField或者ForeignKey的字段,
 
                # <QuerySet [<auther: 作者1>, <auther: 作者2>, <auther: 作者3>, <auther: 作者4>, <auther: 作者5>]>
                # < QuerySet[ < publist: 出版社1 >, < publist: 出版社2 >, < publist: 出版社3 >, < publist: 出版社4 >, < publist: 出版社5 >] >
                data_list = filter_obj.rel.to.objects.all()
            else:
                data_list = self.config.model.objects.all()
 
            temp = []
 
            # 这里要加一个全选的a标签,如果点出版社的是全部，则把参数中的出版社的标签全部去掉，如果点的是作者的全部，则把参数中作者的标签全部去掉
            all_dict = copy.deepcopy(parms)
            if all_dict:
                if all_dict.get(filter_str,None):
                    del all_dict[filter_str]
 
            print(parms,"parms",filter_str)
            _url = "?{url}".format(url=all_dict.urlencode())
            all_label = "<a href='{url}'>全部</a>".format(url = _url)
            temp.append(all_label)
            # 处理全部的a标签的的代码
            # --------------------------------------------------------------------
 
            for obj in data_list:
                parms[filter_str] = obj.id
                if parms.get("p",None):
                    del parms["p"]
                # 这里做一个处理，点击过滤，把page的参数干掉
 
                _url = "?{url}".format(url = parms.urlencode())
                # print(cid,obj.id,"------------------------------")
 
                # 这里做一下判断，如果当前的id和现在循环的id一样，则需要给这个a标签加一个属性，用以区分
                if int(cid) == obj.id:
                    a_str = "<a class='active' href='{url}'>{obj}</a>".format(obj=str(obj), url=_url)
                else:
                    a_str = "<a href='{url}'>{obj}</a>".format(obj=str(obj),url = _url)
                temp.append(a_str)
            link_dict[filter_str] = temp
        return link_dict

　　

  q_filter_obj = self.get_filter(request)
 
        if q_obj and q_filter_obj:
            new_data_list = self.model.objects.all().filter(q_obj).filter(q_filter_obj)
        elif q_obj and not q_filter_obj:
            new_data_list = self.model.objects.all().filter(q_obj)
        elif not q_obj and q_filter_obj:
            new_data_list = self.model.objects.all().filter(q_filter_obj)
        else:
            new_data_list = self.model.objects.all()

　　

  def get_filter(self,request):
        from django.db.models import Q
        q_filter_obj = Q()
        q_filter_obj.connector = "and"
        for k in self.list_filter:
            if request.GET.get(k,None):
                temp = (k,request.GET.get(k))
                q_filter_obj.children.append(temp)
        print(q_filter_obj,"q_filter_obj")
        return q_filter_obj