Xadmin显示视图
1.display显示要设置的字段
1. 自定义样式类，显示出要显示的字段，在这个类中，也可以设置对应函数。 list_display=[check,"title",delete]
2.在 Modelxadmin中设置：list_display=["__str__"]
设置Modelxadmin的静态属性，即当注册的对象没使用样式类时，使用Modelxadmin的样式属性
3.处理表头
display中的函数名或者变量名作为表头
1.需要判断传的列表中的内容是函数名还是字符串
2.如果是字符串，判断是"__str__"还是其他的
3.让相应的字符串表头显示对应的中文，取到字段对象，引用字段中的verbose_name
4.处理表单数据
需要判断传的列表中的内容是函数名还是字符串
1.若是函数名，去执行对应的函数，取到对应的值
2.若是变量，利用反射到相应的数据中取到值
2.设定样式类list_display
from Xadmin.service.Xadmin import site,Modelxadmin from app01 import models from django.utils.safestring import mark_safe class BookConfig(Modelxadmin): href=change/'%s/'自动在当前路径后拼接路径 def edit(self, obj=None, is_header=False): if is_header: # 此时作表头处理 return "操作" return mark_safe("<a href='change/%s/'>编辑</a>"%obj.pk) def delete(self, obj=None, is_header=False): if is_header: # 此时作表头处理 return "删除" return mark_safe("<a href='del/%s/'>删除</a>" % obj.pk) def check(self, obj=None, is_header=False): if is_header: # 此时作表头处理 return "选择" return mark_safe("<input type='checkbox'>") list_display=[check,"title","price","publish","authors",edit,delete] site.register(models.Book,BookConfig)
3.显示设置
1.处理表头
处理表头 [check，'title', 'prcie',edit]
# 1.需要判断传的列表中的内容是函数名还是字符串
# 2.如果是字符串，判断是"__str__"还是其他的
head=[] for field in self.list_display: if isinstance(field,str): if field=="__str__": val=self.model._meta.model_name.upper() #如果没定义样式类，表头就显示操作表的名字的大写 else: # class Book(models.Model): # title = models.CharField(max_length=32, verbose_name="书名") # price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name="价格") #如果是字段字符串，让表头显示其定义的中文表头。title是字段对象，找到title后title.verbose_name 获取这个属性值 obj=self.model._meta.get_field(field) val=obj.verbose_name else: val = field(self,is_header=True) head.append(val)
2.处理表单数据
使用反射 data_list=self.model.objects.all() #取出每一条数据的对象，data_list[0].字段名(title) 就能得到相应的数据 content = [] for obj in data_list: temp=[] for field in self.list_display:#自定义的样式类中有可能放的是自定义的函数名[check，'title', 'prcie',edit] #需要判断传的列表中的内容是函数名还是字符串 if isinstance(field,str): #判断数据类型 val=getattr(obj,field) #相当于obj.title,obj.price 其中obj.__str__会自动触发这个方法 print("结果是：",val) else: val=field(self,obj,) #定义的方法，obj为这个方法执行的哪条数据对象 temp.append(val) content.append(temp) return render(request,"list.html",{"content":content,"head":head,"type":type})
4.利用反向路由解析得到路径
''' #Modelxadmin中设置 class Modelxadmin(object): list_display=["__str__"] #设置Modelxadmin的静态属性，即当注册的对象没使用样式类时，使用Modelxadmin的样式属性 def __init__(self,model,site): #如果传的是book，model就是Book 传的是publish，model就是Publiah self.model=model self.site=site self.model_name = self.model._meta.model_name #得到app名 self.app_name = model._meta.app_label #得到表名 #为路由设置别名： def get_url_2(self): temp = [] # print("=====",model_name ) # temp.append(url(r"^$", self.list_view)) temp.append(url(r"^$", self.list_view,name="{}/{}_list".format( self.app_name, self.model_name))) temp.append(url(r"^add/$", self.add_view,name="{}/{}_add".format( self.app_name, self.model_name))) # temp.append(url(r"^(\d+)/change/$", self.change_view,)) temp.append(url(r"^change/(\d+)/$", self.change_view,name="{}/{}_change".format( self.app_name, self.model_name) )) temp.append(url(r"^del/(\d+)/$", self.del_view,name="{}/{}_del".format( self.app_name, self.model_name))) return temp #自定以样式类中设置： from django.utils.safestring import mark_safe from django.urls import reverse class BookConfig(Modelxadmin): def edit(self, obj=None, is_header=False): if is_header: # 此时作表头处理 return "操作" #BookConfig中没有self.app_name，就去Modelxadmin找 url_name="{}/{}_change".format( self.app_name, self.model_name) v = reverse(url_name, args=(obj.pk,)) return mark_safe("<a href='%s'>编辑</a>" % v) '''
显示页面的html
''' <p> <span>序号</span> {% for foo in head %} <span>{{ foo }}</span> {% endfor %} </p> {% for foo in content %} <P> <span>{{ forloop.counter }}</span> {% for foo1 in foo %} <span>{{ foo1 }}</span> {% endfor %} </P> {% endfor %} '''
5.显示多对多的关系字段
多对多的字段，传过去之后在页面上显示字符串：app01.Author.None
例：作者是多对多的关系 list_display=[check,"title","price","publish","authors",edit,delete] 传过去之后在页面上显示字符串：app01.Author.None 解决方法一：将ManytoMany这个字段当作函数名传过去，不再写成字符串 在样式类中定义ManytoMany字段方法： def display_authors(self,obj=None, is_header=False): if is_header: return "作者名称" s=[] for author in obj.authors.all(): #必须使用all(),得到所有的作者对象 s.append(author.name) #取出每个作者对象的name属性 val=" | ".join(s) return mark_safe(val) list_display = [check, "title", "price", "publish", display_authors, edit, delete] 方法二：判断是不是ManytoMany类型 data_list=self.model.objects.all() #取出每一条数据的对象，data_list[0].字段名(title) 就能得到相应的数据 content = [] for obj in data_list: temp=[] for field in self.list_display:#自定义的样式类中有可能放的是自定义的函数名[check，'title', 'prcie',edit] #需要判断传的列表中的内容是函数名还是字符串 if isinstance(field,str): #判断数据类型 #处理多对多的字段方法二：判断是不是ManytoMany类型 from django.db.models.fields.related import ManyToManyField many_obj = self.model._meta.get_field(field) #取到字段对象 if isinstance(many_obj,ManyToManyField): t=[] for i in getattr(obj,field).all(): t.append(i.name) val=" | ".join(t) else:val=getattr(obj,field) #相当于obj.title,obj.price 其中obj.__str__会自动触发这个方法 list_display=[check,"title","price","publish","authors",edit,delete]
6.将删除，编辑，选择按钮封装起来
''' app01.Xadmin 1.使用继承：但是需要在每个样式类中设定 class Operation(): def edit(self, obj,is_header): if is_header: # 此时作表头处理 return "操作" else: url_name = "{}/{}_change".format(self.app_name, self.model_name) # BookConfig中没有self.app_name，就去Modelxadmin找 v = reverse(url_name, args=(obj.pk,)) return mark_safe("<a href='%s'>编辑</a>" % v) def delete(self, obj, is_header): if is_header: # 此时作表头处理 return "操作" return mark_safe("<a href='del/%s/'>删除</a>" % obj.pk) def check(self, obj, is_header): if is_header: # 此时作表头处理 return "选择" else:print(777) return mark_safe("<input type='checkbox'>") class BookConfig(Modelxadmin, Operation): def check(self,obj=None, is_header=False):return super().check(obj, is_header) def edit(self,obj=None, is_header=False):return super().edit(obj, is_header) def delete(self,obj=None, is_header=False):return super().delete(obj, is_header) list_display=[check,"title","price","publish","authors",edit,delete] #如果不在BookConfig中定义check，edit，delete函数，在list_dispaly中加函数名后，会显示未定义。在用super调用时不能传位置参数 2.在Xadmin中设置，将check，edit，delete加到每个模型表的样式类中，模型表的样式类就不用再加这些函数 class Modelxadmin(object): # 选择按钮 编辑 删除 def edit(self, obj=None, is_header=False): if is_header: # 此时作表头处理 return "操作" else: v=self.get_change_url(obj) return mark_safe("<a href='%s'>编辑</a>" %v) def delete(self, obj=None, is_header=False): if is_header: # 此时作表头处理 return "操作" v = self.get_del_url(obj) return mark_safe("<a href='%s'>删除</a>" %v) def check(self, obj=None, is_header=False): if is_header: # 此时作表头处理 return "选择" v = self.get_del_url(obj) return mark_safe("<input type='checkbox'>") #构建新的list_dispaly def new_list_display(self): temp=[] temp.append(Modelxadmin.check) temp.extend(self.list_display) temp.append(Modelxadmin.edit) temp.append(Modelxadmin.delete) return temp #处理表头 [check，'title', 'prcie',edit] for field in self.new_list_display():pass #处理表单数据，使用反射 data_list=self.model.objects.all() #取出每一条数据的对象，data_list[0].字段名(title) 就能得到相应的数据 content = [] for obj in data_list: temp=[] for field in self.new_list_display():pass 样式类中直接传要显示的字段 list_display = ["title", "price", "publish", "authors"] '''
7.设定样式类list_display_link
1.在循环表单数据时，如果list_display中的字段名在list_display_link，就将改字段的内容设置成编辑标签
2.如果表中数据设置成了编辑标签，那么编辑这个操作就没什么用了，应该判断如果样式中无list_display_link，就显示编辑操作，
有list_display_link则不显示编辑操作
在new_list_display中判断是否加编辑操作 def new_list_display(self): temp=[] temp.append(Modelxadmin.check) temp.extend(self.list_display) #判断是否加编辑操作 if not self.list_display_link: temp.append(Modelxadmin.edit) temp.append(Modelxadmin.delete) return temp ##将相应值设置成编辑标签 from django.db.models.fields.related import ManyToManyField try: many_obj = self.model._meta.get_field(field) #取到字段对象 if isinstance(many_obj,ManyToManyField): t=[] for i in getattr(obj,field).all(): t.append(i.name) val=" | ".join(t) else: #判断改字段是否在list_display_link，如果在，就设置成标签形式，不再就正常显示 if field in self.list_display_link: edit_url=self.get_change_url(obj) val=mark_safe("<a href='%s'>%s</a>"%(edit_url,getattr(obj,field))) else:val=getattr(obj,field) except Exception as e: val = getattr(obj, field)
显示页面的函数形式
''' def list_view(self, request): #self是Modelxadmin的实例对象，要么是自定义样式类的实例对象 # print("这里是：", model_name ) type=request.GET.get("name") if not type:type="" print(type) print(self.model) #用户调用的哪张表，self.model就是哪张表 <class 'app02.models.Order'> print("新的是：",self.new_list_display()) #处理表头 [check，'title', 'prcie',edit] # 1.需要判断传的列表中的内容是函数名还是字符串 # 2.如果是字符串，判断是"__str__"还是其他的 head=[] # for field in self.list_display: for field in self.new_list_display(): if isinstance(field,str): if field=="__str__": print("食物") val=self.model._meta.model_name.upper() #如果没定义样式类，表头就显示操作表的名字的大写 else: # class Book(models.Model): # title = models.CharField(max_length=32, verbose_name="书名") # price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name="价格") #如果是字段字符串，让表头显示其定义的中文表头。title是字段对象，找到title后title.verbose_name 获取这个属性值 obj=self.model._meta.get_field(field) val=obj.verbose_name else: val = field(self,is_header=True) head.append(val) print(head) #处理表单数据，使用反射 data_list=self.model.objects.all() #取出每一条数据的对象，data_list[0].字段名(title) 就能得到相应的数据 content = [] for obj in data_list: temp=[] # for field in self.list_display:#自定义的样式类中有可能放的是自定义的函数名[check，'title', 'prcie',edit] for field in self.new_list_display(): #需要判断传的列表中的内容是函数名还是字符串 if isinstance(field,str): #判断数据类型 #处理多对多的字段方法二：判断是不是ManytoMany类型 from django.db.models.fields.related import ManyToManyField try: #如果是__str__ 走到这会报错，因此使用抛出异常处理 many_obj = self.model._meta.get_field(field) #取到字段对象 if isinstance(many_obj,ManyToManyField): t=[] for i in getattr(obj,field).all(): t.append(i.name) val=" | ".join(t) else: # val=getattr(obj,field) #相当于obj.title,obj.price 其中obj.__str__会自动触发这个方法 #判断改字段是否在list_display_link，如果在，就设置成标签形式，不再就正常显示 if field in self.list_display_link: edit_url=self.get_change_url(obj) val=mark_safe("<a href='%s'>%s</a>"%(edit_url,getattr(obj,field))) else:val=getattr(obj,field) except Exception as e: val = getattr(obj, field) print("结果是：",val) else: val=field(self,obj,) #定义的方法，obj为这个方法执行的哪条数据对象 temp.append(val) print("temp是：", temp) content.append(temp) print("content是：", content) # ##获取增加页面的url 点击增加的时候，跳到增加页面。自动拼接 # add_url="add" return render(request,"list.html",{"content":content,"head":head,"type":type,"add_url":self.get_add_url()}) '''
8.设置分页
将分页方法设置为显示类得属性，用时直接用对象调用
class ShowList(object): def __init__(self,config,data_list,request): self.config=config #config是Modelxadmin的对象 self.data_list=data_list self.request=request ##配置分页设置： current_page = self.request.GET.get("page") pagination = Pagination(current_page, self.data_list.count(), "%s" % self.config.get_list_url(), self.request.GET, per_page_num=3) self.pagination=pagination self.model_list = self.data_list[pagination.start:pagination.end] def get_body(self): content = [] for obj in self.model_list:pass #循环分完页之后数据对象
分页条：
<ul class="pull-right">
{{show_list.pagination.page_html|safe }}
</ul>
9.搜索功能
搜索时用GET请求,后端很根据收到的搜索条件进行处理，在显示全部数据的基础上，将符合搜索的内容显示出来
未使用搜索时，获得当前对象的所有内容
data_list = self.model.objects.all()
加了搜索，就在这基础上进行条件搜索，使用filter
data_list = self.model.objects.filter(条件)
获取到设定的搜索字段，使用Q()进行操作，将字符串类型的字段和接受到的搜索值加到Q()中，搜索时会检测所有对象的这个字段中是否含有搜索值，如果有，就把这个
对象取出来
class Modelxadmin(object): search_fields = [] def get_search(self, request): search_condition = Q() search_condition.connector = 'or' search_value = request.GET.get("search_value") if search_value: for search_field in self.search_fields: search_condition.children.append((search_field + "__icontains", search_value)) return search_condition def list_view(self, request): #self是Modelxadmin的实例对象，要么是自定义样式类的实例对象 #print(self.model) #用户调用的哪张表，self.model就是哪张表 <class 'app02.models.Order'> search_condition=self.get_search(request) data_list = self.model.objects.filter(search_condition) #search_condition有值，就按值搜索，无值就搜索全部
在显示页面，设置搜索框是否显示。通过判断search_fields来判断是都设置了搜索值，如果为空，在页面上就不显示搜索
HTML
''' {% if show_list.config.search_fields %} <div class="input-group"> <form action=" " method="GET"> <span class="input-group-btn"> <input type="text" name="search_value" class="form-control" placeholder="Search for..."> <button class="btn btn-default" >搜索</button> </span> </form> </div> {% endif %} '''
10.批处理功能
实现选择对应得操作后，执行对应得函数
批处理操作使用select选择的方式：value应对应函数名，显示的操作名称不应该直接再HTML中设定，
可以在后端为相应的执行函数起相应的名字
对函数做描述：foo.short_description="批量初始化" #对这个函数作描述
class A(): def foo(self,queryset): queryset.delete() foo.short_description="批量删除" def update(self,queryset): queryset.update(price=100) update.short_description="批量初始化" #对这个函数作描述 action=[foo,update] b=A() for i in b.action: #i是函数名 print(i.__name__,i.short_description) HTML中 <option value="{{ i.__name__ }}">{{ i.short_description) }}</option>
1.设置批处理函数
在app01 Xadmin中设置自定义处理函数： class BookConfig(Modelxadmin): def all_update(self,request,queryset): #queryset为数据对象 queryset.update(price=998) list_url = self.get_list_url() return redirect("%s" % list_url) all_update.short_description="批量初始化" actions=[all_update,] 在全局中设置批量删除函数： class Modelxadmin(object): actions=[] def all_delete(self,request,queryset): queryset.delete() list_url=self.get_list_url() return redirect("%s"%list_url) all_delete.short_description="批量删除"
2.在Modelxadmin将批量删除和样式类中的actions合到一起
def get_action(self): #将批量删除和样式类中的actions合到一起 temp=[] temp.append(self.all_delete) temp.extend(self.actions) #迭代添加 return temp #将得到的temp作为ShowList的一个属性，并函数名和描述值处理后在页面显示出来 class ShowList(object): self.actions=self.config.get_action() def new_actions(self): temp=[] for action in self.actions: temp.append({ "name":action.__name__, "desc":action.short_description }) return temp
3.HTML
<span class="input-group-btn" > <select name="action" id="" class="form-control"> <option value="">------------------</option> {% for foo in show_list.new_actions %} <option value="{{ foo.name }}">{{foo.desc }}</option> {% endfor %} </select> <button class="btn btn-default" >GO</button> </span>
4.后台接收处理：
class Modelxadmin(object): def list_view(self, request): if request.method=='POST': #批量操作 action=request.POST.get("action") #哪种操作,name="action",值为要执行操作的函数名 print("操作是",action) selected_pk=request.POST.getlist("selected") #操作的数据 action_obj=self.model.objects.filter(pk__in=selected_pk) action=getattr(self,action) ret=action(request,action_obj) return ret
完整的views.py
##批处理：得到注册对象样式类中指定的操作，并为所有的注册对象添加上删除操作 def all_delete(self,request,queryset): queryset.delete() list_url=self.get_list_url() return redirect("%s"%list_url) all_delete.short_description="批量删除" def get_action(self): #将批量删除和样式类中的actions合到一起 temp=[] temp.append(self.all_delete) temp.extend(self.actions) #迭代添加 return temp #将得到的temp作为ShowList的一个属性 def list_view(self, request): #self是Modelxadmin的实例对象，要么是自定义样式类的实例对象 if request.method=='POST': #批量操作 action=request.POST.get("action") #哪种操作 print("操作是",action) selected_pk=request.POST.getlist("selected") #操作的数据 action_obj=self.model.objects.filter(pk__in=selected_pk) action=getattr(self,action) ret=action(request,action_obj) return ret
11.过滤功能
1.首先在页面上展示出过滤的内容
页面收到后端传来的数据进行循坏操作，收到的应该是个字典：
{"publish":["a","a"],"author":["a","a"]}，key值为表名，value为表中的所有对象的名字，同时将value
设置成标签，herf设为？key=obj.pk的形式，点完标签后，后台接受到操作的表名和要操作的对象进行搜索操作，从而展示出来
2.在指定的app01中注册模型表中设置过滤的字段：以Book表为例：
class BookConfig(Modelxadmin): list_filter=["publish","authors"] 在Xadimn中作后台处理操作： class Modelxadmin(object): list_filter = []
首先要做的是创建出{"publish":["a","a"],"author":["a","a"]}这种类型给页面展示出来，展示出来之后，在做跳转操作，展示的处理都放在
ShowList中，在ShowList中定义处理函数。得到自定义的search_fields中，得到对应的字符串类型的字段，根据字符串，找到这个字段对象，根据字段
对象，得到关联表中的所有对象，将这个对象名做成链接返给页面
1.def get_filter_link_tags(self): # link_tags={"publish":["a","a"],"author":["a","a"]} link_tags={} for filter_field in self.list_filter: #["title", "price"] filter_field_obj=self.config.model._meta.get_field(filter_field) #得到Book表中的publish和authors字段 #得到字段对象关联表的所有对象。publish和authors中所有对象 related_data_list=filter_field_obj.rel.to.objects.all() temp=[] for obj in related_data_list: #对每个对象做处理 _url="%s=%s"%(filter_field,obj.pk) s="<a href='?%s'>%s</a>"%(_url,str(obj)) #在页面显示出？publish=2 temp.append(mark_safe(s)) link_tags[filter_field]=temp return link_tags
3.点击相应链接
在点击相应链接之后，点击publish中的对象显示？publish=2这种形式，点击author中的内容显示？author=2
但是要保存搜索条件，即在上次选的条件下继续搜索，达到？publish=2&？author=2的效果。使用request.GET
在第一次点击链接之后，页面刷新，会重新走到这一步，获取数据返还给页面，此时self.request.GET获取到？publish=2，在执行到循环authors的对象时
就会将参数拼接起来？publish=2&？author=2
def get_filter_link_tags(self): # link_tags={"publish":["a","a"],"author":["a","a"]} link_tags={} from copy import deepcopy for filter_field in self.list_filter: # /Xadmin/app01/book/?page=2 params = deepcopy(self.request.GET) #将后面的参数以字典的形式接收 {'page':2} filter_field_obj=self.config.model._meta.get_field(filter_field) #得到字段对象关联表的所有对象 related_data_list=filter_field_obj.rel.to.objects.all() temp=[] for obj in related_data_list: params[filter_field]=obj.pk # {"authors":2} _url=params.urlencode() # _url="%s=%s"%(filter_field,obj.pk) s="<a href='?%s'>%s</a>"%(_url,str(obj)) temp.append(mark_safe(s)) link_tags[filter_field]=temp return link_tags
4.点击完当前标签之后，当前标签添加背景色。通过判断当前的接受到的id和循环中的当前id是否相等
current_id=self.request.GET.get(filter_field) if current_id==str(obj.pk): s = "<a class='item' href='?%s'>%s</a>" % (_url, str(obj)) else: s="<a href='?%s'>%s</a>"%(_url,str(obj))
5.链接跳转
点击相应的标签后，后台接收到？publish=2这个数据，进行过滤查询，使用Q().children
class Modelxadmin(object): filter_condition=Q() for filter_field,val in request.GET.items(): ##当选择分页时，页面上会把page=2传过来，仍走这一步，但是表中并没有这个字段，所以会报错 if filter_field not in ['page',"search_value"]: filter_condition.children.append((filter_field,val)) data_list = self.model.objects.filter(filter_condition).filter(search_condition) #search_condition有值
过滤功能views.py
class BookConfig(Modelxadmin): list_filter=["publish","authors"] class Modelxadmin(object): list_filter = [] def list_view(self, request): filter_condition=Q() for filter_field,val in request.GET.items(): ##当选择分页时，页面上会把page=2传过来，仍走这一步，但是表中并没有这个字段，所以会报错 if filter_field not in ['page',"search_value"]: filter_condition.children.append((filter_field,val)) data_list = self.model.objects.filter(filter_condition).filter(search_condition) #search_condition有值，就按值搜索，无值就搜索全部 class ShowList(object): def get_filter_link_tags(self): # link_tags={"publish":["a","a"],"author":["a","a"]} link_tags={} from copy import deepcopy for filter_field in self.list_filter: # /Xadmin/app01/book/?page=2 params = deepcopy(self.request.GET)#将后面的参数以字典的形式接收 {'page':2} current_id=self.request.GET.get(filter_field) filter_field_obj=self.config.model._meta.get_field(filter_field) #得到字段对象关联表的所有对象 related_data_list=filter_field_obj.rel.to.objects.all() temp=[] for obj in related_data_list: params[filter_field]=obj.pk # {"authors":2} _url=params.urlencode() # _url="%s=%s"%(filter_field,obj.pk) if current_id==str(obj.pk): s = "<a class='item' href='?%s'>%s</a>" % (_url, str(obj)) else: s="<a href='?%s'>%s</a>"%(_url,str(obj)) temp.append(mark_safe(s)) link_tags[filter_field]=temp return link_tags HTML: <div class="col-sm-2"> {% for filter_filed,link_tag_list in show_list.get_filter_link_tags.items %} <p>By {{ filter_filed.upper }}</p> {% for link_tag in link_tag_list %} <p>{{ link_tag }}</p> {% endfor %} {% endfor %} </div>
