Настройка Django Admin

18 августа, 2020

Подписывайся на наш канал в Telegram, чтобы ежедневно совершенствоваться в Python. Там выходят задачи, полезные советы и сливы платных курсов - перейти

Оглавление

  • Предпосылки
  • Настройка администратора Django
  • Кастомизация администратора Django
  • Изменение списка изменений с помощью list_display
  • Предоставление ссылок на страницы других объектов
  • Добавление фильтров на экран списка
  • Добавление поиска на экран списка
  • Изменение способа редактирования моделей
  • Переопределение шаблонов администратора Django
  • Вывод

Фреймворк Django поставляется с мощным административным инструментом под названием admin. Вы можете использовать его прямо из коробки, чтобы быстро добавлять, удалять или редактировать любую модель базы данных из веб-интерфейса. Но с помощью небольшого дополнительного кода вы можете настроить администратора Django, чтобы вывести свои административные возможности на новый уровень.

В этом руководстве вы узнаете, как:

  • Добавить столбцы атрибутов в список объектов модели
  • Связь между объектами модели
  • Добавить фильтры в список объектов модели
  • Сделать списки объектов модели доступными для поиска
  • Изменить формы редактирования объекта
  • Переопределить шаблоны администратора Django

Предпосылки

Чтобы получить максимальную отдачу от этого руководства, вам понадобится некоторое знакомство с Django, особенно с объектами модели. Поскольку Django не входит в стандартную библиотеку Python, лучше всего, если вы также знакомы с pip и pyenv (или аналогичным инструментом виртуальной среды).

Фрагменты кода в этом руководстве были протестированы на Django 3.0.7. Все концепции предшествуют Django 2.0, поэтому они должны работать в любой версии, которую вы используете, но могут существовать незначительные различия.

Настройка Django Admin

Django Admin предоставляет веб-интерфейс для создания объектов модели базы данных и управления ими. Чтобы увидеть это в действии, вам сначала понадобится проект Django и несколько объектных моделей. Установите Django в чистой виртуальной среде:

$ python -m pip install django
$ django-admin startproject School
$ cd School
$ ./manage.py startapp core
$ ./manage.py migrate
$ ./manage.py createsuperuser
Username: admin
Email address: admin@example.com
Password:
Password (again):

Сначала вы создаете новый проект Django под названием School с приложением под названием core. Затем вы переносите таблицы аутентификации и создаете администратора. Доступ к экранам администратора Django разрешен только пользователям с флагами персонала или суперпользователя, поэтому вы используете команду управления createduperuser, чтобы создать суперпользователя.

Вам также необходимо изменить School/settings.py, чтобы включить новое приложение с именем core:

# School/settings.py
# ...

INSTALLED_APPS = [
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
    "core",    # Add this line
]

Каталог основного приложения будет начинаться со следующих файлов внутри:

core/
│
├── migrations/
│   └── __init__.py
│
├── __init__.py
├── admin.py
├── apps.py
├── models.py
├── tests.py
└── views.py

Вас интересуют два из этих файлов:

  1. models.py определяет ваши модели базы данных.
  2. admin.py регистрирует ваши модели у администратора Django.

Чтобы продемонстрировать результат при настройке администратора Django, вам понадобятся несколько моделей. Отредактируйте core/models.py:

from django.core.validators import MinValueValidator, MaxValueValidator
from django.db import models

class Person(models.Model):
    last_name = models.TextField()
    first_name = models.TextField()
    courses = models.ManyToManyField("Course", blank=True)

    class Meta:
        verbose_name_plural = "People"

class Course(models.Model):
    name = models.TextField()
    year = models.IntegerField()

    class Meta:
        unique_together = ("name", "year", )

class Grade(models.Model):
    person = models.ForeignKey(Person, on_delete=models.CASCADE)
    grade = models.PositiveSmallIntegerField(
        validators=[MinValueValidator(0), MaxValueValidator(100)])
    course = models.ForeignKey(Course, on_delete=models.CASCADE)

Эти модели представляют учащихся, посещающих курсы в школе. У курса есть name и year, в котором он был предложен. Person имеет имя и фамилию и может пройти ноль или более курсов. Оценка содержит процентную оценку, полученную человеком на курсе.

Вот модельная диаграмма, показывающая отношения между объектами:

Пример отношений объектной модели

Имена основных таблиц в базе данных немного отличаются от этих, но они связаны с моделями, показанными выше.

Каждую модель, которую вы хотите, чтобы Django представлял в интерфейсе администратора, необходимо зарегистрировать. Вы делаете это в файле admin.py. Модели из core/models.py регистрируются в соответствующем файле core/admin.py:

from core.models import Person, Course, Grade

@admin.register(Person)
class PersonAdmin(admin.ModelAdmin):
    pass

@admin.register(Course)
class CourseAdmin(admin.ModelAdmin):
    pass

@admin.register(Grade)
class GradeAdmin(admin.ModelAdmin):
    pass

Вы почти готовы к работе. После переноса моделей баз данных вы можете запустить сервер разработки Django и увидеть результаты:

$ ./manage.py makemigrations
$ ./manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, core, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  ...
  Applying core.0001_initial... OK
  Applying core.0002_auto_20200609_2120... OK
  Applying sessions.0001_initial... OK
$ ./manage.py runserver
Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
Django version 3.0.7, using settings 'School.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Теперь посетите http://127.0.0.1:8000/admin, чтобы увидеть интерфейс администратора. Вам будет предложено войти в систему. Используйте учетные данные, созданные с помощью команды управления createduperuser.

На главном экране администратора перечислены все зарегистрированные модели баз данных:

Список "индекса приложений" Django Admin

Теперь вы можете использовать интерфейс для создания объектов в своей базе данных. Щелкнув название модели, вы увидите экран со списком всех объектов в базе данных для этой модели. Вот список Person:

Пустой экран изменения списка лиц

Список начинается пустым, как и ваша база данных. Нажав ADD PERSON, вы можете создать человека в базе данных. После сохранения вы вернетесь к списку объектов Person:

Листинг человека с новым лицом

Хорошая новость в том, что у вас есть объект. Плохая новость в том, что объект Person (1) сообщает вам идентификатор объекта и ничего больше. По умолчанию администратор Django отображает каждый объект, вызывая для него str(). Вы можете сделать этот экран более полезным, добавив метод .__str __() к классу Person в core / models.py:

class Person(models.Model):
    last_name = models.TextField()
    first_name = models.TextField()
    courses = models.ManyToManyField("Course", blank=True)

    def __str__(self):
        return f"{self.last_name}, {self.first_name}"

Добавление Person .__ str __ () изменяет отображение, чтобы включить в интерфейс имя и фамилию Person. Вы можете обновить экран, чтобы увидеть изменения:

Улучшить отображение с помощью __str __ ()

Так немного лучше! Теперь вы можете увидеть некоторую информацию об объекте Person. Рекомендуется добавить похожие методы как к объектам Course, так и к объектам Grade:

class Course(models.Model):
    # ...

    def __str__(self):
        return f"{self.name}, {self.year}"

class Grade(models.Model):
    # ...

    def __str__(self):
        return f"{self.grade}, {self.person}, {self.course}"

Вам нужно иметь некоторые данные в своей базе данных, чтобы увидеть полный эффект от ваших настроек. Вы можете немного развлечься и создать свои собственные данные прямо сейчас, или вы можете пропустить работу и использовать приспособление. Ниже показано как загружать данные с помощью фикстуры.


Django позволяет загружать данные в базу данных и из нее в файлах, называемых фикстурами. Скопируйте следующее в файл с именем core/fixtures/school.json:

[
    {
        "model": "core.person",
        "pk": 1,
        "fields": {
            "last_name": "Harris",
            "first_name": "Xander",
            "courses": [
                1,
                3
            ]
        }
    },
    {
        "model": "core.person",
        "pk": 3,
        "fields": {
            "last_name": "Rosenberg",
            "first_name": "Willow",
            "courses": [
                1,
                2,
                3
            ]
        }
    },
    {
        "model": "core.person",
        "pk": 16,
        "fields": {
            "last_name": "Summers",
            "first_name": "Buffy",
            "courses": [
                1,
                2,
                3
            ]
        }
    },
    {
        "model": "core.course",
        "pk": 1,
        "fields": {
            "name": "CompSci G11",
            "year": 1998
        }
    },
    {
        "model": "core.course",
        "pk": 2,
        "fields": {
            "name": "Psych 101",
            "year": 1999
        }
    },
    {
        "model": "core.course",
        "pk": 3,
        "fields": {
            "name": "Library Science G10",
            "year": 1997
        }
    },
    {
        "model": "core.grade",
        "pk": 1,
        "fields": {
            "person": 16,
            "grade": 68,
            "course": 1
        }
    },
    {
        "model": "core.grade",
        "pk": 2,
        "fields": {
            "person": 16,
            "grade": 87,
            "course": 2
        }
    },
    {
        "model": "core.grade",
        "pk": 3,
        "fields": {
            "person": 16,
            "grade": 76,
            "course": 3
        }
    },
    {
        "model": "core.grade",
        "pk": 4,
        "fields": {
            "person": 1,
            "grade": 58,
            "course": 1
        }
    },
    {
        "model": "core.grade",
        "pk": 5,
        "fields": {
            "person": 1,
            "grade": 58,
            "course": 3
        }
    },
    {
        "model": "core.grade",
        "pk": 6,
        "fields": {
            "person": 3,
            "grade": 98,
            "course": 3
        }
    },
    {
        "model": "core.grade",
        "pk": 7,
        "fields": {
            "person": 3,
            "grade": 97,
            "course": 2
        }
    }
]

Создав файл, вы можете использовать команду управления Django loaddata, чтобы загрузить его в свою базу данных:

$ ./manage.py loaddata school
Installed 13 object(s) from 1 fixture(s)

Теперь в вашей базе данных есть образцы объектов Person, Course и Grade.


Теперь, когда у вас есть некоторые данные для работы, вы готовы приступить к настройке интерфейса администратора Django.

Кастоимизация Django Admin

Умные люди, создавшие структуру Django, не только создали админку, но и сделали это таким образом, чтобы вы могли настроить его для своих проектов. Когда вы ранее регистрировали объект PersonAdmin, он унаследовал от admin.ModelAdmin. Большая часть настроек, которые вы можете сделать с помощью администратора Django, выполняется путем изменения ModelAdmin, и вы, конечно, можете изменить его!

ModelAdmin имеет более тридцати атрибутов и почти пятьдесят методов. Вы можете использовать каждый из них для тонкой настройки представления администратора и управления интерфейсами ваших объектов. Каждый из этих вариантов подробно описан в документации.

В довершение ко всему, администратор построен с использованием интерфейса шаблонов Django. Механизм шаблонов Django позволяет вам переопределять существующие шаблоны, а поскольку администратор – это просто еще один набор шаблонов, это означает, что вы можете полностью изменить его HTML.

Хотя это выходит за рамки данного руководства, вы даже можете создать несколько сайтов администрирования. Это может показаться излишним, но это позволяет вам фантазировать и определять разные сайты для пользователей с разными разрешениями.

Django Admin разделен на три основные области:

  1. Индекс приложения
  2. Списки изменений
  3. Изменить формы

В указателе приложений перечислены ваши зарегистрированные модели. Для каждой зарегистрированной модели автоматически создается список изменений, в котором перечислены объекты для этой модели. Когда вы добавляете или редактируете один из этих объектов, вы делаете это с помощью формы изменения.

В предыдущем примере индекс приложения отображал объекты Person, Course и Grade. При нажатии кнопки «People» отображаются списки изменений для объектов «Person». На странице со списком изменений Person, щелкнув объект Buffy Summers, вы попадете в форму изменения, чтобы отредактировать данные Buffy.

Изменение списка изменений с помощью list_display.

Реализация .__str__() – это быстрый способ изменить представление объекта Person с бессмысленной строки на понятные данные. Поскольку это представление также будет отображаться в раскрывающихся списках и при множественном выборе, вы определенно захотите сделать его максимально простым для понимания.

Вы можете настроить страницы списка изменений гораздо большим количеством способов, чем просто изменить строковое представление объекта. Атрибут list_display объекта admin.ModelAdmin указывает, какие столбцы отображаются в списке изменений. Это значение представляет собой набор атрибутов моделируемого объекта. Например, в core/admin.py измените PersonAdmin следующим образом:

@admin.register(Person)
class PersonAdmin(admin.ModelAdmin):
    list_display = ("last_name", "first_name")

Приведенный выше код изменяет ваш список изменений Person, чтобы отображать атрибуты last_name и first_name для каждого объекта Person. Каждый атрибут отображается в столбце на странице:

Добавьте столбцы имени и фамилии, чтобы изменить объявление

Два столбца являются интерактивными, что позволяет сортировать страницу по данным столбца. Администратор также учитывает атрибут ordering, Meta раздела:

@admin.register(Person)
class PersonAdmin(admin.ModelAdmin):
    list_display = ("last_name", "first_name", "show_average")

    def show_average(self, obj):
        from django.db.models import Avg
        result = Grade.objects.filter(person=obj).aggregate(Avg("grade"))
        return result["grade__avg"]

В приведенном выше коде вы добавляете столбец для администратора, в котором отображается средняя оценка каждого учащегося. show_average() вызывается один раз для каждого объекта, отображаемого в списке.

Параметр obj – это объект для отображаемой строки. В этом случае вы используете его для запроса соответствующих объектов Grade для учащегося, с усреднением ответа по Grade.grade. Вы можете увидеть результаты здесь:

Добавить вычисленную среднюю оценку в список пользователей

Имейте в виду, что среднюю оценку действительно нужно рассчитывать в объекте модели Person. Скорее всего, вам понадобятся данные где-нибудь еще, а не только в админке Django. Если бы у вас был такой метод, вы могли бы добавить его в атрибут list_display. Пример здесь показывает, что вы можете делать в объекте ModelAdmin, но, вероятно, это не лучший выбор для вашего кода.

По умолчанию сортируются только те столбцы, которые являются атрибутами объекта. show_average() нет. Это связано с тем, что сортировка выполняется базовым QuerySet, а не отображаемыми результатами. В некоторых случаях есть способы сортировки этих столбцов, но это выходит за рамки этого руководства.

Заголовок столбца основан на имени метода. Вы можете изменить заголовок, добавив атрибут к методу:

def show_average(self, obj):
    result = Grade.objects.filter(person=obj).aggregate(Avg("grade"))
    return result["grade__avg"]

show_average.short_description = "Average Grade"

По умолчанию Django защищает вас от HTML в строках, если строка введена пользователем. Чтобы отображение включало HTML, вы должны использовать format_html():

def show_average(self, obj):
    from django.utils.html import format_html

    result = Grade.objects.filter(person=obj).aggregate(Avg("grade"))
    return format_html("<b><i>{}</i></b>", result["grade__avg"])

show_average.short_description = "Average"

show_average() теперь имеет настраиваемый заголовок «Average» и отформатирован курсивом:

Объявление об изменении человека с полужирным курсивом в столбце

К сожалению, Django еще не добавил поддержку f-строки для format_html(), поэтому вы застряли на синтаксисе str.format().

Предоставление ссылок на страницы других объектов

Довольно часто объекты ссылаются на другие объекты с помощью внешних ключей. Вы можете указать list_display на метод, который возвращает ссылку HTML. Внутри core/admin.py измените класс CourseAdmin следующим образом:

from django.urls import reverse
from django.utils.http import urlencode

@admin.register(Course)
class CourseAdmin(admin.ModelAdmin):
    list_display = ("name", "year", "view_students_link")

    def view_students_link(self, obj):
        count = obj.person_set.count()
        url = (
            reverse("admin:core_person_changelist")
            + "?"
            + urlencode({"courses__id": f"{obj.id}"})
        )
        return format_html('<a href="{}">{} Students</a>', url, count)

    view_students_link.short_description = "Students"

Этот код заставляет список изменений Course иметь три столбца:

  1. Название курса
  2. Год, в котором был предложен курс
  3. Ссылка, отображающая количество студентов в курсе

Вы можете увидеть результат на следующем снимке экрана:

Ссылка на другие списки моделей

Когда вы нажимаете 2 ученика, вы попадаете на страницу со списком изменений человека с примененным фильтром. На отфильтрованной странице показаны только ученики из Psych 101, Buffy и Willow. Ксандер не поступил в университет.

В примере кода для поиска URL-адреса в админке Django используется функция reverse(). Вы можете найти любую страницу администратора, используя следующее соглашение об именах:

"admin:%(app)s_%(model)s_%(page)"

Эта структура имени разбивается следующим образом:

  • admin: это пространство имен.
  • app это название приложения.
  • model – объект модели.
  • page это тип страницы администратора Django.

В приведенном выше примере view_students_link() вы используете admin:core_person_changelist, чтобы получить ссылку на страницу списка изменений объекта Person в основном приложении.

Вот доступные имена URL:

СтраницаИмя URLЦель
Список изменений%(app)s\_%(model)s\_changelistСписок страниц объектов модели
Добавить%(app)s\_%(model)s\_addСтраница создания объекта
История%(app)s\_%(model)s\_historyСтраница истории изменений объекта
Принимает object_id в качестве параметра
Удалить%(app)s\_%(model)s\_deleteСтраница удаления объекта
Принимает object_id в качестве параметра
Изменить%(app)s\_%(model)s\_changeСтраница редактирования объекта
Принимает object_id в качестве параметра

Вы можете отфильтровать страницу списка изменений, добавив к URL-адресу строку запроса. Эта строка запроса изменяет QuerySet, используемый для заполнения страницы. В приведенном выше примере строка запроса «?course__id={obj.id}» фильтрует список Person только для тех объектов, которые имеют совпадающее значение в Person.course.

Эти фильтры поддерживают поиск полей QuerySet с использованием двойного подчеркивания (__). Вы можете получить доступ к атрибутам связанных объектов, а также использовать модификаторы фильтра, такие как __exact и __startswith.

Вы можете найти полную информацию о том, чего вы можете достичь с помощью атрибута list_display, в документации Django admin.

Добавление фильтров на экран списка

Помимо фильтрации данных в списке изменений через вызывающий URL-адрес, вы также можете фильтровать с помощью встроенного виджета. Добавьте атрибут list_filter к объекту CourseAdmin в core/admin.py:

@admin.register(Course)
class CourseAdmin(admin.ModelAdmin):
    list_display = ("name", "year", "view_students_link")
    list_filter = ("year", )
# ...

List_filter отобразит новый раздел на странице со списком ссылок. В этом случае ссылки фильтруют страницу по годам. Список фильтров автоматически заполняется значениями года, используемыми объектами курса в базе данных:

Filter Course Objects by Year

Если щелкнуть год справа, в список будут включены только объекты курса с этим значением года. Вы также можете фильтровать по атрибутам связанных объектов, используя синтаксис поиска поля . Например, вы можете отфильтровать объекты GradeAdmin по course__year, показывая объекты Grade только для определенного года курсов.

Если вам нужен больший контроль над фильтрацией, вы даже можете создать объекты фильтра, которые задают атрибуты поиска и соответствующий QuerySet.

Добавление поиска на экран списка

Фильтры экрана – не единственный способ уменьшить объем данных на экране. Django admin также поддерживает поиск с помощью опции search_fields, которая добавляет на экран поле поиска. Вы устанавливаете его с помощью кортежа, содержащего имена полей, которые будут использоваться для построения поискового запроса в базе данных.

Все, что пользователь вводит в поле поиска, используется в предложении ИЛИ полей, фильтрующих QuerySet. По умолчанию каждый параметр поиска окружен знаками%, что означает, что если вы ищете r, то в результатах появится любое слово с r внутри. Вы можете быть более точными, указав модификатор __ в поле поиска.

Отредактируйте PersonAdmin в core/admin.py следующим образом:

@admin.register(Person)
class PersonAdmin(admin.ModelAdmin):
    search_fields = ("last_name__startswith", )

В приведенном выше коде поиск основан на фамилии. Модификатор __startswith ограничивает поиск фамилиями, которые начинаются с параметра поиска. Поиск по R дает следующие результаты:

Add Search to Person Listing

При каждом поиске на странице списка изменений администратор Django вызывает метод get_search_results() вашего объекта admin.ModelAdmin. Он возвращает QuerySet с результатами поиска. Вы можете точно настроить поиск, перегрузив метод и изменив QuerySet. Более подробную информацию можно найти в документации.

Изменение способа редактирования моделей

Вы можете настроить не только страницу со списком изменений. Экраны, используемые для добавления или изменения объекта, основаны на ModelForm. Django автоматически генерирует форму на основе редактируемой модели.

Вы можете контролировать, какие поля включены, а также их порядок, редактируя параметр полей. Измените свой объект PersonAdmin, добавив атрибут fields:

@admin.register(Person)
class PersonAdmin(admin.ModelAdmin):
    fields = ("first_name", "last_name", "courses")
# ...

Страницы добавления и изменения для Person теперь помещают атрибут first_name перед атрибутом last_name, хотя сама модель указывает обратное:

Use The "admin.AdminModels.fields" Attribute to Change the Fields Shown

ModelAdmin.get_form() отвечает за создание ModelForm для вашего объекта. Вы можете переопределить этот метод, чтобы изменить форму. Добавьте в PersonAdmin следующий метод:

def get_form(self, request, obj=None, **kwargs):
    form = super().get_form(request, obj, **kwargs)
    form.base_fields["first_name"].label = "First Name (Humans only!):"
    return form

Теперь, когда отображается страница добавления или изменения, метка поля first_name будет изменена.

Сменить ярлык может быть недостаточно, чтобы вампиры не регистрировались в качестве студентов. Если вам не нравится ModelForm, созданная для вас администратором Django, вы можете использовать атрибут form для регистрации пользовательской формы. Внесите следующие дополнения и изменения в core/admin.py:

class PersonAdminForm(forms.ModelForm):
    class Meta:
        model = Person
        fields = "__all__"

    def clean_first_name(self):
        if self.cleaned_data["first_name"] == "Spike":
            raise forms.ValidationError("No Vampires")

        return self.cleaned_data["first_name"]

@admin.register(Person)
class PersonAdmin(admin.ModelAdmin):
    form = PersonAdminForm
# ...

Приведенный выше код обеспечивает дополнительную проверку на страницах добавления и изменения человека. Объекты ModelForm имеют богатый механизм проверки. В этом случае поле first_name проверяется на соответствие имени “Spike”. ValidationError не позволяет студентам с этим именем зарегистрироваться:

Extra Validation By Modifying the ModelForm

Изменяя или заменяя объект ModelForm, вы можете полностью контролировать внешний вид и проверку страниц, которые вы используете для добавления или изменения страниц объекта.

Переопределение шаблонов администратора Django

Разработчики Django реализовали администрирование с помощью механизма шаблонов Django. Это сделало их работу немного проще, но также принесет пользу вам, позволив вам переопределить шаблоны. Вы можете полностью настроить администратора, изменив шаблоны, используемые для отображения страниц.

Вы можете увидеть все шаблоны, используемые в админке, заглянув внутрь пакета Django в своей виртуальной среде:

.../site-packages/django/contrib/admin/templates/
│
├── admin/
│   │
│   ├── auth/
│   │   └── user/
│   │       ├── add_form.html
│   │       └── change_password.html
│   │
│   ├── edit_inline/
│   │   ├── stacked.html
│   │   └── tabular.html
│   │
│   ├── includes/
│   │   ├── fieldset.html
│   │   └── object_delete_summary.html
│   │
│   ├── widgets/
│   │   ├── clearable_file_input.html
│   │   ├── foreign_key_raw_id.html
│   │   ├── many_to_many_raw_id.html
│   │   ├── radio.html
│   │   ├── related_widget_wrapper.html
│   │   ├── split_datetime.html
│   │   └── url.html
│   │
│   ├── 404.html
│   ├── 500.html
│   ├── actions.html
│   ├── app_index.html
│   ├── base.html
│   ├── base_site.html
│   ├── change_form.html
│   ├── change_form_object_tools.html
│   ├── change_list.html
│   ├── change_list_object_tools.html
│   ├── change_list_results.html
│   ├── date_hierarchy.html
│   ├── delete_confirmation.html
│   ├── delete_selected_confirmation.html
│   ├── filter.html
│   ├── index.html
│   ├── invalid_setup.html
│   ├── login.html
│   ├── object_history.html
│   ├── pagination.html
│   ├── popup_response.html
│   ├── prepopulated_fields_js.html
│   ├── search_form.html
│   └── submit_line.html
│
└── registration/
    ├── logged_out.html
    ├── password_change_done.html
    ├── password_change_form.html
    ├── password_reset_complete.html
    ├── password_reset_confirm.html
    ├── password_reset_done.html
    ├── password_reset_email.html
    └── password_reset_form.html

У шаблонизатора Django есть определенный порядок загрузки шаблонов. Когда он загружает шаблон, он использует первый шаблон, соответствующий названию. Вы можете переопределить шаблоны администратора, используя ту же структуру каталогов и имена файлов.

Шаблоны администратора находятся в двух каталогах:

  1. admin для страниц объекта модели.
  2. registration предназначен для смены пароля, входа и выхода.

Чтобы настроить страницу выхода, вам необходимо переопределить правильный файл. Относительный путь, ведущий к файлу, должен быть таким же, как переопределяемый. Вас интересует файл registration/logged_out.html. Начнем с создания каталога в проекте School:

$ mkdir -p templates/registration

Теперь сообщите Django о вашем новом каталоге шаблонов в файле School/settings.py. Найдите директиву TEMPLATES и добавьте папку в список DIR:

# School/settings.py
# ...

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",

        # Add the templates directory to the DIR option:
        "DIRS": [os.path.join(BASE_DIR, "templates"), ],
        "APP_DIRS": True,
        "OPTIONS": {
            "context_processors": [
                "django.template.context_processors.debug",
                "django.template.context_processors.request",
                "django.contrib.auth.context_processors.auth",
                "django.contrib.messages.context_processors.messages",
            ],
        },
    },
]

Механизм шаблонов ищет каталоги в параметре DIR перед каталогами приложений, поэтому вместо этого будет загружено все, что имеет то же имя, что и шаблон администратора. Чтобы увидеть это в действии, скопируйте файл logged_out.html в каталог templates/registration, затем измените его:

{% extends "admin/base_site.html" %}
{% load i18n %}

{% block breadcrumbs %}<div class="breadcrumbs"><a href="{% url 'admin:index' %}">{% trans 'Home' %}</a></div>{% endblock %}

{% block content %}

<p>You are now leaving Sunnydale</p>

<p><a href="{% url 'admin:index' %}">{% trans 'Log in again' %}</a></p>

{% endblock %}

Вы настроили страницу выхода. Если вы нажмете ВЫЙТИ, вы увидите настраиваемое сообщение:

Customize Django Admin Templates

Шаблоны администратора Django глубоко вложены и не очень интуитивно понятны, но вы можете полностью контролировать их представление, если вам это нужно. Некоторые пакеты, включая Grappelli и Django Admin Bootstrap, полностью заменили шаблоны администратора Django, изменив их внешний вид.

Django Admin Bootstrap еще не совместим с Django 3, а Grappelli только недавно добавил поддержку, так что некоторые проблемы все еще могут возникать. При этом, если вы хотите увидеть силу переопределения шаблонов администратора, ознакомьтесь с этими проектами!

Вывод

Администратор Django – это мощный встроенный инструмент, дающий вам возможность создавать, обновлять и удалять объекты в вашей базе данных с помощью веб-интерфейса. Вы можете настроить администратора Django для выполнения практически всего, что захотите.

В этом руководстве вы узнали, как:

  • Зарегистрировать свои объектные модели с помощью администратора Django
  • Добавить атрибуты в виде столбцов в списке изменений
  • Создать значений столбцов с вычисляемым содержимым
  • Перекрестные ссылки на административные страницы через ссылки
  • Фильтрация страницы списка изменений по строкам запроса
  • Сделать свой список изменений доступным для поиска
  • Настроить автоматический ModelFormобъект
  • Изменить HTML в шаблонах администратора Django

Этот урок касается только поверхности. Количество настроек, которые вы можете сделать для настройки Django Admin, ошеломляет. Вы можете глубже погрузиться в документацию, чтобы изучить такие темы, как встроенные формы, несколько административных сайтов, массовое редактирование, автозаполнение и многое другое. Удачного кодирования!


Совершенствуй знания каждый день у нас в Телеграм-каналах

Вопросы, реклама — VK | Telegram