Как в Django определять админа, персонал, какую-то роль (которую определили в админке), как назначать свежезареганному пользователю роль?
Сразу прошу не ругаться и не кидать ссылки на https://docs.djangoproject.com/en/2.1/ref/contrib/auth/, ибо там не даются примеры простых действий, которые мне нужны и я не могу понять, что сделать чтобы получить результат.
- admin — он же суперпользователь
- personal — просто зарегистрированный пользователь с поставленной галочкой в админке напротив персонала.
- manager — поставлена галочка персонала и добавлена роль manage (в которой разрешения на проверку заказов)
- first, second, test, test2 . — толпа пользователей, которым никакие права и роли не назначены (ибо я не знаю как это делать), но которые зарегистрированы не в админке, а в интернет-магазине при оформлении заказов и каждый из них может логиниться и каждый может заходить в свой ЛК
Да и вообще все перечисленные выше пользователи могут логиниться, оформлять заказы и заходить в свой ЛК.
Изначально планировалось создать серию админок-кабинетов под каждую роль. Но я с этим не могу разобраться уже неделю. Казалось бы простая вещь, но нигде в документации Django и в примерах на ютубе, даже англоязычном, я не могу найти простую вещь. (да, английский я не знаю и пользуюсь лишь гугл-переводчиком).
Что собственно мне нужно? А нужно в фале views.py простую вещь:
# если авторизован, то if request.user.is_authenticated: if это_суперпользователь: # загружаем админку-кабинет суперпользователя (тот который я сам сделал) # . elif это_персонал без ролей: # загружаем админку-кабинет персонала (другой, но тот который я сам сделал) без каких-либо спец.разрешений # . elif это_персонал с ролью manage: # загружаем админку-кабинет менеджера (другой, но тот который я сам сделал) # . else: # загружаем админку-кабинет простых пользователей (другой, но тот который я сам сделал) # . кстати это (надеюсь просто через подготовку данных и # return HttpResponseRedirect(reverse('account')) # и объяснять мне не надо. Мне нужны именно что писать в If-ах?
Ну почему вот в такой простой доступной и понятной форме нельзя это написать в документации? Ребята ну помогите пожалуйста. Устал уже читать и смотреть кучу несвязанных отрывков.
И если не сложно, скажите что добавить в registration_view, чтобы назначить свежерегистрирующемуся определённую роль. Сейчас там так:
def registration_view(request): form = RegistrationForm(request.POST or None) if form.is_valid(): new_user = form.save(commit=False) new_user.username = form.cleaned_data['username'] new_user.set_password(form.cleaned_data['password']) new_user.email = form.cleaned_data['email'] new_user.first_name = form.cleaned_data['first_name'] new_user.last_name = form.cleaned_data['last_name'] new_user.save() login_user = authenticate(request, username=form.cleaned_data['username'], password=form.cleaned_data['password']) if login_user: login(request, login_user) return HttpResponseRedirect(reverse('account')) context = < 'form': form, >return render(request, 'registration.html', context)
- Вопрос задан более трёх лет назад
- 9384 просмотра
1 комментарий
Простой 1 комментарий
Максим Зубенко @JawsIk Автор вопроса
Pavel Denisov, спасибо за ответ.
1. ну это как бы моя собственная форма регистрации (не та, которая по умолчанию), а т.к. я учусь по урокам, то там лектор строго настрого сказал, что брать данные нужно из cleaned_data, т.к. там уже почищенные данные, которые способны избежать XSS-инъекций. Я XSS баловался ещё лет 15 назад, когда от нефиг делать мы убивали asp буржуйские сайты (я тогда вообще не знал что это такое, просто мог скопипастить запрос и чувствовать себя великим хацкером), поэтому я решил, чтобы подобного не случилось с Django, я буду использовать всё как учат.
2. Видимо я не правильно выразился. Под словом Роли я имел ввиду группы. В принципе я уже (вчера) наконец-таки разобрался. Очень печально, что в документации по этому поводу всё так скудно, а достаточно было написать пару примеров с кодом. Я это добавлю здесь в ответы, чтобы людям на будущее не нужно было тратить несколько суток на поиски решения.
Решения вопроса 1
Максим Зубенко @JawsIk Автор вопроса
Python Django, Lua, ЧПУ-станки(ArtCam, Aspire)
Итак, как было в теме, я задавал два вопроса. Отвечу на них по порядку, чтобы людям сразу наглядно было понятно что сделать, чтобы получить результат. Очень меня печалит документация по Django. Вроде бы всё есть, но в итоге нет примеров. А как сказал мой один хороший учитель (не по Django а вообще по программированию): «Документация без примеров кода, это просто справочник. И если ты не специалист, то грош цена такому справочнику». Поэтому я просто приведу два примера кода, после которого сразу всё станет ясно.
Вопрос 1: Опознавание ролей (групп) программно.
В примере будет показан программный код метода account_view из файла views.py, который будет опознавать разные группы пользователей. Для примера в админке была создана группа manager. Ей не были даны специальные разрешения (permissions) и она служит лишь для декоративного разделения, но в программном коде даже такое декоративное разделение позволяет прекрасно опознавать и распределять пользователей. Так же прошу не обращать на функционал корзинки, здесь он оставлен только для того, чтобы показать на какой стадии нужно вставлять условия. Так же нужно понимать, что в каждом условии кроме имени шаблона могут быть (при необходимости) добавлены свои параметры, которые потом можно передать в шаблон.
def account_view(request): cart = Cart() cart_id = cart.get_cart_id(request) items_in_cart = CartItems.objects.filter(cart_id=cart_id) # если не опознан, то дуй на страницу регистрирации if not request.user.is_authenticated: return HttpResponseRedirect(reverse('registration')) # если это суперпользователь if request.user.is_superuser: template = 'account_admin.html' # или если это пользователь с галочкой персонал, а так же принадлежащий группе manager elif request.user.is_staff and request.user.groups.filter(name='manager').exists(): template = 'account_personal_role.html' # или если это просто пользователь с галочкой персонал elif request.user.is_staff: template = 'account_personal.html' # или если это пользователь принадлежащий группе manager elif request.user.groups.filter(name='manager').exists(): template = 'account_role.html' # иначе все остальные (обычные пользователи) else: template = 'account.html' # сортировка выдачи заказов в обратном порядке (от последнего к первому) list_orders = Order.objects.filter(user=request.user).order_by('-id') orders = OrderItems.add_order_info(request, list_orders) context = < 'title': 'Кабинет пользователя', 'orders': orders, 'cart': items_in_cart, 'total_cost': cart_id.total_cost, >return render(request, template, context=context)
Как видно из кода здесь имеет место быть некоторая последовательность. В частности, если второе условие (первый elif) опустить ниже, то возможна неверная работа, т.к. тогда пользователь принадлежащий группе manager и с галочкой персонала, может легко заскочить в чужой шаблон (по одному условию), поэтому при создании сложных условий, этот момент нужно учитывать.
Вопрос 2: Программное добавление пользователей в группу (или в несколько сразу)
Иногда бывает, что (например) при регистрации, нужно сразу добавить пользователя в определённую группу. Для примера была создана группа clients. Это чисто декоративное разделение. Группа не имеет никаких разрешений в админке, но выполняет свою задачу. Ниже представлен код метода registration_view из файла views.py , т.е. регистрации пользователя и этот новый пользователь после регистрации будет уже принадлежать группе clients. Кстати, чтобы код работал нужно выполнить необходимый импорт, это тоже в коде показано.
. from django.contrib.auth.models import Group . def registration_view(request): # (предотвращаем заход по прямой ссылке) # если авторизован, то if request.user.is_authenticated: return HttpResponseRedirect(reverse('account')) form = RegistrationForm(request.POST or None) if form.is_valid(): new_user = form.save(commit=False) new_user.username = form.cleaned_data['username'] new_user.set_password(form.cleaned_data['password']) # вот из-за этой бяки вся засада была у меня с паролями ЗАПОМНИ. new_user.email = form.cleaned_data['email'] new_user.first_name = form.cleaned_data['first_name'] new_user.last_name = form.cleaned_data['last_name'] new_user.save() # после собственно регистрации (сохранения нового) пользователя его можно добавить к группам new_user.groups.add(Group.objects.get(name='clients')) # new_user.groups.add(Group.objects.get(name='manager')) # и в ещё одну группу работает тоже login_user = authenticate(request, username=form.cleaned_data['username'], password=form.cleaned_data['password']) if login_user: login(request, login_user) return HttpResponseRedirect(reverse('account')) context = < 'title': 'Регистрация', 'form': form, >return render(request, 'registration.html', context)
Как видно в коде после создания пользователя, он добавляется к (уже созданной предварительно) группе и теперь зайдя в админку, мы это можем легко проверить. Кроме того, в коде закомментирована строчка с добавлением в ещё одну группу manager. Если её раскомментировать, то пользователь будет добавлен сразу в две группы. Т.о. можно добавлять пользователей сразу в несколько групп (если в этом есть необходимость). Естественно нужно понимать, что подобное добавление в группу можно делать не только при регистрации, но видя этот код, сделать необходимое решение уже не должно составлять большого труда.
Надеюсь код пригодиться людям.
Использование доступа в Django используя is_staff is_superuser
Всем привет не могу разобраться. Хочу запретить во view в частности CreateView создавать записи пользователям, если у него не стоят галочки is_staff или is_superuser. Подскажите как это правильно сделать? Использую классы generic.
Отслеживать
задан 2 июн в 10:02
37 2 2 бронзовых знака
Используйте PermissionRequiredMixin
3 июн в 8:52
PermissionRequiredMixin мне не подходит. У меня выше конкретный вопрос с помощью is_staff is_superuser как это сделать.
8 июн в 12:25
Тогда делать проверку: if not request.user.is_staff
10 июн в 8:09
Вот именно. А в каком методе делать проверку? Эта проверка нужна мне до создания пустой формы, чтоб если галки is_staff не было форма не отобразилась и была переадресация на главную. С помощью класса View я знаю как это сделать, а вот с помощью CreateView не знаю.
10 июн в 10:21
1 ответ 1
Сортировка: Сброс на вариант по умолчанию
Тема закрыта всем спасибо!
Классы generic наследуются от BaseUpdateView в котором есть как и в классе View методы get и post то есть их можно переопределить.
class UserViewList(LoginRequiredMixin, ListView): template_name = 'userlist.html' model = CustomUser paginate_by = 15 context_object_name = 'users' def get(self, request, *args, **kwargs): if self.request.user.is_staff: self.object = None return super().get(request, *args, **kwargs) else: return redirect('home') def post(self, request, *args, **kwargs): if self.request.user.is_staff: self.object = None return super().post(request, *args, **kwargs) else: return redirect('home') def get_queryset(self, **kwargs): queryset = CustomUser.objects.all() return queryset
Настройка админки Django Admin с помощью Python

Высокоуровневый фреймворк Python Django поставляется с панелью администратора, которая также называется Django admin. Это мощный инструмент управления, позволяющий сразу после установки фреймворка добавлять, удалять или редактировать любую модель базы данных через веб-интерфейс.
Но добавив немного кода, можно настроить Django admin под себя и вывести возможности администрирования на новый уровень.
Благодаря этому руководству вы научитесь:
- Добавлять столбцы атрибутов в списки объектов модели.
- Создавать связи между объектами моделей.
- Добавлять фильтры к списку объектов модели.
- Добавлять поиск для списков объектов моделей.
- Изменять формы редактирования объекта.
- Переопределять административные шаблоны Django.
Предварительные требования
Чтобы пользоваться данным руководством наиболее эффективно, вы должны быть немного знакомы с Django, в частности с объектами моделей (model objects). Поскольку Django не часть стандартной библиотеки Python, будет лучше, если вы предварительно освоите «pip», «pyenv» или аналогичные инструменты виртуальной среды.
Это руководство было протестировано на Django 3.0.7. Но основные принципы неизменны со времён Django 2.0, так что всё должно работать на любой используемой версии ПО, хотя возможны небольшие отличия.
Установка Django
Панель администратора Django (Django admin panel) предоставляет веб-интерфейс для создания и управления объектами модели базы данных. Чтобы увидеть его в действии, нам сначала понадобится проект 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». После этого мы выполняем миграцию таблиц аутентификации и создаём пользователя с правами администратора.
Доступ к экранам (screens) Django admin предоставляется пользователями с флажками «staff» или «superuser». Поэтому для создания суперпользователя используем команду управления createsuperuser.
Также нужно изменить файл «School/settings.py», включив новое приложение Django под именем «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", # Добавьте эту строку ]
В каталоге приложения «core» появятся файлы:

Из этих файлов нас интересуют два:
- «models.py» — определяет наши модели баз данных.
- «admin.py» — регистрирует эти модели с помощью Django admin.
Чтобы показать результат кастомизации админ панели 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)
Эти модели представляют учеников, посещающих курсы колледжа. Каждый курс («Course») имеет название («name») и год («year»), в котором его предлагают.
Каждый ученик («Person») имеет имя («first_name») и фамилию («last_name»). Он может посещать «0» или более курсов («courses»). Оценка («Grade») хранит процентные баллы, полученные учеником на курсе.
Диаграмма модели иллюстрирует отношения между объектами:

Соответствующие имена таблиц в базе данных слегка отличаются, но соотносятся с приведённой моделью.
Каждую модель, которую Django будет отображать в интерфейсе администратора, нужно регистрировать. Сделать это можно в файле «admin.py». Модели из файла «core/models.py» регистрируются в соответствующем файле «core/admin.py».
from django.contrib import admin 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 .
Нам предложат залогиниться. Воспользуемся учётной записью, созданной командой администратора « createsuperuser ».
На начальной странице панели администратора приведены все зарегистрированные модели баз данных:

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

В начале список пуст, как и вся наша база данных Django. Внести ученика в базу данных можно, кликнув на элемент «ADD PERSON». После сохранения нас возвращают к списку объектов «Person»:

Хорошая новость в том, что теперь у нас есть объект. Плохая — строка «Person object (1)» не сообщает нам о нём ничего, кроме идентификатора («id»).
По умолчанию Django admin показывает каждый объект, вызывая для него метод «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", "
Добавление метода «Person.__str__()» изменяет интерфейс так, чтобы для каждого объекта «Person» отображались имя и фамилия. Чтобы увидеть изменения, можно обновить экран:

Стало гораздо лучше! Теперь мы видим об объекте «Person» уже какую-то информацию. Неплохая идея — добавить аналогичные методы для объектов «Course» и «Grade».
class Course(models.Model): # . def __str__(self): return f", " class Grade(models.Model): # . def __str__(self): return f", , "
Чтобы по достоинству оценить результат такой кастомизации, надо внести в базу данных больше информации. Можно попробовать создать свои данные или воспользоваться готовой фикстурой (тестовыми данными).
Загрузка фикстур в Django
Django позволяет загружать данные из/в базы данных при помощи файлов, называемых фикстурами. Для того, чтобы воспользоваться этим способом, скопируйте следующее содержимое в файл «core/fixtures/school.json»:
Создав файл, можно воспользоваться административной командой « loaddata ». Это загрузит его в нашу базу данных.
./manage.py loaddata school Installed 13 object(s) from 1 fixture(s)
Теперь в нашей базе есть тестовые объекты «Person», «Course» и «Grade».
Располагая данными для работы, приступим к кастомизации административного интерфейса Django.
Кастомизация Django Admin
Создатели фреймворка Django не просто сделали для него панель администратора, но и заложили возможность тонкой настройки проектов на Django через неё.
Регистрируя ранее объект «PersonAdmin», мы унаследовали его из класса «admin.ModelAdmin». Большая часть кастомизации Django admin выполняется через изменение объектов «ModelAdmin», которые специально предназначены для этого.
У класса «ModelAdmin» больше тридцати атрибутов и почти пятьдесят методов. Для тонкой настройки отображения панели администратора и управления объектами интерфейса можно использовать каждый из них. В документации подробно описаны все эти опции.
В довершение ко всему, панель администратора создана с использованием шаблонов Django. Механизм шаблонов Django позволяет переопределить существующие шаблоны. И, поскольку панель администратора — просто очередной набор шаблонов, её HTML-код полностью открыт для изменений.
Этот механизм позволяет даже создавать множественные административные панели к одному сайту. Хотя это может показаться уже избыточном функционалом, но именно так можно дать волю воображению, создавая разные сайты для пользователей с разными правами.
Django admin состоит из трёх основных частей:
- «Индекс приложения» (app index) отображает перечень зарегистрированных моделей.
- «Списки объектов» (change lists) автоматически создаются для каждой зарегистрированной модели и перечисляют её объекты.
- «Формы изменений» (change forms) позволяют добавлять или изменять эти объекты.
В примере выше индекс приложения показал объекты «Person», «Course» и «Grade». Кликнув на элемент «People», мы видим списки объектов «Person». На странице списка объектов «Person» можно кликнуть на имя Баффи Саммерс (Buffy Summers) и попасть на форму изменения для редактирования данных.
Модификация списка объектов с помощью 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» так, чтобы для каждого объекта «Person» отображались атрибуты «last_name» и «first_name».
Каждый атрибут показан на столбце страницы:

На оба столбца можно кликнуть для сортировки страницы по данным столбца. Django admin также учитывает атрибут «ordering» раздела «Meta»:
@admin.register(Person) class PersonAdmin(admin.ModelAdmin): list_display = ("last_name", "first_name")
Если добавить атрибут «ordering», то по умолчанию все запросы к объекту «Person» будут возвращаться отсортированными сначала по фамилии («last_name»), а затем по имени (first_name»). Django станет использовать такой порядок по умолчанию как в панели администратора, так и при получении объектов.
Кортеж «list_display» может отсылать к любому атрибуту отображаемого объекта. Он может также ссылаться на методы самого объекта «admin.ModelAdmin».
Снова изменим объект «PersonAdmin»:
@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 admin. Если у нас есть такой метод, его можно добавить в атрибут «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-кода в строках, на случай, если строка получена от пользователя. Чтобы его задействовать, нужно использовать функцию «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("<>", result["grade__avg"]) show_average.short_description = "Average"
Теперь у столбца функции «show_average()» новый заголовок «Average», а строки отформатированы курсивом:

К сожалению, в Django пока не добавили поддержку f-строк для функции «format_html()». Поэтому придётся обойтись синтаксисом «str.format()».
Гиперссылки на страницы других объектов
Одни объекты часто ссылаются на другие, используя внешние ключи. Можно включить в кортеж «list_display» метод, возвращающий HTML-ссылку.
Изменим класс «CourseAdmin» в файле «core/admin.py» таким образом:
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): from django.utils.html import format_html count = obj.person_set.count() url = ( reverse("admin:core_person_changelist") + "?" + urlencode(">) ) return format_html('"><> Students', url, count) view_students_link.short_description = "Students"
Благодаря этому коду список объектов «Course» будет иметь три столбца:
- «NAME» — название курса.
- «YEAR» — год, в котором предлагается курс
- «STUDENTS» — гиперссылка с указанием числа учеников
Изменения можно увидеть на скриншоте:

Кликнув на ссылку «2 Students», мы попадём на страницу со списком объектов «Person», к которой применён фильтр. Отфильтрованная страница показывает только учеников курса «Psych 101» — Баффи (Buffy) и Уиллоу (Willow). Ксандер в университет не попал.
Приведённый код использует функцию «reverse()» для нахождения гиперссылки в Django admin. Также можно найти любую страницу панели администратора.
Используется следующий формат именования:
"admin:%(app)s_%(model)s_%(page)"
Он состоит из нескольких частей:
- «admin:» — ключевое слово.
- «app» — название приложения.
- «model»— объект модели.
- «page» — страница административной панели Django.
Вернёмся к примеру с функцией «view_students_link()». Там для получения ссылки на страницу со списком объектов «Person» приложения «core» использовался метод «admin:core_person_changelist».
Вот доступные 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», используемую для формирования страницы.
В приведённом выше примере запрос из строковой переменной «?courses__id=» фильтрует список «Person», оставляя лишь объекты с совпадающим значением «Person.course».
Для выборок «QuerySet» эти фильтры поддерживают запросы типа «field lookups», использующие двойные подчерки («__»). Можно получить доступ к атрибутам соответствующих объектов или использовать такие модификаторы фильтров, как «__exact» и «__startswith».
Подробности о том, чего можно достичь с помощью использования атрибута «list_display», можно найти в документации по панели администратора Django.
Добавление фильтров на экран объектов
Помимо фильтрации списка объекта через URL, можно добавить фильтр с помощью встроенного виджета. Добавим для объекта «CourseAdmin» атрибут «list_filter» в файле «core/admin.py»:
@admin.register(Course) class CourseAdmin(admin.ModelAdmin): list_display = ("name", "year", "view_students_link") list_filter = ("year", ) # .
Атрибут «list_filter» отобразит на странице новый раздел со списком ссылок. В нашем случае это ссылки для фильтрации страниц по году. Список фильтра автоматически наполняется значениями «year» объектов «Course» из базы данных:

Кликая на год («year») справа страницы, мы изменим список, включив только объекты «Course» с заданным значением «year».
Фильтрация также возможна на основании атрибутов связанных объектов при использовании синтаксиса «field lookup» («__»). Например, можно отфильтровать объекты «GradeAdmin» с помощью «course__year». Это выведет только объекты «Grade» за определённый год.
Если нужны расширенные возможности фильтрации, то можно даже создавать объекты фильтра (filter objects), задающие атрибуты поиска и нужную выборку «QuerySet».
Добавление поиска на экран объектов
Фильтры — не единственный способ уменьшить объёмы данных на экране. Django admin также поддерживает поиск с помощью опции «search_fields», которая добавляет на экран поле поиска (search box). Его связывают с кортежем, содержащим имена полей, которые будут использованы для формирования строкового запроса к базе данных.
Всё, что пользователь введёт в поле поиска, будет использовано в качестве фильтра полей для выборки «QuerySet». Условие будет разделено операторами «OR». По умолчанию каждый поисковый параметр окружён знаками «%». Это означает, что если мы будем искать «r», то в результат попадёт любое слово, содержащее «r». Можно указать поле поиска и точнее, используя модификатор «__».
Отредактируем объект «PersonAdmin» в файле «core/admin.py» так:
@admin.register(Person) class PersonAdmin(admin.ModelAdmin): search_fields = ("last_name__startswith", )
В приведённом выше коде поиск основан на фамилии. Модификатор «__startswith» ограничивает поиск по фамилии теми вхождениями, которые начинаются на запрос. Поиск по «R» даст такой результат:

При каждом поиске на странице объектов, Django admin вызывает метод «get_search_results()» нашего объекта «admin.ModelAdmin». Этот метод возвращает выборку «QuerySet» с результатом поиска. В официальной документации также показано, как настроить поиск, перегружая метод и изменяя выборку «QuerySet».
Изменение способа редактирования моделей
Кастомизация возможна не только для страницы списка объектов. Экраны, используемые для добавления и удаления объектов, основаны на объекте «ModelForm». Django автоматически генерирует форму, основываясь на редактируемой модели.
Редактируя опцию «fields», можно управлять включением и порядком полей. Изменим наш объект «PersonAdmin», добавив атрибут «fields»:
@admin.register(Person) class PersonAdmin(admin.ModelAdmin): fields = ("first_name", "last_name", "courses") # .
Теперь страницы добавления («Add») и изменения («Change») для объектов «Person» выводят атрибут имя («first_name») перед фамилией («last_name»), хотя в самой модели порядок обратный:

За создание нашего объекта «ModelForm» отвечает метод «ModelAdmin.get_form()». Для изменения формы этот метод можно переопределить.
Добавим в объект «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 admin, можно задействовать атрибут «form» для регистрации специальной формы. Сделать это можно, добавив и изменив кое-что в файле «core/admin.py»:
from django import forms 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 # .
Этот код вводит дополнительную проверку на страницах добавления и изменения объектов «Person».
У механизма валидации объектов «ModelForm» широкие возможности. В нашем случае, поле «first_name» не допускает введения имени «Спайк» (Spike). Метод «ValidationError» не даст ученикам с таким именем зарегистрироваться:

Изменяя и заменяя объект «ModelForm», можно полностью управлять видом и проверками страниц добавления или изменения объектов.
Добавление поиска на экран объектов
Разработчики Django создавали панель администратора, используя механизм шаблонов. Это упростило им работу, но и нам позволяет извлекать выгоды из возможности переопределять шаблоны. Изменяя шаблоны выдачи страниц, можно полностью кастомизировать панель администратора.
Можно увидеть все её шаблоны, заглянув в виртуальную среду пакета Django:

Движок шаблонов Django имеет определённый порядок их загрузки. Загружая какой-либо шаблон, он использует первый же, совпадающий по имени. Административные шаблоны можно переопределить, используя ту же структуру каталогов и имена файлов.
Административные шаблоны находятся в двух каталогах:
- admin — для страниц объектов модели.
- registration — для смены пароля, а также входа и выхода из системы.
Для тонкой настройки страницы выхода из системы («logout page»), нужно переназначить нужный файл. Относительный путь к файлу должен быть идентичен переназначаемому.
Нужный нам файл — «registration/logged_out.htm»l. Начнём с создания каталога в проекте «School»:
mkdir -p templates/registration
Теперь расскажем Django о нашем новом каталоге шаблонов при помощи файла «School/settings.py». Находим указатель «TEMPLATES» и добавляем каталог в список «DIR»:
# School/settings.py # . TEMPLATES = [ < "BACKEND": "django.template.backends.django.DjangoTemplates", // Добавьте каталог с шаблонами через опцию DIR: "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», а затем отредактируем его:
You are now leaving Sunnydale
«>
Итак, мы настроили под себя страницу выхода из системы. Если нажать «LOG OUT», появится такое сообщение:

Шаблоны Django admin глубоко вложены и не вполне интуитивно понятны, но при необходимости у нас есть полный контроль над их отображением. Некоторые пакеты, включая Grappelli и Django Admin Bootstrap, меняют шаблоны Django admin на собственные, чтобы изменить внешний облик административной панели.
Django Admin Bootstrap пока не совместим с Django 3, а Grappelli добавил поддержку сравнительно недавно, поэтому проблемы пока не исключены. Но если хотите увидеть всю мощь переопределения административных шаблонов, познакомьтесь с этими проектами!
Заключение
Панель администратора Django — мощный встроенный инструмент со множеством возможностей. Она позволяет создавать, обновлять и удалять объекты вашей базы данных с помощью веб-интерфейса.
В этом руководстве мы показали как:
- Регистрировать объекты модели с помощью Django admin.
- Добавлять атрибуты как столбцы списка объектов.
- Создавать значения столбцов с помощью автоматически вычисляемого содержимого (calculated content).
- Делать перекрёстные ссылки для административных страниц
- Фильтровать страницу списка объектов с помощью строкового запроса
- Добавлять поиск для ваших списков объектов
- Кастомизировать автоматический объект «ModelForm»
- Изменять HTML-код административных шаблонов Django
Этот обзор затрагивает только основы. Настойки конфигурации Django admin гораздо шире. Изучив официальную документацию, можно освоить такие возможности, как встроенные формы (inline forms), множественные сайты администратора (admin sites), массовое редактирование, автозаполнение и многое другое.
Нужна надёжная база для размещения сайта? Выбирайте виртуальные сервера от Eternalhost с технической поддержкой 24/7 и бесплатной защитой от DDoS!
What’s the difference between staff, admin, superuser in django?
Django has superuser, staff, admin… superuser and staff are in django.contib.auth.models.UserManager . Then there is the createsuperuser command of django-admin . Well, there are admin apps… What’s the difference?
1,047 1 1 gold badge 10 10 silver badges 21 21 bronze badges
asked Dec 9, 2013 at 11:13
40k 70 70 gold badges 258 258 silver badges 499 499 bronze badges
4 Answers 4
One of the most powerful parts of Django is the automatic admin interface. Best thing is that you can customise it easily.
If logged in as a superuser, you have access to create, edit, and delete any object (models).
You can create staff user using staff flag. The “staff” flag controls whether the user is allowed to log in to the admin interface (i.e., whether that user is considered a “staff member” in your organization). Since this same user system can be used to control access to public (i.e., non-admin) sites, this flag differentiates between public users and administrators.
“Normal” admin users – that is, active, non-superuser staff members – are granted admin access through assigned permissions. Each object editable through the admin interface has three permissions: a create permission, an edit permission and a delete permission for all the models you had created.
Django’s admin site uses a permissions system that you can use to give specific users access only to the portions of the interface that they need. When you create a user, that user has no permissions, and it’s up to you to give the user specific permission
1,460 1 1 gold badge 11 11 silver badges 18 18 bronze badges
answered Dec 9, 2013 at 12:03
1,152 8 8 silver badges 7 7 bronze badges
Django only has one user type. Its simply User . Depending on what permissions you give the user they are able to do different things by default:
- Any normal user can be authenticated (that’s the whole point of the user, to have a login).
- Any user assigned the staff flag, can login to the contributed admin app. Beyond this, they have no other special privileges.
- They can be set as active or not. Only active users are allowed to login.
A superuser is just a convenience method to create a user with all permissions. They are just normal users given staff and all permissions by default.
There is also ADMINS and MANAGERS settings.
These are used for notifications, when the site is running in production (ie, when DEBUG is False).
Admins are notified of any errors that generate a traceback. They are emailed the traceback and information about the request. Managers are emailed when someone requests a link that doesn’t exist (basically, when a 404 is raised).
3,865 2 2 gold badges 27 27 silver badges 43 43 bronze badges
answered Dec 9, 2013 at 11:55
Burhan Khalid Burhan Khalid
171k 18 18 gold badges 245 245 silver badges 285 285 bronze badges
Note that you need to enable mails to Manager using the BrokenLinkEmailsMiddleware.
Aug 30, 2015 at 4:13
A superuser automatically has all permissions ( has_perm will return True).
A staff member can login to the admin pages.
The admin pages are a simple interface to the models that you’ve configured to show up in it. It only shows the models that the current user has the right permissions for.
So if someone is both superuser and staff, they can login to the admin site and have full access to all the models that show up in the admin site.
answered Dec 9, 2013 at 11:40
RemcoGerlich RemcoGerlich
30.7k 6 6 gold badges 63 63 silver badges 80 80 bronze badges
In Django, a superuser is a special type of user that has all permissions and can perform any action on the website. Superusers are usually created during the installation of a Django project, and they can be managed using the Django admin interface or command-line tools. Superusers have the ability to manage all aspects of the website, including creating and managing other users, modifying site settings, and performing administrative tasks.
On the other hand, an admin member is a user with administrative privileges that are specific to a particular application or part of an application. In Django, an admin member is typically a user with permissions to manage a specific app or a specific set of resources within an app. For example, an admin member for a blog application might have permissions to create, edit, and delete blog posts, but not have access to the site settings or other administrative tasks.
Overall, the key difference between a superuser and an admin member in Django is the level of access and control they have over the website:
- superusers have complete control and can perform any action on the site
- admin members are typically limited to a specific set of permissions and actions within a particular app or section of the site