Assoziiere Content mit mehreren Seiten

Die mit Django gebauten Seiten LJWorld.com und Lawrence.com werden innerhalb der selben Nachrichten-Organisation — der Lawrence Journal-World Zeitung in Lawrence, Kansas — betrieben. LJWorld.com spezialisiert sich auf Nachrichten, während Lawrence.com den Schwerpunkt auf lokale Unterhaltung legt. Manchmal jedoch möchten Redakteure einen Artikel auf beiden Seiten veröffentlichen.

Die naive Lösung für dieses Problem wäre, dass die Ersteller der Seiten den selben Artikel zweimal veröffentlichen: Einmal für LJWorld.com und einmal für Lawrence.com. Es ist jedoch ineffizient und redundant, mehrere Kopien ein und desselben Artikels in der Datenbank zu speichern.

Hierfür gibt es eine bessere und dennoch zugleich einfache Lösung: Beide Seite verwenden dieselbe Artikel-Datenbank und ein Artikel ist mit einer oder mehreren Seiten assoziiert. In Djangos Modellterminologie wird dies durch ein ManyToManyField im Article-Modell abgebildet:

from django.db import models
from django.contrib.sites.models import Site

class Article(models.Model):
    headline = models.CharField(max_length=200)
    # ...
    sites = models.ManyToManyField(Site)

Dies ermöglich Folgendes:

• Man kann sämtlichen Content — von beiden Seiten — in einer einzigen Oberfläche (der Django-Administrationsoberfläche) bearbeiten.

• Derselbe Artikel muss nicht doppelt in der Datenbank veröffentlich werden; er hat nur einen einzigen Eintrag in der Datenbank.

• Diese Lösung ermöglicht, dass Entwickler denselben Django-View-Code für beide Seiten verwenden können. Der Code für den View, der einen bestimmten Artikel darstellt, überprüft, ob sich dieser auf der aktuellen Seite befindet. Dies könnte zum Beispiel so aussehen:

  from django.conf import settings
  
  def article_detail(request, article_id):
      try:
          a = Article.objects.get(id=article_id, sites__id__exact=settings.SITE_ID)
      except Article.DoesNotExist:
          raise Http404
      # ...
  

Assoziiere Content mit einer einzigen Seite

Ähnlich dem Ansatz von oben kannst du ein Modell auch durch eine Many-To-One-Relation mit dem Site-Modell assoziieren, indem du einen ForeignKey verwendest.

Wenn, zum Beispiel, ein Artikel nur zu einer einzigen Seite gehören darf, würdest du ein Model wie das Folgende verwenden:

from django.db import models
from django.contrib.sites.models import Site

class Article(models.Model):
    headline = models.CharField(max_length=200)
    # ...
    site = models.ForeignKey(Site)

Diese Lösung hat dieselben Vorteile wie die Lösung, die im vorherigen Abschnitt beschrieben wurde.

Seiten unterscheiden innerhalb von Views

Auf einer sehr tiefen Ebene kannst du das Sites-Framework auch dazu verwenden, um gewisse Dinge innerhalb eines Views abhängig von der aktuellen Seite zu tun. Zum Beispiel:

from django.conf import settings

    def my_view(request):
        if settings.SITE_ID == 3:
            # Mach etwas.
        else:
            # Mach etwas anderes.

Natürlich ist es nicht schön, Site-IDs direkt in den Code zu schreiben. So etwas eignet sich eigentlich nur für schnelle Fixes. Eine etwas schönere Lösung, die genau das gleiche Ergebnis liefert, ist der Vergleich mit der aktuellen Domain:

from django.conf import settings
from django.contrib.sites.models import Site

def my_view(request):
    current_site = Site.objects.get(id=settings.SITE_ID)
    if current_site.domain == 'foo.com':
        # Mach etwas.
    else:
        # Mach etwas anderes.

Sehr häufig will man auch einfach nur das Site-Objekt abfragen, das sich auf die aktuelle Seite bezieht. Aus diesem Grund verfügt der Manager des Site-Modells über die Methode get_current(). Das folgende Beispiel nutzt diese Methode, um das gleiche Ergebnis wie im vorherigen Beispiel zu erzielen:

from django.contrib.sites.models import Site

def my_view(request):
    current_site = Site.objects.get_current()
    if current_site.domain == 'foo.com':
        # Mach etwas.
    else:
        # Mach etwas anderes.

Anzeige der aktuellen Domain

Sowohl LJWorld.com als auch Lawrence.com verfügen über eine E-mail-Benachrichtigung, die es Lesern ermöglicht, sich benachrichtigen zu lassen, wenn es etwas Neues gibt. Die ganze Sache ist recht einfach: Ein Leser meldet sich durch ein Web-Formular an und bekommt umgehend eine Bestätigungs-E-Mail.

Es wäre ineffizient und redundant, diesen Anmeldeprozess zweimal zu implementieren, folglich verwenden beide Seiten denselben Code im Hintergrund. Der Dankeschön-Text muss jedoch für jede Seite etwas anders aussehen. Indem wir nun die Site-Objekte verwenden, können wir die Dankeschön-Nachricht abstrahieren und die entsprechenden Werte für name und domain verwenden.

Hier ein Beispiel, wie der View hinter dem Formular aussieht:

from django.contrib.sites.models import Site
from django.core.mail import send_mail

    def register_for_newsletter(request):
        # Formularfelder etc. überprüfen und lege das Abo für den Benutzer an
        # ...

        current_site = Site.objects.get_current()
        send_mail('Danke, dass du %s Benachrichtigungen abonniert hast' % current_site.name,
            'Danke für dein Abonnement. Wir sind wirklich dankbar.\n\n-Das %s-Team.' % current_site.name,
            'editor@%s' % current_site.domain,
            [user.email])

        # ...

Auf Lawrence.com hat diese E-Mail den Betreff “Thanks for subscribing to lawrence.com alerts”. Auf LJWorld.com hat die E-Mail den Betreff “Thanks for subscribing to LJWorld.com alerts”. Dasselbe gilt für den Inhalt der E-Mail.

Natürlich kannst du hierfür auch Djangos Template-System verwenden, was jedoch etwas schwergewichtiger ist. Gehen wir davon aus, dass Lawrence.com und LJWorld.com unterschiedliche Template-Verzeichnisse (TEMPLATE_DIRS) haben. In diesem Fall könntest du zum Beispiel so vorgehen:

from django.core.mail import send_mail
from django.template import loader, Context

def register_for_newsletter(request):
    # Formularfelder überprüfen etc. und Abo des Benutzers anlegen.
    # ...

    subject = loader.get_template('alerts/subject.txt').render(Context({}))
    message = loader.get_template('alerts/message.txt').render(Context({}))
    send_mail(subject, message, 'editor@ljworld.com', [user.email])

    # ...

In diesem Fall muss du eine subject.txt- und eine message.txt-Templatedatei in beiden Template-Verzeichnissen (also dem von LJWorld.com und auch in dem von Lawrence.com) erstellen. Diese Lösung ist flexibler, jedoch auch komplexer.

Es ist normalerweise ein gute Idee, die Site-Objekte wo immer möglich zu nutzen, um unnötige Komplexität und Redundanz zu vermeiden.

Wie kommt man an vollständige URLs zur aktuellen Domain?

Djangos get_absolute_url()-Konvention ist nützlich, wenn man die URL eines Objektes ohne Domännamen haben möchte, jedoch manchmal möchtest du vielleicht die vollständige URL eines Objektes — also mit http:// usw. — anzeigen. Auch hierfür kannst du das Site-Framework einsetzen. Hier ein einfaches Beispiel:

>>> from django.contrib.sites.models import Site
>>> obj = MyModel.objects.get(id=3)
>>> obj.get_absolute_url()
'/mymodel/objects/3/'
>>> Site.objects.get_current().domain
'example.com'
>>> 'http://%s%s' % (Site.objects.get_current().domain, obj.get_absolute_url())
'http://example.com/mymodel/objects/3/'