# Создание интерфейса пользователя
---
## Модель пользователя
----
Стандартная модель пользователя 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().
Google Drive
Gist
Clipboard
Sign in with Wallet
