Added multi-domain capabilities

src/pretix/multidomain/__init__.py

@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+
+class PretixMultidomainConfig(AppConfig):
+    name = 'pretix.multidomain'
+    label = 'pretixmultidomain'
+
+default_app_config = 'pretix.multidomain.PretixMultidomainConfig'

src/pretix/multidomain/middlewares.py

@@ -0,0 +1,112 @@
+import time
+from urllib.parse import urlparse
+
+from django.conf import settings
+from django.contrib.sessions.middleware import \
+    SessionMiddleware as BaseSessionMiddleware
+from django.core.exceptions import DisallowedHost
+from django.http.request import split_domain_port
+from django.middleware.csrf import CsrfViewMiddleware as BaseCsrfMiddleware
+from django.utils.cache import patch_vary_headers
+from django.utils.http import cookie_date
+
+from pretix.multidomain.models import KnownDomain
+
+
+class MultiDomainMiddleware:
+    def process_request(self, request):
+        # We try three options, in order of decreasing preference.
+        if settings.USE_X_FORWARDED_HOST and ('HTTP_X_FORWARDED_HOST' in request.META):
+            host = request.META['HTTP_X_FORWARDED_HOST']
+        elif 'HTTP_HOST' in request.META:
+            host = request.META['HTTP_HOST']
+        else:
+            # Reconstruct the host using the algorithm from PEP 333.
+            host = request.META['SERVER_NAME']
+            server_port = str(request.META['SERVER_PORT'])
+            if server_port != ('443' if request.is_secure() else '80'):
+                host = '%s:%s' % (host, server_port)
+
+        domain, port = split_domain_port(host)
+        default_domain, default_port = split_domain_port(urlparse(settings.SITE_URL).netloc)
+        if domain:
+            request.host = domain
+            request.port = int(port) if port else None
+            try:
+                kd = KnownDomain.objects.get(domainname=domain)  # noqa
+                request.domain = kd
+            except:
+                if settings.DEBUG or domain in ('testserver', 'localhost') or domain == default_domain:
+                    return  # TODO: Select main page
+                raise DisallowedHost("Unknown host: %r" % host)
+            else:
+                request.organizer = kd.organizer
+        else:
+            raise DisallowedHost("Invalid HTTP_HOST header: %r." % host)
+
+
+class SessionMiddleware(BaseSessionMiddleware):
+    def process_response(self, request, response):
+        try:
+            accessed = request.session.accessed
+            modified = request.session.modified
+            empty = request.session.is_empty()
+        except AttributeError:
+            pass
+        else:
+            # First check if we need to delete this cookie.
+            # The session should be deleted only if the session is entirely empty
+            if settings.SESSION_COOKIE_NAME in request.COOKIES and empty:
+                response.delete_cookie(settings.SESSION_COOKIE_NAME)
+            else:
+                if accessed:
+                    patch_vary_headers(response, ('Cookie',))
+                if modified or settings.SESSION_SAVE_EVERY_REQUEST:
+                    if request.session.get_expire_at_browser_close():
+                        max_age = None
+                        expires = None
+                    else:
+                        max_age = request.session.get_expiry_age()
+                        expires_time = time.time() + max_age
+                        expires = cookie_date(expires_time)
+                    # Save the session data and refresh the client cookie.
+                    # Skip session save for 500 responses, refs #3881.
+                    if response.status_code != 500:
+                        request.session.save()
+                        response.set_cookie(settings.SESSION_COOKIE_NAME,
+                                            request.session.session_key, max_age=max_age,
+                                            expires=expires, domain=request.host,
+                                            path=settings.SESSION_COOKIE_PATH,
+                                            secure=request.scheme == 'https',
+                                            httponly=settings.SESSION_COOKIE_HTTPONLY or None)
+        return response
+
+
+class CsrfViewMiddleware(BaseCsrfMiddleware):
+    def process_response(self, request, response):
+        if getattr(response, 'csrf_processing_done', False):
+            return response
+
+        # If CSRF_COOKIE is unset, then CsrfViewMiddleware.process_view was
+        # never called, probably because a request middleware returned a response
+        # (for example, contrib.auth redirecting to a login page).
+        if request.META.get("CSRF_COOKIE") is None:
+            return response
+
+        if not request.META.get("CSRF_COOKIE_USED", False):
+            return response
+
+        # Set the CSRF cookie even if it's already set, so we renew
+        # the expiry timer.
+        response.set_cookie(settings.CSRF_COOKIE_NAME,
+                            request.META["CSRF_COOKIE"],
+                            max_age=settings.CSRF_COOKIE_AGE,
+                            domain=request.host,
+                            path=settings.CSRF_COOKIE_PATH,
+                            secure=request.scheme == 'https',
+                            httponly=settings.CSRF_COOKIE_HTTPONLY
+                            )
+        # Content varies with the CSRF cookie, so set the Vary header.
+        patch_vary_headers(response, ('Cookie',))
+        response.csrf_processing_done = True
+        return response

src/pretix/multidomain/migrations/0001_initial.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+import versions.models
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('pretixbase', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='KnownDomain',
+            fields=[
+                ('domainname', models.CharField(serialize=False, max_length=255, primary_key=True)),
+                ('organizer', versions.models.VersionedForeignKey(blank=True, to='pretixbase.Organizer', null=True)),
+            ],
+        ),
+    ]

src/pretix/multidomain/migrations/0002_auto_20151018_1007.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+import versions.models
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('pretixmultidomain', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='knowndomain',
+            options={'verbose_name': 'Known domain', 'verbose_name_plural': 'Known domains'},
+        ),
+        migrations.AlterField(
+            model_name='knowndomain',
+            name='organizer',
+            field=versions.models.VersionedForeignKey(to='pretixbase.Organizer', null=True, related_name='domains', blank=True),
+        ),
+    ]

src/pretix/multidomain/models.py

@@ -0,0 +1,27 @@
+from django.db import models
+from django.utils.translation import ugettext_lazy as _
+from versions.models import VersionedForeignKey
+
+from pretix.base.models import Organizer
+
+
+class KnownDomain(models.Model):
+    domainname = models.CharField(max_length=255, primary_key=True)
+    organizer = VersionedForeignKey(Organizer, blank=True, null=True, related_name='domains')
+
+    class Meta:
+        verbose_name = _("Known domain")
+        verbose_name_plural = _("Known domains")
+
+    def __str__(self):
+        return self.domainname
+
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+        if self.organizer:
+            self.organizer.get_cache().clear()
+
+    def delete(self, *args, **kwargs):
+        if self.organizer:
+            self.organizer.get_cache().clear()
+        super().delete(*args, **kwargs)

src/pretix/multidomain/templatetags/eventurl.py

@@ -0,0 +1,71 @@
+from django import template
+from django.core.urlresolvers import NoReverseMatch
+from django.template import TemplateSyntaxError
+from django.template.base import kwarg_re
+from django.template.defaulttags import URLNode
+from django.utils.encoding import smart_text
+from django.utils.html import conditional_escape
+
+register = template.Library()
+
+
+class EventURLNode(URLNode):
+    def __init__(self, event, view_name, kwargs, asvar):
+        self.event = event
+        super().__init__(view_name, [], kwargs, asvar)
+
+    def render(self, context):
+        from pretix.multidomain.urlreverse import eventreverse
+        kwargs = {
+            smart_text(k, 'ascii'): v.resolve(context)
+            for k, v in self.kwargs.items()
+        }
+        view_name = self.view_name.resolve(context)
+        event = self.event.resolve(context)
+        url = ''
+        try:
+            url = eventreverse(event, view_name, kwargs=kwargs)
+        except NoReverseMatch:
+            if self.asvar is None:
+                raise
+
+        if self.asvar:
+            context[self.asvar] = url
+            return ''
+        else:
+            if context.autoescape:
+                url = conditional_escape(url)
+            return url
+
+
+@register.tag
+def eventurl(parser, token):
+    """
+    Similar to {% url %} in the same way that eventreverse() is similar to reverse().
+
+    Takes an event object, an url name and optional keyword arguments
+    """
+    bits = token.split_contents()
+    if len(bits) < 3:
+        raise TemplateSyntaxError("'%s' takes at least one argument, an event and the name of a url()." % bits[0])
+    viewname = parser.compile_filter(bits[2])
+    event = parser.compile_filter(bits[1])
+    kwargs = {}
+    asvar = None
+    bits = bits[3:]
+    if len(bits) >= 3 and bits[-2] == 'as':
+        asvar = bits[-1]
+        bits = bits[:-2]
+
+    if len(bits):
+        for bit in bits:
+            match = kwarg_re.match(bit)
+            if not match:
+                raise TemplateSyntaxError("Malformed arguments to eventurl tag")
+            name, value = match.groups()
+            if name:
+                kwargs[name] = parser.compile_filter(value)
+            else:
+                raise TemplateSyntaxError('Event urls only have keyword arguments.')
+
+    return EventURLNode(event, viewname, kwargs, asvar)

src/pretix/multidomain/urlreverse.py

@@ -0,0 +1,44 @@
+from urllib.parse import urljoin, urlsplit
+
+from django.conf import settings
+from django.core.urlresolvers import reverse
+
+
+def get_domain(event):
+    c = event.organizer.get_cache()
+    domain = c.get('domain')
+    if domain is None:
+        domains = event.organizer.domains.all()
+        domain = domains[0].domainname if domains else None
+        c.set('domain', domain or 'none')
+    elif domain == 'none':
+        return None
+    return domain
+
+
+def eventreverse(event, name, kwargs=None):
+    """
+    Works similar to django.core.urlresolvers.reverse but takes into account that some
+    organizers might have their own (sub)domain instead of a subpath.
+    """
+    kwargs = kwargs or {}
+    kwargs['event'] = event.slug
+    domain = get_domain(event)
+    if domain:
+        if 'organizer' in kwargs:
+            del kwargs['organizer']
+        path = reverse(name, kwargs=kwargs)
+        siteurlsplit = urlsplit(settings.SITE_URL)
+        if siteurlsplit.port and siteurlsplit.port not in (80, 443):
+            domain = '%s:%d' % (domain, siteurlsplit.port)
+        return urljoin('%s://%s' % (siteurlsplit.scheme, domain), path)
+
+    kwargs['organizer'] = event.organizer.slug
+    return reverse(name, kwargs=kwargs)
+
+
+def build_absolute_uri(event, urlname, kwargs=None):
+    reversedurl = eventreverse(event, urlname, kwargs)
+    if '://' in reversedurl:
+        return reversedurl
+    return urljoin(settings.SITE_URL, reversedurl)