自定义admin（self_admin）

admin.site.register(models.UserInfo)
admin.site.register(models.Book,Book_admin)

当下面注册的这个表里面没有这个方法的时候，就是register后面没有这个admin的话，那么这个就默认会使用Modeladmin的方法

print(self_admin.site._register)##拿到所有的表的类对象，调用的是AdminSite里面的_register，里面封装了全部的（包括自己默认加的两个表[类对象]）表

app_name = model._meta.app_label拿到这个类对象（表）的app名字
model_name = model._meta.model_name拿到这个表下面的所有字段

admin里面的所有的自定制：

list_display = ('__str__',)
list_display_links = ()
list_filter = ()
list_select_related = False
list_per_page = 100
list_max_show_all = 200
list_editable = ()
search_fields = ()
date_hierarchy = None
save_as = False
save_as_continue = True
save_on_top = False
paginator = Paginator
preserve_filters = True
inlines = []

# Custom templates (designed to be over-ridden in subclasses)
add_form_template = None
change_form_template = None
change_list_template = None
delete_confirmation_template = None
delete_selected_confirmation_template = None
object_history_template = None
popup_response_template = None

# Actions
actions = []
action_form = helpers.ActionForm
actions_on_top = True
actions_on_bottom = False
actions_selection_counter = True
checks_class = ModelAdminChecks

自定制字段原理实现：（函数）

from django.utils.safestring import   mark_safe
class Book_admin(admin.ModelAdmin):
    ##自定制字段action，放在list_display里面进行渲染出来
    def  action(self):
        ##这传入的self相对应的表的类对象
        return mark_safe('<a href="#">删除</a>')
    list_display = ['num_user','user','room_name','time',action]
    '''
    讲解一下这个原理：
    上面的这个函数的自定义字段的操作，是在modeladmin里面实际是这样来判断下面的list_display是字段，还是函数
    当是函数，就拿这个返回值，拿到这个html在渲染出来（用模板语言）在后端进行的渲染，在浏览器里面解析出相对应的页面出来
    当这个是字段的话，就是某一个表里面的字段，
    实现代码：
    tmp=[]
    a=self.model.objects.all()
    ##这个slef.model是表对象，就是Book
    for  model_obj  in a:
       for field  in  list_display:
          if callback(field):
            print("是函数")
            val=field(model_obj)
            #这是进行的实例化操作，拿到这个返回的值，在浏览器解出来（在前端渲染出来）
            tmp.appned(val)
          else:
            print('是字段')
            val=field
            tmp.append(val)

           
           ##在前端for循环一下，拿到所有的包括自定制的字段 

    {%for  i in dic%}
        <a>{{i}}</a>
    {%endfor%}

原理讲解：
不管下面你注册的是表后面有没有自定义的admin样式的时候，都存在注册的表的样式的类
当你没有配置这个样式的时候，就使用默认的样式类对象ModelAdmin
当你自己配置了这个样式的话，就使用你配置的类样式，自己配置的类样式也是继承了Adminadmin，也会执行这个类方法

自定义admin：
1. admin部分

self_admin.site.register(Book, book_admin)
self_admin.site.register(UserInfo)

2. url部分：

from  django.conf.urls  import url
from  self_admin.server.self_admin import  site
##所有的程序执行起来都是一个单例对象，一直都是一个程序在执行，只有第一个app是调用了site单例对象（modeladmin）
urlpatterns = [
    path('admin/', admin.site.urls),
    url(r'^self_admin/',site.urls),
    url(r'^login',views.login),
    url(r'^index/',views.index),
]

3. self-admin部分：

from django.shortcuts import render, redirect, HttpResponse
from django.conf.urls import url


class Self_Modeladmin(object):
    def __init__(self, model, site):
        self.model = model
        self.site = site
        print('Self_Modeladmin' * 1000)
        ##########<class 'app01.models.Room'>
        print(model)
        print('*' * 200)

    def add(self, request):
        print(self)
        return HttpResponse(self.model._meta.model_name)

    def list(self, request):
        return HttpResponse(self.model._meta.app_label)

    def change(self, request, id):
        return HttpResponse(self.model._meta.app_label)

    ##通过传参数进来调用的时候，不用在加参数进来了，否则会重复
    def delete(self, request, id):
        return HttpResponse(self.model._meta.app_label)

    ###########进行增删改查操作
    '''
    讲解：
    当是加静态方法进行调用的时候，没有传一个参数进来，当没有加这个静态方法的时候，你会传参数进来，所以就可以在add函数
    里面少传一个参数进来，注意区别
    '''

    @property
    def get_url3(self):
        dic = []
        ##类下面的每一个实例对象都有一块独立的内存空间，这个增删改查是独立开来的
        dic.append(url(r'^(\d+)/delete/', self.delete))
        dic.append(url(r'^(\d+)/change/', self.change))
        dic.append(url(r'^add/', self.add))
        dic.append(url(r'^list/', self.list))
        return dic, None, None


class Self_AdminSite():
    def __init__(self):
        self._register = {}

    ###这里面传入两个参数，后面的这个参数可以为空，后面的自定义的类可以为空，当为空的时候，就使用默认的modeladmin
    def register(self, model, stark_class=None):
        if not stark_class:
            #####假如没有自定义的类的话，就用父类样式
            stark_class = Self_Modeladmin
        self._register[model] = stark_class(model, self)  # 在这里已经传了两个参数进去，在了一个了里面可以直接进行调用

    ##注明一下，后面的这个模型类对象是有参数的（adminbook(book))这个是有传参数过去的  self.model=book这个是可以直接去取这个里面的数据的

    @property
    def get_urls(self):
        dic = []
        # 注明一下，这个第一个是model表，第二个是自定义的类，字典里面有这两个值
        for model, admin_class in self._register.items():
            app_name = model._meta.app_label
            model_name = model._meta.model_name  ##这个是字段的名字
            # dic.append(url(r'^%s/%s/'%(app_name,model_name),(admin_class.get_url2,None,None)))
            # 在下面注明，当这个model有自定义部分的时候，这就是这个于自定义的类，当没有自定义的时候，这个就是默认的继承的父类的部分，样式（部分）
            dic.append(url(r'^%s/%s/' % (app_name, model_name), admin_class.get_url3))

            # 上面的两种方法是一样的，这个之前调用的都是同一个类进行的调用

            # dic.append(url(r'^%s/%s/'%(app_name,model_name),
            #                ([ url(r'^delete', slef_Modeladmin.list)],None,None
            #                )))

        return dic

    @property
    def urls(self):

        return self.get_urls, None, None


site = Self_AdminSite()