django-multisite2 2.1.1__py3-none-any.whl

multisite/admin/multisite_changelist.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django.contrib.admin.views.main import ChangeList
+from django.contrib.sites.models import Site
+from django.db import models
+
+from ..utils import get_user_sites
+
+__all__ = ["MultisiteChangeList"]
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import User
+    from django.core.handlers.wsgi import WSGIRequest as BaseWSGIRequest
+
+    class UserProfile(models.Model):
+        user = models.ForeignKey(User, on_delete=models.PROTECT)
+        sites = models.ManyToManyField(Site, blank=True)
+
+    class WSGIRequest(BaseWSGIRequest):
+        user: User
+
+
+class MultisiteChangeList(ChangeList):
+    """
+    A ChangeList like the built-in admin one, but it excludes site filters for
+    sites you're not associated with, unless you're a super-user.
+
+    At this point, it's probably fragile, given its reliance on Django
+    internals.
+    """
+
+    def get_filters(self, request: WSGIRequest, *args, **kwargs) -> tuple[list, bool]:
+        """
+        This might be considered a fragile function, since it relies on a
+        fair bit of Django's internals.
+        """
+        get_filters = super().get_filters
+        filter_specs, has_filter_specs = get_filters(request)
+        if request.user.is_superuser or not has_filter_specs:
+            return filter_specs, has_filter_specs
+        new_filter_specs = []
+        user_sites = frozenset(get_user_sites(request).values_list("pk", "domain"))
+        for filter_spec in filter_specs:
+            try:
+                try:
+                    remote_model = filter_spec.field.remote_field.model
+                except AttributeError:
+                    remote_model = filter_spec.field.related_model
+            except AttributeError:
+                new_filter_specs.append(filter_spec)
+                continue
+            if remote_model is not Site:
+                new_filter_specs.append(filter_spec)
+                continue
+            lookup_choices = frozenset(filter_spec.lookup_choices) & user_sites
+            if len(lookup_choices) > 1:
+                # put the choices back into the form they came in
+                filter_spec.lookup_choices = list(lookup_choices)
+                filter_spec.lookup_choices.sort()
+                new_filter_specs.append(filter_spec)
+
+        return new_filter_specs, bool(new_filter_specs)

multisite/admin/multisite_model_admin.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django.contrib import admin
+from django.contrib.sites.models import Site
+from django.db import models
+
+from ..utils import get_user_sites
+from .multisite_changelist import MultisiteChangeList
+
+__all__ = ["MultisiteModelAdmin"]
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import User
+    from django.core.handlers.wsgi import WSGIRequest as BaseWSGIRequest
+    from django.db.models import QuerySet
+
+    class UserProfile(models.Model):
+        user = models.ForeignKey(User, on_delete=models.PROTECT)
+        sites = models.ManyToManyField(Site, blank=True)
+
+    class WSGIRequest(BaseWSGIRequest):
+        user: User
+
+
+class MultisiteModelAdmin(admin.ModelAdmin):
+    """
+    A very helpful ModelAdmin class for handling multi-site django
+    applications.
+    """
+
+    filter_sites_by_current_object = False
+
+    def __init__(self, model, admin_site):
+        self.object_sites: tuple | None = None
+        super().__init__(model, admin_site)
+
+    def get_queryset(self, request: WSGIRequest) -> QuerySet:
+        """
+        Filters lists of items to items belonging to sites assigned to the
+        current member.
+
+        Additionally, for cases where the field containing a reference
+        to 'site' or 'sites' isn't immediate -- one can supply the
+        ModelAdmin class with a list of fields to check the site of:
+
+         - multisite_filter_fields
+            A list of paths to a 'site' or 'sites' field on a related model to
+            filter the queryset on.
+
+        (As long as you're not a superuser)
+        """
+        qs = super().get_queryset(request)
+        if request.user.is_superuser:
+            return qs
+        user_sites = get_user_sites(request)
+        if hasattr(qs.model, "site"):
+            qs = qs.filter(site__in=user_sites)
+        elif hasattr(qs.model, "sites"):
+            qs = qs.filter(sites__in=user_sites)
+
+        if hasattr(self, "multisite_filter_fields"):
+            for field in self.multisite_filter_fields:
+                qkwargs = {"{field}__in".format(field=field): user_sites}
+                qs = qs.filter(**qkwargs)
+
+        return qs
+
+    def add_view(self, request: WSGIRequest, form_url: str = "", extra_context: dict = None):
+        if self.filter_sites_by_current_object:
+            if hasattr(self.model, "site") or hasattr(self.model, "sites"):
+                self.object_sites = tuple()
+        return super().add_view(request, form_url, extra_context)
+
+    def change_view(
+        self, request: WSGIRequest, object_id, form_url: str = "", extra_context: dict = None
+    ):
+        if self.filter_sites_by_current_object:
+            object_instance = self.get_object(request, object_id)
+            try:
+                self.object_sites = object_instance.sites.values_list("pk", flat=True)
+            except AttributeError:
+                try:
+                    self.object_sites = (object_instance.site.pk,)
+                except AttributeError:
+                    pass  # assume the object doesn't belong to a site
+        return super().change_view(request, object_id, form_url, extra_context)
+
+    def handle_multisite_foreign_keys(self, db_field, request, **kwargs):
+        """
+        Filters the foreignkey queryset for fields referencing other models
+        to those models assigned to a site belonging to the current member
+        (if they aren't a superuser), and (optionally) belonging to the same
+        site as the current object.
+
+        Also prevents (non-super) users from assigning objects to sites that
+        they are not members of.
+
+        If the foreign key does not have a site/sites field directly, you can
+        specify a path to a site/sites field to filter on by setting the key:
+
+            - multisite_foreign_key_site_path
+
+        to a dictionary pointing specific foreign key field instances
+        from their model to the site field to filter on something
+        like:
+
+            multisite_indirect_foreign_key_path = {
+                    'plan_instance': 'plan__site'
+                }
+
+        for a field named 'plan_instance' referencing a model with a
+        foreign key named 'plan' having a foreign key to 'site'.
+
+        To filter the FK queryset to the same sites the current object belongs
+        to, simply set `filter_sites_by_current_object` to `True`.
+
+        Caveats:
+
+        1) If you're adding an object that belongs to a site (or sites),
+        and you've set `self.limit_sites_by_current_object = True`,
+        then the FK fields to objects that also belong to a site won't show
+        any objects. This is due to filtering on an empty queryset.
+        """
+        user_sites = get_user_sites(request)
+        try:
+            remote_model = db_field.remote_field.model
+        except AttributeError:
+            remote_model = db_field.related_model
+        if hasattr(remote_model, "site"):
+            kwargs["queryset"] = remote_model._default_manager.filter(site__in=user_sites)
+        if hasattr(remote_model, "sites"):
+            kwargs["queryset"] = remote_model._default_manager.filter(sites__in=user_sites)
+        if db_field.name == "site" or db_field.name == "sites":
+            kwargs["queryset"] = user_sites
+        if (
+            hasattr(self, "multisite_indirect_foreign_key_path")
+            and db_field.name in self.multisite_indirect_foreign_key_path.keys()
+        ):
+            fkey = self.multisite_indirect_foreign_key_path[db_field.name]
+            kwargs["queryset"] = remote_model._default_manager.filter(**{fkey: user_sites})
+
+        return kwargs
+
+    def formfield_for_foreignkey(self, db_field, request, **kwargs):
+        kwargs = self.handle_multisite_foreign_keys(db_field, request, **kwargs)
+        return super().formfield_for_foreignkey(db_field, request, **kwargs)
+
+    def formfield_for_manytomany(self, db_field, request, **kwargs):
+        kwargs = self.handle_multisite_foreign_keys(db_field, request, **kwargs)
+        return super().formfield_for_manytomany(db_field, request, **kwargs)
+
+    def get_changelist(self, request, **kwargs):
+        """
+        Restrict the site filter (if there is one) to sites you are
+        associated with, or remove it entirely if you're just
+        associated with one site. Unless you're a super-user, of
+        course.
+        """
+        return MultisiteChangeList

multisite/apps.py

@@ -0,0 +1,29 @@
+from django.apps import AppConfig as DjangoAppConfig
+from django.conf import settings
+from django.db.models.signals import post_migrate
+
+from multisite.hacks import use_framework_for_site_cache
+from multisite.utils import create_or_sync_canonical_from_all_sites
+
+
+def post_migrate_sync_alias(apps=None, **kwargs):
+    """Syncs canonical Alias objects for all existing Site objects."""
+    create_or_sync_canonical_from_all_sites(apps)
+
+
+class AppConfig(DjangoAppConfig):
+    name = "multisite"
+    verbose_name = "Multisite"
+    default_auto_field = "django.db.models.BigAutoField"
+
+    def import_models(self):
+        use_framework_for_site_cache()
+        super().import_models()
+
+    def ready(self):
+        if not getattr(settings, "MULTISITE_REGISTER_POST_MIGRATE_SYNC_ALIAS", True):
+            post_migrate.connect(
+                post_migrate_sync_alias,
+                sender=self,
+                dispatch_uid="multisite.post_migrate_sync_alias",
+            )

multisite/exceptions.py

@@ -0,0 +1,57 @@
+from django.conf import settings
+
+
+class MultisiteError(Exception):
+    pass
+
+
+class MultisiteSiteDoesNotExist(Exception):
+    pass
+
+
+class MultisiteCacheError(Exception):
+    pass
+
+
+class MultisiteFallbackError(Exception):
+    pass
+
+
+class MultisiteDisallowedHost(Exception):
+    pass
+
+
+class MultisiteInvalidHostError(Exception):
+    pass
+
+
+class MultisiteServerError(Exception):
+    pass
+
+
+class MultisiteCookieDomainDepthError(Exception):
+    pass
+
+
+def debug_raise_disallowed_host_exception(e):
+    if getattr(settings, "MULTISITE_DEBUG", None):
+        raise MultisiteDisallowedHost(
+            f"DisallowedHost. To silence this exception, set MULTISITE_DEBUG=False. Got {e}."
+        )
+
+
+def debug_raise_cache_missed_exception(netloc, alias):
+    if getattr(settings, "MULTISITE_DEBUG", None):
+        raise MultisiteCacheError(
+            f"Cache missed. Got location {netloc} and Alias {alias}. "
+            "To silence this exception, set MULTISITE_DEBUG=False."
+        )
+
+
+def debug_check_status_code(response, **kwargs) -> None:
+    if response.status_code == 500 and getattr(settings, "MULTISITE_DEBUG", None):
+        raise MultisiteServerError(
+            f"HttpResponse 500. {kwargs}. Got {response}."
+            "To silence this exception, set MULTISITE_DEBUG=False."
+        )
+    return None

multisite/forms.py

@@ -0,0 +1,22 @@
+from __future__ import absolute_import, unicode_literals
+
+from django.contrib.sites.admin import SiteAdmin
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
+
+from .models import Alias
+
+
+class SiteForm(SiteAdmin.form):
+    def clean_domain(self):
+        domain = self.cleaned_data["domain"]
+
+        try:
+            alias = Alias.objects.get(domain=domain)
+        except ObjectDoesNotExist:
+            # New Site that doesn't clobber an Alias
+            return domain
+
+        if alias.site_id == self.instance.pk and alias.is_canonical:
+            return domain
+
+        raise ValidationError('Cannot overwrite non-canonical Alias: "%s"' % alias.domain)

multisite/hacks.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import sys
+
+from django.conf import settings
+from django.core.exceptions import ObjectDoesNotExist
+from django.db.models.signals import post_delete, post_save
+
+__all__ = ["use_framework_for_site_cache"]
+
+from multisite.exceptions import MultisiteSiteDoesNotExist
+
+
+def use_framework_for_site_cache():
+    """Patches sites app to use the caching framework instead of a dict.
+
+    This patch has to exist because SITE_CACHE is normally a dict,
+    which is local only to the process. When running multiple
+    processes, a change to a Site will not be reflected across other
+    ones.
+    """
+    from django.contrib.sites import models
+
+    # Patch the SITE_CACHE
+    site_cache = SiteCache()
+    models.SITE_CACHE = DictCache(site_cache)
+
+    # Patch the SiteManager class
+    models.SiteManager.clear_cache = site_manager_clear_cache
+    models.SiteManager._get_site_by_id = site_manager_get_site_by_id
+
+    # Hooks to update SiteCache
+    post_save.connect(site_cache._site_changed_hook, sender=models.Site)
+    post_delete.connect(site_cache._site_deleted_hook, sender=models.Site)
+
+
+def site_manager_clear_cache(self):
+    """Clears the ``Site`` object cache.
+
+    Override `SiteManager.clear_cache` so it doesn't clobber
+    SITE_CACHE
+    """
+    models = sys.modules.get(self.__class__.__module__)
+    models.SITE_CACHE.clear()
+
+
+def site_manager_get_site_by_id(self, site_id):
+    """Patch _get_site_by_id to retrieve the site from the cache at
+    the beginning of the method to avoid a race condition.
+
+    Override SiteManager._get_site_by_id
+    """
+    models = sys.modules.get(self.__class__.__module__)
+    site = models.SITE_CACHE.get(site_id)
+    if site is None:
+        try:
+            site = self.get(pk=site_id)
+        except ObjectDoesNotExist as e:
+            raise MultisiteSiteDoesNotExist(f"{e} Got site_id={site_id}.")
+        models.SITE_CACHE[site_id] = site
+    return site
+
+
+class SiteCache:
+    """Wrapper for SITE_CACHE that assigns a key_prefix."""
+
+    def __init__(self, cache=None):
+        from django.core.cache import caches
+
+        if cache is None:
+            cache_alias = getattr(settings, "CACHE_MULTISITE_ALIAS", "default")
+            self._key_prefix = getattr(
+                settings,
+                "CACHE_MULTISITE_KEY_PREFIX",
+                settings.CACHES[cache_alias].get("KEY_PREFIX", ""),
+            )
+            cache = caches[cache_alias]
+        else:
+            self._key_prefix = getattr(
+                settings, "CACHE_MULTISITE_KEY_PREFIX", cache.key_prefix
+            )
+        self._cache = cache
+
+    def _get_cache_key(self, key):
+        return "sites.%s.%s" % (self.key_prefix, key)
+
+    def _clean_site(self, site):
+        # Force site.id to be an int, not a SiteID object.
+        site.id = int(site.id)
+        return site
+
+    @property
+    def key_prefix(self):
+        return self._key_prefix
+
+    def get(self, key, *args, **kwargs):
+        return self._cache.get(key=self._get_cache_key(key), *args, **kwargs)
+
+    def set(self, key, value, *args, **kwargs):
+        self._cache.set(
+            key=self._get_cache_key(key), value=self._clean_site(value), *args, **kwargs
+        )
+
+    def delete(self, key, *args, **kwargs):
+        self._cache.delete(key=self._get_cache_key(key), *args, **kwargs)
+
+    def __contains__(self, key, *args, **kwargs):
+        return self._cache.__contains__(key=self._get_cache_key(key), *args, **kwargs)
+
+    def clear(self, *args, **kwargs):
+        self._cache.clear(*args, **kwargs)
+
+    def _site_changed_hook(self, sender, instance, raw, *args, **kwargs):
+        if raw:
+            return
+        self.set(key=instance.pk, value=instance)
+
+    def _site_deleted_hook(self, sender, instance, *args, **kwargs):
+        self.delete(key=instance.pk)
+
+
+class DictCache:
+    """Add dictionary protocol to `django.core.cache.backends.
+    BaseCache`.
+    """
+
+    def __init__(self, cache):
+        self._cache = cache
+
+    def __getitem__(self, key):
+        """x.__getitem__(y) <==> x[y]"""
+        hash(key)  # Raise TypeError if unhashable
+        result = self._cache.get(key=key)
+        if result is None:
+            raise KeyError(key)
+        return result
+
+    def __setitem__(self, key, value):
+        """x.__setitem__(i, y) <==> x[i]=y"""
+        hash(key)  # Raise TypeError if unhashable
+        self._cache.set(key=key, value=value)
+
+    def __delitem__(self, key):
+        """x.__delitem__(y) <==> del x[y]"""
+        hash(key)  # Raise TypeError if unhashable
+        self._cache.delete(key=key)
+
+    def __contains__(self, item):
+        """D.__contains__(k) -> True if D has a key k, else False."""
+        hash(item)  # Raise TypeError if unhashable
+        return self._cache.__contains__(key=item)
+
+    def clear(self):
+        """D.clear() -> None.  Remove all items from D."""
+        self._cache.clear()
+
+    def get(self, key, default=None, version=None):
+        """D.key(k[, d]) -> k if D has a key k, else d.
+
+        Defaults to None.
+        """
+        hash(key)  # Raise TypeError if unhashable
+        return self._cache.get(key=key, default=default, version=version)

multisite/management/commands/update_public_suffix_list.py

@@ -0,0 +1,33 @@
+from __future__ import absolute_import, print_function, unicode_literals
+
+import logging
+import tempfile
+
+import tldextract
+from django.conf import settings
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+    def handle(self, **options):
+        self.setup_logging(verbosity=options.get("verbosity", 1))
+
+        cache_dir = getattr(
+            settings, "MULTISITE_PUBLIC_SUFFIX_LIST_CACHE_DIR", tempfile.gettempdir()
+        )
+        self.log("Updating {cache_dir}".format(cache_dir=cache_dir))
+
+        extract = tldextract.TLDExtract(cache_dir=cache_dir)
+        extract.update(fetch_now=True)
+        self.log("Done.")
+
+    def setup_logging(self, verbosity):
+        self.verbosity = int(verbosity)
+
+        # Connect to tldextract's logger
+        self.logger = logging.getLogger("tldextract")
+        if self.verbosity < 2:
+            self.logger.setLevel(logging.CRITICAL)
+
+    def log(self, msg):
+        self.logger.info(msg)

multisite/middleware/__init__.py

@@ -0,0 +1,4 @@
+from .cookie_domain_middleware import CookieDomainMiddleware
+from .dynamic_site_middleware import DynamicSiteMiddleware
+
+__all__ = ["CookieDomainMiddleware", "DynamicSiteMiddleware"]

multisite/middleware/cookie_domain_middleware.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import tempfile
+
+import tldextract
+from django.conf import settings
+
+__all__ = ["CookieDomainMiddleware"]
+
+from multisite.exceptions import MultisiteCookieDomainDepthError
+
+
+def get_cookie_domain_depth():
+    return getattr(settings, "MULTISITE_COOKIE_DOMAIN_DEPTH", 0)
+
+
+def get_public_suffix_list_cache_dir():
+    return getattr(settings, "MULTISITE_PUBLIC_SUFFIX_LIST_CACHE_DIR", None)
+
+
+class CookieDomainMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+        try:
+            self.depth = int(get_cookie_domain_depth())
+        except ValueError:
+            raise MultisiteCookieDomainDepthError(
+                f"Invalid MULTISITE_COOKIE_DOMAIN_DEPTH. Got {get_cookie_domain_depth()}"
+            )
+        if self.depth < 0:
+            raise MultisiteCookieDomainDepthError(
+                f"Invalid MULTISITE_COOKIE_DOMAIN_DEPTH. Got {get_cookie_domain_depth()}"
+            )
+        self.psl_cache_dir = get_public_suffix_list_cache_dir()
+        if self.psl_cache_dir is None:
+            self.psl_cache_dir = tempfile.gettempdir()
+        self._tldextract = None
+
+    def __call__(self, request):
+        response = self.get_response(request)
+        matched = self.match_cookies(response)
+        if not matched:
+            return response  # No cookies to edit
+
+        parsed = self.tldextract(request.get_host())
+        if not parsed.suffix:
+            return response  # IP address or local path
+        if not parsed.domain:
+            return response  # Only TLD
+
+        subdomains = parsed.subdomain.split(".") if parsed.subdomain else []
+        if not self.depth:
+            subdomains = [""]
+        elif len(subdomains) < self.depth:
+            return response  # Not enough subdomain parts
+        else:
+            subdomains = [""] + subdomains[-self.depth :]
+
+        domain = ".".join(subdomains + [parsed.domain, parsed.suffix])
+
+        for morsel in matched:
+            morsel["domain"] = domain
+        return response
+
+    def tldextract(self, url):
+        if self._tldextract is None:
+            self._tldextract = tldextract.TLDExtract(cache_dir=self.psl_cache_dir)
+        return self._tldextract(url)
+
+    @staticmethod
+    def match_cookies(response):
+        return [c for c in response.cookies.values() if not c["domain"]]