django-multisite2 2.0.0__py3-none-any.whl

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/migrations/0004_alter_alias_managers.py

@@ -0,0 +1,22 @@
+# Generated by Django 4.2.11 on 2024-03-27 04:14
+
+from django.db import migrations
+import multisite.models.managers
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("multisite", "0003_alter_alias_options_alter_alias_unique_together_and_more"),
+    ]
+
+    operations = [
+        migrations.AlterModelManagers(
+            name="alias",
+            managers=[
+                ("objects", multisite.models.managers.AliasManager()),
+                ("canonical", multisite.models.managers.CanonicalAliasManager()),
+                ("aliases", multisite.models.managers.NotCanonicalAliasManager()),
+            ],
+        ),
+    ]

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

multisite/models/managers.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import operator
+from functools import reduce
+from typing import TYPE_CHECKING
+
+from django.contrib.sites import managers
+from django.core.exceptions import FieldDoesNotExist, ValidationError
+from django.core.validators import validate_ipv4_address
+from django.db import models
+from django.db.models import Q
+from django.db.models.constants import LOOKUP_SEP
+
+from ..exceptions import MultisiteInvalidHostError
+
+if TYPE_CHECKING:
+    from django.db.models import QuerySet
+
+    from .alias import Alias
+
+__all__ = [
+    "AliasManager",
+    "CanonicalAliasManager",
+    "NotCanonicalAliasManager",
+    "SpanningCurrentSiteManager",
+]
+
+
+class AliasManager(models.Manager):
+    """Manager for all Aliases."""
+
+    use_in_migrations = True
+
+    def get_queryset(self) -> QuerySet[Alias]:
+        return super().get_queryset().select_related("site")
+
+    def resolve(self, host: str, port: str | None = None) -> list[str] | None:
+        """Returns the Alias that best matches ``host`` and
+        ``port``, or None.
+
+        ``host`` is a hostname like ``'example.com'``.
+        ``port`` is a port number like 8000, or None.
+
+        Attempts to first match by 'host:port' against
+        Alias.domain. If that fails, it will try to match the bare
+        'host' with no port number.
+
+        All comparisons are done case-insensitively.
+        """
+        domains = self._expand_netloc(host=host, port=port)
+        q: Q = reduce(operator.or_, (Q(domain__iexact=d) for d in domains))
+        aliases = dict((a.domain, a) for a in self.get_queryset().filter(q))
+        for domain in domains:
+            try:
+                return aliases[domain]
+            except KeyError:
+                pass
+        return None
+
+    @classmethod
+    def _expand_netloc(cls, host: str, port: str | None = None) -> list[str]:
+        """Returns a list of possible domain expansions for ``host``
+        and ``port``.
+
+        ``host`` is a hostname like ``'example.com'``.
+        ``port`` is a port number like 8000, or None.
+
+        Expansions are ordered from highest to lowest preference and may
+        include wildcards. Examples::
+
+        >>> AliasManager._expand_netloc('www.example.com')
+        ['www.example.com', '*.example.com', '*.com', '*']
+
+        >>> AliasManager._expand_netloc('www.example.com', 80)
+        ['www.example.com:80', 'www.example.com',
+         '*.example.com:80', '*.example.com',
+         '*.com:80', '*.com',
+         '*:80', '*']
+        """
+        if not host:
+            raise MultisiteInvalidHostError("Invalid host: %s" % host)
+        try:
+            validate_ipv4_address(host)
+        except ValidationError:
+            # Not an IP address
+            bits = host.split(".")
+        else:
+            bits = [host]
+        result = []
+        for i in range(0, (len(bits) + 1)):
+            if i == 0:
+                host = ".".join(bits[i:])
+            else:
+                host = ".".join(["*"] + bits[i:])
+            if port:
+                result.append("%s:%s" % (host, port))
+            result.append(host)
+        return result
+
+
+class CanonicalAliasManager(models.Manager):
+    """Manager for Alias objects where is_canonical == 1."""
+
+    use_in_migrations = True
+
+    def get_queryset(self) -> QuerySet[Alias]:
+        queryset = super().get_queryset()
+        return queryset.filter(is_canonical=1)
+
+
+class NotCanonicalAliasManager(models.Manager):
+    """Manager for Aliases where is_canonical != 1."""
+
+    use_in_migrations = True
+
+    def get_queryset(self) -> QuerySet[Alias]:
+        queryset = super().get_queryset()
+        return queryset.exclude(is_canonical=1)
+
+
+class SpanningCurrentSiteManager(managers.CurrentSiteManager):
+    """Unlike ``django.contrib.sites.managers.CurrentSiteManager``,
+    this CurrentSiteManager can span multiple related models by using
+    the django filtering syntax, namely foo__bar__baz__site.
+
+    For example, let's say you have a model called Layer, which has
+    a field called family, which points to a model called LayerFamily,
+    which in turn has a field called site pointing to a
+    django.contrib.sites Site model. On Layer, add the following
+    manager:
+
+        on_site = SpanningCurrentSiteManager("family__site")
+
+    and it will do the proper thing.
+    """
+
+    def _validate_field_name(self):
+        """Given the field identifier, goes down the chain to check that
+        each specified field
+            a) exists,
+            b) is of type ForeignKey or ManyToManyField
+
+        If no field name is specified when instantiating
+        SpanningCurrentSiteManager, it tries to find either 'site' or
+        'sites' as the site link, much like CurrentSiteManager does.
+        """
+        if self._CurrentSiteManager__field_name is None:
+            # Guess at field name
+            field_names = self.model._meta.get_all_field_names()
+            for potential_name in ["site", "sites"]:
+                if potential_name in field_names:
+                    self._CurrentSiteManager__field_name = potential_name
+                    break
+            else:
+                raise ValueError(
+                    f"{self.__class__.__name__} couldn't find a field named either 'site' or 'sites' "
+                    f"in {self.model._meta.object_name}."
+                )
+
+        field_name_chain = self._CurrentSiteManager__field_name.split(LOOKUP_SEP)
+        model = self.model
+
+        for field_name in field_name_chain:
+            # Throws an exception if anything goes bad
+            self.validate_single_field_name(model, field_name)
+            model = self.get_related_model(model, field_name)
+
+        # If we get this far without an exception, everything is good
+        self._CurrentSiteManager__is_validated = True
+
+    @staticmethod
+    def validate_single_field_name(model, field_name) -> None:
+        """Checks if the given field_name can be used to make a link
+        between a model and a site.
+
+        If anything is wrong, will raise an appropriate exception,
+        because that is what CurrentSiteManager expects.
+        """
+        try:
+            field = model._meta.get_field(field_name)
+            if not isinstance(field, (models.ForeignKey, models.ManyToManyField)):
+                raise TypeError(f"Field {field_name} must be a ForeignKey or ManyToManyField.")
+        except FieldDoesNotExist:
+            raise ValueError(
+                f"Couldn't find a field named {field_name} in {model._meta.object_name}."
+            )
+
+    @staticmethod
+    def get_related_model(model, field_name) -> models.Model:
+        """Given a model and the name of a ForeignKey or ManyToManyField column
+        as a string, returns the associated model.
+        """
+        try:
+            return model._meta.get_field(field_name).remote_field.model
+        except AttributeError:
+            return model._meta.get_field(field_name).related_model

multisite/models/signals.py

@@ -0,0 +1,36 @@
+from django.contrib.sites.models import Site
+from django.core.exceptions import ObjectDoesNotExist
+from django.db import connections, router
+from django.db.models.signals import post_save, pre_save
+from django.dispatch import receiver
+
+from multisite.utils import create_or_sync_alias_from_site
+
+
+@receiver(pre_save, sender=Site, weak=False, dispatch_uid="site_domain_changed_hook")
+def pre_save_site_domain_changed(sender, instance, raw, *args, **kwargs):
+    """Updates canonical Alias object if Site.domain has changed."""
+    if not raw and instance.pk is not None:
+        try:
+            original = sender.objects.get(pk=instance.pk)
+        except ObjectDoesNotExist:
+            pass
+        else:
+            # Update Alias.domain to match site
+            if original.domain != instance.domain:
+                create_or_sync_alias_from_site(site=instance)
+
+
+@receiver(post_save, sender=Site, weak=False, dispatch_uid="site_created_hook")
+def post_save_site_created(sender, instance, raw, created, *args, **kwargs):
+    """Creates canonical Alias object for a new Site."""
+    if not raw and created:
+        # When running create_default_site() because of post_syncdb,
+        # don't try to sync before the db_table has been created.
+        using = router.db_for_write(sender)
+        tables = connections[using].introspection.table_names()
+        if sender._meta.db_table not in tables:
+            pass
+        else:
+            # Update Alias.domain to match site
+            create_or_sync_alias_from_site(site=instance)

multisite/models/validators.py

@@ -0,0 +1,14 @@
+from django.core.exceptions import ValidationError
+
+__all__ = ["validate_1_or_none"]
+
+
+def validate_1_or_none(value: bool) -> None:
+    """Raises ValidationError if value is not int(1) or None."""
+    if value not in [1, None]:
+        raise ValidationError("%r must be 1 or None" % value)
+
+
+def validate_true_or_none(value: bool) -> None:
+    # leave for old migrations
+    pass

multisite/tests/get_test_allowed_hosts.py

@@ -0,0 +1,14 @@
+def get_test_allowed_hosts(*extra, replace=None):
+    if replace:
+        allowed_hosts = []
+    else:
+        allowed_hosts = [
+            ".extrahost.com",
+            "app.test1.example.com",
+            "app.test2.example.com",
+            "example.com",
+            "new.app.test3.example.com",
+            "test.example.com",
+        ]
+    allowed_hosts.extend(extra)
+    return allowed_hosts

multisite/tests/get_test_http_response.py

@@ -0,0 +1,13 @@
+from typing import Callable, Type
+
+from django.http import HttpResponse
+
+
+def get_test_http_response(*cookies) -> Callable:
+    def http_response(request) -> HttpResponse:
+        response = HttpResponse()
+        for cookie in cookies:
+            response.set_cookie(**cookie)
+        return response
+
+    return http_response

multisite/tests/hosts.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from django.utils.functional import SimpleLazyObject, empty
+
+__all__ = ["ALLOWED_HOSTS", "AllowedHosts"]
+
+_wrapped_default = empty
+
+
+def get_multisite_extra_hosts():
+    from django.conf import settings
+
+    return getattr(settings, "MULTISITE_EXTRA_HOSTS", [])
+
+
+class IterableLazyObject(SimpleLazyObject):
+    _wrapped_default = globals()["_wrapped_default"]
+
+    def __iter__(self):
+        if self._wrapped is self._wrapped_default:
+            self._setup()
+        return self._wrapped.__iter__()
+
+
+class AllowedHosts(object):
+    alias_model = None
+
+    def __init__(self):
+        self.extra_hosts = get_multisite_extra_hosts()
+        if self.alias_model is None:
+            from multisite.models import Alias
+
+            self.alias_model = Alias
+
+    def __iter__(self):
+        # Yielding extra hosts before actual hosts because there might be
+        # wild cards in there that would prevent us from doing a database
+        # query every time.
+        for host in self.extra_hosts:
+            yield host
+
+        for host in self.alias_model.objects.values_list("domain"):
+            yield host[0]
+
+
+ALLOWED_HOSTS = IterableLazyObject(lambda: AllowedHosts())

multisite/tests/test_settings.py

@@ -0,0 +1,23 @@
+from multisite import SiteID
+
+SILENCED_SYSTEM_CHECKS = ["sites.E101"]
+SECRET_KEY = "iufoj=mibkpdz*%bob952x(%49rqgv8gg45k36kjcg76&-y5=!"  # nosec B105
+SITE_ID = SiteID(default=1)
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": ":memory:",
+    }
+}
+
+INSTALLED_APPS = [
+    # "django.contrib.auth",
+    # "django.contrib.contenttypes",
+    "django.contrib.sites",
+    "multisite",
+    "multisite_app",
+]
+MIDDLEWARE = [
+    "multisite.middleware.DynamicSiteMiddleware",
+    "django.contrib.sites.middleware.CurrentSiteMiddleware",
+]

multisite/tests/tests/request_factory.py

@@ -0,0 +1,12 @@
+from django.test.client import RequestFactory as DjangoRequestFactory
+
+
+class RequestFactory(DjangoRequestFactory):
+    def __init__(self, host):
+        super().__init__()
+        self.host = host
+
+    def get(self, path, data={}, host=None, **extra):
+        if host is None:
+            host = self.host
+        return super().get(path=path, data=data, HTTP_HOST=host, **extra)