自定义admin管理工具(stark组件)

创建项目

了解了admin的功能后，我们可以开始仿照admin编写我们自己的管理工具stark组件

首先创建一个新的项目，并创建三个app

stark就是我们要编写的组件，我们的主要逻辑就写在里面

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

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

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

  1. # app01
  2. from django.db import models
  3.  
  4. # Create your models here.
  5.  
  6. class Book(models.Model):
  7.     title = models.CharField(max_length=32)
  8.  
  9.     def __str__(self):
  10.         return self.title
  11.  
  12. # app02
  13. class Menu(models.Model):
  14.     caption = models.CharField(max_length=32)
  15.  
  16.     def __str__(self):
  17.         return self.caption
  18.  
  19. class UserInfo(models.Model):
  20.     name = models.CharField(max_length=32)
  21.     pwd = models.CharField(max_length=32, default=123)
  22.     email = models.EmailField()
  23.     roles = models.ManyToManyField(to="Role")
  24.  
  25.     def __str__(self):
  26.         return self.name
  27.  
  28. class Role(models.Model):
  29.     title = models.CharField(max_length=32)
  30.     permissions = models.ManyToManyField(to="Permission")
  31.  
  32.     def __str__(self):
  33.         return self.title
  34.  
  35. class Permission(models.Model):
  36.     url = models.CharField(max_length=32)
  37.     title = models.CharField(max_length=32)
  38.     permission_group = models.ForeignKey("PermissionGroup", default=1)
  39.     code = models.CharField(max_length=32, default="")
  40.     parent = models.ForeignKey("self", default=1, null=True, blank=True)
  41.  
  42.     def __str__(self):
  43.         return self.title
  44.  
  45. class PermissionGroup(models.Model):
  46.     caption = models.CharField(max_length=32)
  47.     menu = models.ForeignKey("Menu", default=1)
  48.  
  49.     def __str__(self):
  50.         return self.caption

在app01和app02下分别创建一个stark.py文件

使用admin时，我们知道启动项目时，会扫描每个app下的admin.py文件并执行

  1. def autodiscover():
  2.     autodiscover_modules('admin', register_to=site)

其实就是上面的方法实现了该功能，现在我们也仿照该方法，让项目启动时，扫描每个app下的stark.py文件并执行

在stark的apps.py中配置

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

这个ready函数的内容就实现了我们的需求

仿照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.sites 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, model_config=None):
  7.         if not model_config:
  8.             model_config = ModelStark
  9.  
  10.         self._registry[model] = model_config(model, self)

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

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

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

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

  1. # app01
  2. from stark.service.sites import site
  3. from .models import *
  4.  
  5. site.register(Book)
  6.  
  7. # app02
  8. from stark.service.sites import site
  9. from .models import *
  10.  
  11. site.register(UserInfo)
  12. site.register(Role)

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

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的做法，我们可以来写我们自己的代码了，首先在urls文件中配置

  1. from django.conf.urls import url
  2. from django.contrib import admin
  3. from stark.service.sites 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

列表展示页面

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.  
  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写死了

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函数我们可以实现一些我们自己的逻辑，比如根据权限判断是否需要加入编辑按钮等

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

添加和编辑页面

编辑页面和添加页面的功能我们通过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. <!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>

自定义admin管理工具(stark组件)的更多相关文章

  1. Django框架 之 admin管理工具（组件使用）

    Django框架 之 admin管理工具(组件使用) 浏览目录 激活管理工具 使用管理工具 admin的定制 admin组件使用 Django 提供了基于 web 的管理工具. Django 自动管理 ...

  2. 10.5Djang admin 管理工具

    2018-10-5 17:30:57 Django admin 管理工具  参考连接: https://www.cnblogs.com/yuanchenqi/articles/8323452.html ...

  3. Django 之 admin管理工具

    -------------------------------------------------------------------------妄尝恶果,苦果自来. admin组件使用 Django ...

  4. Django admin 管理工具

    admin 组件的使用 Django 提供了基于 web 的管理工具.Django 自动管理工具是 django.contrib 的一部分. INSTALLED_APPS = [ 'django.co ...

  5. Django的 admin管理工具

    admin组件使用 Django 提供了基于 web 的管理工具. Django 自动管理工具是 django.contrib 的一部分.你可以在项目的 settings.py 中的 INSTALLE ...

  6. admin管理工具

    admin组件使用 Django 提供了基于 web 的管理工具. Django 自动管理工具是 django.contrib 的一部分.你可以在项目的 settings.py 中的 INSTALLE ...

  7. django之admin管理工具

    admin组件 admin是django提供的基于web的管理工具 >如何使用: 1.激活管理工具 通常会在生成项目时在urls.py中自动设置好 from django.urls import ...

  8. Django——admin管理工具

    一.admin组件使用 Django 提供了基于 web 的管理工具. Django 自动管理工具是 django.contrib 的一部分.你可以在项目的 settings.py 中的 INSTAL ...

  9. Django 测试开发3 数据模型models和admin管理工具

    参考:https://blog.csdn.net/weixin_44510615/article/details/89425412 1.Django模型字段常用类型: IntegerField : 整 ...

随机推荐

  1. querySelectorAll 和getElementsByClassName的区别

    querySelectorAll 返回的是映射 改变其值不会改变document 而getElementsByClassName 改变它就会改变document 摘自JavaScript权威指南(jQ ...

  2. linux系统命令记录

    系统 # uname -a # 查看内核/操作系统/CPU信息 # head -n 1 /etc/issue # 查看操作系统版本 # cat /proc/cpuinfo # 查看CPU信息 # ho ...

  3. 通过代码注册COM、DLL组件

    注册代码如下:  C++ Code  1234567891011121314151617181920212223242526272829303132333435363738   // //====== ...

  4. 剑指 offer set 26 不用加减乘除做加法

    总结 1. Leetcode 上有一道题, 是不用乘除做乘法, 那道题算是背包问题的变形 2. 不用加减乘除, 还可以用移位操作 3. 将数字转成二进制格式, 然后运用二进制亦或, 移位运算解决 3. ...

  5. Linux 下8种优秀的屏幕录制机

    导读 屏幕录制机已经成为常见的和良好的实践来记录一个重要桌面会话,例如,你想玩一个难度较大的游戏,并且向记录是如何完成的,或者你打算创建一个视频教程,入门文章或指南,或任何其他活动和记录你的桌面会话, ...

  6. HYSBZ 1036（树的统计Count）

    题目链接:传送门 题目大意:中文题,略 题目思路:树链剖分裸题. 闲谈:树链越练越熟练了 #include <iostream> #include <cstdio> #incl ...

  7. jfinal如何调用存储过程？

    存储过程用一下 Db.execute(ICallback) 这个方法,在其中用一下:connection.prepareCall(sql).execute();就可以调用存储过程了,并且还可以自由控制 ...

  8. js 空正则匹配任意一个位置

    看一个正则 这里明显,起到匹配作用的是 | 后的,可 | 后什么都没有,原理不知道,也没有搜到文献,只有在 Reg101 上是这样解释的, 所以得出结论: js 中,空正则匹配任意一个位置. 不过,这 ...

  9. 详说 CSS 清除浮动

    转自:http://kayosite.com/remove-floating-style-in-detail.html 浮动,从诞生那天起,它就是个特别的属性——既为网页布局带来新的方法,却又随之产生 ...

  10. 报错分析---->jsp自定义标签：类cannot be resolved to a type

    这个困扰我一个晚上,仔细上网查阅发现,主要是因为jsp自定义标签要用到的这个jsp-api.jar的问题 这是我eclipes中的jar: 然而jsp-api.jar这个jar在tomcat中也有(报 ...