自定义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：

admin部分

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


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),
]

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()

#创建一个单例对象site

转载于:https://www.cnblogs.com/yunxintryyoubest/p/9818412.html