django-solomon 0.1.2__py3-none-any.whl

django_solomon/__init__.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+__version__ = version("django_solomon")

django_solomon/admin.py

@@ -0,0 +1,45 @@
+from django.contrib import admin
+from django.utils.translation import gettext_lazy as _
+
+from django_solomon.models import BlacklistedEmail, MagicLink
+
+
+@admin.register(BlacklistedEmail)
+class BlacklistedEmailAdmin(admin.ModelAdmin):
+    """Admin interface for BlacklistedEmail model."""
+
+    list_display = ("email", "reason", "created_at")
+    list_filter = ("created_at",)
+    search_fields = ("email", "reason")
+    date_hierarchy = "created_at"
+
+    fieldsets = (
+        (None, {"fields": ("email", "reason")}),
+        (_("Dates"), {"fields": ("created_at",)}),
+    )
+    readonly_fields = ("created_at",)
+
+
+@admin.register(MagicLink)
+class MagicLinkAdmin(admin.ModelAdmin):
+    """Admin interface for MagicLink model."""
+
+    list_display = ("user", "created_at", "expires_at", "used", "is_valid")
+    list_filter = ("used", "created_at", "expires_at")
+    search_fields = ("user__username", "user__email", "token")
+    readonly_fields = ("id", "token", "created_at", "is_valid")
+    date_hierarchy = "created_at"
+
+    fieldsets = (
+        (None, {"fields": ("id", "user", "token")}),
+        (_("Status"), {"fields": ("used", "is_valid")}),
+        (_("Dates"), {"fields": ("created_at", "expires_at")}),
+    )
+
+    @admin.display(
+        description=_("Valid"),
+        boolean=True,
+    )
+    def is_valid(self, obj: MagicLink) -> bool:
+        """Display if the magic link is valid."""
+        return obj.is_valid

django_solomon/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class DjangoSolomonConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "django_solomon"

django_solomon/backends.py

@@ -0,0 +1,61 @@
+from typing import Any
+
+from django.conf import settings
+from django.contrib.auth.backends import ModelBackend
+from django.http import HttpRequest
+from django.utils.translation import gettext_lazy as _
+
+from django_solomon.models import MagicLink, UserType
+
+
+class MagicLinkBackend(ModelBackend):
+    def authenticate(
+        self,
+        request: HttpRequest | None = None,
+        token: str | None = None,
+        **kwargs: Any,  # noqa: ARG002
+    ) -> UserType | None:
+        """
+        Authenticates a user based on the provided magic link token. This method validates
+        the token, ensures the token is not expired, and checks if the user associated
+        with the token is allowed to login based on their role and the application's
+        settings.
+
+        Args:
+            request (HttpRequest | None): The HTTP request object. Defaults to None.
+                It is used to store error messages in case the authentication fails.
+            token (str | None): A unique string token from the magic link used for
+                authentication. If None, authentication cannot proceed.
+
+        Returns:
+            Any: Returns the authenticated user object if the token is valid and
+                the user is allowed to log in. Returns None if the token is invalid,
+                expired, or if the user is not permitted to log in.
+        """
+        if not token:
+            return None
+
+        magic_link = MagicLink.objects.get_valid_link(token)
+        if not magic_link:
+            if request:
+                request.magic_link_error = _("Invalid or expired magic link")
+            return None
+
+        # Mark the magic link as used
+        magic_link.use()
+
+        user = magic_link.user
+
+        # Check if user is admin and if they are allowed to login
+        if user.is_superuser and not getattr(settings, "SOLOMON_ALLOW_ADMIN_LOGIN", True):
+            if request:
+                request.magic_link_error = _("Admin users are not allowed to login via magic links")
+            return None
+
+        # Check if user is staff (but not admin) and if they are allowed to login
+        if user.is_staff and not user.is_superuser and not getattr(settings, "SOLOMON_ALLOW_STAFF_LOGIN", True):
+            if request:
+                request.magic_link_error = _("Staff users are not allowed to login via magic links")
+            return None
+
+        return user

django_solomon/config.py

@@ -0,0 +1,23 @@
+from django.conf import settings
+
+
+def get_email_text_template():
+    return getattr(settings, "SOLOMON_MAIL_TEXT_TEMPLATE", None) or "django_solomon/email/magic_link.txt"
+
+
+def get_email_mjml_template():
+    return getattr(settings, "SOLOMON_MAIL_MJML_TEMPLATE", None) or "django_solomon/email/magic_link.mjml"
+
+
+def get_login_form_template():
+    return getattr(settings, "SOLOMON_LOGIN_FORM_TEMPLATE", None) or "django_solomon/base/login_form.html"
+
+
+def get_invalid_magic_link_template():
+    return (
+        getattr(settings, "SOLOMON_INVALID_MAGIC_LINK_TEMPLATE", None) or "django_solomon/base/invalid_magic_link.html"
+    )
+
+
+def get_magic_link_sent_template():
+    return getattr(settings, "SOLOMON_MAGIC_LINK_SENT_TEMPLATE", None) or "django_solomon/base/magic_link_sent.html"

django_solomon/forms.py

@@ -0,0 +1,12 @@
+from django import forms
+from django.utils.translation import gettext_lazy as _
+
+
+class MagicLinkForm(forms.Form):
+    """Form for requesting a magic link."""
+
+    email = forms.EmailField(
+        label=_("Email"),
+        max_length=254,
+        widget=forms.EmailInput(attrs={"autocomplete": "email"}),
+    )

django_solomon/locale/de/LC_MESSAGES/django.po

@@ -0,0 +1,27 @@
+# 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: 2023-03-04 23:44+0100\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"
+
+#: config/settings.py:150
+msgid "English"
+msgstr "Englisch"
+
+#: config/settings.py:151
+msgid "German"
+msgstr "Deutsch"

django_solomon/locale/en/LC_MESSAGES/django.po

@@ -0,0 +1,27 @@
+# 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: 2023-03-04 23:44+0100\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"
+
+#: config/settings.py:150
+msgid "English"
+msgstr ""
+
+#: config/settings.py:151
+msgid "German"
+msgstr ""

django_solomon/migrations/0001_initial.py

@@ -0,0 +1,47 @@
+# Generated by Django 5.2 on 2025-04-18 13:46
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='BlacklistedEmail',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('email', models.EmailField(max_length=255, unique=True, verbose_name='Email')),
+                ('reason', models.TextField(blank=True, verbose_name='Reason')),
+                ('created_at', models.DateTimeField(auto_now_add=True, verbose_name='Created at')),
+            ],
+            options={
+                'verbose_name': 'Blacklisted Email',
+                'verbose_name_plural': 'Blacklisted Emails',
+                'ordering': ['-created_at'],
+            },
+        ),
+        migrations.CreateModel(
+            name='MagicLink',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('token', models.CharField(max_length=100, unique=True, verbose_name='Token')),
+                ('created_at', models.DateTimeField(auto_now_add=True, verbose_name='Created at')),
+                ('expires_at', models.DateTimeField(verbose_name='Expires at')),
+                ('used', models.BooleanField(default=False, verbose_name='Used')),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='magic_links', to=settings.AUTH_USER_MODEL, verbose_name='User')),
+            ],
+            options={
+                'verbose_name': 'Magic Link',
+                'verbose_name_plural': 'Magic Links',
+                'ordering': ['-created_at'],
+            },
+        ),
+    ]

django_solomon/models.py

@@ -0,0 +1,133 @@
+from datetime import timedelta
+from typing import Any, TypeVar
+
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.contrib.auth.base_user import AbstractBaseUser
+from django.contrib.auth.tokens import default_token_generator
+from django.db import models
+from django.utils import timezone
+from django.utils.translation import gettext_lazy as _
+
+User = get_user_model()
+UserType = TypeVar("UserType", bound=AbstractBaseUser)
+
+
+class BlacklistedEmail(models.Model):
+    """
+    Model to store blacklisted email addresses.
+
+    These emails will be blocked from using the magic login feature.
+    """
+
+    email = models.EmailField(_("Email"), max_length=255, unique=True)
+    reason = models.TextField(_("Reason"), blank=True)
+    created_at = models.DateTimeField(_("Created at"), auto_now_add=True)
+
+    class Meta:
+        verbose_name = _("Blacklisted Email")
+        verbose_name_plural = _("Blacklisted Emails")
+        ordering = ["-created_at"]
+
+    def __str__(self) -> str:
+        return self.email
+
+
+class MagicLinkManager(models.Manager["MagicLink"]):
+    """
+    Manages the creation and retrieval of MagicLink instances.
+
+    This manager provides utility methods to handle magic links, such as creating a
+    new magic link for a user and retrieving valid magic links based on specific
+    criteria like token, usage status, and expiration date.
+    """
+
+    def create_for_user(self, user: UserType) -> "MagicLink":
+        """
+        Creates a new magic link for a given user. If the setting SOLOMON_ONLY_ONE_LINK_ALLOWED
+        is enabled, marks existing links for the user as used before creating a new one.
+
+        Args:
+            user (UserType): The user for whom the magic link should be created.
+
+        Returns:
+            MagicLink: The newly created magic link instance.
+        """
+        if getattr(settings, "SOLOMON_ONLY_ONE_LINK_ALLOWED", True):
+            self.filter(user=user).update(used=True)
+        return self.create(user=user)
+
+    def get_valid_link(self, token: str) -> "MagicLink":
+        """
+        Returns the first valid magic link that matches the given token.
+
+        A valid magic link is identified by a unique token, marked as unused, and
+        has an expiration date greater than or equal to the current time. The
+        method searches for a link meeting these conditions and returns the first
+        result if found.
+
+        Args:
+            token (str): The unique token used to identify the magic link.
+
+        Returns:
+            MagicLink: An instance of the valid MagicLink, or None if no valid link
+            is found.
+        """
+        return self.filter(token=token, used=False, expires_at__gte=timezone.now()).first()
+
+
+class MagicLink(models.Model):
+    """
+    Model to store magic links for authentication.
+
+    This model supports both the standard User model and custom User models.
+    """
+
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="magic_links", verbose_name=_("User")
+    )
+    token = models.CharField(_("Token"), max_length=100, unique=True)
+    created_at = models.DateTimeField(_("Created at"), auto_now_add=True)
+    expires_at = models.DateTimeField(_("Expires at"))
+    used = models.BooleanField(_("Used"), default=False)
+
+    objects = MagicLinkManager()
+
+    class Meta:
+        verbose_name = _("Magic Link")
+        verbose_name_plural = _("Magic Links")
+        ordering = ["-created_at"]
+
+    def __str__(self) -> str:
+        return f"Magic Link for {self.user}"
+
+    def save(self, *args: Any, **kwargs: Any) -> None:
+        """
+        Saves the instance of the object, ensuring that a token and expiration
+        time are generated and set if not already provided. The token is created
+        using a default token generator, and the expiration time is calculated
+        based on a predefined duration from the settings.
+        """
+        if not self.pk or not self.token:
+            self.token = default_token_generator.make_token(self.user)
+
+        if not self.expires_at:
+            expiration_time = getattr(settings, "SOLOMON_LINK_EXPIRATION", 300)  # seconds
+            self.expires_at = timezone.now() + timedelta(seconds=expiration_time)
+
+        super().save(*args, **kwargs)
+
+    @property
+    def is_expired(self) -> bool:
+        """Check if the magic link has expired."""
+        return self.expires_at < timezone.now()
+
+    @property
+    def is_valid(self) -> bool:
+        """Check if the magic link is valid (not used and not expired)."""
+        return not self.used and not self.is_expired
+
+    def use(self) -> None:
+        """Mark the magic link as used."""
+        self.used = True
+        self.save(update_fields=["used"])

django_solomon/templates/django_solomon/base/invalid_magic_link.html

@@ -0,0 +1,16 @@
+{% extends "base.html" %}
+{% load i18n %}
+
+{% block title %}{% translate "Invalid Magic Link" %}{% endblock %}
+
+{% block content %}
+    <div class="container">
+        <h1>{% translate "Invalid Magic Link" %}</h1>
+        <p>{% translate "The magic link you clicked is invalid or has expired." %}</p>
+        <p>{% translate "Please request a new magic link to log in." %}</p>
+
+        <a href="{% url 'django_solomon:login' %}" class="btn btn-primary">
+            {% translate "Request New Magic Link" %}
+        </a>
+    </div>
+{% endblock content %}

django_solomon/templates/django_solomon/base/login_form.html

@@ -0,0 +1,17 @@
+{% extends "base.html" %}
+{% load i18n %}
+
+{% block title %}{% translate "Magic Link Login" %}{% endblock %}
+
+{% block content %}
+    <div class="container">
+        <h1>{% translate "Magic Link Login" %}</h1>
+        <p>{% translate "Enter your email address to receive a magic link for logging in." %}</p>
+
+        <form method="post">
+            {% csrf_token %}
+            {{ form.as_p }}
+            <button type="submit" class="btn btn-primary">{% translate "Send Magic Link" %}</button>
+        </form>
+    </div>
+{% endblock content %}

django_solomon/templates/django_solomon/base/magic_link_sent.html

@@ -0,0 +1,12 @@
+{% extends "base.html" %}
+{% load i18n %}
+
+{% block title %}{% translate "Magic Link Sent" %}{% endblock %}
+
+{% block content %}
+    <div class="container">
+        <h1>{% translate "Magic Link Sent" %}</h1>
+        <p>{% translate "If an account exists with the email address you provided, we've sent a magic link to that address." %}</p>
+        <p>{% translate "Please check your email and click the link to log in." %}</p>
+    </div>
+{% endblock content %}

django_solomon/templates/django_solomon/email/magic_link.mjml

@@ -0,0 +1,42 @@
+{% load i18n %}
+<mjml>
+    <mj-body>
+        <mj-section>
+            <mj-column>
+                <mj-text>
+                    <p>{% translate "Hello," %}</p>
+
+                    <p>
+                        {% blocktranslate %}
+                        You requested a magic link to log in to your account. Please click the link below
+                        to log in:
+                        {% endblocktranslate %}
+                    </p>
+                </mj-text>
+
+                <mj-button href="{{ magic_link_url }}">{% translate "Click here to log in" %}</mj-button>
+
+                <mj-text>
+                    <p>
+                        {% blocktranslate with expiry_time=expiry_time %}
+                        This link will expire in {{ expiry_time }} minutes. If you did not
+                        request this link, you can safely ignore this email.
+                        {% endblocktranslate %}
+                    </p>
+
+                    <p>
+                        {% translate "Thank you," %}
+                        <br>
+                        {% translate "The Django Solomon Team" %}
+                    </p>
+
+                    <p>
+                        ---
+                        <br>
+                        {% translate "This email was sent by Django Solomon." %}
+                    </p>
+                </mj-text>
+            </mj-column>
+        </mj-section>
+    </mj-body>
+</mjml>

django_solomon/templates/django_solomon/email/magic_link.txt

@@ -0,0 +1,14 @@
+{% load i18n %}
+{% translate "Hello," %}
+
+{% translate "You requested a magic link to log in to your account. Please click the link below to log in:" %}
+
+{{ magic_link_url }}
+
+{% blocktranslate with expiry_time=expiry_time %}This link will expire in {{ expiry_time }} minutes. If you did not request this link, you can safely ignore this email.{% endblocktranslate %}
+
+{% translate "Thank you," %}
+{% translate "The Django Solomon Team" %}
+
+---
+{% translate "This email was sent by Django Solomon." %}

django_solomon/urls.py

@@ -0,0 +1,23 @@
+from django.urls import path
+
+from django_solomon.views import validate_magic_link, magic_link_sent, send_magic_link
+
+app_name = "django_solomon"
+
+urlpatterns = [
+    path(
+        "magic-link/",
+        send_magic_link,
+        name="login",
+    ),
+    path(
+        "magic-link/sent/",
+        magic_link_sent,
+        name="magic_link_sent",
+    ),
+    path(
+        "magic-link/<str:token>/",
+        validate_magic_link,
+        name="validate_magic_link",
+    ),
+]

django_solomon/utilities.py

@@ -0,0 +1,81 @@
+import logging
+
+from django.contrib.auth import get_user_model
+from django.contrib.auth.hashers import make_password
+
+from django_solomon.models import UserType
+
+logger = logging.getLogger(__name__)
+
+
+def get_user_by_email(email: str) -> UserType | None:
+    """
+    Get a user by email.
+
+    This method supports both the standard User model and custom User models
+    by checking if the email field exists on the model.
+
+    Args:
+        email: The email to look up.
+
+    Returns:
+        The user if found, None otherwise.
+    """
+    user_model = get_user_model()
+
+    # Check if the user model has an email field
+    if hasattr(user_model, "EMAIL_FIELD"):
+        email_field = user_model.EMAIL_FIELD
+    else:
+        email_field = "email"
+
+    # Make sure the email field exists on the model
+    if not hasattr(user_model, email_field):
+        logger.warning(f"User model {user_model.__name__} does not have field {email_field}, falling back to 'email'")
+        email_field = "email"
+
+        # Check if the fallback field exists
+        if not hasattr(user_model, email_field):
+            logger.error(f"User model {user_model.__name__} does not have an email field")
+            return None
+
+    # Query for the user
+    try:
+        query = {email_field: email}
+        return user_model.objects.get(**query)
+    except user_model.DoesNotExist:
+        return None
+    except Exception as e:
+        logger.error(f"Error getting user by email: {e}")
+        return None
+
+
+def create_user_from_email(email: str) -> UserType:
+    """
+    Creates a new user with the given email.
+
+    This function uses the email as both the username and email address
+    for the new user.
+
+    Args:
+        email: The email to use for the new user.
+
+    Returns:
+        The newly created user.
+    """
+    user_model = get_user_model()
+
+    # Create the user with email as username
+    user_kwargs = {
+        "username": email,
+        "email": email,
+        "password": make_password(None),
+    }
+
+    # Check if the user model has an email field
+    if hasattr(user_model, "EMAIL_FIELD"):
+        email_field = user_model.EMAIL_FIELD
+        if email_field != "email":
+            user_kwargs[email_field] = email
+
+    return user_model.objects.create_user(**user_kwargs)

django_solomon/views.py

@@ -0,0 +1,141 @@
+import logging
+
+from django.conf import settings
+from django.contrib.auth import get_user_model, authenticate, login
+from django.core.mail import send_mail
+from django.http import HttpRequest, HttpResponse
+from django.shortcuts import redirect, render
+from django.template.loader import render_to_string
+from django.urls import reverse
+from django.utils.translation import gettext_lazy as _
+from mjml import mjml2html
+
+from django_solomon.config import (
+    get_login_form_template,
+    get_invalid_magic_link_template,
+    get_magic_link_sent_template,
+    get_email_text_template,
+    get_email_mjml_template,
+)
+from django_solomon.forms import MagicLinkForm
+from django_solomon.models import BlacklistedEmail, MagicLink
+from django_solomon.utilities import get_user_by_email, create_user_from_email
+
+logger = logging.getLogger(__name__)
+User = get_user_model()
+
+
+def send_magic_link(request: HttpRequest) -> HttpResponse:
+    """
+    Handles the process of sending a magic link to a user via email. A magic link acts as a
+    temporary, secure token allowing the user to authenticate without a password. The endpoint
+    validates incoming requests, checks for blacklisted emails, retrieves a user based on the
+    submitted email, and sends a magic link if the user exists. Supports POST and GET methods.
+
+    Args:
+        request (HttpRequest): The HTTP request object that includes metadata about the request.
+
+    Returns:
+        HttpResponse: A redirect response to the "magic_link_sent" page or renders the form template
+        for sending the magic link.
+    """
+    if request.method == "POST":
+        form = MagicLinkForm(request.POST)
+        if form.is_valid():
+            email = form.cleaned_data["email"]
+
+            # Check if the email is blacklisted
+            if BlacklistedEmail.objects.filter(email=email).exists():
+                logger.info(f"Blocked magic link request for blacklisted email: {email}")
+                return redirect("django_solomon:magic_link_sent")
+
+            # Get user by email
+            user = get_user_by_email(email)
+
+            # Signup unknown users if enabled in settings
+            if not user and getattr(settings, "SOLOMON_CREATE_USER_IF_NOT_FOUND", False):
+                user = create_user_from_email(email)
+
+            # Send magic link if user exists
+            if user:
+                magic_link = MagicLink.objects.create_for_user(user)
+                link_url = request.build_absolute_uri(
+                    reverse(
+                        "django_solomon:validate_magic_link",
+                        kwargs={"token": magic_link.token},
+                    )
+                )
+                # Calculate expiry time in minutes
+                expiry_time = getattr(settings, "SOLOMON_LINK_EXPIRATION", 300) // 60  # Convert seconds to minutes
+
+                context = {
+                    "magic_link_url": link_url,
+                    "expiry_time": expiry_time,
+                }
+
+                text_message = render_to_string(get_email_text_template(), context).strip()
+                html_message = mjml2html(render_to_string(get_email_mjml_template(), context))
+
+                send_mail(
+                    _("Your Magic Link"),
+                    text_message,
+                    getattr(settings, "DEFAULT_FROM_EMAIL", "noreply@example.com"),
+                    [email],
+                    fail_silently=False,
+                    html_message=html_message,
+                )
+
+            return redirect("django_solomon:magic_link_sent")
+    else:
+        form = MagicLinkForm()
+    return render(request, get_login_form_template(), {"form": form})
+
+
+def magic_link_sent(request: HttpRequest) -> HttpResponse:
+    """
+    Renders a page that informs the user a magic link has been sent to their email.
+
+    This view function processes an incoming HTTP request and renders the HTML page
+    to indicate that the magic link email was successfully dispatched.
+
+    Args:
+        request: An HttpRequest object representing the user's request.
+
+    Returns:
+        An HttpResponse object with the rendered "magic_link_sent.html" template.
+    """
+    return render(request, get_magic_link_sent_template())
+
+
+def validate_magic_link(request: HttpRequest, token: str) -> HttpResponse:
+    """
+    Validates a magic link for user authentication in a Django application. If the token is valid, the
+    user is authenticated and logged in. If the token is invalid or expired, an error message is
+    displayed. The function redirects authenticated users to a predetermined success URL.
+
+    Arguments:
+        request: The HTTP request object associated with the current request.
+        token: A string representing the token provided in the magic link.
+
+    Returns:
+        HttpResponse: An HTTP response redirecting the user to the success URL upon successful
+        authentication, or rendering an error page if authentication fails.
+    """
+    user = authenticate(request=request, token=token)
+
+    if not user:
+        # Get the error message from the request object, or use a default message
+        error_message = getattr(request, "magic_link_error", _("Invalid or expired magic link"))
+
+        return render(
+            request,
+            get_invalid_magic_link_template(),
+            {"error": error_message},
+        )
+
+    # Log the user in
+    login(request, user)
+
+    # Redirect to the success URL
+    success_url = getattr(settings, "SOLOMON_LOGIN_REDIRECT_URL", settings.LOGIN_REDIRECT_URL)
+    return redirect(success_url)

django_solomon-0.1.2.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: django-solomon
+Version: 0.1.2
+Project-URL: Home, https://django-solomon.rtfd.io/
+Project-URL: Documentation, https://django-solomon.rtfd.io/
+Project-URL: Repository, https://codeberg.org/oliverandrich/django-solomon
+Author-email: Oliver Andrich <oliver@andrich.me>
+License: MIT License
+        
+        Copyright (c) 2025 Oliver Andrich
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: django
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: django>=4.2
+Requires-Dist: mjml-python>=1.3.5
+Description-Content-Type: text/markdown
+
+# django-solomon
+
+[![PyPI version](https://img.shields.io/pypi/v/django-solomon.svg)](https://pypi.org/project/django-solomon/)
+[![Python versions](https://img.shields.io/pypi/pyversions/django-solomon.svg)](https://pypi.org/project/django-solomon/)
+[![Django versions](https://img.shields.io/pypi/djversions/django-solomon.svg)](https://pypi.org/project/django-solomon/)
+[![Documentation Status](https://readthedocs.org/projects/django-solomon/badge/?version=latest)](https://django-solomon.rtfd.io/en/latest/?badge=latest)
+
+A Django app for passwordless authentication using magic links.
+
+## Features
+
+- Passwordless authentication using magic links sent via email
+- Configurable link expiration time
+- Blacklist functionality to block specific email addresses
+- Support for auto-creating users when they request a magic link
+- Customizable templates for emails and pages
+- Compatible with Django's authentication system
+
+## Installation
+
+```bash
+pip install django-solomon
+```
+
+## Configuration
+
+1. Add `django_solomon` to your `INSTALLED_APPS` in your Django settings:
+
+```python
+INSTALLED_APPS = [
+    # ...
+    'django_solomon',
+    # ...
+]
+```
+
+2. Add the authentication backend to your settings:
+
+```python
+AUTHENTICATION_BACKENDS = [
+    'django_solomon.backends.MagicLinkBackend',
+    'django.contrib.auth.backends.ModelBackend',  # Keep the default backend
+]
+```
+
+3. Include the django-solomon URLs in your project's `urls.py`:
+
+```python
+from django.urls import include, path
+
+urlpatterns = [
+    # ...
+    path('auth/', include('django_solomon.urls')),
+    # ...
+]
+```
+
+4. Set the login URL in your settings to use django-solomon's login view:
+
+```python
+LOGIN_URL = 'django_solomon:login'
+```
+
+This ensures that when users need to authenticate, they'll be redirected to the magic link login page.
+
+5. Configure your email settings to ensure emails can be sent:
+
+```python
+EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
+EMAIL_HOST = 'smtp.example.com'
+EMAIL_PORT = 587
+EMAIL_USE_TLS = True
+EMAIL_HOST_USER = 'your-email@example.com'
+EMAIL_HOST_PASSWORD = 'your-password'
+DEFAULT_FROM_EMAIL = 'your-email@example.com'
+```
+
+## Settings
+
+django-solomon provides several settings that you can customize in your Django settings file:
+
+| Setting                               | Default                                         | Description                                                                            |
+|---------------------------------------|-------------------------------------------------|----------------------------------------------------------------------------------------|
+| `SOLOMON_LINK_EXPIRATION`             | `300`                                           | The expiration time for magic links in seconds                                         |
+| `SOLOMON_ONLY_ONE_LINK_ALLOWED`       | `True`                                          | If enabled, only one active magic link is allowed per user                             |
+| `SOLOMON_CREATE_USER_IF_NOT_FOUND`    | `False`                                         | If enabled, creates a new user when a magic link is requested for a non-existent email |
+| `SOLOMON_LOGIN_REDIRECT_URL`          | `settings.LOGIN_REDIRECT_URL`                   | The URL to redirect to after successful authentication                                 |
+| `SOLOMON_ALLOW_ADMIN_LOGIN`           | `True`                                          | If enabled, allows superusers to log in using magic links                              |
+| `SOLOMON_ALLOW_STAFF_LOGIN`           | `True`                                          | If enabled, allows staff users to log in using magic links                             |
+| `SOLOMON_MAIL_TEXT_TEMPLATE`         | `"django_solomon/email/magic_link.txt"`         | The template to use for plain text magic link emails                                   |
+| `SOLOMON_MAIL_MJML_TEMPLATE`         | `"django_solomon/email/magic_link.mjml"`        | The template to use for HTML magic link emails (MJML format)                           |
+| `SOLOMON_LOGIN_FORM_TEMPLATE`         | `"django_solomon/base/login_form.html"`         | The template to use for the login form page                                            |
+| `SOLOMON_INVALID_MAGIC_LINK_TEMPLATE` | `"django_solomon/base/invalid_magic_link.html"` | The template to use for the invalid magic link page                                    |
+| `SOLOMON_MAGIC_LINK_SENT_TEMPLATE`    | `"django_solomon/base/magic_link_sent.html"`    | The template to use for the magic link sent confirmation page                          |
+
+## Usage
+
+### Basic Usage
+
+1. Direct users to the magic link request page at `/auth/magic-link/`
+2. Users enter their email address
+3. A magic link is sent to their email
+4. Users click the link in their email
+5. They are authenticated and redirected to the success URL
+
+### Template Customization
+
+You can override the default templates by creating your own versions in your project:
+
+- `django_solomon/login_form.html` - The form to request a magic link
+- `django_solomon/magic_link_sent.html` - The confirmation page after a magic link is sent
+- `django_solomon/invalid_magic_link.html` - The error page for invalid magic links
+- `django_solomon/email/magic_link.txt` - The plain text email template for the magic link
+- `django_solomon/email/magic_link.mjml` - The HTML email template for the magic link (in MJML format)
+
+Alternatively, you can specify custom templates using the settings variables:
+
+- `SOLOMON_LOGIN_FORM_TEMPLATE` - Custom template for the login form
+- `SOLOMON_MAGIC_LINK_SENT_TEMPLATE` - Custom template for the confirmation page
+- `SOLOMON_INVALID_MAGIC_LINK_TEMPLATE` - Custom template for the error page
+- `SOLOMON_MAIL_TEXT_TEMPLATE` - Custom template for the plain text email
+- `SOLOMON_MAIL_MJML_TEMPLATE` - Custom template for the HTML email (MJML format)
+
+### Programmatic Usage
+
+You can also use django-solomon programmatically in your views:
+
+```python
+from django.contrib.auth import authenticate, login
+from django_solomon.models import MagicLink
+
+# Create a magic link for a user
+magic_link = MagicLink.objects.create_for_user(user)
+
+# Authenticate a user with a token
+user = authenticate(request=request, token=token)
+if user:
+    login(request, user)
+```
+
+## License
+
+This software is licensed under [MIT license](./LICENSE).
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request
+on [Codeberg](https://codeberg.org/oliverandrich/django-solomon).

django_solomon-0.1.2.dist-info/RECORD

@@ -0,0 +1,26 @@
+django_solomon/__init__.py,sha256=4GdjeQVyChzdc7pZ1jrpknjcnu9Do_0nSh42UZNICKo,80
+django_solomon/admin.py,sha256=hwesCOQgUDDHPh5qq97AObfSyMgIOKsdzoa69naMPx4,1428
+django_solomon/apps.py,sha256=glfjdSSzrxuwJ2FrzuF2C4oFNqikMqhSHHmca2qq5Vg,159
+django_solomon/backends.py,sha256=A_TTNaduRmZOZF-R0C1yhs9QpXejBCRCz7wDcp_BupY,2403
+django_solomon/config.py,sha256=JEl3cY0BnfC9ja0ZVeLmfIwUStbUAO6vRhGZrrig5Yw,787
+django_solomon/forms.py,sha256=ymDsZ-KWyJfo12vGbZCxIhIvVket93xYR4MgDif4fh0,312
+django_solomon/models.py,sha256=NRsN-F7Vnfx-l5cJgjAJqPhbhRIeIctcRh4GeuysUZA,4771
+django_solomon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_solomon/urls.py,sha256=tT-I-p6dA2rD1IvH3pAcJRkPXYW0oYmYWXZAoiLJzGY,471
+django_solomon/utilities.py,sha256=Xna8jlr6E5YYxKx7Pz_xD6LwIm3ZfZGdyYfJpIoOD-g,2275
+django_solomon/views.py,sha256=qPwpSXhKyLg9zXJVmzC4SJqpTwqVFLbwQdq9qWy2Im0,5553
+django_solomon/locale/de/LC_MESSAGES/django.po,sha256=6lo72lsDV1bKBVowiRsQoaVKH5Mbkf34z78sG1LEYq4,747
+django_solomon/locale/en/LC_MESSAGES/django.po,sha256=6MjGCWQn-1AjOnP_gXtLa0Oad4qfNAn5tXdhnw_wEcg,732
+django_solomon/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_solomon/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_solomon/migrations/0001_initial.py,sha256=i-UhR1KQ4p7WmbDg9xUQfMmDo8yYdIigvHNsefLHJEc,1981
+django_solomon/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_solomon/templates/django_solomon/base/invalid_magic_link.html,sha256=3U4T2n4uvPvktiOOHYVyNmk0aXFfE4DPrURE1DinWKk,554
+django_solomon/templates/django_solomon/base/login_form.html,sha256=VYGnrno3c36W9f04XdRqJpjsDfOy0sq5D_cLayPz8Q0,546
+django_solomon/templates/django_solomon/base/magic_link_sent.html,sha256=GIMxnw3E98TXVkVQkMRTHmX5mz0xUsvgXVj25gO2HPQ,461
+django_solomon/templates/django_solomon/email/magic_link.mjml,sha256=OnfVGm2yFrOmoQ1syo6-Duq_Qraf3Tv0Vy5oidvt55g,1427
+django_solomon/templates/django_solomon/email/magic_link.txt,sha256=yl01eie3U2HkFEJvB1Qlm8Z6FPuop5yubDXFY5V507Q,502
+django_solomon-0.1.2.dist-info/METADATA,sha256=C-MpFkZUrPXXrKgQJO1Fs1WW5rIXXUXGcfw1RpeGEBU,8902
+django_solomon-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+django_solomon-0.1.2.dist-info/licenses/LICENSE,sha256=tbfFOFdH5mHIfmNGo6KGOC3U8f-hTCLfetcr8A89WwI,1071
+django_solomon-0.1.2.dist-info/RECORD,,

django_solomon-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

django_solomon-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Oliver Andrich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.