----------------------------------------------------------------烦恼没完没了,内心动荡不安,呜呼哀哉.


一、有个特殊的需求,需要用stark组件来完成

django的admin,自己开发stark组件。完成类似数据库客户端的功能,对数据进行增删改查的需求。

二、这个特殊的需求,需要用stark组件来实现

1、在settings配置中分别注册这三个app

  1. # Application definition
  2.  
  3. INSTALLED_APPS = [
  4. 'django.contrib.admin',
  5. 'django.contrib.auth',
  6. 'django.contrib.contenttypes',
  7. 'django.contrib.sessions',
  8. 'django.contrib.messages',
  9. 'django.contrib.staticfiles',
  10. 'app01.apps.App01Config',
  11. 'app02.apps.App02Config',
  12. 'stark.apps.StarkConfig',
  13. ]

注:python manage.py startapp app02     创建新项目

2、在app01和app02的models文件中创建数据类

  1. from django.db import models
  2.  
  3. # Create your models here.
  4. from django.contrib.auth.models import AbstractUser
  5.  
  6. class UserInfo(models.Model):
  7. """
  8. 用户信息
  9. """
  10. nid = models.AutoField(primary_key=True)
  11. nickname = models.CharField(verbose_name='昵称', max_length=32)
  12. telephone = models.CharField(max_length=11, null=True, unique=True)
  13. avatar = models.FileField(upload_to = 'avatars/',default="/avatars/default.png")
  14. create_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)
  15. blog = models.OneToOneField(to='Blog', to_field='nid',null=True)
  16.  
  17. def __str__(self):
  18. return self.nickname
  19.  
  20. class Blog(models.Model):
  21.  
  22. """
  23. 博客信息
  24. """
  25. nid = models.AutoField(primary_key=True)
  26. title = models.CharField(verbose_name='个人博客标题', max_length=64)
  27. site = models.CharField(verbose_name='个人博客后缀', max_length=32, unique=True)
  28. theme = models.CharField(verbose_name='博客主题', max_length=32)
  29. #
  30. # def __str__(self):
  31. # return self.title
  32. class Category(models.Model):
  33. """
  34. 博主个人文章分类表
  35. """
  36. nid = models.AutoField(primary_key=True)
  37. title = models.CharField(verbose_name='分类标题', max_length=32)
  38. blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid')
  39.  
  40. def __str__(self):
  41. return self.title
  42. class Tag(models.Model):
  43.  
  44. nid = models.AutoField(primary_key=True)
  45. title = models.CharField(verbose_name='标签名称', max_length=32)
  46. blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid')
  47. def __str__(self):
  48. return self.title
  49. class Article(models.Model):
  50.  
  51. nid = models.AutoField(primary_key=True)
  52. title = models.CharField(max_length=50, verbose_name='文章标题')
  53. desc = models.CharField(max_length=255, verbose_name='文章描述')
  54.  
  55. comment_count= models.IntegerField(default=0)
  56. up_count = models.IntegerField(default=0)
  57. down_count = models.IntegerField(default=0)
  58.  
  59. create_time = models.DateTimeField(verbose_name='创建时间')
  60.  
  61. homeCategory = models.ForeignKey(to='Category', to_field='nid', null=True)
  62. #siteDetaiCategory = models.ForeignKey(to='SiteCategory', to_field='nid', null=True)
  63.  
  64. user = models.ForeignKey(verbose_name='作者', to='UserInfo', to_field='nid')
  65. tags = models.ManyToManyField(
  66. to="Tag",
  67. through='Article2Tag',
  68. through_fields=('article', 'tag'),
  69. )
  70.  
  71. def __str__(self):
  72. return self.title
  73. class ArticleDetail(models.Model):
  74. """
  75. 文章详细表
  76. """
  77. nid = models.AutoField(primary_key=True)
  78. content = models.TextField()
  79. article = models.OneToOneField(to='Article', to_field='nid')
  80.  
  81. class Article2Tag(models.Model):
  82. nid = models.AutoField(primary_key=True)
  83. article = models.ForeignKey(verbose_name='文章', to="Article", to_field='nid')
  84. tag = models.ForeignKey(verbose_name='标签', to="Tag", to_field='nid')
  85.  
  86. class Meta:
  87. unique_together = [
  88. ('article', 'tag'),
  89. ]
  90.  
  91. def __str__(self):
  92. v=self.article.title+"----"+self.tag.title
  93. return v
  1. from django.db import models
  2.  
  3. # Create your models here.
  4. class Book(models.Model):
  5. title=models.CharField(max_length=32,verbose_name="标题")
  1. python manage.py makemigrations
  2. python manage.py migrate

3、扫描(加载)每一个app下的stark.py

在app01和app02下分别创建一个stark.py文件,在项目启动时扫描每个app下的stark.py文件并执行

即在stark的apps.py中配置

  1. from django.apps import AppConfig
  2.  
  3. from django.utils.module_loading import autodiscover_modules
  4. class StarkConfig(AppConfig):
  5. name = 'stark'
  6.  
  7. def ready(self):
  8. autodiscover_modules('stark') #自动扫描

4、注册

仿照admin设置相关类,首先创建下面的文件

在执行admin.py文件时我们发现其实第一步就是导入admin,导入时通过单例模式生成了一个site对象,现在我们也来写一个类,生成一个单例对象

  1. class StarkSite(object):
  2.  
  3. def __init__(self):
  4. self._registry = {}
  5.  
  6. site = StarkSite()

在app01和app02的stark.py文件中导入

  1. from stark.service.stark import site

这样我们也就得到了一个单例对象site,在注册时admin使用的是site对象的register方法,我们也学着他写一个register方法

  1. class StarkSite(object):
  2.  
  3. def __init__(self):
  4. self._registry={}
  5.  
  6. def register(self,model,modle_stark=None):
  7. if not modle_stark:
  8. modle_stark=ModelStark
  9.  
  10. self._registry[model]=modle_stark(model)
  1. site = StarkSite()

这个方法的本质其实就是往self._registry这个字典中添加键值对,键就是我们的数据类(如Book类),值是一个类的对象,这个类就是我们要创建的第二个类,样式类

  1. class ModelStark(object):
  2.  
  3. def __init__(self, model, site):
  4. self.model = model
  5. self.site = site

self.model指的是什么?   就是用户访问的model

通过这个类我们控制页面展示的内容和样式

做完这几步我们就可以在app01和app02的stark.py文件中开始注册了

  1. #app01
  2.  
  3. from stark.service.stark import site
  4.  
  5. from .models import *
  6.  
  7. site.register(UserInfo,UserInfoConfig)
  8. site.register(Blog)
  9. site.register(Article)
  10. site.register(Category)
  11. site.register(Tag)
  12.  
  13. #app02
  1. from stark.service.stark import site
  2. from .models import *
  1. site.register(Book,BookConfig)

注册完成后,我们的site._registry字典中就有了我们注册类对应的键值对,接下来就要配置url了

5、url配置

admin中的url配置

  1. from django.conf.urls import url
  2. from django.contrib import admin
  3.  
  4. urlpatterns = [
  5. url(r'^admin/', admin.site.urls),
  6.  
  7. ]

可以看到所有的url都是在admin.site.urls这个方法中生成的,我可以看看这个方法的源码

  1. @property
  2. def urls(self):
  3. return self.get_urls(), 'admin', self.name

其实就是做了一个分发,url是在self.get_urls()这个函数中生成的,接着看这个函数的主要代码

  1. def get_urls(self):
  2. from django.conf.urls import url, include
  3. # Since this module gets imported in the application's root package,
  4. # it cannot import models from other applications at the module level,
  5. # and django.contrib.contenttypes.views imports ContentType.
  6. from django.contrib.contenttypes import views as contenttype_views
  7.  
  8. def wrap(view, cacheable=False):
  9. def wrapper(*args, **kwargs):
  10. return self.admin_view(view, cacheable)(*args, **kwargs)
  11. wrapper.admin_site = self
  12. return update_wrapper(wrapper, view)
  13.  
  14. # Admin-site-wide views.
  15. urlpatterns = [
  16. url(r'^$', wrap(self.index), name='index'),
  17. url(r'^login/$', self.login, name='login'),
  18. url(r'^logout/$', wrap(self.logout), name='logout'),
  19. url(r'^password_change/$', wrap(self.password_change, cacheable=True), name='password_change'),
  20. url(r'^password_change/done/$', wrap(self.password_change_done, cacheable=True),
  21. name='password_change_done'),
  22. url(r'^jsi18n/$', wrap(self.i18n_javascript, cacheable=True), name='jsi18n'),
  23. url(r'^r/(?P<content_type_id>\d+)/(?P<object_id>.+)/$', wrap(contenttype_views.shortcut),
  24. name='view_on_site'),
  25. ]
  26.  
  27. # Add in each model's views, and create a list of valid URLS for the
  28. # app_index
  29. valid_app_labels = []
  30. for model, model_admin in self._registry.items():
  31. urlpatterns += [
  32. url(r'^%s/%s/' % (model._meta.app_label, model._meta.model_name), include(model_admin.urls)),
  33. ]
  34. if model._meta.app_label not in valid_app_labels:
  35. valid_app_labels.append(model._meta.app_label)
  36.  
  37. # If there were ModelAdmins registered, we should have a list of app
  38. # labels for which we need to allow access to the app_index view,
  39. if valid_app_labels:
  40. regex = r'^(?P<app_label>' + '|'.join(valid_app_labels) + ')/$'
  41. urlpatterns += [
  42. url(regex, wrap(self.app_index), name='app_list'),
  43. ]
  44. return urlpatterns

这里我们需要知道到是我们生成的url的格式都是admin/app名/表名,所以我们要想办法取到app名和表名拼接起来

  1. for model, model_admin in self._registry.items():
  2. urlpatterns += [
  3. url(r'^%s/%s/' % (model._meta.app_label, model._meta.model_name), include(model_admin.urls)),
  4. ]

这里的model就是我们的数据类(如Book),如何通过他取到我们想要的呢

model._meta.app_label 取类所在的app名

model._meta.model_name 取类的名字

这样我们就成功拼接出了我们要的url,但是每个url下又有增删改查不同的url,这时又要再次进行分发,admin中使用了include方法,通过model_admin我们注册时样式类生成的对象下的url方法得到我们想要的

  1. def get_urls(self):
  2. from django.conf.urls import url
  3. def wrap(view):
  4. def wrapper(*args, **kwargs):
  5. return self.admin_site.admin_view(view)(*args, **kwargs)
  6. wrapper.model_admin = self
  7. return update_wrapper(wrapper, view)

  8.    info = self.model._meta.app_label, self.model._meta.model_name
  9. urlpatterns = [
  10. url(r'^$', wrap(self.changelist_view), name='%s_%s_changelist' % info),
  11. url(r'^add/$', wrap(self.add_view), name='%s_%s_add' % info),
  12. url(r'^(.+)/history/$', wrap(self.history_view), name='%s_%s_history' % info),
  13. url(r'^(.+)/delete/$', wrap(self.delete_view), name='%s_%s_delete' % info),
  14. url(r'^(.+)/change/$', wrap(self.change_view), name='%s_%s_change' % info),
  15. # For backwards compatibility (was the change url before 1.9)
  16. url(r'^(.+)/$', wrap(RedirectView.as_view(
  17. pattern_name='%s:%s_%s_change' % ((self.admin_site.name,) + info)
  18. ))),
  19. ]
  20. return urlpatterns
  21. @property
  22. def urls(self):
  23. return self.get_urls()

其实和之前一样,只是做了又一次分发,并且对应了视图函数,这里我们先不看视图函数的内容,值得注意的是这一次的分发和视图函数都是写在样式类中的,而不是写在生成site的AdminStie类中

这样有什么好处呢,我们知道当我们要注册时,是可以自己定义一些属性的,其实要显示的页面也是可以自己定义的,所以讲这最后一层url分发和对应的函数写在样式类中可以方便我们进行自定义

看完了admin的做法,我们可以来写我们自己的代码了。

stark配置

首先在urls文件中配置

  1. from django.conf.urls import url
  2. from django.contrib import admin
  3. from stark.service.stark import site
  4.  
  5. urlpatterns = [
  6. url(r'^admin/', admin.site.urls),
  7. url(r'^stark/', site.urls),
  8. ]

然后在我们创建的两个类中添加相关的代码,这里url对应的函数我们先简写

  1. from django.conf.urls import url
  2. from django.shortcuts import HttpResponse, render
  3.  
  4. class ModelStark(object):
  5.  
  6. def __init__(self, model, site):
  7. self.model = model
  8. self.site = site
  9.  
  10. def change_list(self, request):
  11. ret = self.model.objects.all()
  12. return render(request, "stark/change_list.html", locals())
  13.  
  14. def add_view(self, request):
  15. return HttpResponse("add_view")
  16.  
  17. def del_view(self, request, id):
  18. return HttpResponse("del_view")
  19.  
  20. def change_view(self, request, id):
  21. return HttpResponse("change_view")
  22.  
  23. def get_url_func(self):
  24. temp = []
  25. temp.append(url("^$", self.change_list))
  26. temp.append(url("^add/$", self.add_view))
  27. temp.append(url("^(\d+)/delete/$", self.del_view))
  28. temp.append(url("^(\d+)/change/$", self.change_view))
  29. return temp
  30.  
  31. @property
  32. def urls(self):
  33. return self.get_url_func(), None, None
  34.  
  35. class StarkSite(object):
  36.  
  37. def __init__(self):
  38. self._registry = {}
  39.  
  40. def register(self, model, model_config=None):
  41. if not model_config:
  42. model_config = ModelStark
  43.  
  44. self._registry[model] = model_config(model, self)
  45.  
  46. def get_urls(self):
  47. temp = []
  48. for model, model_config in self._registry.items():
  49. model_name = model._meta.model_name
  50. app_label = model._meta.app_label
  51. u = url("^%s/%s/" % (app_label, model_name), model_config.urls)
  52. temp.append(u)
  53. return temp
  54.  
  55. @property
  56. def urls(self):
  57. return self.get_urls(), None, None
  58.  
  59. site = StarkSite()

反向解析,别名的使用

在设置url对应的视图函数时,我们可以给这个url添加一个别名,在使用时可以通过这个别名来反向生成url,这样即使url有修改,这样别名不变我们都不需要修改代码

增加别名时要注意,由于每个数据类我们都生成了增删改查4条url,所以在写别名时应该有些区别,不然会引起混淆,所以我们设计别名的格式为app名_表名_*

  1. def get_url_func(self):
  2. temp = []
  3. model_name = self.model._meta.model_name
  4. app_label = self.model._meta.app_label
  5. app_model = (app_label, model_name)
  6. temp.append(url("^$", self.change_list, name="%s_%s_list" % app_model))
  7. temp.append(url("^add/$", self.add_view, name="%s_%s_add" % app_model))
  8. temp.append(url("^(\d+)/delete/$", self.del_view, name="%s_%s_delete" % app_model))
  9. temp.append(url("^(\d+)/change/$", self.change_view, name="%s_%s_change" % app_model))
  10. return temp
  11. @property
  12. def urls(self):
  13. return self.get_url_func(), None, None

6、列表展示页面

url设计完成后,我们就需要来设计每个url对应的页面了,我们注意到,其实不管是访问哪张表,增删改查都只对应相同的四个视图函数,那么应该如何区分我们访问的表呢

在样式类ModelStark中,我们定义了self.model,这里的model其实就是我们访问表的数据类,通过他我们就能拿到我们需要的数据显示到页面上,访问不同的表时这个model是不同的,这时就做到了访问什么表显示什么表的内容

list_display

在使用admin时,默认给我们展示的是一个个的类对象,当我们想要看到其它内容时,可以通过list_display属性设置

  1. from django.contrib import admin
  2. from .models import *
  3. # Register your models here.
  4.  
  5. admin.site.register(UserInfo)
  6.  
  7. class RoleConfig(admin.ModelAdmin):
  8. list_display = ["id", "title"]
  9. admin.site.register(Role, RoleConfig)

通过上面的方法,在访问admin页面时点击Role表就能看到id和title两个字段的内容了,现在我们也来仿照admin写一个list_display属性

首先,这个属性应该是可以自定制的,如果用户没有定制,那么他应该有一个默认值,所以我们可以在ModelStark样式类中先自己定义一个list_display静态属性

  1. class ModelStark(object):
  2. list_display = []
  3.  
  4. def __init__(self, model, site):
  5. self.model = model
  6. self.site = site

如果用户需要定制他,可以在app对应的stark.py文件中做如下配置

  1. class BookConfig(ModelStark):
  2. list_display = ["id", "title", "price"]
  3. site.register(Book, BookConfig)

这里我们写在list_display中的内容都是表中有的字段,其实里面还可以写我们自己定义的函数,用来将我们自己需要的内容显示到页面上

  1. from stark.service.sites import site, ModelStark
  2. from .models import *
  3. from django.utils.safestring import mark_safe
  4.  
  5. class BookConfig(ModelStark):
  6.  
  7. def edit(self, obj=None, is_header=False):
  8. if is_header:
  9. return "操作"
  10. return mark_safe("<a href='/stark/app01/book/%s/change'>编辑</a>" % obj.pk)
  11.  
  12. def delete(self, obj=None, is_header=False):
  13. if is_header:
  14. return "操作"
  15. return mark_safe("<a href='/stark/app01/book/%s/delete'>删除</a>" % obj.pk)
  16. list_display = ["id", "title", "price", edit, delete]
  17. site.register(Book, BookConfig)
  18.  
  19. class AuthorConfig(ModelStark):
  20. list_display = ["name", "age"]
  21. site.register(Author)

这里我们增加了编辑和删除两个函数,可以看到他们的返回值是一个a标签,这样就可以在页面上显示一个可以点击的编辑和删除,这里的mark_safe和前端渲染时用的safe是一样的功能,可以使标签正确的显示在页面上

这样我们就可以让页面显示成下面的样子

当我们处理列表页面对应的函数时就可以拿到list_display的值,再通过self.model取到对应的数据对象,从对象中拿到我们想要的数据,放到页面上进行显示

  1. class ModelStark(object):
  2. list_display = []
  3.  
  4. def __init__(self, model, site):
  5. self.model = model
  6. self.site = site
  7.  
  8. def change_list(self, request):
  9. # 生成表标头
  10. header_list = []
  11. for field in self.list_display:
  12. if callable(field):
  13. # header_list.append(field.__name__)
  14. val = field(self, is_header=True)
  15. header_list.append(val)
  16. else:
  17. field_obj = self.model._meta.get_field(field)
  18. header_list.append(field_obj.verbose_name)
  19.  
  20. # 生成表数据列表
  21. data_list = self.model.objects.all()
  22. new_data_list = []
  23. for obj in data_list:
  24. temp = []
  25. for field in self.list_display:
  26. if callable(field):
  27. val = field(self, obj)
  28. else:
  29. val = getattr(obj, field)
  30. temp.append(val)
  31. new_data_list.append(temp)
  32. return render(request, "stark/change_list.html", locals())

表头数据

首先,我们要生成表头,表头的内容应该根据list_display中写到的内容进行显示,这里要注意,如果我们在stark.py里自己写了样式类,那么list_display会优先从我们自己写的样式类中取,如果里面没有才会找到ModelStark中的

取到list_display的值后我们对他进行循环,如果值为可调用的,说明值为一个函数,那么我们就执行函数,取到我们要的结果,这里要注意执行函数时,我们给函数传了一个is_header=True,说明我们这次是取表头,在函数中我们给这个参数定义一个默认值为False

进入函数时,首先对他进行判断,如果为True,那么我们直接返回一个表头的信息就行了

  1. class BookConfig(ModelStark):
  2.  
  3. def edit(self, obj=None, is_header=False):
  4. if is_header:
  5. return "操作"
  6. return mark_safe("<a href='/stark/app01/book/%s/change'>编辑</a>" % obj.pk)
  7.  
  8. def delete(self, obj=None, is_header=False):
  9. if is_header:
  10. return "操作"
  11. return mark_safe("<a href='/stark/app01/book/%s/delete'>删除</a>" % obj.pk)
  12. list_display = ["id", "title", "price", edit, delete]
  13. site.register(Book, BookConfig)

上面的内容可以看到我们返回的表头内容为操作

如果我们循环list_display得到的值是一个字符串,那么说明这应该是表中的一个字段,这时我们可以通过self.model._meta.get_field(字段名)的方法取到这个字段的对象,这个对象有一个verbose_name的属性,这个属性是用来描述一个字段的,在models中可以进行定义

  1. class Book(models.Model):
  2. title = models.CharField(verbose_name="标题", max_length=32)
  3. price = models.DecimalField(verbose_name="价格", decimal_places=2, max_digits=5, default=12)
  4.  
  5. def __str__(self):
  6. return self.title

我们可以通过self.model._meta.get_field(字段名).verbose_name取到这个属性,将他作为表头,如果没有定义这个属性,那么默认值为字段名

表内容数据

取表内容数据时,和表头一样要做判断,判断list_display中的每一个值,如果是可调用的就执行函数取值,这里执行时,我们要将对应的数据对象传进去,这样在生成url时才能使用相关的id值

如果这个值是一个字符串,那么我们可以通过反射,取到数据对象中的值,最后将这些值组成下面形式的数据格式发给前端渲染

  1. '''
  2. [
  3. [1, "python", 12],
  4. [2, "linux", 12],
  5. [3,"php"], 12
  6.  
  7. ]
  8. '''

前端页面

  1. <!DOCTYPE html>
  2. <html lang="zh-CN">
  3. <head>
  4. <meta charset="UTF-8">
  5. <meta http-equiv="x-ua-compatible" content="IE=edge">
  6. <meta name="viewport" content="width=device-width, initial-scale=1">
  7. <title>Title</title>
  8. <link rel="stylesheet" href="/static/bootstrap-3.3.7/css/bootstrap.min.css">
  9. </head>
  10. <body>
  11. <h3>数据展示</h3>
  12.  
  13. <div class="container">
  14. <div class="row">
  15. <div class="col-md-8">
  16. <table class="table table-striped table-hover">
  17. <thead>
  18. <tr>
  19. {% for foo in header_list %}
  20. <td>{{ foo }}</td>
  21. {% endfor %}
  22. </tr>
  23. </thead>
  24. <tbody>
  25. {% for data in new_data_list %}
  26. <tr>
  27. {% for item in data %}
  28. <td>{{ item }}</td>
  29. {% endfor %}
  30. </tr>
  31. {% endfor %}
  32. </tbody>
  33. </table>
  34. </div>
  35. </div>
  36. </div>
  37. </body>
  38. </html>

添加checkbox选择框

在使用admin时可以看到展示页面上每条记录前都有一个选择框,可以选择多条记录进行批量操作,我们也给我们的组件增加这一功能,其实实现方法和编辑按钮类似

我们先自己定义一个checkbox函数,返回一个checkbox类型的input标签,然后将这个函数添加到list_display中即可

  1. class BookConfig(ModelStark):
  2.  
  3. def edit(self, obj=None, is_header=False):
  4. if is_header:
  5. return "操作"
  6. return mark_safe("<a href=%s>编辑</a>" % reverse("%s_%s_change" % self.app_model, args=(obj.pk,)))
  7.  
  8. def delete(self, obj=None, is_header=False):
  9. if is_header:
  10. return "操作"
  11. return mark_safe("<a href=%s>删除</a>" % reverse("%s_%s_delete" % self.app_model, args=(obj.pk,)))
  12.  
  13. def select(self, obj=None, is_header=False):
  14. if is_header:
  15. return "选择"
  16. return mark_safe("<input type='checkbox' value=%s />" % obj.pk)
  17.  
  18. list_display = [select, "id", "title", "price", edit, delete]
  19. site.register(Book, BookConfig)

全选

这里checkbox标签的value值可以设置为该记录的主键值,方便以后使用,当我们点击最上面的复选框时应该还有全选和全部取消的功能,这里只需要添加一段Js代码即可

  1. <!DOCTYPE html>
  2. <html lang="zh-CN">
  3. <head>
  4. <meta charset="UTF-8">
  5. <meta http-equiv="x-ua-compatible" content="IE=edge">
  6. <meta name="viewport" content="width=device-width, initial-scale=1">
  7. <title>Title</title>
  8. <link rel="stylesheet" href="/static/bootstrap-3.3.7/css/bootstrap.min.css">
  9. <script src="/static/jquery-3.2.1.min.js"></script>
  10. </head>
  11. <body>
  12. <h3>数据展示</h3>
  13.  
  14. <div class="container">
  15. <div class="row">
  16. <div class="col-md-8">
  17. <table class="table table-striped table-hover">
  18. <thead>
  19. <tr>
  20. {% for foo in header_list %}
  21. <td>{{ foo }}</td>
  22. {% endfor %}
  23. </tr>
  24. </thead>
  25. <tbody>
  26. {% for data in new_data_list %}
  27. <tr>
  28. {% for item in data %}
  29. <td>{{ item }}</td>
  30. {% endfor %}
  31. </tr>
  32. {% endfor %}
  33. </tbody>
  34. </table>
  35. </div>
  36. </div>
  37. </div>

  38. #新添加的js代码
  39. <script>
  40. $("#action-toggle").click(function () {
  41. if ($(this).prop("checked")){
  42. $("tbody :checkbox").prop("checked",true)
  43. }else{
  44. $("tbody :checkbox").prop("checked",false)
  45. }
  46. })
  47. </script>
  48. </body>
  49. </html>

我们还注意到,在编辑和删除函数中我们在生成url时采用了反向解析,利用我们之前使用的别名来反向生成url,这样就不会把url写死了

7、list_display的默认情况

上面的内容我们都是考虑了用户自己定制了list_display的情况,如果用户没用进行自定制呢,那么我们所使用的list_display就应该是ModelStark中定义好的

我们仿照admin将默认的list_display设置为__str__,这样在生成表头时我们需要多做一步判断,当为__str__时,直接将表名的大写添加到header_list中即可

  1. class ModelStark(object):
  2.  
  3. list_display = ["__str__",]
  4.  
  5. def __init__(self, model, site):
  6. self.model = model
  7. self.site = site
  8. self.app_model = (self.model._meta.app_label, self.model._meta.model_name)
  9.  
  10. # 查看数据视图
  11. def change_list(self, request):
  12. # 生成表标头
  13. header_list = []
  14. for field in self.list_display:
  15. if callable(field):
  16. # header_list.append(field.__name__)
  17. val = field(self, is_header=True)
  18. header_list.append(val)
  19. else:
  20. if field == "__str__":
  21. header_list.append(self.model._meta.model_name.upper())
  22. else:
  23. field_obj = self.model._meta.get_field(field)
  24. header_list.append(field_obj.verbose_name)
  25.  
  26. # 生成表数据列表
  27. data_list = self.model.objects.all()
  28. new_data_list = []
  29. for obj in data_list:
  30. temp = []
  31. for field in self.list_display:
  32. if callable(field):
  33. val = field(self, obj)
  34. else:
  35. val = getattr(obj, field)
  36. print(val)
  37. temp.append(val)
  38. new_data_list.append(temp)
  39. return render(request, "stark/change_list.html", locals())

这样我们就完成了默认情况的设置,但是我们发现在admin中不论用户如何设置list_display,其实我们都能看到复选框和编辑删除功能,所以我们也将编辑、删除和复选框的函数直接放入到ModelStark中作为默认配置,然后设置一个get_list_display函数,对所有的list_play都增加这三个功能

  1. class ModelStark(object):
  2. # 编辑按钮
  3. def edit(self, obj=None, is_header=False):
  4. if is_header:
  5. return "操作"
  6. name = "%s_%s_change" % self.app_model
  7. return mark_safe("<a href=%s>编辑</a>" % reverse(name, args=(obj.pk,)))
  8.  
  9. # 删除按钮
  10. def delete(self, obj=None, is_header=False):
  11. if is_header:
  12. return "操作"
  13. name = "%s_%s_delete" % self.app_model
  14. return mark_safe("<a href=%s>删除</a>" % reverse(name, args=(obj.pk,)))
  15.  
  16. # 复选框
  17. def checkbox(self, obj=None, is_header=False):
  18. if is_header:
  19. return mark_safe("<input type='checkbox' id='action-toggle'>")
  20. return mark_safe("<input type='checkbox' value=%s>" % obj.pk)
  21.  
  22. def get_list_display(self):
  23. new_list_display = []
  24. new_list_display.extend(self.list_display)
  25. new_list_display.append(ModelStark.edit)
  26. new_list_display.append(ModelStark.delete)
  27. new_list_display.insert(0, ModelStark.checkbox)
  28. return new_list_display
  29.  
  30. list_display = ["__str__",]
  31.  
  32. def __init__(self, model, site):
  33. self.model = model
  34. self.site = site
  35. self.app_model = (self.model._meta.app_label, self.model._meta.model_name)
  36.  
  37. # 查看数据视图
  38. def change_list(self, request):
  39. # 生成表标头
  40. header_list = []
  41. for field in self.get_list_display():
  42. if callable(field):
  43. # header_list.append(field.__name__)
  44. val = field(self, is_header=True)
  45. header_list.append(val)
  46. else:
  47. if field == "__str__":
  48. header_list.append(self.model._meta.model_name.upper())
  49. else:
  50. field_obj = self.model._meta.get_field(field)
  51. header_list.append(field_obj.verbose_name)
  52.  
  53. # 生成表数据列表
  54. data_list = self.model.objects.all()
  55. new_data_list = []
  56. for obj in data_list:
  57. temp = []
  58. for field in self.get_list_display():
  59. if callable(field):
  60. val = field(self, obj)
  61. else:
  62. val = getattr(obj, field)
  63. print(val)
  64. temp.append(val)
  65. new_data_list.append(temp)
  66. return render(request, "stark/change_list.html", locals())

我们还注意到通过自定制get_list_display函数我们可以实现一些我们自己的逻辑,比如根据权限判断是否需要加入编辑按钮等

8、list_display_links

使用admin时,我们还可以通过list_display_links设置一些字段,点击这些字段也能进入编辑页面

我们也来实现一下这个功能,首先在ModelStark中定义一个默认的list_display_links,当用户自己定制了这个属性时,我们只要在生成表数据时多做一步判断,如果字段在list_display_links中,则在返回时给字段加上一个a标签,使他可以跳转到编辑页即可

由于我们经常要用到增删改查的url,所以我们在ModelStark中定义4个方法,分别获取增删改查的url

  1. class ModelStark(object):
  2. list_display = ["__str__", ]
  3.  
  4. list_display_links = []
  5.  
  6. def __init__(self, model, site):
  7. self.model = model
  8. self.site = site
  9. self.app_model = (self.model._meta.app_label, self.model._meta.model_name)
  10.  
  11. # 获取当前查看表的编辑url
  12. def get_edit_url(self, obj):
  13. edit_url = reverse("%s_%s_change" % self.app_model, args=(obj.pk,))
  14. return edit_url
  15.  
  16. # 获取当前查看表的删除url
  17. def get_delete_url(self, obj):
  18. del_url = reverse("%s_%s_delete" % self.app_model, args=(obj.pk,))
  19. return del_url
  20.  
  21. # 获取当前查看表的增加url
  22. def get_add_url(self):
  23. add_url = reverse("%s_%s_add" % self.app_model)
  24. return add_url
  25.  
  26. # 获取当前查看表的查看url
  27. def get_list_url(self):
  28. list_url = reverse("%s_%s_list" % self.app_model)
  29. return list_url
  30.  
  31. # 查看数据视图
  32. def change_list(self, request):
  33. add_url = self.get_add_url()
  34. # 生成表标头
  35. header_list = []
  36. for field in self.get_list_display():
  37. if callable(field):
  38. # header_list.append(field.__name__)
  39. val = field(self, is_header=True)
  40. header_list.append(val)
  41. else:
  42. if field == "__str__":
  43. header_list.append(self.model._meta.model_name.upper())
  44. else:
  45. field_obj = self.model._meta.get_field(field)
  46. header_list.append(field_obj.verbose_name)
  47.  
  48. # 生成表数据列表
  49. data_list = self.model.objects.all()
  50. new_data_list = []
  51. for obj in data_list:
  52. temp = []
  53. for field in self.get_list_display():
  54. if callable(field):
  55. val = field(self, obj)
  56. else:
  57. val = getattr(obj, field)
  58. if field in self.list_display_links:
  59. val = mark_safe("<a href=%s>%s</a>" % (self.get_edit_url(obj), val))
  60. temp.append(val)
  61. new_data_list.append(temp)
  62. return render(request, "stark/change_list.html", locals())

这样当用户在stark.py中自己定义了list_display_links属性时,我们就能看到下面的效果了

  1. from stark.service.sites import site, ModelStark
  2. from .models import *
  3.  
  4. class BookConfig(ModelStark):
  5. list_display = ["id", "title", "price"]
  6. list_display_links = ["id"]
  7. site.register(Book, BookConfig)

如果能够点击字段内容进入编辑页面,那么我们自己定义的编辑按钮就可以不用显示了,所以可以在get_list_display中再做一次判断

  1. def get_list_display(self):
  2. new_list_display = []
  3. new_list_display.extend(self.list_display)
  4. if not self.list_display_links:
  5. new_list_display.append(ModelStark.edit)
  6. new_list_display.append(ModelStark.delete)
  7. new_list_display.insert(0, ModelStark.checkbox)
  8. return new_list_display

9、添加和编辑页面(modelform)

编辑页面和添加页面的功能我们通过ModelForm实现,但是生成ModelForm时,由于用户访问的表可能是不一样的,所以里面的详细字段我们不能写死,所以我们只能定义一个简单的ModelForm类,然后在ModelStark中设置一个model_form_class,默认为None

用户如果想要对ModelForm的详细字段做设置,可以自己定制一个类,并将该类设置为model_form_class的值

  1. class ModelStark(object):
  2. list_display = ["__str__", ]
  3.  
  4. model_form_class = None
  5.  
  6. list_display_links = []
  7.  
  8. def get_modelform_class(self):
  9. class ModelFormClass(ModelForm):
  10. class Meta:
  11. model = self.model
  12. fields = "__all__"
  13. if not self.model_form_class:
  14. return ModelFormClass
  15. else:
  16. return self.model_form_class

可以看到当用户未设置model_form_class时,我们用自己的类,当用户设置了,则使用用户自己的类

  1. from stark.service.sites import site, ModelStark
  2. from django.forms import ModelForm
  3. from .models import *
  4. from django.forms import widgets as wid
  5.  
  6. class BookModelForm(ModelForm):
  7. class Meta:
  8. model = Book
  9. fields = "__all__"
  10. error_messages = {
  11. "title": {"required": "不能为空"},
  12. "price": {"required": "不能为空"}
  13. }
  14.  
  15. class BookConfig(ModelStark):
  16. list_display = ["id", "title", "price"]
  17. model_form_class = BookModelForm
  18. list_display_links = ["id"]
  19. site.register(Book, BookConfig)

用户设置时就可以设置明确的字段信息了

添加和编辑的函数

  1. # 添加数据视图
  2. def add_view(self, request):
  3. ModelFormClass = self.get_modelform_class()
  4. if request.method == "GET":
  5. form = ModelFormClass()
  6. return render(request, "stark/add_view.html", locals())
  7. else:
  8. form = ModelFormClass(data=request.POST)
  9. if form.is_valid():
  10. form.save()
  11. return redirect(self.get_list_url())
  12. else:
  13. return render(request, "stark/add_view.html", locals())
  14.  
  15. # 编辑数据视图
  16. def change_view(self, request, id):
  17. edit_obj = self.model.objects.filter(pk=id).first()
  18. ModelFormClass = self.get_modelform_class()
  19. if request.method == "GET":
  20. form = ModelFormClass(instance=edit_obj)
  21. return render(request, "stark/change_view.html", locals())
  22. else:
  23. form = ModelFormClass(data=request.POST, instance=edit_obj)
  24. if form.is_valid():
  25. form.save()
  26. return redirect(self.get_list_url())
  27. else:
  28. return render(request, "stark/change_view.html", locals())

就是通过ModelForm来实现添加和编辑

前端页面,由于前端的页面基本相同,所以我们可以把相同的部分写到一个页面中,然后应include调用

  1. <div class="container">
  2. <div class="row">
  3. <div class="col-md-6">
  4. <form action="" method="post" novalidate>
  5. {% csrf_token %}
  6. {% for field in form %}
  7. <div class="form-group">
  8. <label for="">{{ field.label }}</label>
  9. <div>
  10. {{ field }}
  11. <span class="error pull-right">
  12. {{ field.errors.0 }}
  13. </span>
  14. </div>
  15.  
  16. </div>
  17. {% endfor %}
  18.  
  19. <p><input type="submit" class="btn btn-default"></p>
  20. </form>
  21. </div>
  22. </div>
  23. </div>

添加页面

  1. <!DOCTYPE html>
  2. <html lang="zh-CN">
  3. <head>
  4. <meta charset="UTF-8">
  5. <meta http-equiv="x-ua-compatible" content="IE=edge">
  6. <meta name="viewport" content="width=device-width, initial-scale=1">
  7. <title>添加</title>
  8. <link rel="stylesheet" href="/static/bootstrap-3.3.7/css/bootstrap.min.css">
  9. <script src="/static/jquery-3.2.1.min.js"></script>
  10. <style>
  11. .form-group input{
  12. display: block;
  13. width: 100%;
  14. height: 34px;
  15. padding: 6px 12px;
  16. font-size: 14px;
  17. line-height: 1.42857143;
  18. color: #555;
  19. background-color: #fff;
  20. background-image: none;
  21. border: 1px solid #ccc;
  22. border-radius: 4px;
  23. -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.075);
  24. box-shadow: inset 0 1px 1px rgba(0,0,0,.075);
  25. -webkit-transition: border-color ease-in-out .15s,-webkit-box-shadow ease-in-out .15s;
  26. -o-transition: border-color ease-in-out .15s,box-shadow ease-in-out .15s;
  27. transition: border-color ease-in-out .15s,box-shadow ease-in-out .15s;
  28. }
  29.  
  30. </style>
  31. </head>
  32. <body>
  33. <h3>添加数据</h3>
  34.  
  35. {% include 'stark/form.html' %}
  36.  
  37. </body>
  38. </html>

删除页面

当点击删除时,我们不直接将数据删除,而是给用户返回一个确认页面,用户点击确认才真的删除,点击取消还跳回列表页面

  1. # 删除数据视图
  2. def del_view(self, request, id):
  3. del_obj = self.model.objects.filter(pk=id).first()
  4. if request.method == "GET":
  5. list_url = self.get_list_url()
  6. return render(request, "stark/del_view.html", locals())
  7. else:
  8. del_obj.delete()
  9. return redirect(self.get_list_url())

前端页面

  1. <!DOCTYPE html>
  2. <html lang="zh-CN">
  3. <head>
  4. <meta charset="UTF-8">
  5. <meta http-equiv="x-ua-compatible" content="IE=edge">
  6. <meta name="viewport" content="width=device-width, initial-scale=1">
  7. <title>删除</title>
  8. <link rel="stylesheet" href="/static/bootstrap-3.3.7/css/bootstrap.min.css">
  9. <script src="/static/jquery-3.2.1.min.js"></script>
  10. </head>
  11. <body>
  12. <div>
  13. <p>{{ del_obj }}</p>
  14. </div>
  15. <form action="" method="post">
  16. {% csrf_token %}
  17. <input type="submit" value="确认删除" class="btn btn-danger">
  18. <a href="{{ list_url }}" class="btn btn-primary">取消</a>
  19. </form>
  20. </body>
  21. </html>

10、分页功能(url数据保留)

当数据较多时,我们在列表页面需要进行分页,这里分页时我们直接调用以前写好的分页组件使用即可

在使用分页组件时,我们在原有组件的基础上添加一个功能,就是点击页码跳转时,保留原来url上的数据

分页组件如下

 分页组件

可以看到我们在原来的基础上多传了一个参数params,这个参数就是当前页的request.GET,这是一个QueryDict的数据类型(和字典类似),我们取到他后,发现无法直接进行修改,这是应为QueryDict默认是不让修改的,需要修改mutable参数为True才能修改

修改前我们为了防止直接修改request.GET而造成后面的影响,所以先用深拷贝拷贝一份数据,再进行修改,修改时,我们将pape改为当前页的页码,再利用QueryDict的urlencode方法将字典类型的数据转换成a=1&b=2类型的字符串数据,然后在生成页码a标签时在a标签的href属性后面加上生成的字符串,这样我们点击页面跳转时就可以保留url上的数据了

分页组件的使用

  1. from stark.utils.page import Pagination
  2. current_page = request.GET.get("page", 1)
  3. all_count = self.model.objects.all().count()
  4. base_url = request.path_info
  5. params = request.GET
  6. pagination = Pagination(current_page, all_count, base_url, params)
  7. data_list = self.model.objects.all()[pagination.start: pagination.end]

编辑页面实现url数据保留

上面我们在写编辑页面时并没有考虑保留页面url上的数据,现在我们增加上这个功能

首先点击编辑按钮进入编辑页面时我们需要保留url上的数据,这就需要对编辑按钮这个a标签的href属性进行修改,在后面加上url上要保留的数据,同时,为了让加上的数据不和编辑页面可能有的数据冲突,所以我们单独定义一个list_filter键来存放这些数据

  1. def get_link_tag(self, obj, val):
  2. params = self.request.GET
  3. params = copy.deepcopy(params)
  4. params._mutable = True
  5. from django.http import QueryDict
  6. qd = QueryDict(mutable=True)
  7. qd["list_filter"] = params.urlencode()
  8. s = mark_safe("<a href=%s?%s>%s</a>" % (self.get_edit_url(obj), qd.urlencode(), val))
  9. return s

在列表视图中将原来使用get_edit_url的方法换成上面的方法即可

当编辑页面完成编辑后点击提交后我们需要跳转回列表页面,这时我们需要将url上保留的数据还原为原来的形式

  1. # 编辑数据视图
  2. def change_view(self, request, id):
  3. edit_obj = self.model.objects.filter(pk=id).first()
  4. ModelFormClass = self.get_modelform_class()
  5. if request.method == "GET":
  6. form = ModelFormClass(instance=edit_obj)
  7. return render(request, "stark/change_view.html", locals())
  8. else:
  9. form = ModelFormClass(data=request.POST, instance=edit_obj)
  10. if form.is_valid():
  11. form.save()
  12. params = request.GET.get("list_filter")
  13. url = "%s?%s" % (self.get_list_url(), params)
  14. return redirect(url)
  15. else:
  16. return render(request, "stark/change_view.html", locals())

这里我们在原来的url后面加上了我们从request.GET中取出的数据

11、生成为列表页面服务的类ChangeList

写了这么多内容我们发现我们的列表页面的视图函数内容较多,同时列表页面还有很多功能未添加,为了能够减少列表页面的代码,我们生成一个专门为列表视图函数服务的类,将一些主要的逻辑放到这个类中

  1. # ChangeList服务于change_list视图
  2. class ChangeList(object):
  3. def __init__(self, config, request, queryset):
  4. self.config = config
  5. self.request = request
  6. self.queryset = queryset
  7. from stark.utils.page import Pagination
  8. current_page = self.request.GET.get("page", 1)
  9. all_count = self.queryset.count()
  10. base_url = self.request.path_info
  11. params = self.request.GET
  12. pagination = Pagination(current_page, all_count, base_url, params)
  13. data_list = self.queryset[pagination.start: pagination.end]
  14. self.pagination = pagination
  15. self.data_list = data_list
  16.  
  17. def get_header(self):
  18. # 生成表标头
  19. header_list = []
  20. for field in self.config.get_list_display():
  21. if callable(field):
  22. # header_list.append(field.__name__)
  23. val = field(self.config, is_header=True)
  24. header_list.append(val)
  25. else:
  26. if field == "__str__":
  27. header_list.append(self.config.model._meta.model_name.upper())
  28. else:
  29. field_obj = self.config.model._meta.get_field(field)
  30. header_list.append(field_obj.verbose_name)
  31. return header_list
  32.  
  33. def get_body(self):
  34. # 生成表数据列表
  35. new_data_list = []
  36. for obj in self.data_list:
  37. temp = []
  38. for field in self.config.get_list_display():
  39. if callable(field):
  40. val = field(self.config, obj)
  41. else:
  42. val = getattr(obj, field)
  43. if field in self.config.list_display_links:
  44. val = self.config.get_link_tag(obj, val)
  45. temp.append(val)
  46. new_data_list.append(temp)
  47. return new_data_list

我们将现在的生成表头、表数据和分页的功能都放到该类中,初始化时的config参数就是ModelStark类的实例化对象,queryset是我们从数据库中取出的需要渲染到页面上的数据

这时列表视图函数只要保留下面的内容就行了

  1. # 查看数据视图
  2. def change_list(self, request):
  3. self.request = request
  4. add_url = self.get_add_url()
  5.  
  6. queryset = self.model.objects.filter(search_condition)
  7. cl = ChangeList(self, request, queryset)
  8. return render(request, "stark/change_list.html", locals())

页面渲染时我们只要利用ChangeList类的实例化对象cl就可以渲染出我们想要的内容

12、search模糊查询

使用admin时我们能定义一个search_fields列表来生成一个查询框,可以根据列表中的字段进行模糊查询

我们也来定义这么一个参数

  1. class ModelStark(object):
  2. list_display = ["__str__", ]
  3.  
  4. model_form_class = None
  5.  
  6. list_display_links = []
  7.  
  8. search_fields = []

默认让他为一个空列表,当用户定义了值时,我们就需要在页面生成一个搜索框,并且根据模糊查询得到需要的数据展示到页面上,这里需要注意如果用户在列表中定义了多个字段,那么多个字段查询时应该是或的关系

Q查询利用字符串进行查询的方式

在查询时由于是或的关系所以我们要用到Q查询,但是我们之前使用Q查询时都是直接使用的字段名,现在我们只能拿到字段名的字符串,所以需要用Q查询的另外一种方式

  1. def get_search_condition(self):
  2. from django.db.models import Q
  3. search_condition = Q()
  4. search_condition.connector = "or" # 设置关系为或
  5. if self.search_fields:
  6. key_word = self.request.GET.get("q")
  7. if key_word:
  8. for search_field in self.search_fields:
  9. search_condition.children.append((search_field + "__contains", key_word))
  10. return search_condition

先生成一个Q对象,设置为或的关系,然后通过循环将要查询的字段的字符串和查询关键字以元组的形式添加到Q对象中,这里要注意,由于是模糊查询,我们在字段字符串后拼接了__contains

最后在列表视图函数中取到这个Q对象,根据他进行查询

  1. # 查看数据视图
  2. def change_list(self, request):
  3. self.request = request
  4. add_url = self.get_add_url()
  5. # 关于search的模糊查询
  6. search_condition = self.get_search_condition()
  7. queryset = self.model.objects.filter(search_condition)
  8. cl = ChangeList(self, request, queryset)
  9. return render(request, "stark/change_list.html", locals())

前端页面

  1. <!DOCTYPE html>
  2. <html lang="zh-CN">
  3. <head>
  4. <meta charset="UTF-8">
  5. <meta http-equiv="x-ua-compatible" content="IE=edge">
  6. <meta name="viewport" content="width=device-width, initial-scale=1">
  7. <title>Title</title>
  8. <link rel="stylesheet" href="/static/bootstrap-3.3.7/css/bootstrap.min.css">
  9. <script src="/static/jquery-3.2.1.min.js"></script>
  10. </head>
  11. <body>
  12. <h3>数据展示</h3>
  13.  
  14. <div class="container">
  15. <div class="row">
  16. <div class="col-md-8">
  17. <a href="{{ add_url }}"><button class="btn btn-primary">添加数据</button></a>
  18. {% if cl.config.search_fields %}
  19. <div class="pull-right form-group">
  20. <form action="" method="get" class="form-inline">
  21. <input type="text" class="form-control" name="q"> <input type="submit" class="btn btn-primary" value="search">
  22. </form>
  23. </div>
  24. {% endif %}
  25. <table class="table table-striped table-hover">
  26. <thead>
  27. <tr>
  28. {% for foo in cl.get_header %}
  29. <td>{{ foo }}</td>
  30. {% endfor %}
  31. </tr>
  32. </thead>
  33. <tbody>
  34. {% for data in cl.get_body %}
  35. <tr>
  36. {% for item in data %}
  37. <td>{{ item }}</td>
  38. {% endfor %}
  39. </tr>
  40. {% endfor %}
  41. </tbody>
  42. </table>
  43. <nav aria-label="Page navigation" class="pull-right">
  44. <ul class="pagination">
  45. {{ cl.pagination.page_html|safe }}
  46. </ul>
  47. </nav>
  48. </div>
  49. </div>
  50. </div>
  51.  
  52. <script>
  53. $("#action-toggle").click(function () {
  54. if ($(this).prop("checked")){
  55. $("tbody :checkbox").prop("checked",true)
  56. }else{
  57. $("tbody :checkbox").prop("checked",false)
  58. }
  59. })
  60. </script>
  61. </body>
  62. </html>

生成搜索框时需要做判断,如果用户没有定义search_fields,则不需要生成搜索框

13、action功能(批量操作)

使用admin时,我们发现有一个action功能,有一个下拉菜单可以选择功能批量操作,现在我们也来实现这个功能

首先在ModelStark中定义一个变量actions,默认为一个空列表

  1. class ModelStark(object):
  2. list_display = ["__str__", ]
  3.  
  4. model_form_class = None
  5.  
  6. list_display_links = []
  7.  
  8. search_fields = []
  9.  
  10. actions = []

这表示如果用户没有自己定制actions,那么则没有任何功能,但是我们使用admin时,发现默认有一个批量删除的功能,所以我们也来写一个批量删除

  1. def patch_delete(self, queryset):
  2. queryset.delete()
  3. patch_delete.desc = "批量删除"

python中一切皆对象,我们给这个函数对象一个新的desc属性,这个属性的值就是我们想要在页面上展示给别人看的这个函数的用途,然后我们要将这个函数添加到actions中,同时也要考虑用户自己定制时的情况

  1. # 获取真正展示的actions
  2. def get_actions(self):
  3. temp = []
  4. temp.extend(self.actions)
  5. temp.append(ModelStark.patch_delete)
  6. return temp

这样通过ModelStark中的get_actions我们就能拿到最终的actions列表,上面我们自己定制了一个ChangeList类,专门为列表页面服务,actions功能也是在列表页面中使用的,所以我们在ChangeList类中定义一个方法# ChangeList服务于change_list视图

  1. class ChangeList(object):
  2. def __init__(self, config, request, queryset):
  3. self.config = config
  4. self.request = request
  5. self.queryset = queryset
  6.  
  7. from stark.utils.page import Pagination
  8. current_page = self.request.GET.get("page", 1)
  9. all_count = self.queryset.count()
  10. base_url = self.request.path_info
  11. params = self.request.GET
  12. pagination = Pagination(current_page, all_count, base_url, params)
  13. data_list = self.queryset[pagination.start: pagination.end]
  14. self.pagination = pagination
  15. self.data_list = data_list
  16. # actions
  17. self.actions = self.config.get_actions()
  18.  
  19. def handle_action(self):
  20. temp =[]
  21. for action_func in self.actions:
  22. temp.append({"name": action_func.__name__, "desc": action_func.desc})
  23. return temp

这里我们通过这个方法获得的是一个列表,列表中有一个个的字典,字典里放着函数的名字和我们要展示的描述

前端页面

 

这里每一个下拉菜单的option的value值就是我们定义的函数名,还要注意要将select标签和复选框标签都放到同一个form表单中,这样在发送数据时我们发送了,选择的批量操作函数和被选中的数据的pk值

后端操作

后端接收到选择的批量操作函数和被选中的数据的pk值就可以进行操作了

  1. # 查看数据视图
  2. def change_list(self, request):
  3. if request.method == "POST":
  4. func_name = request.POST.get("action")
  5. pk_list = request.POST.getlist("_selected_action")
  6. queryset = self.model.objects.filter(pk__in=pk_list)
  7. func = getattr(self, func_name)
  8. func(queryset)
  9. self.request = request
  10. add_url = self.get_add_url()
  11. # 关于search的模糊查询
  12. search_condition = self.get_search_condition()
  13. queryset = self.model.objects.filter(search_condition)
  14. cl = ChangeList(self, request, queryset)
  15. return render(request, "stark/change_list.html", locals())

首先判断,当请求为POST请求时,取到批量操作函数的函数名,和选择数据的pk值列表(由于是复选框,可能选择了多个值,所以这里用getlist取值),然后通过pk值列表查找到要操作的数据的queryset集合,利用反射通过函数名的字符串取到批量操作函数,最后将取到的quertset传给函数执行

14、多级过滤

和其它功能一样,我们先在ModelStark中定义一个list_filter空列表

  1. class ModelStark(object):
  2. list_display = ["__str__", ]
  3.  
  4. model_form_class = None
  5.  
  6. list_display_links = []
  7.  
  8. search_fields = []
  9.  
  10. actions = []
  11. # 多级过滤
  12. list_filter = []

当用户自己定义了这个列表时,我们要取到列表中的字段,然后查处该字段对应的内容,显示到页面上,当用户点击某一个内容时,要过滤出和这个内容相关的数据

当用户点击这个内容的a标签时,我们要向后台发送一个get请求,请求带着我们要过滤的内容,内容的键为字段的名称,值为你选中值的pk值

第一步我们要先想办法将list_filter中字段的对应数据都显示到页面上,先要取到所有数据

  1. # ChangeList服务于change_list视图
  2. class ChangeList(object):
  3. def __init__(self, config, request, queryset):
  4. self.config = config
  5. self.request = request
  6. self.queryset = queryset
  7.  
  8. from stark.utils.page import Pagination
  9. current_page = self.request.GET.get("page", 1)
  10. all_count = self.queryset.count()
  11. base_url = self.request.path_info
  12. params = self.request.GET
  13. pagination = Pagination(current_page, all_count, base_url, params)
  14. data_list = self.queryset[pagination.start: pagination.end]
  15. self.pagination = pagination
  16. self.data_list = data_list
  17. # actions
  18. self.actions = self.config.get_actions()
  19. # filter
  20. self.list_filter = self.config.list_filter
  21.  
  22. def get_filter_link_tag(self):
  23. # link_tags = []
  24. for filter_field_name in self.list_filter:
  25. current_id = int(self.request.GET.get(filter_field_name, 0))
  26. filter_field_obj = self.config.model._meta.get_field(filter_field_name)
  27. filter_field = FilterField(filter_field_name, filter_field_obj)

在ChangeList中我们先拿到拿到list_filter,并定义self.list_filter,然后定义一个get_filter_link_tag方法,循环self.list_filter,循环的每一个值就是各个字段的名称,然后通过字段名称拿到这个字段的对象filter_field_obj,然后通过字段名称和字段对象通过FilterField类实例化出一个对象,这个新的类内容如下

  1. # 为每一个过滤的字段封装成整体类
  2. class FilterField(object):
  3. def __init__(self, filter_field_name, filter_field_obj):
  4. self.filter_field_name = filter_field_name
  5. self.filter_field_obj = filter_field_obj
  6.  
  7. def get_data(self):
  8. if isinstance(self.filter_field_obj, ForeignKey) or isinstance(self.filter_field_obj, ManyToManyField):
  9. return self.filter_field_obj.rel.to.objects.all()
  10. elif self.filter_field_obj.choices:
  11. return self.filter_field_obj.choices
  12. else:
  13. pass

通过这个类的对象我们可以调用get_data方法拿到需要的数据列表(queryset或元组里套元组),这里我们暂时不考虑普通字段,由于需要的字段变多了,我们将Book表的字段进行一些修改,增加外键和多对多的关系

  1. from django.db import models
  2.  
  3. # Create your models here.
  4.  
  5. class Book(models.Model):
  6. title = models.CharField(verbose_name="标题", max_length=32)
  7. price = models.DecimalField(verbose_name="价格", decimal_places=2, max_digits=5, default=12)
  8. state = models.IntegerField(choices=((1, "已出版"), (2, "未出版")), default=1)
  9. publish = models.ForeignKey(to="Publish", default=1)
  10. authors = models.ManyToManyField(to="Author", default=1)
  11.  
  12. def __str__(self):
  13. return self.title
  14.  
  15. class Author(models.Model):
  16. name = models.CharField(max_length=32)
  17. age = models.IntegerField()
  18.  
  19. def __str__(self):
  20. return self.name
  21.  
  22. class Publish(models.Model):
  23. name = models.CharField(max_length=32)
  24.  
  25. def __str__(self):
  26. return self.name

拿到数据的列表后,我们再循环每一个数据,通过判断字段对象的类型,生成不同的a标签,同时我们也取到当前get求情的数据,如果当前标签为选中的标签,我们要给他增加一个active属性

还有需要保留之前的选择,我们也要取到每次get请求的数据,保留到生成的a标签中

  1. # ChangeList服务于change_list视图
  2. class ChangeList(object):
  3. def __init__(self, config, request, queryset):
  4. self.config = config
  5. self.request = request
  6. self.queryset = queryset
  7.  
  8. from stark.utils.page import Pagination
  9. current_page = self.request.GET.get("page", 1)
  10. all_count = self.queryset.count()
  11. base_url = self.request.path_info
  12. params = self.request.GET
  13. pagination = Pagination(current_page, all_count, base_url, params)
  14. data_list = self.queryset[pagination.start: pagination.end]
  15. self.pagination = pagination
  16. self.data_list = data_list
  17. # actions
  18. self.actions = self.config.get_actions()
  19. # filter
  20. self.list_filter = self.config.list_filter
  21.  
  22. def get_filter_link_tag(self):
  23. # link_tags = []
  24. for filter_field_name in self.list_filter:
  25. current_id = int(self.request.GET.get(filter_field_name, 0))
  26. filter_field_obj = self.config.model._meta.get_field(filter_field_name)
  27. filter_field = FilterField(filter_field_name, filter_field_obj)
  28.  
  29. def inner(filter_field, current_id):
  30. for obj in filter_field.get_data():
  31. params = copy.deepcopy(self.request.GET)
  32. params._mutable = True
  33. if isinstance(filter_field.filter_field_obj, ForeignKey) or isinstance(filter_field.filter_field_obj, ManyToManyField):
  34. params[filter_field.filter_field_name] = obj.pk
  35. if current_id == obj.pk:
  36. yield mark_safe("<a href='?%s' class='active'>%s</a>" % (params.urlencode(), obj))
  37. else:
  38. yield mark_safe("<a href='?%s'>%s</a>" % (params.urlencode(), obj))
  39. elif filter_field.filter_field_obj.choices:
  40. params[filter_field.filter_field_name] = obj[0]
  41. if current_id == obj[0]:
  42. yield mark_safe("<a href='?%s' class='active'>%s</a>" % (params.urlencode(), obj[1]))
  43. else:
  44. yield mark_safe("<a href='?%s'>%s</a>" % (params.urlencode(), obj[1]))
  45. else:
  46. pass
  47.  
  48. yield inner(filter_field, current_id)
  49. # link_tags.append(temp)
  50. # return link_tags

这里我们使用的yield功能,在渲染模板时需要注意,当for循环中还套了一个for循环时,会先取到第一个for循环的所有内容,再进行内部的for循环,这在使用yield时会出现一些问题,所以我们在内部的生成器函数中要直接将当前的数据传进去,避免出错

前端页面

  1. <!DOCTYPE html>
  2. <html lang="zh-CN">
  3. <head>
  4. <meta charset="UTF-8">
  5. <meta http-equiv="x-ua-compatible" content="IE=edge">
  6. <meta name="viewport" content="width=device-width, initial-scale=1">
  7. <title>Title</title>
  8. <link rel="stylesheet" href="/static/bootstrap-3.3.7/css/bootstrap.min.css">
  9. <script src="/static/jquery-3.2.1.min.js"></script>
  10. <style>
  11. .filter a{
  12. padding: 5px 3px;
  13. border: 1px solid grey;
  14. background-color: #336699;
  15. color: white;
  16. }
  17. .active{
  18. background-color: white!important;
  19. color: black!important;
  20. }
  21. </style>
  22. </head>
  23. <body>
  24. <h3>数据展示</h3>
  25.  
  26. <div class="container">
  27. <div class="row">
  28. <div class="col-md-8">
  29. <a href="{{ add_url }}"><button class="btn btn-primary">添加数据</button></a>
  30. {% if cl.config.search_fields %}
  31. <div class="pull-right form-group">
  32. <form action="" method="get" class="form-inline">
  33. <input type="text" class="form-control" name="q"> <input type="submit" class="btn btn-primary" value="search">
  34. </form>
  35. </div>
  36. {% endif %}
  37. <form action="" method="post">
  38. {% csrf_token %}
  39. <div>
  40. <select class="form-control" name="action" id="" style="width: 200px;margin: 5px 0;display: inline-block;vertical-align: -1px" >
  41. <option value="">---------</option>
  42. {% for item in cl.handle_action %}
  43. <option value="{{ item.name }}">{{ item.desc }}</option>
  44.  
  45. {% endfor %}
  46.  
  47. </select>
  48. <button type="submit" class="btn btn-default">Go</button>
  49. </div>
  50. <table class="table table-striped table-hover">
  51. <thead>
  52. <tr>
  53. {% for foo in cl.get_header %}
  54. <td>{{ foo }}</td>
  55. {% endfor %}
  56. </tr>
  57. </thead>
  58. <tbody>
  59. {% for data in cl.get_body %}
  60. <tr>
  61. {% for item in data %}
  62. <td>{{ item }}</td>
  63. {% endfor %}
  64. </tr>
  65. {% endfor %}
  66. </tbody>
  67. </table>
  68. </form>
  69. <nav aria-label="Page navigation" class="pull-right">
  70. <ul class="pagination">
  71. {{ cl.pagination.page_html|safe }}
  72. </ul>
  73. </nav>
  74. </div>
  75. <div class="col-md-4">
  76. <div class="filter">
  77. {% for filter_link_tag in cl.get_filter_link_tag %}
  78. <p class="field">{% for data in filter_link_tag %}
  79. {{ data }}
  80. {% endfor %}
  81. </p>
  82. {% endfor %}
  83.  
  84. </div>
  85. </div>
  86. </div>
  87. </div>
  88.  
  89. <script>
  90. $("#action-toggle").click(function () {
  91. if ($(this).prop("checked")){
  92. $("tbody :checkbox").prop("checked",true)
  93. }else{
  94. $("tbody :checkbox").prop("checked",false)
  95. }
  96. })
  97. </script>
  98. </body>
  99. </html>

数据的过滤

上面我们已经能在页面上生成对应的过滤标签了,当通过点击这些标签时,会向后端发送含有相应条件的GET请求,我们要在后端拿到条件并进行过滤,将过滤后的数据显示在页面上,这个功能和我们上面做的search类似

  1. # 获取filter的查询条件Q对象
  2. def get_filter_condition(self):
  3. from django.db.models import Q
  4. filter_condition = Q()
  5. for field, val in self.request.GET.items():
  6. if field in self.list_filter:
  7. filter_condition.children.append((field, val))
  8. return filter_condition
  9. # 查看数据视图
  10. def change_list(self, request):
  11. if request.method == "POST":
  12. func_name = request.POST.get("action")
  13. pk_list = request.POST.getlist("_selected_action")
  14. queryset = self.model.objects.filter(pk__in=pk_list)
  15. func = getattr(self, func_name)
  16. func(queryset)
  17. self.request = request
  18. add_url = self.get_add_url()
  19. # 关于search的模糊查询
  20. search_condition = self.get_search_condition()
  21. # filter多级过滤
  22. filter_condition = self.get_filter_condition()
  23. queryset = self.model.objects.filter(search_condition).filter(filter_condition)
  24. cl = ChangeList(self, request, queryset)
  25. return render(request, "stark/change_list.html", locals())

这里我们需要做一次判断,当get请求的数据中有page时,需要过滤掉,不然会报错

普通字段

上面的过滤我们都没有考虑普通字段,如果是一个普通字段,我们可以按下面的代码执行

  1. # 针对((),()),[[],[]]数据类型构建a标签
  2. class LinkTagGen(object):
  3. def __init__(self, data, filter_field, request):
  4. self.data = data
  5. self.filter_field = filter_field
  6. self.request = request
  7.  
  8. def __iter__(self):
  9. current_id = self.request.GET.get(self.filter_field.filter_field_name, 0)
  10. params = copy.deepcopy(self.request.GET)
  11. params._mutable = True
  12. if params.get(self.filter_field.filter_field_name):
  13. del params[self.filter_field.filter_field_name]
  14. _url = "%s?%s" % (self.request.path_info, params.urlencode())
  15. yield mark_safe("<a href='%s'>全部</a>" % _url)
  16. else:
  17. _url = "%s?%s" % (self.request.path_info, params.urlencode())
  18. yield mark_safe("<a href='%s' class='active'>全部</a>" % _url)
  19. for item in self.data:
  20. if self.filter_field.filter_field_obj.choices:
  21. pk, text = str(item[0]), item[1]
  22. elif isinstance(self.filter_field.filter_field_obj, ForeignKey) or isinstance(self.filter_field.filter_field_obj, ManyToManyField):
  23. pk, text = str(item.pk), item
  24. else:
  25. pk, text = item[1], item[1]
  26.  
  27. params[self.filter_field.filter_field_name] = pk
  28. _url = "%s?%s" % (self.request.path_info, params.urlencode())
  29. if current_id == pk:
  30. link_tag = "<a href='%s' class='active'>%s</a>" % (_url, text)
  31. else:
  32. link_tag = "<a href='%s'>%s</a>" % (_url, text)
  33. yield mark_safe(link_tag)
  34.  
  35. # 为每一个过滤的字段封装成整体类
  36. class FilterField(object):
  37. def __init__(self, filter_field_name, filter_field_obj, config):
  38. self.filter_field_name = filter_field_name
  39. self.filter_field_obj = filter_field_obj
  40. self.config = config
  41.  
  42. def get_data(self):
  43. if isinstance(self.filter_field_obj, ForeignKey) or isinstance(self.filter_field_obj, ManyToManyField):
  44. return self.filter_field_obj.rel.to.objects.all()
  45. elif self.filter_field_obj.choices:
  46. return self.filter_field_obj.choices
  47. else:
  48. return self.config.model.objects.values_list("pk", self.filter_field_name)

14、POPUP功能

使用admin添加数据时我们会发现在外键和多对多的字段旁边有一个小加号,点击后会弹出一个小窗口,在小窗口中可以直接添加外键和多对多字段对应的表的数据

这里我们使用popup来实现这个功能,我们的逻辑应该是在添加页面的视图函数中

  1. # 添加数据视图
  2. def add_view(self, request):
  3. ModelFormClass = self.get_modelform_class()
  4. if request.method == "GET":
  5. form = ModelFormClass()
  6. else:
  7. form = ModelFormClass(data=request.POST)
  8. if form.is_valid():
  9. obj = form.save()
  10. pop_id = request.GET.get("pop_id")
  11. if pop_id:
  12. res = {"pk": obj.pk, "text": str(obj), "pop_id": pop_id}
  13. import json
  14. return render(request, "stark/pop_res.html", {"res": json.dumps(res)})
  15. return redirect(self.get_list_url())
  16. from django.forms.models import ModelChoiceField
  17. for bound_field in form:
  18. if isinstance(bound_field.field, ModelChoiceField):
  19. bound_field.is_pop = True
  20. app_label = bound_field.field.queryset.model._meta.app_label
  21. model_name = bound_field.field.queryset.model._meta.model_name
  22. _url = "%s_%s_add" % (app_label, model_name)
  23. bound_field.url = reverse(_url) + "?pop_id=id_%s" % bound_field.name
  24. else:
  25. bound_field.is_pop = False
  26. bound_field.url = None
  27. return render(request, "stark/add_view.html", locals())

我们的添加页面是利用ModelForm生成的,在请求过来时我们会使用ModelForm实例化一个对象,我们使用for循环遍历这个对象,可以得到这个对象的每一个字段(其实就是ModelForm对应表的每一个字段),这个字段是BoundField类型的,下面有两个方法.name.field.name可以得到字段的名称,而.field则可以得到字段在ModelForm中的类型,外键类型在Form中对应的是ModelChoiceField类型,而多对多在Form中对应的是ModelMultipleChoiceField类型(继承ModelChoiceField),所以我们只要判断bound_field.field是否是ModelChoiceField类型的对象就能知道这个字段是否是外键或多对多的字段,如果是的话,我们给这个字段对象添加一个is_pop=True的属性,不是则为False,在前端页面我们可以根据这个属性判断是否需要在字段的框后面添加+号,这个+号应该绑定一个点击事件,点击后可以弹出一个窗口让我们添加数据(pop请求),弹出窗口的url应该就是该字段对应表的添加url,如何取到字段对应的表呢?

前面我们取到了外键和多对多在Form中对应的字段bound_field.field,这里面有一个queryset属性可以取到这个外键字段对应表中的数据集合,而queryset这个数据类型中有个model属性可以得到数据集合对应的表,这样我们就可以通过bound_field.field.queryset.model得到外键或多对多对应的表,再取出表名和app名,通过反向解析就可以得到对应的添加url,这里要注意,我们要在这个url后面加上一个?pop_id=id_当前字段名,这样当添加的数据通过post请求过来时,我们才能知道是哪个字段添加的数据,数据返回时我们才能找到这个字段对应的select框,给他添加一个option标签

当添加的数据通过post请求过来时,如果数据验证成功了,我们先取pop_id,如果能取到,说明这个请求是通过弹出框来的,我们取到相关数据放到一个字典中,将字典返回给pop响应页面,响应页面中我们可以通过opener获得是哪个页面弹出的这个窗口,然后调用这个opener中的函数,并把后端接收的字典传给他,这样就可以利用这个函数在页面上添加option标签了。如果取不到pop_id则直接保存数据,跳转到列表页面即可。如果post请求发来的数据没有验证成功,那么我们依然要做上面两段提到的内容,所以我们将上面两段的逻辑放到了函数的最后

前端页面

add_view.html

  1. <!DOCTYPE html>
  2. <html lang="zh-CN">
  3. <head>
  4. <meta charset="UTF-8">
  5. <meta http-equiv="x-ua-compatible" content="IE=edge">
  6. <meta name="viewport" content="width=device-width, initial-scale=1">
  7. <title>添加</title>
  8. <link rel="stylesheet" href="/static/bootstrap-3.3.7/css/bootstrap.min.css">
  9. <script src="/static/jquery-3.2.1.min.js"></script>
  10. <style>
  11. .form-group input,select{
  12. display: block;
  13. width: 100%;
  14. height: 34px;
  15. padding: 6px 12px;
  16. font-size: 14px;
  17. line-height: 1.42857143;
  18. color: #555;
  19. background-color: #fff;
  20. background-image: none;
  21. border: 1px solid #ccc;
  22. border-radius: 4px;
  23. -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.075);
  24. box-shadow: inset 0 1px 1px rgba(0,0,0,.075);
  25. -webkit-transition: border-color ease-in-out .15s,-webkit-box-shadow ease-in-out .15s;
  26. -o-transition: border-color ease-in-out .15s,box-shadow ease-in-out .15s;
  27. transition: border-color ease-in-out .15s,box-shadow ease-in-out .15s;
  28. }
  29.  
  30. </style>
  31. </head>
  32. <body>
  33. <h3>添加数据</h3>
  34.  
  35. {% include 'stark/form.html' %}
  36.  
  37. <script>
  38. function foo(res) {
  39. var res=JSON.parse(res);
  40. var ele_option=document.createElement("option");
  41. ele_option.value=res.pk;
  42. ele_option.innerHTML=res.text;
  43. ele_option.selected="selected";
  44. document.getElementById(res.pop_id).appendChild(ele_option)
  45. }
  46. </script>
  47. </body>
  48. </html>

这里的foo就是pop响应页面调用的函数

form.html

  1. <div class="container">
  2. <div class="row">
  3. <div class="col-md-6 col-xs-8">
  4. <form action="" method="post" novalidate>
  5. {% csrf_token %}
  6. {% for field in form %}
  7. <div class="form-group" style="position: relative">
  8. <label for="">{{ field.label }}</label>
  9. <div>
  10. {{ field }}
  11. <span class="error pull-right">
  12. {{ field.errors.0 }}
  13. </span>
  14. </div>
  15. {% if field.is_pop %}
  16. <a href="" onclick="pop('{{ field.url }}')" class="pop_btn" style="position: absolute;top: 45%;right: -23px"><span class="pull-right" style="font-size: 22px">+</span></a>
  17. {% endif %}
  18. </div>
  19. {% endfor %}
  20.  
  21. <p><input type="submit" class="btn btn-default"></p>
  22. </form>
  23. </div>
  24. </div>
  25. </div>
  26. <script>
  27. function pop(url) {
  28. window.open(url,"","width=500,height=400")
  29. }
  30. </script>

通过is_pop来判断能是否添加+号,并给这个加号绑定点击事件,弹出pop框

pop_res.html

  1. <!DOCTYPE html>
  2. <html lang="zh-CN">
  3. <head>
  4. <meta charset="UTF-8">
  5. <meta http-equiv="x-ua-compatible" content="IE=edge">
  6. <meta name="viewport" content="width=device-width, initial-scale=1">
  7. <title>Title</title>
  8. </head>
  9. <body>
  10.  
  11. <script>
  12. opener.foo('{{ res|safe }}');
  13. window.close()
  14. </script>
  15. </body>
  16. </html>

执行opener的函数,并直接关闭弹出框

编辑页面和添加页面同时实现popup功能

通过上面的方式我们就实现了添加页面的popup功能,但是当我们点击编辑时,我们发现在编辑页面上也需要有popup的功能,我们可以将上面的逻辑再在编辑页面中写一份,但是这样的话会造成代码的重复

这里我们使用自定义标签的形式,添加和编辑页面用的都是form.html页面中的内容,而这个页面中的内容中我们只需要提供一个form

所以我们在stark组件中创建一个目录templatetags,在该目录中自定义我们的标签my_tags

  1. from django import template
  2. from django.shortcuts import reverse
  3. register = template.Library()
  4.  
  5. @register.inclusion_tag("stark/form.html")
  6. def get_form(form):
  7. from django.forms.models import ModelChoiceField
  8. for bound_field in form:
  9. if isinstance(bound_field.field, ModelChoiceField):
  10. bound_field.is_pop = True
  11. app_label = bound_field.field.queryset.model._meta.app_label
  12. model_name = bound_field.field.queryset.model._meta.model_name
  13. _url = "%s_%s_add" % (app_label, model_name)
  14. bound_field.url = reverse(_url) + "?pop_id=id_%s" % bound_field.name
  15. return {"form": form}

这样在添加和编辑视图中就不用再写这么多逻辑了,直接将form对象传给前端就行了

  1. # 添加数据视图
  2. def add_view(self, request):
  3. ModelFormClass = self.get_modelform_class()
  4. if request.method == "GET":
  5. form = ModelFormClass()
  6. else:
  7. form = ModelFormClass(data=request.POST)
  8. if form.is_valid():
  9. obj = form.save()
  10. pop_id = request.GET.get("pop_id")
  11. if pop_id:
  12. res = {"pk": obj.pk, "text": str(obj), "pop_id": pop_id}
  13. import json
  14. return render(request, "stark/pop_res.html", {"res": json.dumps(res)})
  15. return redirect(self.get_list_url())
  16. return render(request, "stark/add_view.html", locals())
  17.  
  18. # 编辑数据视图
  19. def change_view(self, request, id):
  20. edit_obj = self.model.objects.filter(pk=id).first()
  21. ModelFormClass = self.get_modelform_class()
  22. if request.method == "GET":
  23. form = ModelFormClass(instance=edit_obj)
  24. return render(request, "stark/change_view.html", locals())
  25. else:
  26. form = ModelFormClass(data=request.POST, instance=edit_obj)
  27. if form.is_valid():
  28. form.save()
  29. params = request.GET.get("list_filter")
  30. url = "%s?%s" % (self.get_list_url(), params)
  31. return redirect(url)
  32. else:
  33. return render(request, "stark/change_view.html", locals())

前端收到这个form对象,直接调用自定义标签即可

  1. {% load my_tags %}
  2. <!DOCTYPE html>
  3. <html lang="zh-CN">
  4. <head>
  5. <meta charset="UTF-8">
  6. <meta http-equiv="x-ua-compatible" content="IE=edge">
  7. <meta name="viewport" content="width=device-width, initial-scale=1">
  8. <title>添加</title>
  9. <link rel="stylesheet" href="/static/bootstrap-3.3.7/css/bootstrap.min.css">
  10. <script src="/static/jquery-3.2.1.min.js"></script>
  11. <style>
  12. .form-group input,select{
  13. display: block;
  14. width: 100%;
  15. height: 34px;
  16. padding: 6px 12px;
  17. font-size: 14px;
  18. line-height: 1.42857143;
  19. color: #555;
  20. background-color: #fff;
  21. background-image: none;
  22. border: 1px solid #ccc;
  23. border-radius: 4px;
  24. -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.075);
  25. box-shadow: inset 0 1px 1px rgba(0,0,0,.075);
  26. -webkit-transition: border-color ease-in-out .15s,-webkit-box-shadow ease-in-out .15s;
  27. -o-transition: border-color ease-in-out .15s,box-shadow ease-in-out .15s;
  28. transition: border-color ease-in-out .15s,box-shadow ease-in-out .15s;
  29. }
  30.  
  31. </style>
  32. </head>
  33. <body>
  34. <h3>编辑数据</h3>
  35.  
  36. {% get_form form %}
  37.  
  38. <script>
  39. function foo(res) {
  40. var res=JSON.parse(res);
  41. var ele_option=document.createElement("option");
  42. ele_option.value=res.pk;
  43. ele_option.innerHTML=res.text;
  44. ele_option.selected="selected";
  45. document.getElementById(res.pop_id).appendChild(ele_option)
  46. }
  47. </script>
  48. </body>
  49. </html>

15、list_display补充

list_display可以定义我们在列表页面上显示哪些内容,如果展示的内容是一个包含choices的字段的话(比如说Book的state字段),按我们之前写的,在页面上只能看到1或者2这样的数字,如果想要看到已出版或未出版该怎么办呢,可以让用户自己定制,在stark.py中

  1. class BookConfig(ModelStark):
  2.  
  3. def state(self, obj=None, is_header=False):
  4. if is_header:
  5. return "状态"
  6. return obj.get_state_display()
  7.  
  8. list_display = ["id", "title", "price", "publish", state]
  9. model_form_class = BookModelForm
  10. list_display_links = ["id"]
  11. search_fields = ["title", "price"]
  12.  
  13. def patch_init(self, queryset):
  14. queryset.update(price=100)
  15.  
  16. patch_init.desc = "批量初始化"
  17. actions = [patch_init, ]
  18. list_filter = ["title", "state", "publish", "authors"]
  19. site.register(Book, BookConfig)

自己定义一个函数,obj.get_state_display()方法就可以取到choice中的内容,这个方法的state是字段名,get和display是固定用法

在list_display中增加多对多字段

在admin中我们不能往list_display中增加多对多字段,在我们自己写的stark中我们来实现这一功能,其实就是在ChangList类中的get_body方法中多做一次判断

  1. def get_body(self):
  2. # 生成表数据列表
  3. new_data_list = []
  4. for obj in self.data_list:
  5. temp = []
  6. for field in self.config.get_list_display():
  7. if callable(field):
  8. val = field(self.config, obj)
  9. else:
  10. field_obj = self.config.model._meta.get_field(field)
  11. if isinstance(field_obj, ManyToManyField):
  12. t = []
  13. for i in getattr(obj, field).all():
  14. t.append(str(i))
  15. val = ",".join(t)
  16. else:
  17. val = getattr(obj, field)
  18. if field in self.config.list_display_links:
  19. val = self.config.get_link_tag(obj, val)
  20. temp.append(val)
  21. new_data_list.append(temp)
  22. return new_data_list

当list_display中的值是不可调用的时,我们先取出其对应的字段对象,如果是多对多的类型,则通过getattr的方法拿到多对多的内容,并通过join生成字符串


django 之 stark组件的更多相关文章

  1. 【django之stark组件】

    一.需求 仿照django的admin,开发自己的stark组件.实现类似数据库客户端的功能,对数据进行增删改查. 二.实现 1.在settings配置中分别注册这三个app # Applicatio ...

  2. Django之stark组件

    现在让我说啥是stark组件,我也说不清楚.反正从今天讲的知识来看,今天完成的就是自己写一个模块,这个模块包含了admin后台管理工具的一些比较好用的功能,我们把它提炼出来,也就是相当于自己写一个ad ...

  3. Django之stark组件的使用和总结

    Stark组件的使用 组件的字段 list_display=[] 需要显示的字段 list_display_links=[] #需要链接编辑字段 Stark_Model_Form=[] #设置Mode ...

  4. Django之stark组件1

    stark组件 stark组件是根据Django admin为原型写的一个组件,能够让我们告别增删改查.stark组件是可插拔试的组件, 移植性强,而且只用配置文件就能够得到想要的数据 一.stark ...

  5. Django之stark组件2

    action批量处理功能 用户可以自定义批量处理功能,但是默认的有批量删除功能. ***思路*** 1,定义一个列表用来装action的类名并extend用户自定义列表 2.循环该列表获取到函数名(用 ...

  6. stark组件之pop操作【模仿Django的admin】

    一.先看下什么django的admin的pop到底是个什么东西 其实就是这么一个东西, a.在添加页面,在一对多和多对多的项后加了一个+号 b.点击这个加号,会弹出对应的添加 页面,在新的添加 c.添 ...

  7. stark组件之批量操作【模仿Django的admin】

    一.先看下django的admin是如何实现批量操作 首先在配置类中定义一个函数 然后我们为这个函数对象设置一个属性,这个属性主要用来显示在select标签中显示的文本内容 最后把函数对象放到一个ac ...

  8. stark组件之搜索【模仿Django的admin】

    一.先看下django的admin是如何做搜索功能的 配置一个search_fields的列表就可以实现搜索的功能 class testbook(admin.ModelAdmin): # 第一步,定义 ...

  9. stark组件之路由分发【模仿Django的admin】

    一.先看下django的admin是如何进行路由分发的 1.先看下django的admin的url路径有哪些 其实很简单,假如有一个书籍表,那么每张表对应四个url,增.删.改.查 查看的url ht ...

随机推荐

  1. jmeter 分布式压测(windows)

    单台压测机通常会遇到客户端瓶颈,受制于客户机的性能.可能由于网络带宽,CPU,内存的限制不能给到服务器足够的压力,这个时候你就需要用到分布式方案来解决客户机的瓶颈,压测的结果也会更加接近于真实情况. ...

  2. Ruby数组(1):基本用法

    数组 Ruby中的数组是一个容器,数组中的每个元素都是一个对象的引用. 注意,Array类中包含了Enumerable模块,所以Enumerable中的方法也都能使用,例如Enumerable中的re ...

  3. 超级账本fabric原理之gossip详解

    Goosip协议 去中心化.容错和最终一致性的算法 信息达到同步的最优时间:log(N). 功能: 节点发现 数据广播 gossip中有三种基本的操作: push - A节点将数据(key,value ...

  4. [CSS] css的background及多背景设置

    问题 首先是一个 div 块里需要一张背景,带文本和图案的那种,但是身为容器的 div 是能够随数据的改变而变化长度的,所以一张静态图片不免的会有拉伸和挤扁的状态,尤其是有图案和文本的情况下最为明显 ...

  5. Java多线程之---用 CountDownLatch 说明 AQS 的实现原理

    本文基于 jdk 1.8 . CountDownLatch 的使用 前面的文章中说到了 volatile 以及用 volatile 来实现自旋锁,例如 java.util.concurrent.ato ...

  6. 忘记时间戳的存在——Yii2超实用的自动更新时间戳的Behavior(改进版)

    本文改进了Yii2中内置行为类TimestampBehavior,使得时间戳字段(如created_at,updated_at) 完全自己更新,方便得让你忘记它们的存在. Yii2的内置行为类Time ...

  7. 前端入门11-JavaScript语法之数组

    声明 本系列文章内容全部梳理自以下几个来源: <JavaScript权威指南> MDN web docs Github:smyhvae/web Github:goddyZhao/Trans ...

  8. 引入UEditor后其他列表项不显示

    最近在做的一个后台管理系统,发现一个bug: 问题描述:如果其他列表项都用类为col-xs-12的div包裹,而引入UEditor的部分不用类为col-xs-12的div包裹,那么其他列表项将无法显示 ...

  9. C语言使用HZK16显示每个像素的代码

    下边内容段是关于C语言使用HZK16显示每个像素的内容. #include<stdio.h>#include<stdlib.h>void main(){ int i,j; ch ...

  10. Headless Android开发板的调试及远程显示和控制

    最近在调试msm8996的开发板,由于主板和LCD子板还没回来,所以先回的核心板算是个Headless的Android Device.核心板有独立供电,另外还有USB Type-C.FAN.HDMI. ...