diff options
Diffstat (limited to 'alphabetlearning/users')
22 files changed, 763 insertions, 0 deletions
diff --git a/alphabetlearning/users/__init__.py b/alphabetlearning/users/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/alphabetlearning/users/__init__.py diff --git a/alphabetlearning/users/adapters.py b/alphabetlearning/users/adapters.py new file mode 100644 index 0000000..29396c4 --- /dev/null +++ b/alphabetlearning/users/adapters.py @@ -0,0 +1,48 @@ +from __future__ import annotations + +import typing + +from allauth.account.adapter import DefaultAccountAdapter +from allauth.socialaccount.adapter import DefaultSocialAccountAdapter +from django.conf import settings + +if typing.TYPE_CHECKING: + from allauth.socialaccount.models import SocialLogin + from django.http import HttpRequest + + from alphabetlearning.users.models import User + + +class AccountAdapter(DefaultAccountAdapter): + def is_open_for_signup(self, request: HttpRequest) -> bool: + return getattr(settings, "ACCOUNT_ALLOW_REGISTRATION", True) + + +class SocialAccountAdapter(DefaultSocialAccountAdapter): + def is_open_for_signup( + self, + request: HttpRequest, + sociallogin: SocialLogin, + ) -> bool: + return getattr(settings, "ACCOUNT_ALLOW_REGISTRATION", True) + + def populate_user( + self, + request: HttpRequest, + sociallogin: SocialLogin, + data: dict[str, typing.Any], + ) -> User: + """ + Populates user information from social provider info. + + See: https://docs.allauth.org/en/latest/socialaccount/advanced.html#creating-and-populating-user-instances + """ + user = super().populate_user(request, sociallogin, data) + if not user.name: + if name := data.get("name"): + user.name = name + elif first_name := data.get("first_name"): + user.name = first_name + if last_name := data.get("last_name"): + user.name += f" {last_name}" + return user diff --git a/alphabetlearning/users/admin.py b/alphabetlearning/users/admin.py new file mode 100644 index 0000000..04da035 --- /dev/null +++ b/alphabetlearning/users/admin.py @@ -0,0 +1,49 @@ +from django.conf import settings +from django.contrib import admin +from django.contrib.auth import admin as auth_admin +from django.contrib.auth.decorators import login_required +from django.utils.translation import gettext_lazy as _ + +from .forms import UserAdminChangeForm +from .forms import UserAdminCreationForm +from .models import User + +if settings.DJANGO_ADMIN_FORCE_ALLAUTH: + # Force the `admin` sign in process to go through the `django-allauth` workflow: + # https://docs.allauth.org/en/latest/common/admin.html#admin + admin.site.login = login_required(admin.site.login) # type: ignore[method-assign] + + +@admin.register(User) +class UserAdmin(auth_admin.UserAdmin): + form = UserAdminChangeForm + add_form = UserAdminCreationForm + fieldsets = ( + (None, {"fields": ("email", "password")}), + (_("Personal info"), {"fields": ("name",)}), + ( + _("Permissions"), + { + "fields": ( + "is_active", + "is_staff", + "is_superuser", + "groups", + "user_permissions", + ), + }, + ), + (_("Important dates"), {"fields": ("last_login", "date_joined")}), + ) + list_display = ["email", "name", "is_superuser"] + search_fields = ["name"] + ordering = ["id"] + add_fieldsets = ( + ( + None, + { + "classes": ("wide",), + "fields": ("email", "password1", "password2"), + }, + ), + ) diff --git a/alphabetlearning/users/apps.py b/alphabetlearning/users/apps.py new file mode 100644 index 0000000..a4e4679 --- /dev/null +++ b/alphabetlearning/users/apps.py @@ -0,0 +1,13 @@ +import contextlib + +from django.apps import AppConfig +from django.utils.translation import gettext_lazy as _ + + +class UsersConfig(AppConfig): + name = "alphabetlearning.users" + verbose_name = _("Users") + + def ready(self): + with contextlib.suppress(ImportError): + import alphabetlearning.users.signals # noqa: F401 diff --git a/alphabetlearning/users/context_processors.py b/alphabetlearning/users/context_processors.py new file mode 100644 index 0000000..e2633ae --- /dev/null +++ b/alphabetlearning/users/context_processors.py @@ -0,0 +1,8 @@ +from django.conf import settings + + +def allauth_settings(request): + """Expose some settings from django-allauth in templates.""" + return { + "ACCOUNT_ALLOW_REGISTRATION": settings.ACCOUNT_ALLOW_REGISTRATION, + } diff --git a/alphabetlearning/users/forms.py b/alphabetlearning/users/forms.py new file mode 100644 index 0000000..fe8a886 --- /dev/null +++ b/alphabetlearning/users/forms.py @@ -0,0 +1,44 @@ +from allauth.account.forms import SignupForm +from allauth.socialaccount.forms import SignupForm as SocialSignupForm +from django.contrib.auth import forms as admin_forms +from django.forms import EmailField +from django.utils.translation import gettext_lazy as _ + +from .models import User + + +class UserAdminChangeForm(admin_forms.UserChangeForm): + class Meta(admin_forms.UserChangeForm.Meta): + model = User + field_classes = {"email": EmailField} + + +class UserAdminCreationForm(admin_forms.UserCreationForm): + """ + Form for User Creation in the Admin Area. + To change user signup, see UserSignupForm and UserSocialSignupForm. + """ + + class Meta(admin_forms.UserCreationForm.Meta): + model = User + fields = ("email",) + field_classes = {"email": EmailField} + error_messages = { + "email": {"unique": _("This email has already been taken.")}, + } + + +class UserSignupForm(SignupForm): + """ + Form that will be rendered on a user sign up section/screen. + Default fields will be added automatically. + Check UserSocialSignupForm for accounts created from social. + """ + + +class UserSocialSignupForm(SocialSignupForm): + """ + Renders the form when user has signed up using social accounts. + Default fields will be added automatically. + See UserSignupForm otherwise. + """ diff --git a/alphabetlearning/users/managers.py b/alphabetlearning/users/managers.py new file mode 100644 index 0000000..d8beaa4 --- /dev/null +++ b/alphabetlearning/users/managers.py @@ -0,0 +1,42 @@ +from typing import TYPE_CHECKING + +from django.contrib.auth.hashers import make_password +from django.contrib.auth.models import UserManager as DjangoUserManager + +if TYPE_CHECKING: + from .models import User # noqa: F401 + + +class UserManager(DjangoUserManager["User"]): + """Custom manager for the User model.""" + + def _create_user(self, email: str, password: str | None, **extra_fields): + """ + Create and save a user with the given email and password. + """ + if not email: + msg = "The given email must be set" + raise ValueError(msg) + email = self.normalize_email(email) + user = self.model(email=email, **extra_fields) + user.password = make_password(password) + user.save(using=self._db) + return user + + def create_user(self, email: str, password: str | None = None, **extra_fields): # type: ignore[override] + extra_fields.setdefault("is_staff", False) + extra_fields.setdefault("is_superuser", False) + return self._create_user(email, password, **extra_fields) + + def create_superuser(self, email: str, password: str | None = None, **extra_fields): # type: ignore[override] + extra_fields.setdefault("is_staff", True) + extra_fields.setdefault("is_superuser", True) + + if extra_fields.get("is_staff") is not True: + msg = "Superuser must have is_staff=True." + raise ValueError(msg) + if extra_fields.get("is_superuser") is not True: + msg = "Superuser must have is_superuser=True." + raise ValueError(msg) + + return self._create_user(email, password, **extra_fields) diff --git a/alphabetlearning/users/migrations/0001_initial.py b/alphabetlearning/users/migrations/0001_initial.py new file mode 100644 index 0000000..20b1233 --- /dev/null +++ b/alphabetlearning/users/migrations/0001_initial.py @@ -0,0 +1,118 @@ +import django.contrib.auth.models +import django.contrib.auth.validators +import django.utils.timezone +from django.db import migrations +from django.db import models + +import alphabetlearning.users.models + + +class Migration(migrations.Migration): + initial = True + + dependencies = [ + ("auth", "0012_alter_user_first_name_max_length"), + ] + + operations = [ + migrations.CreateModel( + name="User", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ("password", models.CharField(max_length=128, verbose_name="password")), + ( + "last_login", + models.DateTimeField( + blank=True, + null=True, + verbose_name="last login", + ), + ), + ( + "is_superuser", + models.BooleanField( + default=False, + help_text="Designates that this user has all permissions without explicitly assigning them.", + verbose_name="superuser status", + ), + ), + ( + "email", + models.EmailField( + unique=True, + max_length=254, + verbose_name="email address", + ), + ), + ( + "is_staff", + models.BooleanField( + default=False, + help_text="Designates whether the user can log into this admin site.", + verbose_name="staff status", + ), + ), + ( + "is_active", + models.BooleanField( + default=True, + help_text="Designates whether this user should be treated as active. Unselect this instead of deleting accounts.", + verbose_name="active", + ), + ), + ( + "date_joined", + models.DateTimeField( + default=django.utils.timezone.now, + verbose_name="date joined", + ), + ), + ( + "name", + models.CharField( + blank=True, + max_length=255, + verbose_name="Name of User", + ), + ), + ( + "groups", + models.ManyToManyField( + blank=True, + help_text="The groups this user belongs to. A user will get all permissions granted to each of their groups.", + related_name="user_set", + related_query_name="user", + to="auth.Group", + verbose_name="groups", + ), + ), + ( + "user_permissions", + models.ManyToManyField( + blank=True, + help_text="Specific permissions for this user.", + related_name="user_set", + related_query_name="user", + to="auth.Permission", + verbose_name="user permissions", + ), + ), + ], + options={ + "verbose_name": "user", + "verbose_name_plural": "users", + "abstract": False, + }, + managers=[ + ("objects", alphabetlearning.users.models.UserManager()), + ], + ), + ] diff --git a/alphabetlearning/users/migrations/__init__.py b/alphabetlearning/users/migrations/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/alphabetlearning/users/migrations/__init__.py diff --git a/alphabetlearning/users/models.py b/alphabetlearning/users/models.py new file mode 100644 index 0000000..f536bc7 --- /dev/null +++ b/alphabetlearning/users/models.py @@ -0,0 +1,38 @@ +from typing import ClassVar + +from django.contrib.auth.models import AbstractUser +from django.db.models import CharField +from django.db.models import EmailField +from django.urls import reverse +from django.utils.translation import gettext_lazy as _ + +from .managers import UserManager + + +class User(AbstractUser): + """ + Default custom user model for pyblackbird-cc. + If adding fields that need to be filled at user signup, + check forms.SignupForm and forms.SocialSignupForms accordingly. + """ + + # First and last name do not cover name patterns around the globe + name = CharField(_("Name of User"), blank=True, max_length=255) + first_name = None # type: ignore[assignment] + last_name = None # type: ignore[assignment] + email = EmailField(_("email address"), unique=True) + username = None # type: ignore[assignment] + + USERNAME_FIELD = "email" + REQUIRED_FIELDS = [] + + objects: ClassVar[UserManager] = UserManager() + + def get_absolute_url(self) -> str: + """Get URL for user's detail view. + + Returns: + str: URL for user detail. + + """ + return reverse("users:detail", kwargs={"pk": self.id}) diff --git a/alphabetlearning/users/tasks.py b/alphabetlearning/users/tasks.py new file mode 100644 index 0000000..ca51cd7 --- /dev/null +++ b/alphabetlearning/users/tasks.py @@ -0,0 +1,9 @@ +from celery import shared_task + +from .models import User + + +@shared_task() +def get_users_count(): + """A pointless Celery task to demonstrate usage.""" + return User.objects.count() diff --git a/alphabetlearning/users/tests/__init__.py b/alphabetlearning/users/tests/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/alphabetlearning/users/tests/__init__.py diff --git a/alphabetlearning/users/tests/factories.py b/alphabetlearning/users/tests/factories.py new file mode 100644 index 0000000..c0e94a3 --- /dev/null +++ b/alphabetlearning/users/tests/factories.py @@ -0,0 +1,40 @@ +from collections.abc import Sequence +from typing import Any + +from factory import Faker +from factory import post_generation +from factory.django import DjangoModelFactory + +from alphabetlearning.users.models import User + + +class UserFactory(DjangoModelFactory): + email = Faker("email") + name = Faker("name") + + @post_generation + def password(self, create: bool, extracted: Sequence[Any], **kwargs): # noqa: FBT001 + password = ( + extracted + if extracted + else Faker( + "password", + length=42, + special_chars=True, + digits=True, + upper_case=True, + lower_case=True, + ).evaluate(None, None, extra={"locale": None}) + ) + self.set_password(password) + + @classmethod + def _after_postgeneration(cls, instance, create, results=None): + """Save again the instance if creating and at least one hook ran.""" + if create and results and not cls._meta.skip_postgeneration_save: + # Some post-generation hooks ran, and may have modified us. + instance.save() + + class Meta: + model = User + django_get_or_create = ["email"] diff --git a/alphabetlearning/users/tests/test_admin.py b/alphabetlearning/users/tests/test_admin.py new file mode 100644 index 0000000..bd7296f --- /dev/null +++ b/alphabetlearning/users/tests/test_admin.py @@ -0,0 +1,65 @@ +import contextlib +from http import HTTPStatus +from importlib import reload + +import pytest +from django.contrib import admin +from django.contrib.auth.models import AnonymousUser +from django.urls import reverse +from pytest_django.asserts import assertRedirects + +from alphabetlearning.users.models import User + + +class TestUserAdmin: + def test_changelist(self, admin_client): + url = reverse("admin:users_user_changelist") + response = admin_client.get(url) + assert response.status_code == HTTPStatus.OK + + def test_search(self, admin_client): + url = reverse("admin:users_user_changelist") + response = admin_client.get(url, data={"q": "test"}) + assert response.status_code == HTTPStatus.OK + + def test_add(self, admin_client): + url = reverse("admin:users_user_add") + response = admin_client.get(url) + assert response.status_code == HTTPStatus.OK + + response = admin_client.post( + url, + data={ + "email": "new-admin@example.com", + "password1": "My_R@ndom-P@ssw0rd", + "password2": "My_R@ndom-P@ssw0rd", + }, + ) + assert response.status_code == HTTPStatus.FOUND + assert User.objects.filter(email="new-admin@example.com").exists() + + def test_view_user(self, admin_client): + user = User.objects.get(email="admin@example.com") + url = reverse("admin:users_user_change", kwargs={"object_id": user.pk}) + response = admin_client.get(url) + assert response.status_code == HTTPStatus.OK + + @pytest.fixture() + def _force_allauth(self, settings): + settings.DJANGO_ADMIN_FORCE_ALLAUTH = True + # Reload the admin module to apply the setting change + import alphabetlearning.users.admin as users_admin + + with contextlib.suppress(admin.sites.AlreadyRegistered): + reload(users_admin) + + @pytest.mark.django_db() + @pytest.mark.usefixtures("_force_allauth") + def test_allauth_login(self, rf, settings): + request = rf.get("/fake-url") + request.user = AnonymousUser() + response = admin.site.login(request) + + # The `admin` login view should redirect to the `allauth` login view + target_url = reverse(settings.LOGIN_URL) + "?next=" + request.path + assertRedirects(response, target_url, fetch_redirect_response=False) diff --git a/alphabetlearning/users/tests/test_forms.py b/alphabetlearning/users/tests/test_forms.py new file mode 100644 index 0000000..9ab1f7e --- /dev/null +++ b/alphabetlearning/users/tests/test_forms.py @@ -0,0 +1,35 @@ +"""Module for all Form Tests.""" + +from django.utils.translation import gettext_lazy as _ + +from alphabetlearning.users.forms import UserAdminCreationForm +from alphabetlearning.users.models import User + + +class TestUserAdminCreationForm: + """ + Test class for all tests related to the UserAdminCreationForm + """ + + def test_username_validation_error_msg(self, user: User): + """ + Tests UserAdminCreation Form's unique validator functions correctly by testing: + 1) A new user with an existing username cannot be added. + 2) Only 1 error is raised by the UserCreation Form + 3) The desired error message is raised + """ + + # The user already exists, + # hence cannot be created. + form = UserAdminCreationForm( + { + "email": user.email, + "password1": user.password, + "password2": user.password, + }, + ) + + assert not form.is_valid() + assert len(form.errors) == 1 + assert "email" in form.errors + assert form.errors["email"][0] == _("This email has already been taken.") diff --git a/alphabetlearning/users/tests/test_managers.py b/alphabetlearning/users/tests/test_managers.py new file mode 100644 index 0000000..1e5a5e3 --- /dev/null +++ b/alphabetlearning/users/tests/test_managers.py @@ -0,0 +1,55 @@ +from io import StringIO + +import pytest +from django.core.management import call_command + +from alphabetlearning.users.models import User + + +@pytest.mark.django_db() +class TestUserManager: + def test_create_user(self): + user = User.objects.create_user( + email="john@example.com", + password="something-r@nd0m!", # noqa: S106 + ) + assert user.email == "john@example.com" + assert not user.is_staff + assert not user.is_superuser + assert user.check_password("something-r@nd0m!") + assert user.username is None + + def test_create_superuser(self): + user = User.objects.create_superuser( + email="admin@example.com", + password="something-r@nd0m!", # noqa: S106 + ) + assert user.email == "admin@example.com" + assert user.is_staff + assert user.is_superuser + assert user.username is None + + def test_create_superuser_username_ignored(self): + user = User.objects.create_superuser( + email="test@example.com", + password="something-r@nd0m!", # noqa: S106 + ) + assert user.username is None + + +@pytest.mark.django_db() +def test_createsuperuser_command(): + """Ensure createsuperuser command works with our custom manager.""" + out = StringIO() + command_result = call_command( + "createsuperuser", + "--email", + "henry@example.com", + interactive=False, + stdout=out, + ) + + assert command_result is None + assert out.getvalue() == "Superuser created successfully.\n" + user = User.objects.get(email="henry@example.com") + assert not user.has_usable_password() diff --git a/alphabetlearning/users/tests/test_models.py b/alphabetlearning/users/tests/test_models.py new file mode 100644 index 0000000..502536f --- /dev/null +++ b/alphabetlearning/users/tests/test_models.py @@ -0,0 +1,5 @@ +from alphabetlearning.users.models import User + + +def test_user_get_absolute_url(user: User): + assert user.get_absolute_url() == f"/users/{user.pk}/" diff --git a/alphabetlearning/users/tests/test_tasks.py b/alphabetlearning/users/tests/test_tasks.py new file mode 100644 index 0000000..92f0e8a --- /dev/null +++ b/alphabetlearning/users/tests/test_tasks.py @@ -0,0 +1,17 @@ +import pytest +from celery.result import EagerResult + +from alphabetlearning.users.tasks import get_users_count +from alphabetlearning.users.tests.factories import UserFactory + +pytestmark = pytest.mark.django_db + + +def test_user_count(settings): + """A basic test to execute the get_users_count Celery task.""" + batch_size = 3 + UserFactory.create_batch(batch_size) + settings.CELERY_TASK_ALWAYS_EAGER = True + task_result = get_users_count.delay() + assert isinstance(task_result, EagerResult) + assert task_result.result == batch_size diff --git a/alphabetlearning/users/tests/test_urls.py b/alphabetlearning/users/tests/test_urls.py new file mode 100644 index 0000000..e70dc03 --- /dev/null +++ b/alphabetlearning/users/tests/test_urls.py @@ -0,0 +1,19 @@ +from django.urls import resolve +from django.urls import reverse + +from alphabetlearning.users.models import User + + +def test_detail(user: User): + assert reverse("users:detail", kwargs={"pk": user.pk}) == f"/users/{user.pk}/" + assert resolve(f"/users/{user.pk}/").view_name == "users:detail" + + +def test_update(): + assert reverse("users:update") == "/users/~update/" + assert resolve("/users/~update/").view_name == "users:update" + + +def test_redirect(): + assert reverse("users:redirect") == "/users/~redirect/" + assert resolve("/users/~redirect/").view_name == "users:redirect" diff --git a/alphabetlearning/users/tests/test_views.py b/alphabetlearning/users/tests/test_views.py new file mode 100644 index 0000000..27e6064 --- /dev/null +++ b/alphabetlearning/users/tests/test_views.py @@ -0,0 +1,101 @@ +from http import HTTPStatus + +import pytest +from django.conf import settings +from django.contrib import messages +from django.contrib.auth.models import AnonymousUser +from django.contrib.messages.middleware import MessageMiddleware +from django.contrib.sessions.middleware import SessionMiddleware +from django.http import HttpRequest +from django.http import HttpResponseRedirect +from django.test import RequestFactory +from django.urls import reverse +from django.utils.translation import gettext_lazy as _ + +from alphabetlearning.users.forms import UserAdminChangeForm +from alphabetlearning.users.models import User +from alphabetlearning.users.tests.factories import UserFactory +from alphabetlearning.users.views import UserRedirectView +from alphabetlearning.users.views import UserUpdateView +from alphabetlearning.users.views import user_detail_view + +pytestmark = pytest.mark.django_db + + +class TestUserUpdateView: + """ + TODO: + extracting view initialization code as class-scoped fixture + would be great if only pytest-django supported non-function-scoped + fixture db access -- this is a work-in-progress for now: + https://github.com/pytest-dev/pytest-django/pull/258 + """ + + def dummy_get_response(self, request: HttpRequest): + return None + + def test_get_success_url(self, user: User, rf: RequestFactory): + view = UserUpdateView() + request = rf.get("/fake-url/") + request.user = user + + view.request = request + assert view.get_success_url() == f"/users/{user.pk}/" + + def test_get_object(self, user: User, rf: RequestFactory): + view = UserUpdateView() + request = rf.get("/fake-url/") + request.user = user + + view.request = request + + assert view.get_object() == user + + def test_form_valid(self, user: User, rf: RequestFactory): + view = UserUpdateView() + request = rf.get("/fake-url/") + + # Add the session/message middleware to the request + SessionMiddleware(self.dummy_get_response).process_request(request) + MessageMiddleware(self.dummy_get_response).process_request(request) + request.user = user + + view.request = request + + # Initialize the form + form = UserAdminChangeForm() + form.cleaned_data = {} + form.instance = user + view.form_valid(form) + + messages_sent = [m.message for m in messages.get_messages(request)] + assert messages_sent == [_("Information successfully updated")] + + +class TestUserRedirectView: + def test_get_redirect_url(self, user: User, rf: RequestFactory): + view = UserRedirectView() + request = rf.get("/fake-url") + request.user = user + + view.request = request + assert view.get_redirect_url() == f"/users/{user.pk}/" + + +class TestUserDetailView: + def test_authenticated(self, user: User, rf: RequestFactory): + request = rf.get("/fake-url/") + request.user = UserFactory() + response = user_detail_view(request, pk=user.pk) + + assert response.status_code == HTTPStatus.OK + + def test_not_authenticated(self, user: User, rf: RequestFactory): + request = rf.get("/fake-url/") + request.user = AnonymousUser() + response = user_detail_view(request, pk=user.pk) + login_url = reverse(settings.LOGIN_URL) + + assert isinstance(response, HttpResponseRedirect) + assert response.status_code == HTTPStatus.FOUND + assert response.url == f"{login_url}?next=/fake-url/" diff --git a/alphabetlearning/users/urls.py b/alphabetlearning/users/urls.py new file mode 100644 index 0000000..56c246c --- /dev/null +++ b/alphabetlearning/users/urls.py @@ -0,0 +1,12 @@ +from django.urls import path + +from .views import user_detail_view +from .views import user_redirect_view +from .views import user_update_view + +app_name = "users" +urlpatterns = [ + path("~redirect/", view=user_redirect_view, name="redirect"), + path("~update/", view=user_update_view, name="update"), + path("<int:pk>/", view=user_detail_view, name="detail"), +] diff --git a/alphabetlearning/users/views.py b/alphabetlearning/users/views.py new file mode 100644 index 0000000..215daa3 --- /dev/null +++ b/alphabetlearning/users/views.py @@ -0,0 +1,45 @@ +from django.contrib.auth.mixins import LoginRequiredMixin +from django.contrib.messages.views import SuccessMessageMixin +from django.urls import reverse +from django.utils.translation import gettext_lazy as _ +from django.views.generic import DetailView +from django.views.generic import RedirectView +from django.views.generic import UpdateView + +from alphabetlearning.users.models import User + + +class UserDetailView(LoginRequiredMixin, DetailView): + model = User + slug_field = "id" + slug_url_kwarg = "id" + + +user_detail_view = UserDetailView.as_view() + + +class UserUpdateView(LoginRequiredMixin, SuccessMessageMixin, UpdateView): + model = User + fields = ["name"] + success_message = _("Information successfully updated") + + def get_success_url(self): + # for mypy to know that the user is authenticated + assert self.request.user.is_authenticated + return self.request.user.get_absolute_url() + + def get_object(self): + return self.request.user + + +user_update_view = UserUpdateView.as_view() + + +class UserRedirectView(LoginRequiredMixin, RedirectView): + permanent = False + + def get_redirect_url(self): + return reverse("users:detail", kwargs={"pk": self.request.user.pk}) + + +user_redirect_view = UserRedirectView.as_view() |