django-multisite2 2.1.1__py3-none-any.whl

multisite/middleware/dynamic_site_middleware.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+from hashlib import md5 as md5_constructor
+from urllib.parse import urlsplit, urlunsplit
+
+from django.conf import settings
+from django.contrib.sites.models import SITE_CACHE, Site
+from django.core import mail
+from django.core.cache import caches
+from django.core.exceptions import DisallowedHost
+from django.db.models.signals import post_delete, post_init, pre_save
+from django.http import HttpResponse, HttpResponsePermanentRedirect
+
+from ..exceptions import (
+    MultisiteError,
+    MultisiteInvalidHostError,
+    debug_check_status_code,
+    debug_raise_cache_missed_exception,
+    debug_raise_disallowed_host_exception,
+)
+from ..models import Alias
+
+__all__ = ["DynamicSiteMiddleware"]
+
+from ..utils import (
+    get_cache_multisite_alias,
+    get_cache_multisite_prefix,
+    get_fallback_kwargs,
+    get_fallback_view_or_404,
+)
+
+
+class DynamicSiteMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+        if not hasattr(settings.SITE_ID, "set"):
+            raise MultisiteError(
+                "Invalid type for settings.SITE_ID: %s" % type(settings.SITE_ID).__name__
+            )
+
+        self.cache_alias = get_cache_multisite_alias()
+        self.key_prefix = get_cache_multisite_prefix() or settings.CACHES[
+            self.cache_alias
+        ].get("KEY_PREFIX", "")
+
+        self.cache = caches[self.cache_alias]
+        post_init.connect(
+            self.site_domain_cache_hook, sender=Site, dispatch_uid="multisite_post_init"
+        )
+        pre_save.connect(self.site_domain_changed_hook, sender=Site)
+        post_delete.connect(self.site_deleted_hook, sender=Site)
+
+    def __call__(self, request):
+        response = self.get_response(request)
+        # if 500 here -> Site ObjectDoesNotExist was raised by get_current_site()
+        debug_check_status_code(response, request=request)
+        try:
+            netloc = request.get_host().lower()
+        except DisallowedHost as e:
+            debug_raise_disallowed_host_exception(e)
+            settings.SITE_ID.reset()
+            response = self.fallback_view(request)
+        else:
+            cache_key = self.get_cache_key(netloc)
+            if (alias := self.cache.get(cache_key)) is not None:
+                # found Alias
+                self.cache.set(cache_key, alias)
+                settings.SITE_ID.set(alias.site_id)
+                response = self.redirect_to_canonical(request, response, alias)
+            elif (alias := self.get_alias(netloc)) is None:
+                # Cache missed, fallback using settings.MULTISITE_FALLBACK
+                debug_raise_cache_missed_exception(netloc, alias)
+                settings.SITE_ID.reset()
+                response = self.fallback_view(request)
+            else:
+                # found Site
+                self.cache.set(cache_key, alias)
+                settings.SITE_ID.set(alias.site_id)
+                SITE_CACHE[settings.SITE_ID] = alias.site  # Pre-populate SITE_CACHE
+                response = self.redirect_to_canonical(request, response, alias)
+                debug_check_status_code(response, netloc=netloc, alias=alias, site=alias.site)
+        return response
+
+    @staticmethod
+    def redirect_to_canonical(request, response, alias: Alias) -> HttpResponse:
+        if not alias.redirect_to_canonical or alias.is_canonical:
+            return response
+        url = urlsplit(request.build_absolute_uri(request.get_full_path()))
+        url = urlunsplit((url.scheme, alias.site.domain, url.path, url.query, url.fragment))
+        return HttpResponsePermanentRedirect(url)
+
+    def get_cache_key(self, netloc):
+        """Returns a cache key based on ``netloc``."""
+        netloc = md5_constructor(netloc.encode("utf-8"), usedforsecurity=False)
+        return "multisite.alias.%s.%s" % (self.key_prefix, netloc.hexdigest())
+
+    @staticmethod
+    def netloc_parse(netloc):
+        """Returns ``(host, port)`` for ``netloc`` of the form
+        ``'host:port'``.
+
+        If netloc does not have a port number, ``port`` will be None.
+        """
+        if ":" in netloc:
+            return netloc.rsplit(":", 1)
+        else:
+            return netloc, None
+
+    def get_alias(self, netloc) -> Alias | None:
+        """Returns Alias matching ``netloc``. Otherwise,
+        returns None.
+        """
+        host, port = self.netloc_parse(netloc)
+        try:
+            alias = Alias.objects.resolve(host=host, port=port)
+        except MultisiteInvalidHostError:
+            alias = None
+        if alias is None:
+            # Running under TestCase or runserver?
+            alias = self.get_development_alias(netloc)
+        return alias
+
+    @staticmethod
+    def fallback_view(request) -> HttpResponse:
+        """Runs the fallback view function in
+        ``settings.MULTISITE_FALLBACK``.
+
+        If ``MULTISITE_FALLBACK`` is None, raises an Http404 error.
+
+        If ``MULTISITE_FALLBACK`` is callable, will treat that
+        callable as a view that returns an HttpResponse.
+
+        If ``MULTISITE_FALLBACK`` is a string, will resolve it to a
+        view that returns an HttpResponse.
+
+        In order to use a generic view that takes additional
+        parameters, ``settings.MULTISITE_FALLBACK_KWARGS`` may be a
+        dictionary of additional keyword arguments.
+        """
+        view = get_fallback_view_or_404()
+        kwargs = get_fallback_kwargs()
+        if hasattr(view, "as_view"):
+            return view.as_view(**kwargs)(request)
+        return view(request, **kwargs)
+
+    @staticmethod
+    def get_development_alias(netloc) -> Alias:
+        """Returns valid Alias when in development mode. Otherwise,
+        returns None.
+
+        Development mode is either:
+        - Running tests, i.e. manage.py test
+        - Running locally in `settings.DEBUG` = True, where the
+          hostname is a top-level name, i.e. localhost
+        """
+        alias = None
+        # When running tests, django.core.mail.outbox exists and
+        # netloc == 'testserver'
+        is_testserver = hasattr(mail, "outbox") and netloc in (
+            "testserver",
+            "adminsite.com",
+        )
+        # When using runserver, assume that host will only have one path
+        # component. This covers 'localhost' and your machine name.
+        is_local_debug = settings.DEBUG and len(netloc.split(".")) == 1
+        if is_testserver or is_local_debug:
+            try:
+                # Prefer the default SITE_ID
+                site_id = settings.SITE_ID.get_default()
+            except ValueError:
+                # Fallback to the first Site object
+                alias = Alias.canonical.order_by("site")[0]
+            else:
+                alias = Alias.canonical.get(site=site_id)
+        return alias
+
+    @classmethod
+    def site_domain_cache_hook(cls, sender, instance, *args, **kwargs):
+        """Caches `Site.domain` in the object for
+        site_domain_changed_hook.
+        """
+        instance._domain_cache = instance.domain
+
+    def site_domain_changed_hook(self, sender, instance, raw, *args, **kwargs):
+        """Clears the cache if `Site.domain` has changed."""
+        if raw or instance.pk is None:
+            return
+
+        original = getattr(instance, "_domain_cache", None)
+        if original != instance.domain:
+            self.cache.clear()
+
+    def site_deleted_hook(self, *args, **kwargs):
+        """Clears the cache if Site was deleted."""
+        self.cache.clear()

multisite/migrations/0001_initial.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, unicode_literals
+
+from django.db import migrations, models
+
+import multisite.models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("sites", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Alias",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        verbose_name="ID",
+                        serialize=False,
+                        auto_created=True,
+                        primary_key=True,
+                    ),
+                ),
+                (
+                    "domain",
+                    models.CharField(
+                        help_text='Either "domain" or "domain:port"',
+                        unique=True,
+                        max_length=100,
+                        verbose_name="domain name",
+                    ),
+                ),
+                (
+                    "is_canonical",
+                    models.NullBooleanField(
+                        default=None,
+                        validators=[multisite.models.validators.validate_true_or_none],
+                        editable=False,
+                        help_text="Does this domain name match the one in site?",
+                        verbose_name="is canonical?",
+                    ),
+                ),
+                (
+                    "redirect_to_canonical",
+                    models.BooleanField(
+                        default=True,
+                        help_text="Should this domain name redirect to the one in site?",
+                        verbose_name="redirect to canonical?",
+                    ),
+                ),
+                (
+                    "site",
+                    models.ForeignKey(
+                        related_name="aliases",
+                        to="sites.Site",
+                        on_delete=models.CASCADE,
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name_plural": "aliases",
+            },
+        ),
+        migrations.AlterUniqueTogether(
+            name="alias",
+            unique_together=set([("is_canonical", "site")]),
+        ),
+    ]

multisite/migrations/0002_alter_alias_id_alter_alias_is_canonical.py

@@ -0,0 +1,32 @@
+# Generated by Django 4.0.4 on 2022-05-12 23:39
+
+from django.db import migrations, models
+
+import multisite.models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("multisite", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="alias",
+            name="id",
+            field=models.BigAutoField(
+                auto_created=True, primary_key=True, serialize=False, verbose_name="ID"
+            ),
+        ),
+        migrations.AlterField(
+            model_name="alias",
+            name="is_canonical",
+            field=models.BooleanField(
+                default=False,
+                editable=False,
+                help_text="Does this domain name match the one in site?",
+                validators=[multisite.models.validators.validate_true_or_none],
+                verbose_name="is canonical?",
+            ),
+        ),
+    ]

multisite/migrations/0003_alter_alias_options_alter_alias_unique_together_and_more.py

@@ -0,0 +1,41 @@
+# Generated by Django 5.0.3 on 2024-03-22 03:52
+
+import multisite.models
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("multisite", "0002_alter_alias_id_alter_alias_is_canonical"),
+        ("sites", "0002_alter_domain_unique"),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name="alias",
+            options={"verbose_name": "Alias", "verbose_name_plural": "Aliases"},
+        ),
+        migrations.AlterUniqueTogether(
+            name="alias",
+            unique_together=set(),
+        ),
+        migrations.AlterField(
+            model_name="alias",
+            name="is_canonical",
+            field=models.IntegerField(
+                default=None,
+                editable=False,
+                help_text="Does this domain name match the one in site?",
+                null=True,
+                validators=[multisite.models.validate_1_or_none],
+                verbose_name="is canonical?",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="alias",
+            constraint=models.UniqueConstraint(
+                fields=("is_canonical", "site"), name="unique_is_canonical_site"
+            ),
+        ),
+    ]

multisite/models/__init__.py

@@ -0,0 +1,3 @@
+from .alias import Alias
+from .signals import post_save_site_created, pre_save_site_domain_changed
+from .validators import validate_1_or_none, validate_true_or_none

multisite/models/alias.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from django.contrib.sites.models import Site
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.db.models import UniqueConstraint
+from django.utils.translation import gettext_lazy as _
+
+from .managers import AliasManager, CanonicalAliasManager, NotCanonicalAliasManager
+from .validators import validate_1_or_none
+
+_site_domain = Site._meta.get_field("domain")
+
+
+__all__ = ["Alias"]
+
+
+class Alias(models.Model):
+    """
+    Model for domain-name aliases for Site objects.
+
+    Domain names must be unique in the format of: 'hostname[:port].'
+    Each Site object that has a domain must have an ``is_canonical``
+    Alias.
+    """
+
+    domain = type(_site_domain)(
+        _("domain name"),
+        max_length=_site_domain.max_length,
+        unique=True,
+        help_text=_('Either "domain" or "domain:port"'),
+    )
+
+    site = models.ForeignKey(Site, related_name="aliases", on_delete=models.CASCADE)
+
+    is_canonical = models.IntegerField(
+        _("is canonical?"),
+        default=None,
+        null=True,
+        editable=False,
+        validators=[validate_1_or_none],
+        help_text=_("Does this domain name match the one in site?"),
+    )
+
+    redirect_to_canonical = models.BooleanField(
+        _("redirect to canonical?"),
+        default=True,
+        help_text=_("Should this domain name redirect to the one in site?"),
+    )
+
+    def __str__(self):
+        return f"{self.domain} -> {self.site.domain}"
+
+    def __repr__(self):
+        return f"<Alias: {self}>"
+
+    objects = AliasManager()
+    canonical = CanonicalAliasManager()
+    aliases = NotCanonicalAliasManager()
+
+    class Meta:
+        verbose_name = _("Alias")
+        verbose_name_plural = _("Aliases")
+        constraints = [
+            UniqueConstraint(
+                name="unique_is_canonical_site",
+                fields=["is_canonical", "site"],
+                # nulls_distinct=False, DJ5
+            )
+        ]
+
+    def save_base(self, *args, **kwargs):
+        """For canonical Alias, domains must match Site domains.
+
+        This needs to be validated here so that it is executed *after* the
+        Site pre-save signal updates the domain (an AliasInline modelform
+        on SiteAdmin will be saved (and it's clean methods run before
+        the Site is saved)
+        """
+        self.full_clean()
+        if self.is_canonical and self.domain != self.site.domain:
+            raise ValidationError({"domain": ["Does not match %r" % self.site]})
+        super().save_base(*args, **kwargs)
+
+    def validate_unique(self, exclude=None) -> None:
+        errors = {}
+        try:
+            super().validate_unique(exclude=exclude)
+        except ValidationError as e:
+            errors = e.update_error_dict(errors)
+        if exclude is not None and "domain" not in exclude:
+            errors = self._validate_domain_is_unique(errors)
+        if errors:
+            raise ValidationError(errors)
+
+    def _validate_domain_is_unique(self, errors: dict) -> dict:
+        """Ensure domain is unique, insensitive to case"""
+        field_name = "domain"
+        field_error = self.unique_error_message(self.__class__, (field_name,))
+        if field_name not in errors or str(field_error) not in [
+            str(err) for err in errors[field_name]
+        ]:
+            queryset = self.__class__.objects.filter(
+                **{field_name + "__iexact": getattr(self, field_name)}
+            )
+            if self.pk is not None:
+                queryset = queryset.exclude(pk=self.pk)
+            if queryset.exists():
+                errors.setdefault(field_name, []).append(field_error)
+        return errors