Django1.11.4中文文档

时间  2019-11-08
标签 django1.11.4 django 中文 文档 栏目 Python 繁體版
原文   原文链接

 

Django管理站点

自动管理界面是Django最强大的部分之一。它从您的模型中读取元数据，以提供一个快速，以模型为中心的界面，让受信任的用户能够管理您网站上的内容。管理员建议的使用仅限于组织的内部管理工具。它并不打算构建你的整个前端。javascript

管理员有不少自定义钩子，但要当心尝试独占使用这些钩子。若是您须要提供一个更加以流程为中心的接口，以抽象出数据库表和字段的实现细节，那么多是编写本身的视图的时候了。css

在本文中，咱们将讨论如何激活，使用和自定义Django的管理界面。html

概述

管理员在默认的项目模板中使用 startproject。前端

做为参考，这里是要求：java

  1. 添加'django.contrib.admin'到您的INSTALLED_APPS设置。
  2. 管理有四个依赖- ，， django.contrib.auth和 。若是这些应用程序不在您的列表中，请添加它们。django.contrib.contenttypesdjango.contrib.messagesdjango.contrib.sessionsINSTALLED_APPS
  3. 添加django.contrib.auth.context_processors.auth和 django.contrib.messages.context_processors.messages到'context_processors'了的选项DjangoTemplates在您定义的后端TEMPLATES，以及 django.contrib.auth.middleware.AuthenticationMiddleware和 django.contrib.messages.middleware.MessageMiddleware对 MIDDLEWARE。这些默认状况下都处于活动状态，因此若是您手动调整了设置，则只需执行此操做。
  4. 肯定哪些应用程序的模型应该能够在管理界面中编辑。
  5. 对于每一个模型，可选择建立一个ModelAdmin封装了该特定模型的自定义管理功能和选项的类。
  6. 实例化一个AdminSite并告诉它关于你的每一个模型和 ModelAdmin类。
  7. 将AdminSite实例挂钩到您的URLconf中。

完成这些步骤后，您能够经过访问您挂钩的URL（/admin/默认状况下）来使用您的Django管理站点。若是您须要建立用户登陆，您可使用该createsuperuser 命令。jquery

其余主题

也能够看看数据库

有关提供与生产中的管理员关联的静态文件（图像，JavaScript和CSS）的信息，请参阅提供文件。django

有问题吗？尝试常见问题：管理员。编程

ModelAdmin对象

class ModelAdmin [source]

该ModelAdmin班是在管理界面模型的表示。一般，这些文件存储admin.py在您的应用程序中指定的文件中。咱们来看一个很是简单的例子ModelAdmin：后端

from django.contrib import admin
from myproject.myapp.models import Author

class AuthorAdmin(admin.ModelAdmin):
    pass
admin.site.register(Author, AuthorAdmin)

你须要一个ModelAdmin物体吗？

在前面的例子中，ModelAdmin类没有定义任何自定义值（还没有）。所以，将提供默认的管理界面。若是您对默认的管理界面感到满意，则根本不须要定义ModelAdmin对象 - 您能够在不提供ModelAdmin描述的状况下注册模型类。前面的例子能够简化为：

from django.contrib import admin
from myproject.myapp.models import Author

admin.site.register(Author)

该register装饰

register （ * models ， site = django.admin.sites.site ） [source]

还有一个注册你的ModelAdmin类的装饰器：

from django.contrib import admin
from .models import Author

@admin.register(Author)
class AuthorAdmin(admin.ModelAdmin):
    pass

若是您未使用默认值，则会 为其指定一个或多个模型类以注册ModelAdmin 和一个可选的关键字参数：siteAdminSite

from django.contrib import admin
from .models import Author, Reader, Editor
from myproject.admin_site import custom_admin_site

@admin.register(Author, Reader, Editor, site=custom_admin_site)
class PersonAdmin(admin.ModelAdmin):
    pass

若是必须在__init__()方法中引用模型admin类，则不能使用此装饰器，例如 。若是您使用Python 3而且没必要担忧支持Python 2，则可使用。不然，你将不得不使用 这个装饰器。super(PersonAdmin, self).__init__(*args, **kwargs)super().__init__(*args, **kwargs)admin.site.register()

发现管理文件

当你放入'django.contrib.admin'你的INSTALLED_APPS 设置时，Django自动admin在每一个应用程序中查找一个模块并导入它。

类 apps. AdminConfig

这是AppConfig管理员的默认类。它autodiscover()在Django启动时调用。

类 apps. SimpleAdminConfig

这个类的做用就像AdminConfig，除非它没有调用autodiscover()。

autodiscover （） [source]

此功能尝试admin在每一个已安装的应用程序中导入模块。预计这些模块将向管理员注册模型。

一般你不须要直接调用这个函数做为 AdminConfigDjango启动时的调用。

若是您使用的是自定义AdminSite，则一般会将全部 ModelAdmin子类导入您的代码并将其注册到自定义 AdminSite。在这种状况下，为了禁用自动发现，你应该把'django.contrib.admin.apps.SimpleAdminConfig'，而不是 'django.contrib.admin'在你的INSTALLED_APPS设置。

ModelAdmin选项

这ModelAdmin很是灵活。它有几个处理定制界面的选项。全部选项都在ModelAdmin 子类上定义：

from django.contrib import admin

class AuthorAdmin(admin.ModelAdmin):
    date_hierarchy = 'pub_date'
ModelAdmin. actions

在更改列表页面上提供的操做列表。详细信息请参阅 管理员操做

ModelAdmin. actions_on_top
ModelAdmin. actions_on_bottom

控制页面上操做栏的显示位置。默认状况下，管理更改列表显示页面顶部的操做（）。actions_on_top = True; actions_on_bottom = False

ModelAdmin. actions_selection_counter

控制是否在操做下拉菜单旁边显示选择计数器。默认状况下，管理员更改列表将显示它（）。actions_selection_counter = True

ModelAdmin. date_hierarchy

设置date_hierarchy为 模型名称DateField或DateTimeField模型名称，更改列表页面将包含该字段的基于日期的向下钻取导航。

例：

date_hierarchy = 'pub_date'

您还可使用__查找在相关模型上指定一个字段，例如：

date_hierarchy = 'author__pub_date'

这将根据可用数据智能填充自身，例如，若是全部日期都在一个月内，它将只显示日期级别的下钻。

在Django 1.11中更改：

增长了在相关模型上引用字段的功能。

注意

date_hierarchyQuerySet.datetimes()内部使用。若是启用时区支持（），请参阅其文档以了解一些注意事项。USE_TZ = True

ModelAdmin. empty_value_display

该属性将覆盖记录的空字段（None空字符串等）的默认显示值。默认值是-（短划线）。例如：

from django.contrib import admin

class AuthorAdmin(admin.ModelAdmin):
    empty_value_display = '-empty-'

你也能够覆盖empty_value_display全部的管理页面 AdminSite.empty_value_display，或者像这样的特定字段：

from django.contrib import admin

class AuthorAdmin(admin.ModelAdmin):
    fields = ('name', 'title', 'view_birth_date')

    def view_birth_date(self, obj):
        return obj.birth_date

    view_birth_date.empty_value_display = '???'
ModelAdmin. exclude

该属性（若是给出）应该是从表单中排除的字段名称列表。

例如，让咱们考虑如下模型：

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)
    title = models.CharField(max_length=3)
    birth_date = models.DateField(blank=True, null=True)

若是你想要一个Author只包含name 和title字段的模型的表单，你能够指定fields或exclude像这样：

from django.contrib import admin

class AuthorAdmin(admin.ModelAdmin):
    fields = ('name', 'title')

class AuthorAdmin(admin.ModelAdmin):
    exclude = ('birth_date',)

因为做者模型只有三个字段，name，title，和 birth_date，从上面的声明产生的形式将包含彻底相同的领域。

ModelAdmin. fields

使用该fields选项能够在“添加”和“更改”页面上的表单中进行简单的布局更改，例如仅显示可用字段的子集，修改其顺序或将它们分组成行。例如，您能够为该django.contrib.flatpages.models.FlatPage模型定义一个更简单的管理员表单版本， 以下所示：

class FlatPageAdmin(admin.ModelAdmin):
    fields = ('url', 'title', 'content')

在上面的例子中，只有字段url，title并将content 依次显示在表单中。fields能够包含定义ModelAdmin.readonly_fields为显示为只读的值。

如需更复杂的布局需求，请参阅fieldsets选项。

fields与此不一样的是list_display，该选项可能只包含模型上的字段名称或由指定的表单 form。它只有列入英文才可能包含可卡因readonly_fields。

要在同一行显示多个字段，请将这些字段包装在本身的元组中。在这个例子中，url和title字段将显示在同一行上，而且content字段将显示在它们的下面：

class FlatPageAdmin(admin.ModelAdmin):
    fields = (('url', 'title'), 'content')

注意

此fields选项不该与选项fields 内的字典密钥混淆fieldsets，以下一节所述。

若是既没有fields也没有fieldsets选项，Django将默认显示每一个不是AutoField和的字段，而且editable=True在单个字段集中按照与模型中定义的字段相同的顺序显示。

ModelAdmin. fieldsets

设置fieldsets为控制管理“添加”和“更改”页面的布局。

fieldsets是一个二元组列表，其中每一个二元组表明一个<fieldset>在管理页面上的a元组 。（A <fieldset>是表格的“部分”。）

二元组的格式为：其中 是一个字符串，表示字段集的标题，而且是关于字段集的信息字典，包括要在其中显示的字段列表。(name, field_options)namefield_options

一个完整的例子，取自 django.contrib.flatpages.models.FlatPage模型：

from django.contrib import admin

class FlatPageAdmin(admin.ModelAdmin):
    fieldsets = (
        (None, {
            'fields': ('url', 'title', 'content', 'sites')
        }),
        ('Advanced options', {
            'classes': ('collapse',),
            'fields': ('registration_required', 'template_name'),
        }),
    )

这会产生一个以下所示的管理页面：

../../../_images/fieldsets.png

若是既没有fieldsets也没有fields选项，Django将默认显示每一个不是AutoField和的字段，而且editable=True在单个字段集中按照与模型中定义的字段相同的顺序显示。

该field_options字典能够包含如下键值：

  • fields

    要在此字段集中显示的字段名称的元组。该密钥是必需的。

    例：

    {
'fields': ('first_name', 'last_name', 'address', 'city', 'state'),
}

    与fields选项同样，要在同一行显示多个字段，请将这些字段包装在它们本身的元组中。在这个例子中，first_name和last_name字段将显示在同一行上：

    {
'fields': (('first_name', 'last_name'), 'address', 'city', 'state'),
}

    fields能够包含定义 readonly_fields为显示为只读的值。

    若是您添加了可调用的名称fields，则适用与fields选项相同的规则：必须列出可调用的名称readonly_fields。

  • classes

    包含额外CSS类以应用于字段集的列表或元组。

    例：

    {
'classes': ('wide', 'extrapretty'),
}

    由默认管理网站样式表定义的两个有用的类是 collapse和wide。具备该collapse样式的字段集将首先在管理员中折叠并替换为一个小的“点击展开”连接。与字段集wide的风格将给予额外的水平空间。

  • description

    一组可选的额外文本显示在每一个字段集的顶部，位于字段集的标题下。TabularInline因为其布局，此字符串未呈现。

    请注意，该值在管理界面中显示时不是 HTML转义的。若是你愿意的话，这可让你包含HTML。或者，您可使用纯文本并 django.utils.html.escape()转义任何HTML特殊字符。

ModelAdmin. filter_horizontal

默认状况下，a ManyToManyField在管理站点中显示为a 。可是，选择多个项目时，多选框可能很难使用。添加一个 到这个列表将改成使用一个漂亮的不显眼的JavaScript“过滤器”界面，容许在选项内进行搜索。未选中和选定的选项并排显示在两个框中。请参阅使用垂直界面。<select multiple>ManyToManyFieldfilter_vertical

ModelAdmin. filter_vertical

filter_horizontal与之相同，但使用过滤器界面的垂直显示，并在所选选项框的上方显示未选定的选项框。

ModelAdmin. form

默认状况下，ModelForm会为您的模型动态建立。它用于建立添加/更改页面上显示的表单。您能够轻松地提供本身的设置ModelForm来覆盖添加/更改页面上的任何默认表单行为。或者，您能够自定义默认表单，而不是经过使用该ModelAdmin.get_form()方法指定一个全新的表单 。

有关示例，请参阅向管理员添加自定义验证部分。

注意

若是您Meta.model在a上定义属性 ModelForm，则还必须定义 Meta.fields属性（或Meta.exclude属性）。可是，因为管理员有本身的定义字段的方式，该Meta.fields 属性将被忽略。

若是ModelForm仅用于管理员，最简单的解决方案是省略该Meta.model属性，由于它ModelAdmin 会提供正确的模型以供使用。或者，您能够在课堂上设置 以知足对课程的验证 。fields = []MetaModelForm

注意

若是你ModelForm和ModelAdmin他们都定义了一个exclude 选项，那么ModelAdmin优先：

from django import forms
from django.contrib import admin
from myapp.models import Person

class PersonForm(forms.ModelForm):

    class Meta:
        model = Person
        exclude = ['name']

class PersonAdmin(admin.ModelAdmin):
    exclude = ['age']
    form = PersonForm

在上例中，“年龄”字段将被排除，但“名称”字段将包含在生成的表单中。

ModelAdmin. formfield_overrides

这提供了一种快速和肮脏的方式来覆盖Field在管理中使用的一些 选项。 formfield_overrides是一个将字段类映射为参数字典的字典，以在施工时传递给字段。

因为这有点抽象，咱们来看一个具体的例子。最多见的用法formfield_overrides是为特定类型的字段添加自定义小部件。因此，想象一下，咱们已经写了一个RichTextEditorWidget 咱们想用于大文本字段而不是默认的字段 <textarea>。如下是咱们如何作到的：

from django.db import models
from django.contrib import admin

# Import our custom widget and our model from where they're defined
from myapp.widgets import RichTextEditorWidget
from myapp.models import MyModel

class MyModelAdmin(admin.ModelAdmin):
    formfield_overrides = {
        models.TextField: {'widget': RichTextEditorWidget},
    }

请注意，字典中的键是实际的字段类，而不是字符串。价值是另外一个字典; 这些参数将传递给表单字段的__init__()方法。有关详细信息，请参阅表单API。

警告

若是要使用具备关系字段（即ForeignKey或 ManyToManyField）的自定义小部件 ，请确保您没有在raw_id_fields或中包含该字段的名称radio_fields。

formfield_overrides不会让你改变已经raw_id_fields或radio_fields设置的关系字段上的小部件。这是由于raw_id_fields并radio_fields暗示本身的定制小部件。

ModelAdmin. inlines

请参阅InlineModelAdmin下面的对象以及 ModelAdmin.get_formsets_with_inlines()。

ModelAdmin. list_display

设置list_display为控制哪些字段显示在管理员的更改列表页面上。

例：

list_display = ('first_name', 'last_name')

若是您没有设置list_display，管理网站将显示一个显示每一个对象__str__()（__unicode__()在Python 2上）表示的单个列。

您可使用四种可能的值list_display：

  • 模型的一个字段。例如：

    class PersonAdmin(admin.ModelAdmin):
    list_display = ('first_name', 'last_name')

  • 一个可调用的接受模型实例的一个参数。例如：

    def upper_case_name(obj):
    return ("%s%s" % (obj.first_name, obj.last_name)).upper()
upper_case_name.short_description = 'Name'

class PersonAdmin(admin.ModelAdmin):
    list_display = (upper_case_name,)

  • 表示属性的字符串ModelAdmin。这与可调用的行为相同。例如：

    class PersonAdmin(admin.ModelAdmin):
    list_display = ('upper_case_name',)

    def upper_case_name(self, obj):
        return ("%s%s" % (obj.first_name, obj.last_name)).upper()
    upper_case_name.short_description = 'Name'

  • 表示模型上属性的字符串。这与可调用的行为几乎相同，但self在此状况下是模型实例。如下是一个完整的示例：

    from django.db import models
from django.contrib import admin

class Person(models.Model):
    name = models.CharField(max_length=50)
    birthday = models.DateField()

    def decade_born_in(self):
        return self.birthday.strftime('%Y')[:3] + "0's"
    decade_born_in.short_description = 'Birth decade'

class PersonAdmin(admin.ModelAdmin):
    list_display = ('name', 'decade_born_in')

须要注意的几个特殊状况list_display：

  • 若是该字段是a ForeignKey，Django将显示相关对象的 __str__()（__unicode__()在Python 2上）。

  • ManyToManyField字段不受支持，由于这须要为表中的每一行执行单独的SQL语句。若是你想这样作，给你的模型一个自定义的方法，并添加该方法的名称list_display。（有关自定义方法的更多信息，请参见下文list_display。）

  • 若是该字段是BooleanField或NullBooleanField，Django将显示一个漂亮的“开”或“关”图标而不是True或 False。

  • 若是给定的字符串是模型的方法ModelAdmin或可调用的字符串，Django默认会HTML输出。要逃避用户输入并容许本身未转义的标签，请使用 format_html()。

    这是一个完整的示例模型：

    from django.db import models
from django.contrib import admin
from django.utils.html import format_html

class Person(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    color_code = models.CharField(max_length=6)

    def colored_name(self):
        return format_html(
            '<span style="color: #{};">{}{}</span>',
            self.color_code,
            self.first_name,
            self.last_name,
        )

class PersonAdmin(admin.ModelAdmin):
    list_display = ('first_name', 'last_name', 'colored_name')

    自1.9版弃用：在旧版本中，您能够allow_tags向方法添加属性以防止自动转义。该属性是不为它的安全使用format_html()， format_html_join()或 mark_safe()代替。

  • 正如一些示例已经说明的那样，在使用可调用对象，模型方法或ModelAdmin方法时，能够经过向short_description可调用对象添加属性来自定义列的标题。

  • 若是一个字段的值是None一个空字符串，或者一个没有元素的迭代，Django将显示-（一个破折号）。你能够重写此AdminSite.empty_value_display：

    from django.contrib import admin

admin.site.empty_value_display = '(None)'

    你也可使用ModelAdmin.empty_value_display：

    class PersonAdmin(admin.ModelAdmin):
    empty_value_display = 'unknown'

    或者在现场层面：

    class PersonAdmin(admin.ModelAdmin):
    list_display = ('name', 'birth_date_view')

    def birth_date_view(self, obj):
         return obj.birth_date

    birth_date_view.empty_value_display = 'unknown'

  • 若是给定的字符串是模型的一个方法，ModelAdmin或者返回True或False的可调用方法，那么若是给方法一个boolean值为的属性，Django将显示一个漂亮的“on”或“off”图标True。

    这是一个完整的示例模型：

    from django.db import models
from django.contrib import admin

class Person(models.Model):
    first_name = models.CharField(max_length=50)
    birthday = models.DateField()

    def born_in_fifties(self):
        return self.birthday.strftime('%Y')[:3] == '195'
    born_in_fifties.boolean = True

class PersonAdmin(admin.ModelAdmin):
    list_display = ('name', 'born_in_fifties')

  • 在__str__()（__unicode__()Python的2）方法只是做为有效的list_display任何其余模型的方法，因此这是彻底能够作到这一点：

    list_display = ('__str__', 'some_other_field')

  • 一般，这些元素list_display不是实际的数据库字段不能用于排序（由于Django在数据库级别进行全部排序）。

    可是，若是元素list_display表明某个数据库字段，则能够经过设置admin_order_field该项目的属性来指明这一事实 。

    例如：

    from django.db import models
from django.contrib import admin
from django.utils.html import format_html

class Person(models.Model):
    first_name = models.CharField(max_length=50)
    color_code = models.CharField(max_length=6)

    def colored_first_name(self):
        return format_html(
            '<span style="color: #{};">{}</span>',
            self.color_code,
            self.first_name,
        )

    colored_first_name.admin_order_field = 'first_name'

class PersonAdmin(admin.ModelAdmin):
    list_display = ('first_name', 'colored_first_name')

    以上将告诉Django first_name在试图colored_first_name在管理员中排序时按字段排序。

    要指示降序，admin_order_field能够在字段名称上使用连字符前缀。使用上面的例子，这看起来像：

    colored_first_name.admin_order_field = '-first_name'

    admin_order_field支持查询查找按相关模型上的值进行排序。此示例在列表显示中包含“做者名”列，并容许按名称对其进行排序：

    class Blog(models.Model):
    title = models.CharField(max_length=255)
    author = models.ForeignKey(Person, on_delete=models.CASCADE)

class BlogAdmin(admin.ModelAdmin):
    list_display = ('title', 'author', 'author_first_name')

    def author_first_name(self, obj):
        return obj.author.first_name

    author_first_name.admin_order_field = 'author__first_name'

  • 元素list_display也能够是属性。可是，请注意，因为性能在Python工做，设置的方式 short_description使用时，一个属性是惟一可能的 property()功能，并没有与@property装饰。

    例如：

    class Person(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)

    def my_property(self):
        return self.first_name + ' ' + self.last_name
    my_property.short_description = "Full name of the person"

    full_name = property(my_property)

class PersonAdmin(admin.ModelAdmin):
    list_display = ('full_name',)

  • 字段名称list_display也将在HTML输出中以CSS 元素的形式出现column-<field_name>在每一个<th>元素上。例如，这能够用来设置CSS文件中的列宽。

  • Django将尝试list_display按照如下顺序解释每一个元素：

    • 模型的一个字段。
    • 可调用。
    • 表明ModelAdmin属性的字符串。
    • 表明模型属性的字符串。

    例如，若是您有first_name模型字段和ModelAdmin属性，则将使用模型字段。

使用list_display_links来控制是否以及哪些字段 list_display应与“变”的页面对象。

默认状况下，更改列表页面会将第一列（指定的第一个字段）连接list_display到每一个项目的更改页面。但list_display_links让你改变这一点：

  • 将其设置None为根本没有连接。

  • 将其设置为列表或元组的字段（格式相同 list_display），其列要转换为连接。

    您能够指定一个或多个字段。只要字段出现 list_display在内，Django就不会关心链接了多少个（或多少个）字段。惟一的要求是，若是你想以list_display_links这种方式使用 ，你必须定义list_display。

在这个例子中，first_name和last_name字段将连接到更改列表页面上：

class PersonAdmin(admin.ModelAdmin):
    list_display = ('first_name', 'last_name', 'birthday')
    list_display_links = ('first_name', 'last_name')

在这个例子中，更改列表页面网格将没有连接：

class AuditEntryAdmin(admin.ModelAdmin):
    list_display = ('timestamp', 'message')
    list_display_links = None
ModelAdmin. list_editable

设置list_editable为模型上的字段名称列表，该列表将容许在更改列表页面上进行编辑。也就是说，列出的字段 list_editable将显示为更改列表页面上的表格小部件，容许用户一次编辑和保存多行。

注意

list_editable以特定方式与其余一些选项进行交互; 你应该注意如下规则：

  • 任何领域list_editable也必须在list_display。您没法编辑未显示的字段！
  • 同一个字段不能同时列在两个字段中，list_editable而且 list_display_links- 字段不能同时是表单和连接。

若是这些规则中的任何一个被破坏，您将获得验证错误。

ModelAdmin. list_filter

设置list_filter为激活管理员更改列表页右侧栏中的过滤器，以下图所示：

../../../_images/list_filter.png

list_filter 应该是元素的列表或元组，其中每一个元素应该是如下类型之一：

  • 字段名称，其中指定的字段应该是一个 BooleanField，CharField，DateField，DateTimeField， IntegerField，ForeignKey或ManyToManyField，例如：

    class PersonAdmin(admin.ModelAdmin):
    list_filter = ('is_staff', 'company')

    字段名称list_filter也可使用__查找跨越关系，例如：

    class PersonAdmin(admin.UserAdmin):
    list_filter = ('company__name',)

  • 一个继承的类django.contrib.admin.SimpleListFilter，你须要提供title和parameter_name 属性，并覆盖lookups和queryset方法，例如：

    from datetime import date

from django.contrib import admin
from django.utils.translation import ugettext_lazy as _

class DecadeBornListFilter(admin.SimpleListFilter):
    # Human-readable title which will be displayed in the
    # right admin sidebar just above the filter options.
    title = _('decade born')

    # Parameter for the filter that will be used in the URL query.
    parameter_name = 'decade'

    def lookups(self, request, model_admin):
        """
        Returns a list of tuples. The first element in each
        tuple is the coded value for the option that will
        appear in the URL query. The second element is the
        human-readable name for the option that will appear
        in the right sidebar.
        """
        return (
            ('80s', _('in the eighties')),
            ('90s', _('in the nineties')),
        )

    def queryset(self, request, queryset):
        """
        Returns the filtered queryset based on the value
        provided in the query string and retrievable via
        `self.value()`.
        """
        # Compare the requested value (either '80s' or '90s')
        # to decide how to filter the queryset.
        if self.value() == '80s':
            return queryset.filter(birthday__gte=date(1980, 1, 1),
                                    birthday__lte=date(1989, 12, 31))
        if self.value() == '90s':
            return queryset.filter(birthday__gte=date(1990, 1, 1),
                                    birthday__lte=date(1999, 12, 31))

class PersonAdmin(admin.ModelAdmin):
    list_filter = (DecadeBornListFilter,)

    注意

    为了方便，将HttpRequest对象传递给 lookupsand queryset方法，例如：

    class AuthDecadeBornListFilter(DecadeBornListFilter):

    def lookups(self, request, model_admin):
        if request.user.is_superuser:
            return super(AuthDecadeBornListFilter, self).lookups(request, model_admin)

    def queryset(self, request, queryset):
        if request.user.is_superuser:
            return super(AuthDecadeBornListFilter, self).queryset(request, queryset)

    一样为了方便起见，该ModelAdmin对象被传递给该lookups方法，例如，若是您想要查找可用数据：

    class AdvancedDecadeBornListFilter(DecadeBornListFilter):

    def lookups(self, request, model_admin):
        """
        Only show the lookups if there actually is
        anyone born in the corresponding decades.
        """
        qs = model_admin.get_queryset(request)
        if qs.filter(birthday__gte=date(1980, 1, 1),
                      birthday__lte=date(1989, 12, 31)).exists():
            yield ('80s', _('in the eighties'))
        if qs.filter(birthday__gte=date(1990, 1, 1),
                      birthday__lte=date(1999, 12, 31)).exists():
            yield ('90s', _('in the nineties'))

  • 一个元组，第一个元素是一个字段名，第二个元素是一个继承的类 django.contrib.admin.FieldListFilter，例如：

    class PersonAdmin(admin.ModelAdmin):
    list_filter = (
        ('is_staff', admin.BooleanFieldListFilter),
    )

    您可使用如下方法将相关模型的选择限制为涉及该关系的对象RelatedOnlyFieldListFilter：

    class BookAdmin(admin.ModelAdmin):
    list_filter = (
        ('author', admin.RelatedOnlyFieldListFilter),
    )

    假设author是ForeignKey一个User模型，这将限制list_filter选择，谁写的，而不是列出全部用户一本书的用户。

    注意

    该FieldListFilterAPI被认为是内部的，而且可能被改变。

列表过滤器一般仅在过滤器有多个选项时出现。过滤器的has_output()方法控制它是否出现。

能够指定用于呈现列表过滤器的自定义模板：

class FilterWithCustomTemplate(admin.SimpleListFilter):
    template = "custom_template.html"

有关admin/filter.html具体示例，请参阅Django（）提供的默认模板。

ModelAdmin. list_max_show_all

设置list_max_show_all为控制在“显示所有”管理更改列表页面上能够显示多少项目。只有当结果总数小于或等于此设置时，管理员才会在更改列表中显示“所有显示”连接。默认状况下，它被设置为200。

ModelAdmin. list_per_page

设置list_per_page为控制每一个分页的管理更改列表页面上显示的项目数量。默认状况下，它被设置为100。

设置list_select_related为告诉Django使用它 select_related()来检索管理更改列表页面上的对象列表。这能够为您节省一堆数据库查询。

该值应该是布尔值，列表或元组。默认是 False。

当价值是True，select_related()将永远被称为。当值设置False为时，Django将查看list_display并呼叫， select_related()若是有任何ForeignKey存在。

若是您须要更细粒度的控制，请使用元组（或列表）做为值 list_select_related。空元组将阻止Django从select_related根本上调用 。任何其余元组将直接传递给 select_related参数。例如：

class ArticleAdmin(admin.ModelAdmin):
    list_select_related = ('author', 'category')

会打电话。select_related('author', 'category')

若是您须要根据请求指定动态值，则能够实施一种get_list_select_related()方法。

ModelAdmin. ordering

设置ordering为指定如何在Django管理视图中排列对象列表。这应该是与模型ordering参数具备相同格式的列表或元组。

若是没有提供，Django管理员将使用模型的默认排序。

若是您须要指定动态顺序（例如取决于用户或语言），则能够实施一种get_ordering()方法。

ModelAdmin. paginator

paginator类用于分页。默认状况下， django.core.paginator.Paginator使用。若是自定义分页程序类没有与之相同的构造函数接口 django.core.paginator.Paginator，则还须要为其提供实现ModelAdmin.get_paginator()。

ModelAdmin. prepopulated_fields

设置prepopulated_fields字典映射字段名称到它应该预填充的字段：

class ArticleAdmin(admin.ModelAdmin):
    prepopulated_fields = {"slug": ("title",)}

设置时，给定的字段将使用一点JavaScript来从指定的字段填充。此功能的主要用途是自动为SlugField一个或多个其余字段的字段生成值。生成的值经过链接源字段的值生成，而后将该结果转换为有效的段落（例如，用空格替换空格）。

prepopulated_fields不接受DateTimeField，ForeignKey， OneToOneField，和ManyToManyField领域。

ModelAdmin. preserve_filters

管理员在建立，编辑或删除对象后，如今会在列表视图中保留过滤器。您能够经过设置此属性来恢复先前清除过滤器的行为False。

ModelAdmin. radio_fields

默认状况下，Django的管理员为ForeignKey已choices设置或已设置的字段使用选择框界面（<select>）。若是存在一个字段radio_fields，Django将使用一个单选按钮接口。假设group是ForeignKey对Person模型：

class PersonAdmin(admin.ModelAdmin):
    radio_fields = {"group": admin.VERTICAL}

您能够选择使用HORIZONTAL或VERTICAL从 django.contrib.admin模块中选择。

radio_fields除非ForeignKey已choices设置或已 设置，不然不要包含字段。

ModelAdmin. raw_id_fields

默认状况下，Django的管理员使用选择框界面（<select>）来显示字段ForeignKey。有时你不想承担必须选择全部相关实例以显示在下拉菜单中的开销。

raw_id_fields是您想要更改成Inputa ForeignKey或 小部件的字段列表ManyToManyField：

class ArticleAdmin(admin.ModelAdmin):
    raw_id_fields = ("newspaper",)

raw_id_fields Input若是该字段是a，则该小部件应包含主键，若是该字段是a，则该部分应包含以ForeignKey逗号分隔的值列表ManyToManyField。该raw_id_fields小部件在该字段旁边显示放大镜按钮，该按钮容许用户搜索并选择一个值：

../../../_images/raw_id_fields.png
ModelAdmin. readonly_fields

默认状况下，管理员将全部字段显示为可编辑。此选项中的任何字段（应该是a list或tuple）将按原样显示其数据而且不可编辑; 它们也被排除在 ModelForm用于建立和编辑的位置。请注意，指定ModelAdmin.fields或ModelAdmin.fieldsets 只读字段必须存在才能显示（不然将被忽略）。

若是readonly_fields在没有定义显式排序的状况下使用， ModelAdmin.fields或者ModelAdmin.fieldsets将在全部可编辑字段以后最后添加。

只读字段不只能够显示模型字段中的数据，还能够显示模型方法的输出或ModelAdmin类自己的方法 。这与ModelAdmin.list_display行为很是类似 。这提供了一种简单的方法来使用管理界面来提供关于正在编辑的对象状态的反馈，例如：

from django.contrib import admin
from django.utils.html import format_html_join
from django.utils.safestring import mark_safe

class PersonAdmin(admin.ModelAdmin):
    readonly_fields = ('address_report',)

    def address_report(self, instance):
        # assuming get_full_address() returns a list of strings
        # for each line of the address and you want to separate each
        # line by a linebreak
        return format_html_join(
            mark_safe('<br/>'),
            '{}',
            ((line,) for line in instance.get_full_address()),
        ) or mark_safe("<span class='errors'>I can't determine this address.</span>")

    # short_description functions like a model field's verbose_name
    address_report.short_description = "Address"
ModelAdmin. save_as

设置save_as为在管理员更改表单上启用“另存为新功能”功能。

一般，对象有三个保存选项：“保存”，“保存并继续编辑”和“保存并添加另外一个”。若是save_as是True，“保存并添加另外一个”将被替换为“Save as new”按钮，该按钮将建立一个新对象（使用新的ID），而不是更新现有对象。

默认状况下，save_as设置为False。

ModelAdmin. save_as_continue
Django 1.10新增功能

什么时候save_as=True，保存新对象以后的默认重定向是指该对象的更改视图。若是您设置 save_as_continue=False，重定向将转到更改列表视图。

默认状况下，save_as_continue设置为True。

ModelAdmin. save_on_top

设置save_on_top为在管理员更改表单顶部添加保存按钮。

一般，保存按钮只出如今表格的底部。若是设置save_on_top，按钮将出如今顶部和底部。

默认状况下，save_on_top设置为False。

ModelAdmin. search_fields

设置search_fields为启用管理员更改列表页面上的搜索框。这应该设置为一个字段名称列表，只要有人在该文本框中提交搜索查询，就会搜索该字段名称。

这些字段应该是某种文本字段，例如CharField或 TextField。您也能够在执行相关的查询ForeignKey或 ManyToManyField与查找API“跟随”符号：

search_fields = ['foreign_key__related_fieldname']

例如，若是您有做者的博客条目，则如下定义​​将启用经过做者的电子邮件地址搜索博客条目：

search_fields = ['user__email']

当有人在管理搜索框中进行搜索时，Django会将搜索查询拆分为单词并返回包含每一个单词的全部对象，不区分大小写，每一个单词必须至少包含一个单词 search_fields。例如，若是search_fields设置为 而且用户搜索，则Django将执行与此SQL 子句等效的操做：['first_name', 'last_name']john lennonWHERE

WHERE (first_name ILIKE '%john%' OR last_name ILIKE '%john%')
AND (first_name ILIKE '%lennon%' OR last_name ILIKE '%lennon%')

对于更快和/或更具限制性的搜索，请在字段名称前加上运算符：

^

使用'^'运算符匹配字段开始处的开始。例如，若是search_fields设置为 而且用户搜索 ，则Django将执行与此SQL 子句等效的操做：['^first_name', '^last_name']john lennonWHERE

WHERE (first_name ILIKE 'john%' OR last_name ILIKE 'john%')
AND (first_name ILIKE 'lennon%' OR last_name ILIKE 'lennon%')

这个查询比普通'%john%'查询更有效率，由于数据库只须要检查列数据的开始，而不是查找整个列的数据。另外，若是列上有一个索引，有些数据库可能可以使用该查询的索引，即便它是LIKE查询。

=

使用'='运算符进行不区分大小写的精确匹配。例如，若是search_fields设置为 而且用户搜索 ，则Django将执行与此SQL 子句等效的操做 ：['=first_name', '=last_name']john lennonWHERE

WHERE (first_name ILIKE 'john' OR last_name ILIKE 'john')
AND (first_name ILIKE 'lennon' OR last_name ILIKE 'lennon')

请注意，查询输入由空格分隔，所以，在此示例以后，目前没法搜索first_name彻底（包含空格）的全部记录 。'john winston'

@
使用'@'运算符执行全文匹配。这就像默认的搜索方法，但使用索引。目前这只适用于MySQL。

若是您须要自定义搜索，则可使用它 ModelAdmin.get_search_results()来提供其余或替代搜索行为。

ModelAdmin. show_full_result_count

设置show_full_result_count为控制是否应在过滤的管理页面上显示对象的完整数量（例如）。若是此选项设置为， 则会显示相似文字。99 results (103 total)False99 results (Show all)

show_full_result_count=True若是表包含大量行，则默认状况下会生成一个查询以在表上执行完整计数，这可能很是昂贵。

ModelAdmin. view_on_site

设置view_on_site为控制是否显示“查看现场”连接。这个连接应该带你到一个URL，你能够显示保存的对象。

该值能够是布尔标志或可调用的。若是True（默认），该对象的get_absolute_url() 方法将用于生成url。

若是您的模型有一个get_absolute_url()方法，但不想显示“查看现场”按钮，则只需设置 view_on_site为False：

from django.contrib import admin

class PersonAdmin(admin.ModelAdmin):
    view_on_site = False

若是它是可调用的，它将接受模型实例做为参数。例如：

from django.contrib import admin
from django.urls import reverse

class PersonAdmin(admin.ModelAdmin):
    def view_on_site(self, obj):
        url = reverse('person-detail', kwargs={'slug': obj.slug})
        return 'https://example.com' + url

自定义模板选项

该重写管理模板部分介绍如何重写或扩展默认的管理模板。使用如下选项覆盖ModelAdmin视图使用的默认模板：

ModelAdmin. add_form_template

自定义模板的路径，由其使用add_view()。

ModelAdmin. change_form_template

自定义模板的路径，由其使用change_view()。

ModelAdmin. change_list_template

自定义模板的路径，由其使用changelist_view()。

ModelAdmin. delete_confirmation_template

自定义模板的路径，用于delete_view()在删除一个或多个对象时显示确认页面。

ModelAdmin. delete_selected_confirmation_template

自定义模板的路径，delete_selected在删除一个或多个对象时由action方法用于显示确认页面。请参阅操做文档。

ModelAdmin. object_history_template

自定义模板的路径，由其使用history_view()。

ModelAdmin. popup_response_template
Django 1.11新增功能

路径的自定义模板，经过使用response_add()， response_change()和response_delete()。

ModelAdmin方法

警告

当重写ModelAdmin.save_model()和 ModelAdmin.delete_model()，你的代码必须保存/删除对象。它们不是用于否决的目的，而是容许你执行额外的操做。

ModelAdmin. save_model （ request ， obj ， form ， change ） [source]

该save_model方法根据是添加仍是更改对象HttpRequest，给出模型实例，ModelForm实例和布尔值。覆盖此方法能够执行保存前或保存后的操做。调用super().save_model()以保存使用的对象Model.save()。

例如，request.user要在保存以前附加到对象：

from django.contrib import admin

class ArticleAdmin(admin.ModelAdmin):
    def save_model(self, request, obj, form, change):
        obj.user = request.user
        super(ArticleAdmin, self).save_model(request, obj, form, change)
ModelAdmin. delete_model （ request ， obj ） [source]

该delete_model方法给出了HttpRequest一个模型实例。重写此方法能够执行预删除操做。调用super().delete_model()以删除使用的对象 Model.delete()。

ModelAdmin. save_formset （ request ， form ， formset ， change ） [source]

该save_formset方法根据是否添加或更改父对象给出HttpRequest父 ModelForm实例和布尔值。

例如，要附加request.user到每一个更改的formset模型实例：

class ArticleAdmin(admin.ModelAdmin):
    def save_formset(self, request, form, formset, change):
        instances = formset.save(commit=False)
        for obj in formset.deleted_objects:
            obj.delete()
        for instance in instances:
            instance.user = request.user
            instance.save()
        formset.save_m2m()

另请参见保存表单集中的对象。

ModelAdmin. get_ordering （ 请求 ）

该get_ordering方法采用requestas参数，而且预期会返回一个list或tuple与该ordering属性相似的排序。例如：

class PersonAdmin(admin.ModelAdmin):

    def get_ordering(self, request):
        if request.user.is_superuser:
            return ['name', 'rank']
        else:
            return ['name']
ModelAdmin. get_search_results （ request ， queryset ， search_term ） [source]

该get_search_results方法将显示的对象列表修改成与提供的搜索项匹配的对象列表。它接受请求，应用当前过滤器的查询集以及用户提供的搜索术语。它返回一个包含被修改来实现搜索的查询集的元组，以及一个指示结果是否包含重复项的布尔值。

默认实现搜索名为in的字段ModelAdmin.search_fields。

此方法可能会被您本身的自定义搜索方法覆盖。例如，您可能但愿按整数字段进行搜索，或使用外部工具（如Solr或Haystack）。您必须肯定您的搜索方法实施的查询集更改是否可能会在结果中引入重复项，并返回True返回值的第二个元素。

例如，要经过name和进行搜索age，您可使用：

class PersonAdmin(admin.ModelAdmin):
    list_display = ('name', 'age')
    search_fields = ('name',)

    def get_search_results(self, request, queryset, search_term):
        queryset, use_distinct = super(PersonAdmin, self).get_search_results(request, queryset, search_term)
        try:
            search_term_as_int = int(search_term)
        except ValueError:
            pass
        else:
            queryset |= self.model.objects.filter(age=search_term_as_int)
        return queryset, use_distinct

这个实现比致使字符串比较数字字段的效率更高，例如 PostgreSQL。search_fields = ('name', '=age')... OR UPPER("polls_choice"."votes"::text) = UPPER('4')

该save_related方法根据是否正在添加或更改HttpRequest父项ModelForm，给出父级 实例，内联窗体集列表和布尔值。在这里，您能够为与父项相关的对象执行任何预保存或后保存操做。请注意，此时父对象及其表单已被保存。

ModelAdmin. get_readonly_fields （ request ， obj = None ）

该get_readonly_fields方法被赋予HttpRequest和 obj正在编辑（或None添加表单），而且预期会返回一个list或tuple多个字段名称，这些名称将按照只读方式显示，如上面的ModelAdmin.readonly_fields部分所述。

ModelAdmin. get_prepopulated_fields （ request ， obj = None ）

该get_prepopulated_fields方法被赋予HttpRequest和 obj正在编辑（或None在添加表单上），而且预期会返回一个dictionary，如上面的ModelAdmin.prepopulated_fields 部分所述。

ModelAdmin. get_list_display （ 请求 ） [源]

该get_list_display方法给出的HttpRequest和预期返回一个list或tuple将如上述所描述的变动列表视图中显示的字段名的 ModelAdmin.list_display段。

该get_list_display_links方法被赋予HttpRequest和由list或tuple返回ModelAdmin.get_list_display()。预计返回任一None或一个list或tuple字段名称的对将被连接到的变化视图，如在所描述的变动表ModelAdmin.list_display_links部分。

ModelAdmin. get_exclude （ request ， obj = None ）
Django 1.11新增功能

该get_exclude方法被赋予HttpRequest和obj 正在编辑（或None添加表单），而且预期返回一个字段列表，以下所述ModelAdmin.exclude。

ModelAdmin. get_fields （ request ， obj = None ） [source]

该get_fields方法被赋予HttpRequest和obj 正在编辑（或None添加表单），而且预期会返回一个字段列表，如上面的ModelAdmin.fields部分所述。

ModelAdmin. get_fieldsets （ request ， obj = None ）

该get_fieldsets方法被赋予HttpRequest和obj 被编辑（或None添加表单），而且预期返回一个两元组列表，其中每一个二元组表示一个<fieldset>在管理表单页面上的，如上面在本ModelAdmin.fieldsets节中所述。

ModelAdmin. get_list_filter （ 请求 ） [源]

该get_list_filter方法给出HttpRequest而且有望恢复同种序列类型做为 list_filter属性。

该get_list_select_related方法给出的HttpRequest和应该返回一个布尔值或列表ModelAdmin.list_select_related 同样。

ModelAdmin. get_search_fields （ 请求 ） [源]

该get_search_fields方法给出HttpRequest而且有望恢复同种序列类型做为 search_fields属性。

ModelAdmin. get_inline_instances （ request ， obj = None ） [source]

该get_inline_instances方法被赋予HttpRequest和 obj正在编辑（或None添加表单），而且预期会返回一个list或tuple多个InlineModelAdmin 对象，以下面的InlineModelAdmin 部分所述。例如，如下内容将根据添加，更改和删除权限在没有默认筛选的状况下返回内联：

class MyModelAdmin(admin.ModelAdmin):
    inlines = (MyInline,)

    def get_inline_instances(self, request, obj=None):
        return [inline(self.model, self.admin_site) for inline in self.inlines]

若是您重写此方法，请确保返回的内联是在其中定义的类的实例，inlines或者在添加相关对象时可能会遇到“错误的请求”错误。

ModelAdmin. get_urls （） [source]

在get_urls上一个方法ModelAdmin返回到用于以相同的方式做为URL配置其的ModelAdmin的网址。所以，您能够按照URL调度程序中的说明扩展它们：

class MyModelAdmin(admin.ModelAdmin):
    def get_urls(self):
        urls = super(MyModelAdmin, self).get_urls()
        my_urls = [
            url(r'^my_view/$', self.my_view),
        ]
        return my_urls + urls

    def my_view(self, request):
        # ...
        context = dict(
           # Include common variables for rendering the admin template.
           self.admin_site.each_context(request),
           # Anything else you want in the context...
           key=value,
        )
        return TemplateResponse(request, "sometemplate.html", context)

若是您想使用管理布局，请从admin/base_site.html如下位置扩展：

{% extends "admin/base_site.html" %}
{% block content %}
...
{% endblock %}

注意

请注意，自定义模式包含在常规管理网址以前：管理网址模式很是宽容，几乎能够匹配任何内容，所以您一般会但愿将自定义网址预置为内置网址。

在这个例子中，my_view将被访问 /admin/myapp/mymodel/my_view/（假设管理网址包含在/admin/。）

可是，self.my_view上面注册的功能存在两个问题：

  • 它不会执行任何权限检查，所以它可供公众访问。
  • 它不会提供任何头部细节来防止缓存。这意味着若是页面从数据库中检索数据，而且缓存中间件处于活动状态，则页面可能会显示过期的信息。

因为这一般不是你想要的，Django提供了一个方便的包装来检查权限并将视图标记为不可缓存。这个包装是AdminSite.admin_view()（即self.admin_site.admin_view 在一个ModelAdmin实例内）; 像这样使用它：

class MyModelAdmin(admin.ModelAdmin):
    def get_urls(self):
        urls = super(MyModelAdmin, self).get_urls()
        my_urls = [
            url(r'^my_view/$', self.admin_site.admin_view(self.my_view))
        ]
        return my_urls + urls

注意上面第五行的包装视图：

url(r'^my_view/$', self.admin_site.admin_view(self.my_view))

这个包装将防止self.my_view未经受权的访问，并将应用django.views.decorators.cache.never_cache()装饰器，以确保若是缓存中间件处于活动状态，则不会缓存它。

若是页面可缓存，但您仍但愿执行权限检查，则能够将cacheable=True参数传递给 AdminSite.admin_view()：

url(r'^my_view/$', self.admin_site.admin_view(self.my_view, cacheable=True))

ModelAdmin视图具备model_admin属性。其余 AdminSite视图具备admin_site属性。

ModelAdmin. get_form （ request ， obj = None ， ** kwargs ） [source]

返回一个ModelForm用于管理添加和更改视图的类，请参阅add_view()和change_view()。

基本实现使用modelform_factory() 子类form，经过fields 和等属性进行修改exclude。所以，例如，若是您想为超级用户提供其余字段，则可使用不一样的基本形式，以下所示：

class MyModelAdmin(admin.ModelAdmin):
    def get_form(self, request, obj=None, **kwargs):
        if request.user.is_superuser:
            kwargs['form'] = MySuperuserForm
        return super(MyModelAdmin, self).get_form(request, obj, **kwargs)

您也能够直接返回一个自定义ModelForm类。

ModelAdmin. get_formsets_with_inlines （ request ， obj = None ） [source]

产量（FormSet，InlineModelAdmin）配对用于管理添加和更改视图。

例如，若是您只想在更改视图中显示特定的内联，则能够覆盖get_formsets_with_inlines，以下所示：

class MyModelAdmin(admin.ModelAdmin):
    inlines = [MyInline, SomeOtherInline]

    def get_formsets_with_inlines(self, request, obj=None):
        for inline in self.get_inline_instances(request, obj):
            # hide MyInline in the add view
            if isinstance(inline, MyInline) and obj is None:
                continue
            yield inline.get_formset(request, obj), inline
ModelAdmin. formfield_for_foreignkey （ db_field ， request ， ** kwargs ）

a上的formfield_for_foreignkey方法ModelAdmin容许您覆盖外键字段的默认窗体字段。例如，要根据用户返回此外键字段的对象的子集：

class MyModelAdmin(admin.ModelAdmin):
    def formfield_for_foreignkey(self, db_field, request, **kwargs):
        if db_field.name == "car":
            kwargs["queryset"] = Car.objects.filter(owner=request.user)
        return super(MyModelAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs)

这将使用HttpRequest实例来过滤Car外键字段以仅显示User实例拥有的汽车。

ModelAdmin. formfield_for_manytomany （ db_field ， request ， ** kwargs ）

就像这个formfield_for_foreignkey方法同样，这个 formfield_for_manytomany方法能够被覆盖，为多到多的字段更改默认的表单域。例如，若是拥有者能够拥有多辆汽车，而且汽车能够属于多个全部者 - 多对多关系 - 那么您能够过滤Car外键字段以仅显示如下内容拥有的汽车User：

class MyModelAdmin(admin.ModelAdmin):
    def formfield_for_manytomany(self, db_field, request, **kwargs):
        if db_field.name == "cars":
            kwargs["queryset"] = Car.objects.filter(owner=request.user)
        return super(MyModelAdmin, self).formfield_for_manytomany(db_field, request, **kwargs)
ModelAdmin. formfield_for_choice_field （ db_field ， request ， ** kwargs ）

像formfield_for_foreignkey和和formfield_for_manytomany 方法同样，formfield_for_choice_field能够重写该方法来更改已声明选项的字段的默认表单域。例如，若是超级用户可用的选择不一样于普通员工可用的选择，则可按如下步骤操做：

class MyModelAdmin(admin.ModelAdmin):
    def formfield_for_choice_field(self, db_field, request, **kwargs):
        if db_field.name == "status":
            kwargs['choices'] = (
                ('accepted', 'Accepted'),
                ('denied', 'Denied'),
            )
            if request.user.is_superuser:
                kwargs['choices'] += (('ready', 'Ready for deployment'),)
        return super(MyModelAdmin, self).formfield_for_choice_field(db_field, request, **kwargs)

注意

choices在formfield上设置的任何属性将仅限于表单域。若是模型上的相应字段设置了选项，则提供给表单的选项必须是这些选项的有效子集，不然表单提交将失败，而且ValidationError在保存前验证模型自己。

ModelAdmin. get_changelist （ 请求 ， ** kwargs ） [源代码]

返回Changelist要用于列表的类。默认状况下， django.contrib.admin.views.main.ChangeList使用。经过继承这个类，你能够改变列表的行为。

ModelAdmin. get_changelist_form （ 请求 ， ** kwargs ） [源代码]

返回 在更改列表页面上ModelForm使用的类Formset。要使用自定义表单，例如：

from django import forms

class MyForm(forms.ModelForm):
    pass

class MyModelAdmin(admin.ModelAdmin):
    def get_changelist_form(self, request, **kwargs):
        return MyForm

注意

若是您Meta.model在a上定义属性 ModelForm，则还必须定义 Meta.fields属性（或Meta.exclude属性）。然而， ModelAdmin忽略这个值，用ModelAdmin.list_editable属性覆盖它 。最简单的解决方案是省略该Meta.model属性，由于ModelAdmin它将提供正确的模型以供使用。

ModelAdmin. get_changelist_formset （ 请求 ， ** kwargs ） [源代码]

若是使用的话，返回一个ModelFormSet类用于更改列表页面list_editable。要使用自定义表单，例如：

from django.forms import BaseModelFormSet

class MyAdminFormSet(BaseModelFormSet):
    pass

class MyModelAdmin(admin.ModelAdmin):
    def get_changelist_formset(self, request, **kwargs):
        kwargs['formset'] = MyAdminFormSet
        return super(MyModelAdmin, self).get_changelist_formset(request, **kwargs)
ModelAdmin. lookup_allowed （ lookup ， value ）

更改列表页面中的对象可使用来自URL的查询字符串的查找进行过滤。list_filter例如，这是如何工做的。查找与QuerySet.filter()（例如 user__email=user@example.com）中使用的类似。因为查询字符串中的查找能够由用户操做，所以必须对其进行消毒以防止未经受权的数据暴露。

该lookup_allowed()方法从查询字符串（例如'user__email'）和相应的值（例如'user@example.com'）给出一个查找路径，并返回一个布尔值，指示是否QuerySet容许使用参数过滤更改列表。若是lookup_allowed()返回False，则引起DisallowedModelAdminLookup （的子类SuspiciousOperation）。

默认状况下，lookup_allowed()容许访问模型的本地字段，list_filter（但不包括路径 get_list_filter()）中使用的字段路径以及limit_choices_to正确运行所需的查找 raw_id_fields。

重写此方法以自定义您的ModelAdmin子类容许的查找 。

ModelAdmin. has_add_permission （ 请求 ）

True若是添加一个对象应该返回，False 不然。

ModelAdmin. has_change_permission （ request ， obj = None ）

True若是编辑obj被容许，应该返回，False不然。若是obj是None，应返回True或False指示是否容许一般容许编辑此类对象（例如，False 将被解释为意味着当前用户不被容许编辑此类型的任何对象）。

ModelAdmin. has_delete_permission （ request ， obj = None ）

True若是删除obj被容许，应该返回，False不然。若是obj是None，应返回True或False指示是否容许删除此类型的对象（例如，False将被解释为意味着当前用户不容许删除此类型的任何对象）。

ModelAdmin. has_module_permission （ 请求 ）

若是True在管理索引页面上显示模块并访问模块的索引页面应该返回，False不然返回。使用User.has_module_perms()默认。重写它不限制访问添加，更改或删除意见， has_add_permission()， has_change_permission()，和 has_delete_permission()应该用于这一点。

ModelAdmin. get_queryset （ 请求 ）

返回 能够由管理站点编辑的全部模型实例的get_queryset方法。覆盖此方法的一个用例是显示登陆用户拥有的对象：ModelAdminQuerySet

class MyModelAdmin(admin.ModelAdmin):
    def get_queryset(self, request):
        qs = super(MyModelAdmin, self).get_queryset(request)
        if request.user.is_superuser:
            return qs
        return qs.filter(author=request.user)
ModelAdmin. message_user （ request ， message ， level = messages.INFO ， extra_tags ='' ， fail_silently = False ） [source]

使用django.contrib.messages 后端向用户发送消息。请参阅自定义的ModelAdmin示例。

关键字参数容许您更改消息级别，添加额外的CSS标签，或者若是contrib.messages未安装框架，将自动失败。这些关键字参数与之匹配 django.contrib.messages.add_message()，请参阅该函数的文档以获取更多详细信息。一个区别是，除了整数/常量以外，该级别还能够做为字符串标签传递。

ModelAdmin. get_paginator （ request ， queryset ， per_page ， orphans = 0 ， allow_empty_first_page = True ） [source]

返回用于此视图的分页程序实例。默认状况下，实例化一个实例paginator。

ModelAdmin. response_add （ request ， obj ， post_url_continue = None ） [source]

肯定HttpResponse的 add_view()阶段。

response_add在提交管理员表单后以及在建立和保存对象和全部相关实例以后调用。您能够覆盖它以更改对象建立后的默认行为。

ModelAdmin. response_change （ request ， obj ） [source]

肯定HttpResponse的 change_view()阶段。

response_change在提交管理表单而且刚刚保存了对象和全部相关实例以后调用。您能够覆盖它以更改对象更改后的默认行为。

ModelAdmin. response_delete （ request ， obj_display ， obj_id ） [source]

肯定HttpResponse的 delete_view()阶段。

response_delete在对象被删除后调用。您能够覆盖它以更改对象删除后的默认行为。

obj_display 是一个带有删除对象名称的字符串。

obj_id 是用于检索要删除的对象的序列化标识符。

ModelAdmin. get_changeform_initial_data （ 请求 ） [源]

管理员更改表单上的初始数据的挂钩。默认状况下，字段从GET参数中得到初始值。例如， ?name=initial_value将name字段的初始值设置为 initial_value。

这个方法应该如下面的形式返回一个字典 ：{'fieldname': 'fieldval'}

def get_changeform_initial_data(self, request):
    return {'name': 'custom_initial_value'}

其余方法

ModelAdmin. add_view （ request ， form_url ='' ， extra_context = None ） [source]

用于模型实例添加页面的Django视图。见下面的注释。

ModelAdmin. change_view （ request ， object_id ， form_url ='' ， extra_context = None ） [source]

用于模型实例编辑页面的Django视图。见下面的注释。

ModelAdmin. changelist_view （ request ， extra_context = None ） [source]

用于模型实例的Django视图更改列表/操做页面。见下面的注释。

ModelAdmin. delete_view （ request ， object_id ， extra_context = None ） [source]

用于模型实例删除确认页面的Django视图。见下面的注释。

ModelAdmin. history_view （ request ， object_id ， extra_context = None ） [source]

显示给定模型实例的修改历史记录的页面的Django视图。

与ModelAdmin上一节中详述的钩子类型方法不一样，这五种方法实际上被设计为从管理应用程序URL分派处理程序调用为Django视图来呈现处理模型实例CRUD操做的页面。所以，彻底覆盖这些方法将显着改变管理应用程序的行为。

覆盖这些方法的一个常见缘由是增长提供给呈现视图的模板的上下文数据。在如下示例中，将更改视图被覆盖，以便为呈现的模板提供一些额外的映射数据，不然这些映射数据不可用：

class MyModelAdmin(admin.ModelAdmin):

    # A template for a very customized change view:
    change_form_template = 'admin/myapp/extras/openstreetmap_change_form.html'

    def get_osm_info(self):
        # ...
        pass

    def change_view(self, request, object_id, form_url='', extra_context=None):
        extra_context = extra_context or {}
        extra_context['osm_data'] = self.get_osm_info()
        return super(MyModelAdmin, self).change_view(
            request, object_id, form_url, extra_context=extra_context,
        )

这些视图返回的TemplateResponse 实例容许您在呈现前轻松定制响应数据。有关更多详细信息，请参阅TemplateResponse文档。

ModelAdmin资产定义

有些时候您想添加一些CSS和/或JavaScript到添加/更改视图。这能够经过Media在你的下面使用一个内部类来完成ModelAdmin：

class ArticleAdmin(admin.ModelAdmin):
    class Media:
        css = {
            "all": ("my_styles.css",)
        }
        js = ("my_code.js",)

所述staticfiles应用预规划 STATIC_URL（或MEDIA_URL若是STATIC_URL是 None），以任何资产路径。与表格上的常规资产定义相同的规则也适用。

jQuery的

Django管理JavaScript使用jQuery库。

为了不与用户提供的脚本或库冲突，Django的jQuery（版本2.2.3）命名空间为django.jQuery。若是您想在本身的管理JavaScript中使用jQuery而不包含第二个副本，则能够django.jQuery在更改列表上使用该 对象并添加/编辑视图。

在Django 1.10中更改：

嵌入式jQuery从2.1.4升级到2.2.3。

本ModelAdmin类须要jQuery的默认，因此没有必要将jQuery添加到您的ModelAdmin“媒体资源的名单，除非你有特殊的须要。例如，若是您须要将jQuery库放在全局名称空间中（例如，使用第三方jQuery插件时）或者须要更新版本的jQuery，则必须包含本身的副本。

Django提供未压缩和jQuery的“精缩”版本， jquery.js和jquery.min.js分别。

ModelAdmin并InlineModelAdmin有一个media属性返回Media存储指向表单和/或表单集的JavaScript文件路径的对象列表。若是DEBUG是True，将返回不一样的JavaScript文件，其中包括未压缩的版本 jquery.js; 若是不是，它将返回'缩小'版本。

将自定义验证添加到管理员

在管理员中添加自定义数据验证很是简单。自动管理界面重用django.forms，而且ModelAdmin该类让您能够定义本身的表单：

class ArticleAdmin(admin.ModelAdmin):
    form = MyArticleAdminForm

MyArticleAdminForm能够在任何地方定义，只要您在须要的地方导入便可。如今在表单中，您能够为任何字段添加您本身的自定义验证：

class MyArticleAdminForm(forms.ModelForm):
    def clean_name(self):
        # do something that validates your data
        return self.cleaned_data["name"]

你在ModelForm这里使用这一点很重要，不然事情可能会破裂。请参阅自定义验证的表单文档，更具体来讲，请参阅 模型表单验证说明以获取更多信息。

InlineModelAdmin对象

类 InlineModelAdmin
class TabularInline [source]
class StackedInline [source]

管理界面能够在与父模型相同的页面上编辑模型。这些被称为内联。假设你有这两个模型：

from django.db import models

class Author(models.Model):
   name = models.CharField(max_length=100)

class Book(models.Model):
   author = models.ForeignKey(Author, on_delete=models.CASCADE)
   title = models.CharField(max_length=100)

您能够编辑做者页面上做者创做的书籍。经过在模型中指定它们，能够将内联添加到模型中ModelAdmin.inlines：

from django.contrib import admin

class BookInline(admin.TabularInline):
    model = Book

class AuthorAdmin(admin.ModelAdmin):
    inlines = [
        BookInline,
    ]

Django提供了两个子类，InlineModelAdmin它们是：

这二者之间的区别仅仅是用于呈现它们的模板。

InlineModelAdmin选项

InlineModelAdmin与许多相同的功能ModelAdmin共享，并增长了一些功能（共享功能其实是在BaseModelAdmin超类中定义的 ）。共享功能是：

该InlineModelAdmin班增长：

InlineModelAdmin. model

内联使用的模型。这是必需的。

InlineModelAdmin. fk_name

模型上外键的名称。在大多数状况下，这将自动处理，但fk_name若是同一父模型有多个外键，则必须明确指定。

InlineModelAdmin. formset

这默认为BaseInlineFormSet。使用你本身的formset能够给你不少定制的可能性。内联是围绕模型框架构建的。

InlineModelAdmin. form

该值form默认为ModelForm。这是inlineformset_factory()为内联建立formset时传递的内容。

警告

在为InlineModelAdmin窗体编写自定义验证时，请谨慎编写依赖父模型功能的验证。若是父模型没法验证，则可能会使其处于不一致状态，如ModelForm上的验证中的警告中所述。

InlineModelAdmin. classes
Django 1.10新增功能

包含额外CSS类的列表或元组，用于应用于为内联呈现的字段集。默认为None。与配置fieldsets的collapse 类同样，内联的类将首先被​​折叠，而且它们的标题将会有一个小的“显示”连接。

InlineModelAdmin. extra

除了初始表单以外，它控制着formset将显示的额外表单的数量。有关更多信息，请参阅 formset文档。

对于启用了JavaScript的浏览器的用户，提供了“添加另外一个”连接，除了做为extra参数提供的内容以外，还能够添加任意数量的附加内联。

若是当前显示的表单数量超过max_num，或者用户没有启用JavaScript，则动态连接不会显示。

InlineModelAdmin.get_extra() 还容许您自定义额外表格的数量。

InlineModelAdmin. max_num

这将控制内联中显示的最大表单数量。这并不直接与对象的数量相关，但若是值足够小，则可使用。请参阅限制可编辑对象的数量以获取更多信息。

InlineModelAdmin.get_max_num() 还容许您自定义额外表格的最大数量。

InlineModelAdmin. min_num

这控制了要在内联中显示的最少数量的表单。查看modelformset_factory()更多信息。

InlineModelAdmin.get_min_num() 还容许您自定义显示表单的最小数量。

InlineModelAdmin. raw_id_fields

默认状况下，Django的管理员使用选择框界面（<select>）来显示字段ForeignKey。有时你不想承担必须选择全部相关实例以显示在下拉菜单中的开销。

raw_id_fields是您想要更改成Inputa ForeignKey或小部件的字段列表 ManyToManyField：

class BookInline(admin.TabularInline):
    model = Book
    raw_id_fields = ("pages",)
InlineModelAdmin. template

用于在页面上呈现内联的模板。

InlineModelAdmin. verbose_name

verbose_name在模型的内部Meta 类中找到的重写。

InlineModelAdmin. verbose_name_plural

verbose_name_plural在模型的内部Meta类中找到 的重写。

InlineModelAdmin. can_delete

指定是否能够内嵌删除嵌入式对象。默认为True。

指定是否能够在admin中更改的内嵌对象连接到更改表单。默认为False。

InlineModelAdmin. get_formset （ request ， obj = None ， ** kwargs ）

返回一个BaseInlineFormSet用于管理员添加/更改视图的类。看到的例子 ModelAdmin.get_formsets_with_inlines。

InlineModelAdmin. get_extra （ request ， obj = None ， ** kwargs ）

返回要使用的额外内联表单的数量。默认状况下，返回 InlineModelAdmin.extra属性。

重写此方法以编程方式肯定额外内联表单的数量。例如，这可能基于模型实例（做为关键字参数传递obj）：

class BinaryTreeAdmin(admin.TabularInline):
    model = BinaryTree

    def get_extra(self, request, obj=None, **kwargs):
        extra = 2
        if obj:
            return extra - obj.binarytree_set.count()
        return extra
InlineModelAdmin. get_max_num （ request ， obj = None ， ** kwargs ）

返回要使用的额外内联表单的最大数量。默认状况下，返回InlineModelAdmin.max_num属性。

重写此方法以编程方式肯定内联表单的最大数量。例如，这可能基于模型实例（做为关键字参数传递obj）：

class BinaryTreeAdmin(admin.TabularInline):
    model = BinaryTree

    def get_max_num(self, request, obj=None, **kwargs):
        max_num = 10
        if obj and obj.parent:
            return max_num - 5
        return max_num
InlineModelAdmin. get_min_num （ request ， obj = None ， ** kwargs ）

返回要使用的内联表单的最小数量。默认状况下，返回InlineModelAdmin.min_num属性。

重写此方法以编程方式肯定内联表单的最小数量。例如，这可能基于模型实例（做为关键字参数传递obj）。

使用具备两个或更多外键的模型来处理同一父模型

有时可能有多个外键用于同一模型。以这个模型为例：

from django.db import models

class Friendship(models.Model):
    to_person = models.ForeignKey(Person, on_delete=models.CASCADE, related_name="friends")
    from_person = models.ForeignKey(Person, on_delete=models.CASCADE, related_name="from_friends")

若是您想要在Person管理添加/更改页面上显示内联，则须要显式定义外键，由于它没法自动执行：

from django.contrib import admin
from myapp.models import Friendship

class FriendshipInline(admin.TabularInline):
    model = Friendship
    fk_name = "to_person"

class PersonAdmin(admin.ModelAdmin):
    inlines = [
        FriendshipInline,
    ]

使用多对多模型

默认状况下，多对多关系的管理小部件将显示在任何包含实际引用的模型上 ManyToManyField。根据您的ModelAdmin 定义，模型中的每一个多对多字段将由标准HTML ，水平或垂直过滤器或 小部件表示。可是，也能够用内联替换这些小部件。<select multiple>raw_id_admin

假设咱们有如下模型：

from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=128)

class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(Person, related_name='groups')

若是要使用内联显示多对多关系，能够经过定义InlineModelAdmin关系的对象来实现：

from django.contrib import admin

class MembershipInline(admin.TabularInline):
    model = Group.members.through

class PersonAdmin(admin.ModelAdmin):
    inlines = [
        MembershipInline,
    ]

class GroupAdmin(admin.ModelAdmin):
    inlines = [
        MembershipInline,
    ]
    exclude = ('members',)

在这个例子中有两个值得注意的特征。

首先 - MembershipInline类参考Group.members.through。该through属性是对管理多对多关系的模型的引用。当您定义多对多字段时，此模型由Django自动建立。

其次，GroupAdmin必须手动排除该members字段。Django在定义关系的模型上显示一个多对多字段的管理小部件（在这种状况下Group）。若是您想使用内联模型来表示多对多关系，那么您必须告诉Django的管理员不要显示此小部件 - 不然您将在管理页面上以管理关系的方式结束两个小部件。

请注意，使用这种技术时， m2m_changed信号不会被触发。这是由于就管理员而言，through只是一个有两个外键字段而不是多对多关系的模型。

在全部其余方面，这与其余方面InlineModelAdmin彻底相同。您可使用任何常规ModelAdmin属性自定义外观 。

使用多对多中介模型

当您使用through参数 指定中介模型时ManyToManyField，管理员默认不会显示小部件。这是由于该中介模型的每一个实例都须要比能够在单个窗口小部件中显示的信息更多的信息，而且多个窗口小部件所需的布局会因中间模型而异。

可是，咱们仍然但愿可以内联编辑该信息。幸运的是，这对于内联管理员模型很容易。假设咱们有如下模型：

from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=128)

class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(Person, through='Membership')

class Membership(models.Model):
    person = models.ForeignKey(Person, on_delete=models.CASCADE)
    group = models.ForeignKey(Group, on_delete=models.CASCADE)
    date_joined = models.DateField()
    invite_reason = models.CharField(max_length=64)

在管理中显示这个中间模型的第一步是为模型定义一个内联类Membership：

class MembershipInline(admin.TabularInline):
    model = Membership
    extra = 1

这个简单的示例使用模型的默认InlineModelAdmin值 Membership，并将额外的添加表单限制为一个。这可使用InlineModelAdmin课程提供的任何选项进行定制。

如今为这些Person和Group模型建立管理员视图：

class PersonAdmin(admin.ModelAdmin):
    inlines = (MembershipInline,)

class GroupAdmin(admin.ModelAdmin):
    inlines = (MembershipInline,)

最后，注册Person和Group使用管理网站的型号：

admin.site.register(Person, PersonAdmin)
admin.site.register(Group, GroupAdmin)

如今，您的管理网站已设置为能够Membership从内容Person或Group详细信息页面内联编辑对象。

使用泛型关系做为内联

可使用与通常相关对象的内联。假设您有如下型号：

from django.db import models
from django.contrib.contenttypes.fields import GenericForeignKey

class Image(models.Model):
    image = models.ImageField(upload_to="images")
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    content_object = GenericForeignKey("content_type", "object_id")

class Product(models.Model):
    name = models.CharField(max_length=100)

若是你想容许编辑和建立一个Image实例 Product，你可使用添加/更改视图， GenericTabularInline 或者提供的GenericStackedInline（（的两个子类GenericInlineModelAdmin））admin。它们分别为表明内联对象的表单实现表格式和堆叠式可视化布局，就像它们的非通用对象同样。他们的行为与其余任何内联行为同样。在你admin.py的这个示例应用程序中：

from django.contrib import admin
from django.contrib.contenttypes.admin import GenericTabularInline

from myproject.myapp.models import Image, Product

class ImageInline(GenericTabularInline):
    model = Image

class ProductAdmin(admin.ModelAdmin):
    inlines = [
        ImageInline,
    ]

admin.site.register(Product, ProductAdmin)

有关更多特定信息，请参阅contenttypes文档。

覆盖管理模板

覆盖管理模块用于生成管理站点各类页面的许多模板相对比较容易。您甚至能够为特定的应用程序或特定的模型覆盖这些模板中的一部分。

设置你的项目管理模板目录

管理员模板文件位于contrib/admin/templates/admin 目录中。

为了覆盖它们中的一个或多个，首先admin在项目目录中建立一个templates目录。这能够是您在设置DIRS中的DjangoTemplates后端选项中 指定的任何目录TEMPLATES。若是您已经自定义了该'loaders'选项，请务必 'django.template.loaders.filesystem.Loader'在以前出现， 'django.template.loaders.app_directories.Loader'以便您的自定义模板将由模板加载系统找到以前的模板加载系统找到django.contrib.admin。

在此admin目录中，建立以应用程序命名的子目录。在这些应用程序子目录中建立以您的模型命名的子目录。请注意，当查找目录时，管理应用程序将小写模型名称，所以，若是要在区分大小写的文件系统上运行应用程序，请确保以所有小写命名该目录。

要覆盖特定应用程序的管理员模板，请从该django/contrib/admin/templates/admin目录复制并编辑模板，并将其保存到您刚建立的其中一个目录中。

例如，若是咱们想要将一个工具添加到名为app的全部模型的变动列表视图中my_app，咱们将复制 contrib/admin/templates/admin/change_list.html到templates/admin/my_app/咱们项目的 目录中，并进行必要的更改。

若是咱们只想为名为'Page'的特定模型添加一个工具到变动列表视图，咱们会将同一个文件复制到templates/admin/my_app/page咱们项目的 目录中。

重写与替换管理模板

因为管理模板的模块化设计，替换整个模板一般既没必要要也不可取。只覆盖模板中须要更改的部分几乎老是更好。

要继续上面的示例，咱们但愿在History该Page模型的工具旁边添加一个新连接 。看完后change_form.html 咱们肯定咱们只须要重写该object-tools-items块。因此这里是咱们的新东西change_form.html：

{% extends "admin/change_form.html" %}
{% load i18n admin_urls %}
{% block object-tools-items %}
    <li>
        <a href="{% url opts|admin_urlname:'history' original.pk|admin_urlquote %}" class="historylink">{% trans "History" %}</a>
    </li>
    <li>
        <a href="mylink/" class="historylink">My Link</a>
    </li>
    {% if has_absolute_url %}
        <li>
            <a href="{% url 'admin:view_on_site' content_type_id original.pk %}" class="viewsitelink">{% trans "View on site" %}</a>
        </li>
    {% endif %}
{% endblock %}

就是这样！若是咱们将这个文件放在templates/admin/my_app 目录中，咱们的连接将出如今my_app中全部模型的更改表单上。

每一个应用或模型可能会覆盖的模板

并不是每一个模板都contrib/admin/templates/admin可能被每一个应用或每一个模型覆盖。如下内容能够：

  • app_index.html
  • change_form.html
  • change_list.html
  • delete_confirmation.html
  • object_history.html
  • popup_response.html
在Django 1.11中更改：

popup_response.html添加了覆盖模板的功能。

对于那些没法以这种方式覆盖的模板，您可能仍然会覆盖整个项目的模板。只需将新版本放入您的 templates/admin目录便可。这对建立自定义404和500页特别有用。

注意

某些管理模板（如change_list_results.html用于呈现自定义包含标记）。这些可能会被覆盖，但在这种状况下，您最好建立本身的标记版本并给它一个不一样的名称。这样你能够有选择地使用它。

根和登陆模板

若是你想改变索引，登陆或注销的模板，你最好建立本身的AdminSite实例（见下文），并更改 AdminSite.index_template，AdminSite.login_template或 AdminSite.logout_template属性。

AdminSite对象

class AdminSite （ name ='admin' ） [source]

Django管理站点由一个实例表明 django.contrib.admin.sites.AdminSite; 默认状况下，该类的一个实例被建立为django.contrib.admin.site，您能够ModelAdmin使用它注册模型和实例。

在构建一个实例时AdminSite，可使用name构造函数的参数提供惟一的实例名称。此实例名称用于标识实例，特别是在 反转管理URL时。若是未提供实例名称，admin则将使用默认实例名称。有关自定义类的示例， 请参阅自定义AdminSiteAdminSite类。

AdminSite属性

模板能够覆盖或扩展基本管理模板，如 覆盖管理模板中所述。

AdminSite. site_header

做为<h1>（字符串）放在每一个管理页面顶部的文本。默认状况下，这是“Django管理”。

AdminSite. site_title

将文本放在每一个管理页面的末尾<title>（一个字符串）。默认状况下，这是“Django网站管理员”。

AdminSite. site_url

每一个管理页面顶部的“查看网站”连接的网址。默认状况下 site_url是/。将其设置None为删除连接。

对于在子路径上运行的站点，该each_context()方法检查当前请求是否已request.META['SCRIPT_NAME']设置，若是site_url没有设置为非/。

在Django 1.10中更改：

SCRIPT_NAME增长了前一段中描述的支持。

AdminSite. index_title

放在管理索引页面顶部的文本（字符串）。默认状况下，这是“网站管理”。

AdminSite. index_template

管理网站主索引视图将使用的自定义模板的路径。

AdminSite. app_index_template

管理网站应用程序索引视图将使用的自定义模板的路径。

AdminSite. empty_value_display

用于在管理网站的更改列表中显示空值的字符串。默认为短划线。经过在字段上设置属性，也能够ModelAdmin逐个覆盖该值并在一个自定义字段中覆盖该值 。举例来看 。ModelAdminempty_value_displayModelAdmin.empty_value_display

AdminSite. login_template

管理网站登陆视图将使用自定义模板的路径。

AdminSite. login_form

AuthenticationForm那个子类将被管理网站登陆视图使用。

AdminSite. logout_template

管理网站注销视图将使用的自定义模板的路径。

AdminSite. password_change_template

管理站点密码更改视图将使用的自定义模板的路径。

AdminSite. password_change_done_template

将由管理员站点密码更改完成视图使用的自定义模板的路径。

AdminSite方法

AdminSite. each_context （ 请求 ） [源]

返回管理站点中每一个页面的模板上下文中的变量字典。

默认包含如下变量和值：

  • site_header： AdminSite.site_header

  • site_title： AdminSite.site_title

  • site_url： AdminSite.site_url

  • has_permission： AdminSite.has_permission()

  • available_apps：当前用户可用的应用程序注册表中的应用程序列表。列表中的每一个条目都是一个表明具备如下键的应用程序的字典：

    • app_label：应用程序标签
    • app_url：管理员中应用程序索引的URL
    • has_module_perms：一个布尔值，指示是否容许当前用户显示和访问模块的索引页
    • models：应用程序中可用模型的列表

    每一个模型都是一个带有如下键的字典：

    • object_name：模型的类名称
    • name：模型的复数名称
    • perms：一个dict跟踪add，change和delete权限
    • admin_url：模型的admin更改列表URL
    • add_url：admin URL来添加一个新的模型实例
AdminSite. has_permission （ 请求 ） [源]

返回True给定用户HttpRequest是否有权查看管理站点中的至少一个页面。默认为既须要 User.is_active和 User.is_staff要 True。

AdminSite. register （ model_or_iterable ， admin_class = None ， **选项 ） [source]

给定的模型类（或类的迭代） admin_class。admin_class默认为 ModelAdmin（默认管理选项）。若是给出关键字参数 - 例如list_display- 它们将做为选项应用于管理类。

ImproperlyConfigured若是模型是抽象的，则引起。而且django.contrib.admin.sites.AlreadyRegistered若是模型已经注册。

将AdminSite实例挂接到你的URLconf中

设置Django管理员的最后一步是将您的AdminSite 实例挂接到您的URLconf中。经过在AdminSite.urls方法中指定给定的URL来完成此操做 。没有必要使用 include()。

在这个例子中，咱们在URL处注册了默认AdminSite实例 django.contrib.admin.site/admin/

# urls.py
from django.conf.urls import url
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),
]

定制AdminSite类

若是您想使用自定义行为设置本身的管理网站，则能够自由分类AdminSite并覆盖或添加任何您喜欢的内容。而后，简单地建立一个你的AdminSite子类的实例（就像你实例化任何其余Python类同样），并ModelAdmin使用它注册你的模型和 子类，而不是默认的站点。最后，更新myproject/urls.py以引用您的AdminSite子类。

MYAPP / admin.py 
从 django.contrib.admin  导入 AdminSite

从 .models  导入 MyModel

class  MyAdminSite （AdminSite ）：
    site_header  =  'Monty Python administration'

admin_site  =  MyAdminSite （name = 'myadmin' ）
admin_site 。注册（MyModel ）
MyProject的/ urls.py 
从 django.conf.urls  导入 网址

从 myapp.admin  导入 admin_site

urlpatterns的 =  [ 
    URL （[R '^ myadmin /' ， admin_site 。网址），
]

请注意，您可能不但愿admin在使用本身的AdminSite实例时自动发现模块，由于您可能会导入admin模块中的全部每一个应用程序 myproject.admin模块。这意味着你须要投入'django.contrib.admin.apps.SimpleAdminConfig'，而不是 'django.contrib.admin'在你的INSTALLED_APPS设置。

多个管理站点在同一个URLconf中

在同一个Django驱动的网站上建立管理站点的多个实例很容易。只需AdminSite在不一样的URL上建立多个实例和root。

在这个例子中，URL /basic-admin/和/advanced-admin/管理站点的不​​同版本具备不一样的功能 - 分别使用AdminSite实例 myproject.admin.basic_site和myproject.admin.advanced_site：

# urls.py
from django.conf.urls import url
from myproject.admin import basic_site, advanced_site

urlpatterns = [
    url(r'^basic-admin/', basic_site.urls),
    url(r'^advanced-admin/', advanced_site.urls),
]

AdminSite实例对它们的构造函数采用一个参数，它们的名称能够是任何你喜欢的。此参数成为URL名称的前缀，用于反转它们。这只在您使用多个应用程序时才有必要AdminSite。

添加视图到管理网站

就像ModelAdmin，AdminSite提供了一个get_urls()能够被覆盖的 方法来定义网站的附加视图。要向管理网站添加新视图，请扩展基本 get_urls()方法以包含新视图的模式。

注意

request.current_app在渲染模板以前，您渲染的任何使用管理模板的视图或者扩展基本管理模板都应该设置。它应该被设置为，self.name若是你的观点是在 AdminSite或者self.admin_site.name你的观点是在一个 ModelAdmin。

添加密码重置功能

您能够经过在URLconf中添加几行来为管理站点添加密码重置功能。具体来讲，添加这四种模式：

from django.contrib.auth import views as auth_views

url(
    r'^admin/password_reset/$',
    auth_views.PasswordResetView.as_view(),
    name='admin_password_reset',
),
url(
    r'^admin/password_reset/done/$',
    auth_views.PasswordResetDoneView.as_view(),
    name='password_reset_done',
),
url(
    r'^reset/(?P<uidb64>[0-9A-Za-z_\-]+)/(?P<token>.+)/$',
    auth_views.PasswordResetConfirmView.as_view(),
    name='password_reset_confirm',
),
url(
    r'^reset/done/$',
    auth_views.PasswordResetCompleteView.as_view(),
    name='password_reset_complete',
),

（这假设你已经添加了管理员admin/而且要求你^admin/在包含管理应用程序自己的行以前开始添加URL ）。

admin_password_reset指定URL 的存在会致使“忘记密码？”连接出如今密码框的默认管理员登陆页面上。

LogEntry对象

类 models. LogEntry

该LogEntry班跟踪添加，修改，并经过管理界面作对象的缺失。

LogEntry属性

LogEntry. action_time

行动的日期和时间。

LogEntry. user

AUTH_USER_MODEL执行操做的用户（实例）。

LogEntry. content_type

所述ContentType经修改的对象的。

LogEntry. object_id

修改对象的主键的文本表示。

LogEntry. object_repr

该object`s repr()修改后。

LogEntry. action_flag

操做类型的记录：ADDITION，CHANGE，DELETION。

例如，要获取经过管理员完成的全部添加的列表：

from django.contrib.admin.models import LogEntry, ADDITION

LogEntry.objects.filter(action_flag=ADDITION)
LogEntry. change_message

修改的详细说明。例如，在编辑的状况下，该消息包含编辑字段的列表。Django管理站点将此内容格式化为JSON结构，以便get_change_message()能够从新构造 用当前用户语言翻译的消息。自定义代码可能会将其设置为纯字符串。建议您使用该get_change_message()方法来检索该值，而不是直接访问它。

在Django 1.10中更改：

之前，这个属性老是一个纯字符串。它如今是JSON结构，所以能够用当前用户语言翻译消息。旧信息未触及。

LogEntry方法

LogEntry. get_edited_object （）

返回引用对象的快捷方式。

LogEntry. get_change_message （）
Django 1.10新增功能

格式化并翻译change_message成当前的用户语言。在Django 1.10以前建立的消息将始终以它们所记录的语言显示。

反转管理网址

当AdminSite被部署，由该网站提供的意见是使用Django的访问URL倒车系统。

该AdminSite提供了如下命名的URL模式：

页 网址名称 参数
指数 index  
登陆 login  
登出 logout  
密码更改 password_change  
密码更改完成 password_change_done  
i18n JavaScript jsi18n  
应用程序索引页 app_list app_label
重定向到对象的页面 view_on_site content_type_id， object_id

每一个ModelAdmin实例都提供了一组额外的指定URL：

页 网址名称 参数
更改列表 {{ app_label }}_{{ model_name }}_changelist  
加 {{ app_label }}_{{ model_name }}_add  
历史 {{ app_label }}_{{ model_name }}_history object_id
删除 {{ app_label }}_{{ model_name }}_delete object_id
更改 {{ app_label }}_{{ model_name }}_change object_id

在UserAdmin提供了一个名为网址：

页 网址名称 参数
密码更改 auth_user_password_change user_id

这些命名的URL在应用程序名称空间中注册admin，而且与实例名称空间相对应，该名称空间与Site实例的名称相对应。

所以 - 若是您想要Choice在默认管理员中获取特定对象（来自投票应用程序）的Change视图的引用 ，您能够调用：

>>> from django.urls import reverse
>>> c = Choice.objects.get(...)
>>> change_url = reverse('admin:polls_choice_change', args=(c.id,))

这将找到管理应用程序的第一个注册实例（不管实例名称如何），并poll.Choice在该实例中解析为视图以更改 实例。

若是您想在特定的管理员实例中查找URL，请提供该实例的名称做为current_app反向调用的提示。例如，若是您特别想要来自admin实例的管理视图，则 custom须要调用：

>>> change_url = reverse('admin:polls_choice_change', args=(c.id,), current_app='custom')

有关更多详细信息，请参阅反转名称空间URL的文档。

为了让模板中的管理url更容易反转，Django提供了一个admin_urlname以action做为参数的 过滤器：

{% load admin_urls %}
<a href="{% url opts|admin_urlname:'add' %}">Add user</a>
<a href="{% url opts|admin_urlname:'delete' user.pk %}">Delete this user</a>

以上示例中的操做与上述实例的URL名称的最后一部分相匹配 ModelAdmin。该opts变量能够是其具备的任何对象app_label和model_name属性，一般是由当前模型管理员视图提供。

该staff_member_required装饰

staff_member_required （ redirect_field_name ='next' ， login_url ='admin：login' ） [source]

此装饰器用于须要受权的管理视图。用这个函数装饰的视图将具备如下行为：

  • 若是用户登陆，是职员（User.is_staff=True），而且处于活动状态（User.is_active=True），则正常执行该视图。
  • 不然，请求将被重定向到由login_url参数指定的URL ，其中最初请求的路径将由查询字符串变量指定redirect_field_name。例如： /admin/login/?next=/admin/polls/question/3/。

用法示例：

from django.contrib.admin.views.decorators import staff_member_required

@staff_member_required
def my_view(request):
    ...原文连接：https://docs.djangoproject.com/en/1.11/ref/contrib/admin/
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程