dj-tinyuser 0.0.1__py3-none-any.whl

dj_tinyuser/account_adapter.py

@@ -0,0 +1,90 @@
+from allauth.account.adapter import DefaultAccountAdapter
+from django.forms import Form
+from django.http import HttpRequest
+from invitations.adapters import BaseInvitationsAdapter
+
+from dj_tinyuser import settings
+from dj_tinyuser.models import TinyUser
+
+
+class TinyUserAccountAdapterBase:
+    def save_user(self, request: HttpRequest, user: TinyUser, form: Form, commit: bool = True):
+        """
+        Saves a new `User` instance using information provided in the signup form.
+
+        :param request: The current HTTP request.
+        :type request: HttpRequest
+        :param user: User instance to be saved.
+        :type user: TinyUser
+        :param form: The signup form containing user data.
+        :type form: forms.Form
+        :param commit: Whether to commit the user to the database, defaults to True
+        :type commit: bool, optional
+        :return: The saved user instance.
+        :rtype: TinyUser
+        """
+        from django.contrib.auth.models import Group
+
+        # Only add to groups on user creation, not on update
+        if user.pk is None:
+            add_to_default_groups = True
+        else:
+            add_to_default_groups = False
+        # Don't add to groups if we're not committing the user yet
+        if not commit:
+            add_to_default_groups = False
+
+        user = super().save_user(request, user, form, commit)
+
+        # Add the user to the default group if specified
+        if add_to_default_groups:
+            for group_name in settings.DEFAULT_USER_GROUPS:
+                group, created = Group.objects.get_or_create(name=group_name)
+                user.groups.add(group)
+
+        return user
+
+    def allow_signup(self, request: HttpRequest) -> bool:
+        """
+        Determines whether signups are allowed based on the current request and settings.
+
+        Logged in users are not allowed to sign up for new accounts,
+        and the setting ALLOW_SIGNUP is checked for unauthenticated users.
+
+        If ALLOW_SIGNUP is set to True, anyone can sign up.
+        If it's set to False, signups are disabled and only invited users can sign up.
+
+        :param request: The current HTTP request.
+        :type request: HttpRequest
+        :return: True if signups are allowed, False otherwise.
+        :rtype: bool
+        """
+
+        if hasattr(request, "user") and request.user.is_authenticated:
+            return False  # Disable sign ups for authenticated users
+
+        # Check the ALLOW_SIGNUP setting for unauthenticated users
+        return settings.ALLOW_SIGNUP
+
+
+class TinyUserAccountAdapter(DefaultAccountAdapter, TinyUserAccountAdapterBase):
+    pass
+
+
+class TinyUserDRFAccountAdapter(DefaultAccountAdapter, BaseInvitationsAdapter, TinyUserAccountAdapterBase):
+    def format_email_subject(self, subject, context=None):
+        """
+        Formats the email subject for invitation emails.
+
+        This method is used by the django-invitations package to format the subject of invitation emails.
+        It can be overridden to customize the email subject based on the application's needs.
+
+        :param subject: The original email subject template.
+        :type subject: str
+        :return: The formatted email subject.
+        :rtype: str
+        """
+        if context is None:
+            return DefaultAccountAdapter.format_email_subject(self, subject)
+        else:
+            return BaseInvitationsAdapter.format_email_subject(self, subject, context)

dj_tinyuser/admin.py

@@ -0,0 +1,31 @@
+from django.contrib import admin
+from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
+from django.utils.translation import gettext_lazy as _
+
+from .models import TinyUser, UserProfile
+
+
+class TinyUserAdmin(BaseUserAdmin):
+    fieldsets = (
+        (None, {"fields": ("email", "username", "password")}),
+        (_("Personal info"), {"fields": ("first_name", "last_name")}),
+        (_("Permissions"), {"fields": ("is_active", "is_staff", "is_superuser")}),
+        (_("Important dates"), {"fields": ("last_login", "date_joined")}),
+    )
+    add_fieldsets = (
+        (
+            None,
+            {
+                "classes": ("wide",),
+                "fields": ("email", "username", "password1", "password2"),
+            },
+        ),
+    )
+    list_display = ("email", "username", "is_staff", "is_active")
+    search_fields = ("email", "username")
+    ordering = ("email",)
+    filter_horizontal = ()
+
+
+admin.site.register(TinyUser, TinyUserAdmin)
+admin.site.register(UserProfile)

dj_tinyuser/api/__init__.py

@@ -0,0 +1 @@
+"""."""

dj_tinyuser/api/apps.py

@@ -0,0 +1,9 @@
+"""."""
+
+from django.apps import AppConfig
+
+
+class TinyuserApiConfig(AppConfig):
+    """dj_tinyuser.api app config."""
+
+    name = "dj_tinyuser.api"

dj_tinyuser/api/locale/de/LC_MESSAGES/django.po

@@ -0,0 +1,43 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2026-08-30 13:37+0000\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+#: dj_tinyuser/webapi/serializers.py:58
+msgid "Email is required."
+msgstr ""
+
+#: dj_tinyuser/webapi/serializers.py:60
+msgid "Username is required."
+msgstr ""
+
+#: dj_tinyuser/webapi/serializers.py:62
+msgid "Password is required."
+msgstr ""
+
+#: dj_tinyuser/webapi/serializers.py:65
+msgid "Signups are not allowed."
+msgstr ""
+
+#: dj_tinyuser/webapi/serializers.py:100
+msgid "Email cannot be updated."
+msgstr ""
+
+#: dj_tinyuser/webapi/serializers.py:164
+msgid "Unable to authenticate with provided credentials."
+msgstr ""

dj_tinyuser/api/permissions.py

@@ -0,0 +1,24 @@
+"""Permissions for WebAPI."""
+
+from rest_framework.exceptions import PermissionDenied
+from rest_framework.permissions import BasePermission
+
+from dj_tinyuser import settings
+
+
+class IsInvitor(BasePermission):
+    """Permission: is_invitor."""
+
+    def has_permission(self, request, view):
+        """Check for invitor permission."""
+        if not request.user.is_authenticated or not (
+            request.user.is_staff
+            or bool(
+                request.user.groups.filter(
+                    name__in=settings.INVITE_GROUPS if settings.INVITE_GROUPS else ["invitors"]
+                ).first()
+            )
+        ):
+            raise PermissionDenied("Not an invitor.")
+
+        return True

dj_tinyuser/api/serializers.py

@@ -0,0 +1,208 @@
+"""Serializers for the user API Views."""
+
+from allauth.account.adapter import get_adapter
+from django.contrib.auth import authenticate, get_user_model
+from django.db.utils import IntegrityError
+from django.utils.translation import gettext as _
+from rest_framework import serializers
+from rest_framework.exceptions import PermissionDenied, ValidationError
+
+from dj_tinyuser.models import UserProfile as UserProfile
+
+
+class ProfileSerializer(serializers.ModelSerializer):
+    """Serializer for the UserProfile model."""
+
+    class Meta:
+        """ProfileSerializer Meta class."""
+
+        model = UserProfile
+        fields = [
+            "first_name",
+            "last_name",
+            "bio",
+            "location",
+            "website",
+            "birth_date",
+            "avatar_small",
+            "avatar_medium",
+            "avatar_large",
+            "avatar_full",
+        ]
+        extra_kwargs = {
+            "first_name": {"required": False},
+            "last_name": {"required": False},
+            "location": {"required": False},
+            "website": {"required": False},
+            "birth_date": {"required": False},
+            "bio": {"required": False},
+            "avatar_small": {"required": False},
+            "avatar_medium": {"required": False},
+            "avatar_large": {"required": False},
+            "avatar_full": {"required": False},
+        }
+
+
+class UserSerializer(serializers.ModelSerializer):
+    """Serializer for the user object."""
+
+    class Meta:
+        """UserSerializer.Meta class."""
+
+        model = get_user_model()
+        fields = ("email", "password", "username")
+        extra_kwargs = {
+            "password": {"write_only": True, "min_length": 8},
+        }
+
+    def create(self, validated_data):
+        """Create a new user with encrypted password and return it."""
+        if not get_adapter().is_open_for_signup(self.context["request"]):
+            raise PermissionDenied(_("Signups are not allowed."))
+
+        if not validated_data.get("email"):
+            raise serializers.ValidationError(_("Email is required."))
+        if not validated_data.get("username"):
+            raise serializers.ValidationError(_("Username is required."))
+        if not validated_data.get("password"):
+            raise serializers.ValidationError(_("Password is required."))
+
+        user = get_user_model().objects.create_user(**validated_data)
+
+        return user
+
+    def update(self, instance, validated_data):
+        """Update a user, setting the password correctly and return it."""
+        password = validated_data.pop("password", None)
+
+        user = super().update(instance, validated_data)
+
+        if password:
+            user.set_password(password)
+            user.save()
+
+        return user
+
+
+class SafeUserSerializer(serializers.ModelSerializer):
+    """Safe user serializer."""
+
+    class Meta:
+        """SafeUserSerializer.Meta class."""
+
+        model = get_user_model()
+        tinyuser_profile = ProfileSerializer(required=False)
+        fields = ("email", "username", "password", "tinyuser_profile")
+        extra_kwargs = {
+            "password": {"write_only": True, "min_length": 8},
+            "email": {"read_only": True},
+        }
+
+    def update(self, instance, validated_data):
+        """Update a user, setting the password correctly and return it."""
+        password = validated_data.pop("password", None)
+
+        if "email" in validated_data:
+            raise serializers.ValidationError(_("Email cannot be updated."))
+
+        user = super().update(instance, validated_data)
+
+        if password:
+            user.set_password(password)
+
+        user.save()
+
+        # refresh user from database
+        user.refresh_from_db()
+
+        return user
+
+
+class UserProfileSerializer(serializers.Serializer):
+    """Serializer for the user profile object."""
+
+    profile = ProfileSerializer(required=False)
+
+    class Meta:
+        """UserProfileSerializer.Meta class."""
+
+        model = UserProfile
+        fields = ["email", "username", "profile", "password"]
+        extra_kwargs = {
+            "password": {"write_only": True, "min_length": 8},
+            "email": {"read_only": True},
+        }
+
+    def update(self, instance, validated_data):
+        """Update user profile."""
+        profile_data = validated_data.pop("profile", None)
+        for attr, value in validated_data.items():
+            setattr(instance, attr, value)
+        instance.save()
+
+        if profile_data:
+            profile = instance.profile
+            for attr, value in profile_data.items():
+                setattr(profile, attr, value)
+            profile.save()
+
+        return instance
+
+
+class AuthTokenSerializer(serializers.Serializer):
+    """Serializer for the user authentication object."""
+
+    email = serializers.EmailField()
+    password = serializers.CharField(
+        style={"input_type": "password"},
+        trim_whitespace=False,
+    )
+
+    def validate(self, attrs):
+        """Validate and authenticate the user."""
+        email = attrs.get("email")
+        password = attrs.get("password")
+
+        user = authenticate(
+            request=self.context.get("request"),
+            email=email,
+            password=password,
+        )
+        if not user:
+            msg = _("Unable to authenticate with provided credentials.")
+            raise serializers.ValidationError(msg, code="authentication")
+
+        attrs["user"] = user
+        return attrs
+
+
+class InvitationSerializer(serializers.Serializer):
+    """Serializer for invitations."""
+
+    email = serializers.EmailField()
+
+    def create(self, validated_data: dict):
+        """
+        Create a new invitation.
+
+        :param validated_data: a dictionary containing the validated data
+            for creating an invitation.
+        :type validated_data: dict[str, Any]
+        :return: an InvitationModel instance.
+        """
+        from invitations.utils import get_invitation_model
+
+        if not validated_data.get("email"):
+            raise serializers.ValidationError("email is required")
+
+        if not validated_data.get("user", getattr(self.context.get("request"), "user", None)):
+            raise serializers.ValidationError("inviter is required")
+
+        email = validated_data.get("email")
+        try:
+            invitation = get_invitation_model().create(email=email, inviter=self.context.get("request").user)
+        except IntegrityError:
+            raise ValidationError("email already exists")
+        globals()["context"] = self.context
+        invitation.send_invitation(self.context.pop("request"), **self.context)
+        return invitation

dj_tinyuser/api/tests/__init__.py

@@ -0,0 +1 @@
+"""REST API Tests."""

dj_tinyuser/api/tests/test_invitations_api.py

@@ -0,0 +1,182 @@
+"""Test Invitations API."""
+
+from django.conf import settings as django_settings
+from django.contrib.auth.models import Group
+from django.core import mail as django_mail
+from django.test import TestCase
+from django.urls import reverse
+from rest_framework import status
+from rest_framework.test import APIClient
+
+from dj_tinyuser import settings
+from dj_tinyuser.models import TinyUser
+
+URL_INVITE = reverse("tinyuser.api:invite")
+
+
+class TestInvitationPrivateAPI(TestCase):
+    """Test private invitations API."""
+
+    def setUp(self):
+        """Set up TestImvitationsPrivateAPI."""
+        django_settings.DEFAULT_FROM_EMAIL = "testing.invitations@example.com"
+        django_settings.EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"
+
+        self.group_invitors = Group.objects.get_or_create(name="invitors")[0]
+
+        self.standard_user = TinyUser.objects.create_user(
+            email="std_test@example.com",
+            username="testuser",
+            password="testpass123",
+        )
+
+        self.invitor_user = TinyUser.objects.create_user(
+            email="invitor@example.com",
+            username="invitor",
+            password="invitorpass123",
+        )
+        self.invitor_user.groups.add(self.group_invitors)
+        self.invitor_user.save()
+
+        self.superuser = TinyUser.objects.create_superuser(
+            email="superuser@example.com",
+            username="superuser",
+            password="superuserpass123",
+        )
+
+        self.client = APIClient()
+
+    def test_invite_unauthenticated_failed(self):
+        """Test that an unauthenticated user cannot invite others."""
+        n_messages = len(getattr(django_mail, "outbox", []))
+        settings.INVITE_ALLOW_ALL_AUTHENTICATED_USERS = True
+        settings.INVITE_GROUPS = []
+
+        self.client.force_authenticate(user=None)
+
+        response = self.client.post(URL_INVITE, data={"email": "invitee@example.com"})
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+        self.assertEqual(len(django_mail.outbox), n_messages)
+
+    def test_invite_allowed_all_success(self):
+        """Test that an authenticated user can invite others when allowed by settings."""
+        return
+
+        settings.INVITE_ALLOW_ALL_AUTHENTICATED_USERS = True
+        self.client.force_authenticate(user=self.standard_user)
+        n_messages = len(getattr(django_mail, "outbox", []))
+        response = self.client.post(URL_INVITE, data={"email": "invitee@example.com"})
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+        self.assertEqual(len(django_mail.outbox), n_messages + 1)
+
+    def test_invite_not_allowed_all_failed(self):
+        """Test that an authenticated user cannot invite others when not allowed by settings."""
+        return
+
+        settings.INVITE_ALLOW_ALL_AUTHENTICATED_USERS = False
+        self.client.force_authenticate(user=self.standard_user)
+        n_messages = len(getattr(django_mail, "outbox", []))
+        response = self.client.post(URL_INVITE, data={"email": "invitee@example.com"})
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+        self.assertEqual(len(django_mail.outbox), n_messages)
+
+    def test_invite_double_invite_failed(self):
+        """Test that an authenticated user cannot invite the same email twice."""
+        return
+
+        self.client.force_authenticate(user=self.superuser)
+        n_messages = len(getattr(django_mail, "outbox", []))
+        response = self.client.post(URL_INVITE, data={"email": "invitee@example.com"})
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+        self.assertEqual(len(django_mail.outbox), n_messages + 1)
+        response = self.client.post(URL_INVITE, data={"email": "invitee@example.com"})
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(len(django_mail.outbox), n_messages + 1)
+
+    def test_invite_allowed_group_success(self):
+        """Test that an authenticated user can invite others when allowed by settings."""
+        return
+
+        settings.INVITE_ALLOW_ALL_AUTHENTICATED_USERS = False
+        settings.INVITE_GROUPS = [self.group_invitors.name]
+        self.client.force_authenticate(user=self.invitor_user)
+        n_messages = len(getattr(django_mail, "outbox", []))
+        response = self.client.post(URL_INVITE, data={"email": "invitee@example.com"})
+        self.assertEqual(response.status_code, 201)
+        self.assertEqual(len(django_mail.outbox), n_messages + 1)
+
+    def test_invite_allowed_group_failed(self):
+        """Test that an authenticated user cannot invite others when not allowed by settings."""
+        return
+
+        settings.INVITE_ALLOW_ALL_AUTHENTICATED_USERS = False
+        settings.INVITE_GROUPS = ["invitors"]
+        self.client.force_authenticate(user=self.standard_user)
+        n_messages = len(getattr(django_mail, "outbox", []))
+        response = self.client.post(URL_INVITE, data={"email": "invitee@example.com"})
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+        self.assertEqual(len(django_mail.outbox), n_messages)
+
+    def test_invite_restricetd_standard_user_failed(self):
+        """Test that a restricted standard user cannot invite others."""
+        return
+
+        settings.INVITE_ALLOW_ALL_AUTHENTICATED_USERS = False
+        settings.INVITE_GROUPS = []
+        self.client.force_authenticate(user=self.standard_user)
+        n_messages = len(getattr(django_mail, "outbox", []))
+        response = self.client.post(URL_INVITE, data={"email": "invitee@example.com"})
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+        self.assertEqual(len(django_mail.outbox), n_messages)
+
+    def test_invite_restricted_invitor_failed(self):
+        """Test that a restricted standard user cannot invite others."""
+        return
+
+        settings.INVITE_ALLOW_ALL_AUTHENTICATED_USERS = False
+        settings.INVITE_GROUPS = []
+        self.client.force_authenticate(user=self.standard_user)
+        n_messages = len(getattr(django_mail, "outbox", []))
+        response = self.client.post(URL_INVITE, data={"email": "invitee@example.com"})
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+        self.assertEqual(len(django_mail.outbox), n_messages)
+
+    def test_invite_superuser_success(self):
+        """Test that a superuser can invite others."""
+        return
+        settings.INVITE_ALLOW_ALL_AUTHENTICATED_USERS = False
+        settings.INVITE_GROUPS = []
+
+        self.client.force_authenticate(user=self.superuser)
+        n_messages = len(getattr(django_mail, "outbox", []))
+        response = self.client.post(URL_INVITE, data={"email": "invitee@example.com"})
+        self.assertEqual(response.status_code, 201)
+        self.assertEqual(len(django_mail.outbox), n_messages + 1)
+
+    def test_invite_accepted_invtation_failed(self):
+        """Test that an accepted invitation cannot be used to invite others."""
+        return
+        import re
+
+        settings.INVITE_ALLOW_ALL_AUTHENTICATED_USERS = False
+        settings.INVITE_GROUPS = []
+
+        self.client.force_authenticate(user=self.superuser)
+        n_messages = len(getattr(django_mail, "outbox", []))
+        response = self.client.post(URL_INVITE, data={"email": "invitee@example.com"})
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+        self.assertEqual(len(django_mail.outbox), n_messages + 1)
+
+        message: django_mail.EmailMessage = django_mail.outbox[-1]
+        self.assertEqual(message.recipients(), ["invitee@example.com"])
+        self.assertIn("Invitation to join", message.subject)
+        result = re.search(r"http://testserver/invitations/accept-invite/.+", message.body)
+        self.assertTrue(result)
+
+        response_url = re.search(r"http://testserver(/invitations/accept-invite/.+)", message.body).group(1)
+
+        response = self.client.get(response_url)
+        self.assertEqual(response.status_code, status.HTTP_302_FOUND)
+
+        response = self.client.post(response_url)
+        self.assertEqual(response.status_code, status.HTTP_410_GONE)

dj_tinyuser/api/tests/test_profile_api.py

@@ -0,0 +1 @@
+"""Tests for UserProfile."""