stark - 4 ⇲ 视图函数

✘  list_view

处理表格（默认是显示表结构的所有字段）

 1 list_display = self.get_list_display()
 # 4.1处理表头
 header_list = []
 if list_display:
     for multi_key in list_display:
         if isinstance(multi_key,FunctionType):  #判断 传入值是否为函数
             verbose_name = multi_key(self,obj=None,is_header=True)
         else:
             verbose_name = self.model_class._meta.get_field(multi_key).verbose_name
         header_list.append(verbose_name)
 else:
     header_list.append(self.model_class._meta.model_name)

 # 4.2处理表的内容
 data_list = queryset[pager.start:pager.end]

 body_list = []
 for row in data_list:  #row 是UserInfo object (1)
     row_list = []

     if list_display:
         for multi_key in list_display:
             if isinstance(multi_key,FunctionType):
                 row_list.append(multi_key(self,row,is_header=False,*args,**kwargs))
             else:
                 row_list.append(getattr(row,multi_key))  #获取UserInfo object (1)的属性
     else:
         row_list.append(row)

     body_list.append(row_list)

为了能够扩展以后业务的功能（推出新的业务，高级用户可能要显示多的列或者新的功能），我们可以针对某张表进行自定义修改定制。只需在自己的Handler子类重写此方法

这是StarkHandler类的方法
1     list_display = []
     def get_list_display(self):
         """
         获取页面上应该显示的列,预留自定义扩展
         :return:
         """
         field_list = []
         field_list.extend(self.list_display)
         return field_list

在上面方法的架构基础下，实现以往对表〔编辑〕〔删除〕的基本功能，同样放在基类中

如图           

 def display_edit(self,obj=None,is_header=None):
     """
     生成<编辑>a标签
     :param obj:
     :param is_header:
     :return:
     """
     if is_header:
         return "编辑操作"
     change_url = self.reverse_change_url(pk=obj.pk)
     return mark_safe('<a href="%s">编辑</a>'%change_url)

 def display_delete(self,obj=None,is_header=None):
     """
     生成<删除>a标签
     :param obj:
     :param is_header:
     :return:
     """
     if is_header:
         return "删除操作"
     delete_url = self.reverse_delete_url(pk=obj.pk)
     return mark_safe('<a href="%s">删除</a>'% delete_url)

示例：

 #models.py下的Major类：
 #class Major(models.Model):
 #    title = models.CharField(verbose_name='专业',max_length=32)
 #
 #    def __str__(self):
 #        return self.title

 #该model类view函数下，继承StarkHanler，list_display[字段+方法]：
 from stark.service.v1 import StarkHandler

 class MajorHandler(StarkHandler):
     list_display = ['title',StarkHandler.display_edit,StarkHandler.display_delete]

---

但是，如果表结构里有choice字段呢？

则需要使用obj.get_字段名_display 获取orm对象的信息。解决的话，同样写一个方法放在基类，以后提取choice字段的信息直接使用

 这里不是StarkHandler类。
 1 def get_choice_text(title,field):
     """
     对于Stark组件中定义列时，choice如果想要显示中文信息，调用此方法即可
     :param title: 表头名称（自定义）
     :param field: 字段名称（需要提取的）
     :return:
     """
     def inner(self,obj=None,is_header=None):
         if is_header:
             return title
         method = "get_%s_display" %field
         return getattr(obj,method)()

     return inner

Exa: list_display=[get_choice_text('性别','gender')]

表结构里有manytomany的字段呢？

 def get_m2m_text(title, field):
     """
     对于Stark组件中定义列时，显示m2m文本信息
     :param title: 表头名称
     :param field: 字段名称
     :return:
     """

     def inner(self, obj=None, is_header=None, *args, **kwargs):
         if is_header:
             return title
         queryset = getattr(obj, field).all()
         text_list = [str(row) for row in queryset]
         return ','.join(text_list)

     return inner

Exa: list_display=[get_m2m_text('授课老师','teacher')]

---

当存储数据多了呢？滚动查找所有数据？

这边借鉴了前辈所写的分页组件

 """
 分页组件
 """
 from django.utils.safestring import mark_safe

 class Pagination(object):
     def __init__(self, current_page, all_count, base_url, query_params, per_page=20, pager_page_count=11):
         """
         分页初始化
         :param current_page: 当前页码
         :param per_page: 每页显示数据条数
         :param all_count: 数据库中总条数
         :param base_url: 基础URL
         :param query_params: QueryDict对象，内部含所有当前URL的原条件
         :param pager_page_count: 页面上最多显示的页码数量
         """
         self.base_url = base_url
         try:
             self.current_page = int(current_page)
             if self.current_page <= 0:
                 raise Exception()
         except Exception as e:
             self.current_page = 1
         self.query_params = query_params
         self.per_page = per_page
         self.all_count = all_count
         self.pager_page_count = pager_page_count
         pager_count, b = divmod(all_count, per_page)
         if b != 0:
             pager_count += 1
         self.pager_count = pager_count

         half_pager_page_count = int(pager_page_count / 2)
         self.half_pager_page_count = half_pager_page_count

     @property
     def start(self):
         """
         数据获取值起始索引
         :return:
         """
         return (self.current_page - 1) * self.per_page

     @property
     def end(self):
         """
         数据获取值结束索引
         :return:
         """
         return self.current_page * self.per_page

     def page_html(self):
         """
         生成HTML页码
         :return:
         """
         # 如果数据总页码pager_count<11 pager_page_count
         if self.pager_count < self.pager_page_count:
             pager_start = 1
             pager_end = self.pager_count
         else:
             # 数据页码已经超过11
             # 判断： 如果当前页 <= 5 half_pager_page_count
             if self.current_page <= self.half_pager_page_count:
                 pager_start = 1
                 pager_end = self.pager_page_count
             else:
                 # 如果： 当前页+5 > 总页码
                 if (self.current_page + self.half_pager_page_count) > self.pager_count:
                     pager_end = self.pager_count
                     pager_start = self.pager_count - self.pager_page_count + 1
                 else:
                     pager_start = self.current_page - self.half_pager_page_count
                     pager_end = self.current_page + self.half_pager_page_count

         page_list = []

         if self.current_page <= 1:
             prev = '<li><a href="#">上一页</a></li>'
         else:
             self.query_params['page'] = self.current_page - 1
             prev = '<li><a href="%s?%s">上一页</a></li>' % (self.base_url, self.query_params.urlencode())
         page_list.append(prev)
         for i in range(pager_start, pager_end + 1):
             self.query_params['page'] = i
             if self.current_page == i:
                 tpl = '<li class="active"><a href="%s?%s">%s</a></li>' % (
                     self.base_url, self.query_params.urlencode(), i,)
             else:
                 tpl = '<li><a href="%s?%s">%s</a></li>' % (self.base_url, self.query_params.urlencode(), i,)
             page_list.append(tpl)

         if self.current_page >= self.pager_count:
             nex = '<li><a href="#">下一页</a></li>'
         else:
             self.query_params['page'] = self.current_page + 1
             nex = '<li><a href="%s?%s">下一页</a></li>' % (self.base_url, self.query_params.urlencode(),)
         page_list.append(nex)
         page_str = "".join(page_list)
         return mark_safe(page_str)

Combine▼

 list_view下的分页功能:
 1         all_count = queryset.count()
         query_params = request.GET.copy() # ?=page=1&name='李四'
         query_params._mutable = True  #query_params['page']默认是不可以修改的

         pager = Pagination(
             current_page=request.GET.get('page'),
             all_count=all_count,
             base_url=request.path_info,
             query_params=query_params,
             per_page=self.per_page_count,
         )

✘  add_view

如图，    

为了能够在模板循环展示表单数据、错误信息等，我们得创建forms.ModelForm对象，然后把form对象传递过去。

但是每张表model_class所产生的form对象是不一样的，因此不同请求进来都得创建一个ModelForm，这样就太不方便了

解决：

 class DynamicModelForm(forms.ModelForm):
     class Meta:
         model = self.model_class  不把model表写死了，应该是动态的，即需要访问的model类
         fields = "__all__"

在这基础下，封装成为一个方法，往后需要产生form对象时，代入model类，直接调用。

     model_form = False
     def get_model_form(self):
         if self.model_form:   #预留勾子，拓展或者自定义定制覆盖即可
             return self.model_form

         class DynamicModelForm(forms.ModelForm):
             class Meta:
                 model = self.model_class
                 fields = "__all__"

             def __init__(self, *args, **kwargs):
                 super(DynamicModelForm, self).__init__(*args, **kwargs)
                 # 统一给ModelForm生成字段添加样式
                 for name, field in self.fields.items():
                     field.widget.attrs['class'] = 'form-control'

         return DynamicModelForm

如果有需求想让form对象多一行确认密码，或者控制显示的行呢？

前者可以在子类重写ModelForm，而后者我们则需为form.save()预留勾子，方便拓展或重写覆盖。

     def save(self,request,form,is_update,*args,**kwargs):
         form.save()

实现save基操下，想到如果在点击添加按钮的时候，URL本身带有 /?page=1的参数下，执行添加操作后，理应返回原来页面的时候带回这个参数。

这里，简单地理一下。

1.在进入添加路由时，我们先把参数部分urlencode()，然后把数据作为键值"_filter"的value值，最后urlencode() 作为新的参数。

     def reverse_add_url(self,**kwargs):
         name = "%s:%s" % (self.site.namespace, self.get_add_url_name)  #stark:Web_customer_public_list
         url = reverse(name,kwargs=kwargs)

         if not self.request.GET:
             add_url = url
         else:
             param = self.request.GET.urlencode()  # page=1

             new_query_dict = QueryDict(mutable=True)
             new_query_dict['_filter'] = param  # <QueryDict: {'_filter': ['page=1']}>

             add_url = "%s?%s" % (url, new_query_dict.urlencode(()))

         return add_url

2.类似地，添加完后 redirect 回原来页面并带回参数

     def reverse_list_url(self,**kwargs):
         name = "%s:%s" % (self.site.namespace, self.get_list_url_name)
         url = reverse(name,kwargs=kwargs)
         if not self.request.GET:
             list_url = url
         else:
             param = self.request.GET.get('_filter')
             # print(param)  #page=1
             if not param:
                 return redirect(url)
             list_url = "%s?%s" % (url, param)

         return list_url

所有的铺垫下，添加视图方法基本完成。

     def add_view(self,request,*args,**kwargs):
         """
         添加视图
         :param request:
         :return:
         """
         model_form = self.get_model_form()
         if request.method == 'GET':
             form = model_form
             return render(request, 'change.html', {'form': form})

         form = model_form(data=request.POST)
         if form.is_valid():
             response =  self.save(request,form,False,*args,**kwargs)
             return response or redirect(self.reverse_list_url(**kwargs))
         return render(request,'change.html',{'form':form})

✘  change_view

基本跟添加视图一样，只是form对象在表单默认显示数据

     def get_change_object(self, request, pk, *args, **kwargs):
         return self.model_class.objects.filter(pk=pk).first()

     def change_view(self,request,pk,*args,**kwargs):
         """
         编辑视图
         :param request:
         :param pk:
         :return:
         """
         checked_obj = self.get_change_object(request, pk, *args, **kwargs)

         if not checked_obj:
             return render(request,'rbac\error.html')

         model_form = self.get_model_form()
         if request.method == 'GET':
             form = model_form(instance=checked_obj)
             return render(request, 'change.html', {'form': form})

         form = model_form(data=request.POST,instance=checked_obj)
         if form.is_valid():
             response = self.save(request, form, True, *args, **kwargs)
             return response or redirect(self.reverse_list_url(**kwargs))
         return render(request, 'change.html', {'form': form})

✘  delete_view

基本跟添加视图一样。

这里继承以往为了防止用户删除数据时小手一抖，做出的确认选择按钮

     def delete_object(self, request, pk, *args, **kwargs):
         self.model_class.objects.filter(pk=pk).delete()

     def delete_view(self,request,pk,*args,**kwargs):
         """
         删除视图
         :param request:
         :param pk:
         :return:
         """
         checked_obj  = self.model_class.objects.filter(pk=pk).first()
         if not checked_obj:
             return render(request,'rbac\error.html',)

         list_url = self.reverse_list_url(**kwargs)
         if request.method == 'GET':
             return render(request,'delete.html',{'list_url':list_url})

         response = self.delete_object(request, pk, *args, **kwargs)
         return response or redirect(list_url)