# Создание интерфейса пользователя --- ## Модель пользователя ---- Стандартная модель пользователя user, предлагаемая стандартным же приложением django.contrib.auth, не подходит, поскольку нам нужно хранить дополнительные данные о пользователе. ---- Наша модель будет носить название AdvUser. Список полей, которые мы объявим в ней, приведен в таблице  ---- Код, объявляющий эту модель: ``` from django.db import models from django.contrib.auth.models import AbstractUser class AdvUser(AbstractUser): is_activated = models.BooleanField(default=True, db_index=True, verbose_name='Прошел активацию?') send_messages = models.BooleanField(default=True, verbose_name='Слать оповещения о новых комментариях?') class Meta(AbstractUser.Meta): pass ``` ---- Сразу же укажем ее как модель пользователя, используемую подсистемой разграничения доступа Django. Для этого откроем модуль settings.py пакета конфигурации и добавим в него строку: `AUTH_USER_MODEL = 'main.AdvUser'` ---- Остановим отладочный веб-сервер Django и зададим в командной строке команду сначала на создание миграций: `python manage.py makemigrations` ---- а потом — на их выполнение: `python manage.py migrate` ---- Как только миграции будут выполнены, создадим суперпользователя, подав команду: `python manage.py createsuperuser` ---- апоследок откроем модуль admin.ру пакета приложения, в котором объявляются классы-редакторы и регистрируются модели в административном сайте. Зарегистрируем нашу модель пользователя, добавив в этот модуль код: ``` from .models import AdvUser admin.site.register(AdvUser) ``` --- ## Страница входа ---- Далее ради простоты мы будем, по возможности, следовать установленным Django соглашениям. ---- Код контроллера-класса, выполняющего вход и носящего имя BBLoginView. Добавим его в модуль `views.py` пакета приложения. ``` from django.contrib.auth.views import LoginView class BBLoginView(LoginView): template_name = 'main/login.html' ``` ---- Шаблон страницы входа login.html мы поместили в папку templates\main — туда же, где находятся все остальные шаблоны. Поскольку наш сайт включает относительно немного страниц, будем хранить их в одной папке, чтобы упростить сопровождение сайта. ---- Запишем новый маршрут, указывающий на контроллер BBLoginView, в списке уровня приложения. Откроем модуль `urls.py` пакета приложения и добавим в него код: ``` from .views import BBLoginView ... urlpatterns = [ path ('accounts/login/', BBLoginView.as_view(), name='login'), ... ] ``` ---- В маршруте мы указали шаблонный путь accounts/login/. По умолчанию именно по нему Django выполняет перенаправление при попытке гостя получить доступ к закрытой от него странице. ---- Напишем шаблон страницы входа templates\main\login.html. ``` {% extends "layout/basic.html" %} {% load bootstrap4 %} {% block title %}Вход{% endblock %} {% block content %} <h2>Вход</h2> {% if user.is_authenticated %} <р>Вы уже выполнили вход.</р> {% else %} <form method="post"> {% csrf_token %} {% bootstrap_form form layout='horizontal' %} <input type="hidden" name="next" value="{{ next }}"> {% buttons submit='Войти' %}{% endbuttons %} </form> {% endif %} {% endblock %} ``` ---- Напоследок внесем правки в базовый шаблон templates\layout\basic.html. Найдем в нем фрагмент кода, создающего пункт Вход и пункт с раскрывающимся меню Профиль горизонтальной полосы навигации, и исправим его следующим образом: ``` <ul class="col nav justify-content-end border"> <li class="nav-item"><a ....>Регистрация</a></li> {% if user.is_authenticated %} <li class="nav-item dropdown"> ... </li> {% else %} <li class="nav-item"><a ... >Вход</a></li> {% endif %} </ul> ``` ---- Запишем в тег <а>, создающий гиперссылку Вход, интернет-адрес страницы входа: `<а . . . href="{% url 'main:login' %}">Вход</а>` ---- Но пока не будем выполнять вход, иначе возникнет ошибка. Сначала сделаем страницы профиля и выхода --- ## Страница профиля ---- Контроллер, выводящий страницу пользовательского профиля, реализуем в виде функции и назовем profile(). Его код чрезвычайно прост. ``` from django.contrib.auth.decorators import login_required @login_required def profile(request): return render(request, 'main/profile.html') ``` ---- Добавим в список маршрутов уровня приложения (не забываем, что он хранитсяв модуле `urls.py` пакета приложения) маршрут на контроллер profile (): ``` from .views import profile urlpatterns = [ path ('accounts/profile/', profile, name='profile'), ... ] ``` ---- Код шаблона templates\main\profile.html, формирующего страницу профиля. ``` {% extends "layout/basic.html" %} {% block title %}Профиль пользователя{% endblock %} {% block content %} <h2>Профиль пользователя {{ user.username }}</h2> {% if user.first_name and user.last_name %} <p>3дравствуйте, {{ user.first_name }} {{ user.last_name }}!</p> {% else %} <p>3дравствуите!</p> {% endif %} <h3>Ваши объявления</h3> {% endblock %} ``` ---- В шаблоне templates/layout/basic.html найдем тег <а>, выводящий гиперссылку Мои объявления, и вставим в него интернет-адрес страницы профиля: `<a . . . href="{% url 'main:profile' %}">Мои объявления</a>` --- ## Страница выхода ---- Контроллер выхода реализуем в виде класса BBLogoutview, производного от класса LogoutView. ``` from django.contrib.auth.views import LogoutView from django.contrib.auth.mixins import LoginRequiredMixin class BBLogoutView(LoginRequiredMixin, LogoutView): template_name = 'main/logout.html' ``` ---- Страница выхода должна быть доступна только зарегистрированным пользователям, выполнившим вход. Поэтому мы добавили в число суперклассов контроллера- класса `BBLogoutView` примесь `LoginRequiredMixin`. ---- В списке маршрутов уровня приложения запишем маршрут, ведущий на этот контроллер: ``` from .views import BBLogoutView urlpatterns = [ path('accounts/logout/', BBLogoutView.as_view(), name='logout'), ] ``` ---- Напишем шаблон страницы выхода templates\main\logout.html. ``` {% extends "layout/basic.html" %} {% block title %}Выход{% endblock %} {% block content %} <h2>Выход</h2> <p>Вы успешно вышли с сайта.</p> {% endblock %} ``` ---- В шаблоне templates/layout/basic.html найдем тег `<a>`, выводящий гиперссылку Выход, и поместим в него интернет-адрес страницы выхода: `<a . . . href="{% url 'main:logout' %}">Выйти</a>` --- ## Страница редактирования ---- Сначала объявим форму ChangeUserlnfoForm, связанную с моделью AdvUser и предназначенную для ввода основных данных. Его мы запишем во вновь созданный модуль forms.py пакета приложения. ``` from django import forms from .models import AdvUser class ChangeUserInfoForm (forms.ModelForm): email = forms.EmailField(required=True, label='Адрес электронной почты') class Meta: model = AdvUser fields = ('username', 'email', 'first_name', 'last_name', 'send_messages') ``` ---- Контроллер страницы основных данных должен выполнять правку записи модели, так что мы можем написать его на базе высокоуровневого класса UpdateView. ``` from django.views.generic.edit import UpdateView from django.contrib.messages.views import SuccessMessageMixin from django.urls import reverse_lazy from django.shortcuts import get_object_or_404 from .models import AdvUser from .forms import ChangeUserInfoForm class ChangeUserInfoView(SuccessMessageMixin, LoginRequiredMixin, UpdateView): model = AdvUser template_name = 'main/change_user_info.html' form_class = ChangeUserInfoForm success_url = reverse_lazy('main:profile') success_message = 'Данные пользователя изменены' def setup(self, request, *args, **kwargs): self.user_id = request.user.pk return super().setup(request, *args, **kwargs) def get_object(self, queryset=None): if not queryset: queryset = self.get_queryset() return get_object_or_404(queryset, pk=self.user_id) ``` ---- В процессе работы этот контроллер должен извлечь из модели AdvUser запись, представляющую текущего пользователя, для чего ему нужно предварительно получить ключ текущего пользователя. Получить его можно из объекта текущего пользователя, хранящегося в атрибуте user объекта запроса. ---- Вероятно, наилучшее место для получения ключа текущего пользователя — метод setup(), наследуемый всеми контроллерами-классами от их общего суперкласса view. ---- Этот метод выполняется в самом начале исполнения контроллера-класса и получает объект запроса в качестве одного из параметров. В переопределенном методе setup () мы извлечем ключ пользователя и сохраним его в атрибуте user_id. ---- Извлечение исправляемой записи выполняем в методе get_object(), который контроллер-класс унаследовал от примеси SingieObjectMixin. ---- В качестве одного из суперклассов этого контроллера-класса мы указали примесь LoginRequiredMixin, запрещающую доступ к контроллеру гостям, и примесь SuccessMessageMixin, которая применяется для вывода всплывающих сообщений об успешном выполнении операции. ---- В список маршрутов уровня приложения добавим соответствующий маршрут: ``` from .views import ChangeUserInfoView ... urlpatterns = [ path('accounts/profile/change/', ChangeUserInfoView.as_view(), name='profile_change'), path('accounts/profile/', profile, name='profile'), ... ] ``` ---- Код шаблона templates\main\change_user_info.html, создающего страницу для правки основных данных. ``` {% extends "layout/basic.html" %} {% load bootstrap4 %} {% block title %}Правка личных данных{% endblock %} {% block content %} <h2>Правка личных данных пользователя {{ user.username }}</h2> <form method="post"> {% csrf_token %} {% bootstrap_form form layout='horizontal' %} {% buttons submit='Сохранить' %}{% endbuttons %} </form> {% endblock %} ``` ---- В шаблоне templates\layout\basic.html отыщем тег <а>, выводящий гиперссылку Изменить личные данные, и вставим в него интернет-адрес страницы правки основных данных: `<a . . . href="{% url 'main:profile_change'%}">Изменить личные данные</a>` --- ## Страница изменения пароля ---- ``` from django.contrib.auth.views import PasswordChangeView class BBPasswordChangeView(SuccessMessageMixin, LoginRequiredMixin, PasswordChangeView): template_name = 'main/password_change.html' success_url = reverse_lazy('main:profile') success_message = 'Пароль пользователя изменен' ``` ---- Добавим в список маршрутов уровня приложения маршрут, который укажет на новый контроллер: ``` ... urlpatterns = [ path('accounts/logout/', BBLogoutView.as_view(), name='logout'), path ('accounts/password/change/', BBPasswordChangeView.as_view(), name='password_change'), ... ] ``` ---- Код шаблона страницы для смены пароля templates\main\password_change.html. ``` {% extends "layout/basic.html" %} {% load bootstrap4 %} {% block title %}Смена пароля{% endblock %} {% block content %} <h2>Смена пароля пользователя {{ user.username }}</h2> <form method="post"> {% csrf_token %} {% bootstrap_form form layout='horizontal' %} {% buttons submit='Сменить пароль' %}{% endbuttons %} </form> {% endblock %} ``` ---- Осталось в коде шаблона templates\layout\basic.html найти код, создающий гиперссылку Изменить пароль, и поместить в нее правильный интернет-адрес: `<a . . . href="{% url 'main:password_change' %}">Изменить пароль</a>` --- ## Регистрация нового пользователя ---- Мы напишем форму для ввода сведений о новом пользователе, контроллеры и шаблоны для страниц непосредственно регистрации и уведомления об успешной регистрации. ---- Для отправки письма о необходимости активации мы объявим свой сигнал. Называться он будет user_registered и получит в качестве единственного параметра instance объект вновь созданного пользователя. ---- Сигнал мы объявим в модуле apps.py пакета приложения. Этот модуль выполняется непосредственно при инициализации приложения и, таким образом, является идеальным местом для записи кода, объявляющего сигналы. ---- Код класса формы RegisterUserForm запишем в модуль forms.py пакета приложения. ``` from django.contrib.auth import password_validation from django.core.exceptions import ValidationError from .apps import user_registered class RegisterUserForm(forms.ModelForm): email = forms.EmailField(required=True, label='Адрес электронной почты') password1 = forms.CharField(label='Пароль', widget=forms.PasswordInput, help_text=password_validation.password_validators_help_text_html()) password2 = forms.CharField(label='Пароль (повторно)', widget = forms.PasswordInput, help_text='Введите тот же самый пароль еще раз для проверки') def clean_passwordl(self): password1 = self.cleaned_data['password1'] if password1: password_validation.validate_password(password1) return password1 def clean(self): super().clean() password1 = self.cleaned_data['password1'] password2 = self.cleaned_data['password2'] if password1 and password2 and password1 != password2: errors = {'password2': ValidationError('Введенные пароли не совпадают', code='password_mismatch')} raise ValidationError(errors) def save(self, commit=True): user = super().save(commit=False) user.set_password(self.cleaned_data['password1']) user.is_active = False user.is_activated = False if commit: user.save() user_registered.send(RegisterUserForm, instance=user) return user class Meta: model = AdvUser fields = ('username', 'email', 'password1', 'password2', 'first_name', 'last_name', 'send_messages') ``` ---- Здесь мы также комбинируем быстрое и полное объявление полей. Полное объявление используем для создания полей электронной почты (поскольку хотим сделать его обязательным для заполнения) и обоих полей для занесения пароля. ---- В качестве дополнительного поясняющего текста у первого поля пароля указываем объединенный текст с требованиями к вводимому паролю, предоставленный всеми доступными в системе валидаторами, — там новый пользователь сразу поймет, какие требования предъявляются к паролю. ---- В методе clean_password1() выполняем валидацию пароля, введенного в первое поле, с применением доступных в системе валидаторов пароля. ---- В переопределенном методе clean() проверяем, совпадают ли оба введенных пароля. Эта проверка будет проведена после валидации пароля из первого поля. ---- В переопределенном методе save() при сохранении нового пользователя заносим значения False в поля is_active (признак, является ли пользователь активным) и is_activated (признак, выполнил ли пользователь процедуру активации), тем самым сообщая фреймворку, что этот пользователь еще не может выполнять вход на сайт. ---- Далее сохраняем в записи закодированный пароль и отправляем сигнал user registered, чтобы отослать пользователю письмо с требованием активации. ---- Контроллер-класс, регистрирующий пользователя, мы назовем RegisterUserView и сделаем производным от класса CreateView. ---- ``` from django.views.generic.edit import CreateView from .forms import RegisterUserForm class RegisterUserView(CreateView): model = AdvUser template_name = 'main/register_user.html' form_class = RegisterUserForm success_url = reverse_lazy('main:register_done') ``` ---- Контроллер, который выведет сообщение об успешной регистрации, будет называться RegisterDoneView и, в силу его исключительной простоты, станет производным от класса Templateview. ``` from django.views.generic.base import TemplateView class RegisterDoneView(TemplateView): template_name = 'main/register_done.html' ``` ---- В список маршрутов уровня приложения добавим два маршрута, ведущие на только что написанные нами контроллеры: ``` from .views import RegisterUserView, RegisterDoneView ... urlpatterns = [ path('acoounts/register/done/', RegisterDoneView.as_view(), name='register_done'), path('acoounts/register/', RegisterUserView.as_view(), name='register'), path('accounts/login', BBLoginView.as_view(), name='login'), ... ] ``` ---- Код шаблонa templates\main\register_user.html ``` {% extends "layout/basic.html" %} {% load bootstrap4 %} {% block title %}Регистрация{% endblock %} {% block content %} <h2>Регистрация нового пользователя</h2> <form method="post"> {% csrf_token %} {% bootstrap_form form layout='horizontal' %} {% buttons submit='Зарегистрироваться' %}{% endbuttons %} </form> {% endblock %} ``` ---- Код шаблонa templates\main\register_done.html ``` {% extends "layout/basic.html" %} {% block title %}Регистрация завершена{% endblock %} {% block content %} <h2>Регистрация</h2> <p>Регистрация пользователя завершена.</p> <p>На адрес электронной почты, указанный пользователем, выслано письмо для активации.</p> {% endblock %} ``` ---- В шаблоне templates\layout\basic.html найдем фрагмент, создающий гиперссылку Регистрация, и вставим в нее интернет-адрес страницы регистрации: `<а . . . href="{% url 'main:register' %}">Регистрация</а>` --- ## Валидация аккаунта через письмо подтверждение Откроем модуль `apps.py` пакета приложения и запишем в него код, который объявит сигнал user registered и привяжет к нему обработчик: ``` from django.dispatch import Signal from .utilities import send_activation_notification user_registered = Signal(providing_args=['instance']) def user_registered_dispatcher(sender, **kwargs): send_activation_notification(kwargs['instance']) user_registered.connect(user_registered_dispatcher) ``` ---- Создадим в пакете приложения модуль `utilities.py`. Занесем в него объявление функции send_activation_notification() ``` from django.template.loader import render_to_string from django.core.signing import Signer from bboard.settings import ALLOWED_HOSTS signer = Signer() def send_activation_notification(user): if ALLOWED_HOSTS: host = 'http://' + ALLOWED_HOSTS[0] else: host = 'http://localhost:8000' context = {'user': user, 'host': host, 'sign': signer.sign(user.username)} subject = render_to_string('email/activation_letter_subject.txt', context) body_text = render_to_string('email/activation_letter_body.txt', context) user.email_user(subject, body_text) ``` ---- Чтобы сформировать интернет-адрес, ведущий на страницу подтверждения активации, понадобится, во-первых, домен, на котором находится наш сайт, а во-вторых, некоторое значение, уникально идентифицирующее только что зарегистрированного пользователя и при этом устойчивое к попыткам его подделать. ---- Домен мы можем извлечь из списка разрешенных доменов, который записан в параметре allowed_hosts настроек проекта. Выберем самый первый домен, присутствующий в списке. ---- В качестве уникального и стойкого к подделке идентификатора пользователя применяем его имя, защищенное цифровой подписью. Создание цифровой подписи выполняем посредством класса signer. ---- Текст темы и тела письма формируем с применением шаблонов templates\email\activation_letter_subject.txt и templates\email\activation_letter_body.txt соответственно. ---- templates\email\activation_letter_subject.txt `Активация пользователя {{ user.username }}` ---- templates\email\activation_letter_body.txt ``` Уважаемый пользователь {{ user.username }}! Вы зарегистрировались на сайте "Доска объявлений". Вам необходимо выполнить активацию, чтобы подтвердить свою личность. Для этого пройдите, пожалуйста, по ссылке {{ host }}{% url 'main:register_activate' sign=sign %} До свидания! С уважением, администрация сайта "Доска объявлений". ``` ---- Чтобы реализовать активацию нового пользователя, мы напишем один контроллер и целых три шаблона. Они создадут страницы с сообщением об успешной активации, о том, что активация была выполнена ранее, и о том, что цифровая подпись у идентификатора пользователя, полученного в составе интернет-адреса, скомпрометирована. ---- Контроллер мы реализуем в виде функции user_activate(). ``` from django.core.signing import BadSignature from .utilities import signer def user_activate(request, sign): try: username = signer.unsign(sign) except BadSignature: return render(request, 'main/bad_signature.html') user = get_object_or_404(AdvUser, username=username) if user.is_activated: template = 'main/user_is_activated.html' else: template = 'main/activation_done.html' user.is_active = True user.is_activated = True user.save() return render(request, template) ``` ---- Подписанный идентификатор пользователя, передаваемый в составе интернет-адреса, получаем с параметром sign. Далее извлекаем из него имя пользователя, ищем пользователя с этим именем, делаем его активным, присвоив значения True полям is active и is activated модели, и выводим страницу с сообщением об успешной активации. ---- Если цифровая подпись оказалась скомпрометированной, выводим страницу с сообщением о неуспехе активации, а если пользователь был активирован ранее (поле is activated уже хранит значение True) — страницу с сообщением, что активация уже произошла. ---- Для обработки подписанного значения используем экземпляр класса signer, созданный в модуле utilities.py и хранящийся в переменной signer. Так мы сэкономим оперативную память. ---- В списке маршрутов уровня приложения запишем маршрут, ведущий на контроллер user_activate(): ``` from .views import user_activate ... urlpatterns = [ path('accounts/register/асtivate/<str:sign>/', user_activate, name='register_activate'), path('accounts/register/done/', RegisterDoneView.as_view(), name='register_done'), ... ] ``` ---- templates\main\activation_done.html ``` {% extends "layout/basic.html" %} {% block title %}Активация выполнена{% endblock %} {% block content %} <h2>Активация</h2> <p>Пользователь с таким именем успешно активирован.</p> <p><a href="{% url 'main:login' %}">Войти на сайт</a></p> {% endblock %} ``` ---- templates\main\bad_signature.html ``` {% extends "layout/basic.html" %} {% block title %}Ошибка при активации{% endblock %} {% block content %} <h2>Активация</h2> <p>Активация пользователя с таким именем прошла неудачно.</p> <p><a href="{% url 'main:register' %}">Зарегистрироваться повторно</a></p> {% endblock %} ``` ---- templates\main\user_is_activated.html ``` {% extends "layout/basic.html" %} {% block title %}Пользователь уже активирован{% endblock %} {% block content %} <h2 >Активация</h2> <p>Пользователь с таким именем был активирован ранее.</p> <p><а href="{% url 'main:login' %}">Войти на сайт</а></p> {% endblock %} ``` ---- Чтобы протестировать отправку электронных писем, воспользуемся отладочным SMTP-сервером. Simple Mail Transfer Protocol (SMTP) — простой протокол связи, применяемый с целью пересылки электронных писем с сервера отправителя на сервер получателя. ---- Добавим в модуль settings.py пакета конфигурации выражение, задающее TCP-порт № 1025, который используется этим сервером по умолчанию: `EMAIL_PORT = 1025` ---- Запустим еще один экземпляр командной строки и отдадим команду, запускающую отладочный SMTP-сервер с использованием TCP-порта № 1025: `python -m smtpd -n -c DebuggingServer localhost:1025` --- ## Удаление пользователя ---- Контроллер-класс DeleteUserView, удаляющий текущего пользователя, сделаем производным от класса DeleteView. ``` from django.views.generic.edit import DeleteView from django.contrib.auth import logout from django.contrib import messages class DeleteUserView(LoginRequiredMixin, DeleteView): model = AdvUser template_name = 'main/delete_user.html' success_url = reverse_lazy('main:index') def setup(self, request, *args, **kwargs): self.user_id = request.user.pk return super().setup(request, *args, **kwargs) def post(self, request, *args, **kwargs): logout(request) messages.add_message(request, messages.SUCCESS, 'Пользователь удален') return super().post(request, *args, **kwargs) def get_object(self, queryset=None): if not queryset: queryset = self.get_queryset() return get_object_or_404(queryset, pk=self.user_id) ``` ---- Здесь мы использовали те же программные приемы, что и в контроллере ChangeUserInfoView. В переопределенном методе setup() сохранили ключ текущего пользователя, а в переопределенном методе get_object() отыскали по этому ключу пользователя, подлежащего удалению. ---- Перед удалением текущего пользователя необходимо выполнить выход, что мы и сделали в переопределенном методе post(). В том же методе post() мы создали всплывающее сообщение об успешном удалении пользователя. ---- В списке маршрутов уровня приложения запишем код, который добавит новый маршрут: ``` from .views import DeleteUserView ... urlpatterns = [ path ('accounts/profile/delete/' , DeleteUserView.as_view (), name='profile_delete'), path('accounts/profile/change/', ChangeUserlnfoView.as_view(), name='profile_change'), ... ] ``` ---- Напишем шаблон templates\main\delete_user.html страницы для удаления пользователя. ``` {% extends "layout/basic.html" %} {% load bootstrap4 %} {% block title %}Удаление пользователя!{% endblock %} {% block content %} <h2>Удаление пользователя {{ object.username }}</h2> <form method="post"> {% csrf_token %} {% buttons submit='Удалить' %}{% endbuttons %} </form> {% endblock %} ``` ---- Осталось записать в шаблоне templates\layout\basic.html интернет-адрес, ведущий на страницу удаления пользователя: `<а . . . href="{% url 'main:profile_delete' %}">Удалить</а>` --- ## Редактор для административной панели ---- Полный код класса редактора AdvUserAdmin, вспомогательного класса. Этот код следует занести в модуль admin.ру пакета приложения, заменив им имеющийся там код. ``` from django.contrib import admin import datetime from .models import AdvUser from .utilities import send_activation_notification def send_activation_notifications(modeladmin, request, queryset): for rec in queryset: if not rec.is_activated: send_activation_notification(rec) modeladmin.message_user(request, 'Письма с требованиями отправлены') send_activation_notifications.short_description = \ 'Отправка писем с требованиями активации' class NonactivatedFilter(admin.SimpleListFilter): title = 'Прошли активацию?' parameter_name = 'actstate' def lookups(self, request, model_admin): return ( ('activated', 'Прошли'), ('threedays', 'He прошли более 3 дней'), ('week', 'He прошли более недели'), ) def queryset(self, request, queryset): val = self.value() if val == 'activated': return queryset.filter(is_active=True, is_activated=True) elif val == 'threedays': d = datetime.date.today() - datetime.timedelta(days=3) return queryset.filter(is_active=False, is_activated=False, date_joined__date__lt=d) elif val == 'week': d = datetime.date.today() - datetime.timedelta(weeks=l) return queryset.filter(is_active=False, is_activated=False, date_joined__date__lt=d) class AdvUserAdmin (admin.ModelAdmin) : list_display = ('is_activated', 'date_joined') search_fields = ('username', 'email', 'first_name', 'last_name') list_filter = (NonactivatedFilter,) fields = (('username', 'email'), ('first_name', 'last_name'), ('send_messages', 'is_active', 'is_activated'), ('is_staff', 'is_superuser'), 'groups', 'user_permissions', ('last_login', 'date_joined')) readonly_fields = ('last_login', 'date_joined') actions = (send_activation_notifications,) admin.site.register(AdvUser, AdvUserAdmin) ``` ---- В списке записей указываем выводить строковое представление записи (имя пользователя — как реализовано в модели Abstractuser, от которой наследует наша модель), поле признака, выполнил ли пользователь активацию, временную отметку его регистрации. ---- Также разрешаем выполнять фильтрацию по полям имени, адреса электронной почты, настоящих имени и фамилии. ---- Для выполнения фильтрации пользователей, выполнивших активацию, не выполнивших ее в течение трех дней и недели, используем класс NonactivatedFilter. ---- Мы явно указываем список полей, которые должны выводиться в формах для правки пользователей, чтобы выстроить их в удобном для работы порядке. ---- Поля даты регистрации пользователя и последнего его входа на сайт делаем доступными только для чтения. ---- Наконец, регистрируем действие, которое разошлет пользователям письма с предписаниямивыполнить активацию. Это действие реализовано функцией send_activation_notifications().