• Django per Repository installieren
• HTML-Dateien als Templates

Für dynamische Seiten wie etwa Shops werden Seiten benötigt, die sich serverseitig dynamisch verändern, beispielsweise anhand von Datenbankinhalten. Solche Systeme der Webprogrammierung können auch in anderen Programmiersprachen umgesetzt werden.

• Bei Jakarta/JEE wird ein Application Server gestartet, der Java-programmierte Servlets ausführt.
• Bei PHP liefert Apache den Interpreter als Modul mit, der die die Webseiten dynamisch verändert.
• Bei Node.js & Co wird der Server in JavaScript geschrieben.

Django per Repository installieren

apt-get install python3-django

Environment für Projekt anlegen

apt install python3-venv

Nun wird das Django-Environment angelegt. Dieses enthält neben den Sourcen auch die verwendeten Tools. Aufruf:

python3 -m venv env

Das Verzeichnis env entsteht. Gern wird als Verzeichnisname auch .env verwendet. Das führt dazu, dass das Environment ohne explizite Nennung verdeckt bleibt.

Aktivieren unter Linux und Mac

source env/bin/activate

Aktivieren auf Windows mit CMD.EXE

Das Skript existiert auch in einer Power-Shell-Version an gleichem Ort mit der Erweiterung ps1. Das Skript activate sorgt dafür, dass die Pfade auf dieses Verzeichnis umgebogen werden und so erreicht wird, dass Django nur im lokalen Umfeld installiert wird.

Aktivieren auf Windows mit Power-Shell

Test der Aktivierung

$ which python
/home/.../env/bin/python

Reaktivierung

Installation von Django per PIP

pip install Django

Projekt einrichten

Mit dem Argument startproject wird ein Projekt erzeugt. Als weiteren Parameter muss der Name des Projekts angegeben werden. Im folgenden Beispiel ist das fewo.

django-admin startproject fewo

Nun wechselt man in das Projektverzeichnis und ruft die Datei manage.py über den Python-Interpreter auf:

cd fewo
python3 manage.py runserver

Der Server meldet, dass er unter der Portnummer 8000 zu erreichen ist. Um das zu testen, ruft man einen Browser auf und gibt als URL localhost:8000 ein. Es meldet sich die Standard-Django-Seite mit der Gratulation, dass die Installation geklappt hat.

Möglicherweise tritt auch eine Fehlermeldung auf, die besagt, dass es noch "unapplied migrations" gäbe und schlägt auch gleich die Behandlung vor:

python manage.py migrate

• settings.py
• urls.py: Hierin steht, welches Modul sich um welche URL kümmert.
• asgi.py
• wsgi.py

Erzeugen einer App

python3 manage.py startapp gast

fewo (Das Projekt)
  +-- fewo
  |    +-- urls.py - Pfade des Projekts
  |
  +-- gast
  |    +-- urls.py - Pfade der App (muss später angelegt werden)
  |    +-- models.py
  |    +-- views.py
  |    :
  |
  +-- manage.py

Infrastruktur in urls.py

Die Projekt-urls.py

from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls),
]

from django.urls import path, include

app_name="gast"
urlpatterns = [
    path('admin/', admin.site.urls),
    path('gast/', include('gast.urls')),
]

Die App-urls.py

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
]

Verarbeitung von Anfragen

from django.http import HttpResponse
  
def index(request):
    return HttpResponse("<h1>Hallo</h1>")

python manage.py runserver

Der Parameter Request und die Rückgabe Response

Die Request

• scheme: Hier finden Sie typischerweise die Strings 'http' oder 'https'
• method ('GET', 'POST', 'PUT', 'DELETE', ...)
  • GET: holt eine Datei
  • POST: legt ein neues Objekt an, bei wiederholtem Aufruf wird ein weiteres Objekt angelegt.
  • PUT: ändert ein Objekt, sofern es vorliegt, ansonsten legt es ein neues an.
  • PATCH: ändert Teile eines Objekts
  • DELETE: löscht ein Objekt
  • OPTIONS: fragt, welche Optionen ein Server unterstützt
  • HEAD: holt nur den head-Bereich einer Datei.
• path
• content-type: MIME-Typ des Objekts
  • 'text/plain'
  • 'text/html'
  • 'text/css'
  • 'image/png'
  • 'application/json'
  • 'application/xml'
  • 'video/mp4'
• GET bzw POST Ein Objekt, das dictionary-artig ist
• headers ist eine Liste
• session
• user

Die Response

from django.http import HttpResponse

def index(request):
    return HttpResponse("<h1>Hallo</h1>")

• content: Der Inhalt (Body) der Seite
• status_code: Liefert den HTTP-Status-Code einer Anfrage.
• headers: Liste der Headereinträge

Dynamische Response

Um dynamische Antworten zu geben, können in den String lokale Variablen eingebettet werden. Das ist natürlich auch mit den üblichen String-Manipulationen möglich. Eine häufig verwendete Sonderform für Python stellt der f-String dar.

from django.http import HttpResponse

def index(request):
    name = "James Bond"
    text = f"<h1>Hallo {name} </h1>")
    return HttpResponse(text)

Die Ausgabe von Listen wird immer wieder gebraucht. Hier können die Möglichkeiten von Python im Umgang mit Listen ausgiebig genutzt werden.

from django.http import HttpResponse

def index(request):
    name = "Reisegruppe 007"
    actlist = ["Sean Connery", "Roger Moore", "Timothy Dalton", "Pierce Brosnan"]
    liste = "".join([f"<li>{act}" for act in actlist])
    text =f"""
        <h1> {name} </h1>
        <ul>
        {liste}
        </ul>
    """
    return HttpResponse(text)

Damit haben wir hier erreicht, dass wir mit einem Python-Programm die Antwort an den Browser dynamisch verändern können. Dabei können wir alle Möglichkeiten nutzen, die uns Python zur Verfügung stellt.

HTML-Dateien als Templates

• In der App wird ein Ordner templates angelegt.
• In dem Ordner templates wird wiederum ein Ordner für jede App angelegt. Praktischerweise trägt dieser den Namen der App.
• Darin wird für dieses Beispiel eine Datei mit dem Namen index.html angelegt und mit HTML-Code gefüllt.
• Der Gesamtpfad wäre in unserem Beispiel gast/templates/gast/index.html

INSTALLED_APPS = [
     'gast.apps.GastConfig',
     'django.contrib.admin', ...

from django.apps import AppConfig

class GastConfig(AppConfig):
    default_auto_field = "django.db.models.BigAutoField"
    name = "gast"

Die View kann nun angepasst werden, um die Datei index.html zu laden.

from django.shortcuts import render

def index(request):
    return render(request, "gast/index.html")

Tags im Templates

def index(request):
    gastlist = ["Sean Connery", "Roger Moore", "Timothy Dalton", "Pierce Brosnan"]
    gastcontext = {
        "liste": gastlist,
        "spruch": "Geschüttelt nicht gerührt"
    }
    return render(request, "gast/index.html", gastcontext)

Diese Daten können innerhalb des HTML-Dokuments zugegriffen werden. Sehr einfach ist der Zugriff auf den String in spruch. Eine Variable kann zugegriffen werden, indem sie mit doppelt geschweiften Klammern umgeben wird.

<html>
    <body>
        <h1>Gästeliste</h1>
        {{spruch}}
        </ul>
    </body>
</html>

<html>
    <body>
        <h1>Gästeliste</h1>
        {{spruch}}
        <ul>
        {% for gast in liste %}
        <li>{{gast}}</li>
        {% endfor %}
        </ul>
    </body>
</html>

Formulare

• action: Das Ziel, das die Formularinhalte verarbeitet
• method: Die Art der Sendung, GET oder POST.
  • GET sendet die Fomularinhalte als Teil der URL (nicht verschlüsselbar).
  • POST sendet die Formularinhalte im Body.

Formular ruft Django per GET

Mit dem folgenden Formular wird eine GET-Anfrage an insert gesendet. Diese Funktion soll später die Verarbeitung der eingegebenen Daten übernehmen.

<form action="insert" method="GET">
    <label>Name: </label> <input type="text" name="name"><br>
    <label>E-Mail</label> <input type="text" name="mail">
    <input type="submit" value="ok">
</form>

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('eingabe', views.eingabe),
    path('insert', views.insert),
]

from django.http import HttpResponse
from django.shortcuts import render

# Create your views here.
def index(request):
    return render(request, "gast/index.html")

def eingabe(request):
    return render(request, "gast/eingabe.html")

def insert(request):
    return HttpResponse("Insert")

Da die Eingabemaske die Methode GET verwendet, sieht man die Eingaben auch in der URL:

http://localhost:8000/gast/insert?name=Hugo&mail=hm%40m.de

Durch den Zugriff auf die Variable request und deren GET können die eingegebenen Werte auch in der Funktion insert ausgelesen werden.

def insert(request):
    name = request.GET.get('name', '')
    mail  = request.GET.get('mail','')
    return HttpResponse("Name: " + name + " E-Mail: " + mail)

Formular-POST und das CSRF-Cookie

Der Hintergrund ist, dass der Browser von einem Tab zum anderen springen kann (Cross Site Request) und vielleicht auf diesem bereits angemeldet ist. Auf diese Weise könnte diese Anmeldung benutzt werden, ohne authentifiert zu sein. Um solche Angriffe zu verhindern, verfügt Django über einen CSRF-Mechanismus per Cookie. Dieser kann mit der Tag {% csrf_token %} im FORM eingetragen werden.

<form method=POST ...
    {% csrf_token %}
    <input ....
</form>

def insert(request):
    name = request.POST.get('name', '')
    mail  = request.POST.get('mail','')
    return HttpResponse("Name: " + name + " E-Mail: " + mail)

Umgang mit Datenbanken

# settings.py im Projektordner
# ...
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

• MySQL: django.db.backends.mysql
• PostgreSQL: django.db.backends.postgresql_psycopg2

Definition eines Modells

Die Klassen dieser Objekte werden in der Datei models.py der App definiert. Für einen Gast enthält die Klasse an Attributen:

• ein Name,
• eine Adresse,
• eine Telefonnummer und
• eine E-Mail-Adresse.

Die Klasse wird zum Modell, indem Sie die Basisklasse models.Model erweitert.

# models.py der App
from django.db import models

class Gast(models.Model):
    name    = models.CharField(max_length=100)
    adresse = models.CharField(max_length=100)
    telefon = models.CharField(max_length=50)
    email   = models.EmailField()

    def __str__(self) -> str:
        return f"{self.name}, Adresse {self.adresse}, Tel {self.telefon}, E-Mail {self.email}"

• models.CharField(max_length=200)
• models.EmailField()
• models.DateTimeField('date published')
• models.IntegerField(default=0)

• https://docs.djangoproject.com/en/4.1/ref/models/fields/#field-types

Datenbankerzeugung: Migration

python manage.py makemigrations gast

Migrations for 'gast':
  gast/migrations/0001_initial.py
    - Create model Gast

Bevor man mit der Datenbank arbeiten kann, muss sie explizit migriert werden. Das ist auch erforderlich, wenn sich am Modell irgendetwas ändert.

python manage.py migrate

Erzeugen von Objekten in der Datenbank

Ohne dass dies explizit erwähnt wird, wird automatisch eine Spalte id vom Typ integer angelegt, die einen primären Schlüssel darstellt.

python manage.py shell
>>> from gast.models import Gast
>>> gast = Gast(name="Anton Meier", adresse="Quarkmuehle", telefon="089-112", email="anton@m.de")
>>> gast.save()
>>> gast
<Gast: Anton Meier, Adresse Quarkmuehle, Tel 089-112, E-Mail anton@m.de>
>>>

Anfragen

>>> Gast.objects.all()

>>> Gast.objects.all()[0]

>>> Gast.objects.get(id=1)
>>> Gast.objects.get(adresse="Hamburg")

Filter

>>> Gast.objects.filter(adresse__contains="amb")
<QuerySet [<Gast: Anke Evers, Adresse Hamburg, Tel 220, E-Mail a@e.de>]>

Als Parametervariable wird die Klassenvariable, gefolgt von zwei Unterstrichen und dem Filter-Lookup gesetzt. Das Filter-Lookup ist hier contains (enthält): Es kann startswith (beginnt mit), gt (größer), lt (kleiner), in (in Liste enthalten) oder week (Kalenderwoche) lauten.

Die folgende URL verweist auf eine ausführlichere Beschreibung der Lookups:

• https://docs.djangoproject.com/en/4.1/ref/models/querysets/#field-lookups

Änderungen

>>> g = Gast.objects.get(adresse="Hamburg")
>>> g.telefon="220"
>>> g.save()

Löschen

Views für die Datenverwaltung

index: Liste der Objekte

Nach wie vor steht in der Datei models.py das Model für einen Gast.

from django.db import models

class Gast(models.Model):
    name    = models.CharField(max_length=100)
    adresse = models.CharField(max_length=100)
    telefon = models.CharField(max_length=50)
    email   = models.EmailField()

    def __str__(self) -> str:
        return f"{self.name}, Adresse {self.adresse}, Tel {self.telefon}, E-Mail {self.email}"

from django.shortcuts import render
from . import models

def index(request):
    gastlist = models.Gast.objects.all()
    gastcontext = {
        "liste": gastlist,
        "spruch": "Geschüttelt nicht gerührt"
    }
    return render(request, "gast/index.html", gastcontext)

Die Datei index.html befindet sich immer noch im App-Verzeichnis templates/gast und benötigt keine Änderungen. Sie wertet die übergebene Variable gaeste in einer for-Schleife aus, die daraus die li-Elemente einer ul erzeugt.

<html>
    <body>
        <h1>Gästeliste</h1>
        {{spruch}}
        <ul>
            {% for gast in gaeste %}
            <li> {{gast}} </li>
            {% endfor %}
        </ul>
    </body>
</html>

Detailanzeige eines einzelnen Objekts

<ul>
    {% for gast in gaeste %}
    <li> {{gast}}
         <a href="{% url 'gast:detail' gast.id %}">Details</a></li>
    {% endfor %}
</ul>

Die URL gast:detail in der index.html zeigt auf eine URL, die in der Datei urls.py aufgeführt werden muss. Hier muss auch erwähnt werden, dass die Funktion die id als Parameter benötigt. Diese wurde hinter der URL als gast.id angegeben und ist eine ganze Zahl, also ein int.

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('detail/<int:id>', views.detail, name='detail'),
]

from django.shortcuts import render
from . import models

def index(request):
    gaeste = models.Gast.objects.all()
    context = { 'gaeste': gaeste }
    return render(request, "gast/index.html", context)

def detail(request, id):
    gast = models.Gast.objects.get(id=id)
    context = { 'gast': gast }
    return render(request, "gast/detail.html", context)

<html>
    <body>
        <h1>Gast</h1>
        {{gast.name}}<br>
        {{gast.adresse}}<br>
        {{gast.telefon}}<br>
        {{gast.email}}<p>
        <p>
        <a href="{% url 'gast:index' %}">Liste</a>
        </p>
    </body>
</html>

Anlegen eines Gastes

<a href="{% url 'gast:eingabe' %}">Neuer Gast</a>

Dazu muss eingabe in der Datei urls.py der App eingetragen werden, wo sich die Funktion für das Anlegen eines Gastes befindet. Da die Funktion über einen Link mit gast:eingabe aufgerufen wird, muss der dritte Parameter name gesetzt sein.

from django.urls import path
from . import views

app_name="gast"
urlpatterns = [
    path('', views.index, name='index'),
    path('detail/<int:id>', views.detail, name='detail'),
    path('eingabe/', views.eingabe, name='eingabe'),
]

def eingabe(request):
    return render(request, "gast/eingabe.html")

<form action="{% url 'gast:insert' %}" method="POST">
    {% csrf_token %}
    <label>Name: </label> <input type="text" name="name"><br>
    <label>Adr:</label> <input type="text" name="adr"><br>
    <label>Tel.:</label> <input type="text" name="tel" id="tel"><br>
    <label>Mail:</label> <input type="text" name="mail" id="mail"><br>
    <input type="submit" value="ok">
</form>

from django.urls import path
from . import views

app_name="gast"
urlpatterns = [
    path('', views.index, name='index'),
    path('detail/<int:id>', views.detail, name='detail'),
    path('eingabe/', views.eingabe, name='eingabe'),
    path('insert/', views.insert),
]

from django.shortcuts import render, redirect, reverse
from . import models
# ...
def insert(request):
    name = request.POST.get("name")
    adr = request.POST.get("adr")
    tel = request.POST.get("tel")
    mail = request.POST.get("mail")
    gast = models.Gast(name=name, adresse=adr, telefon=tel, email=mail)
    gast.save()
    return redirect(reverse("gast:detail", args=[gast.id]))

Pflichtfelder und Eingabevalidierung

<input type="text" name="adr" id="adr" required>

def insert(request):
    name = request.POST.get("name")
    adr = request.POST.get("adr")
    tel = request.POST.get("tel")
    mail = request.POST.get("mail")
    if name and adr and tel and mail:
        # Alle Felder sind gefüllt
        b = models.Gast(name=name, adresse=adr, telefon=tel)
        b.save()
        return redirect(reverse("gast:detail", args=[gast.id]))
    else:
        # Da fehlt ein Feld. Zurück in die Eingabemaske
        return render(request, "gast/eingabe.html",{"error":"Alle Eingabefelder füllen"})

<html>
    <body>
        <h1>Gast erfassen</h1>
        <form action="{% url 'gast:insert' %}" method="post">
            {% csrf_token %}
            {% if error %}
                <p>Fehler: {{error}}</p>
            {% endif %}
            Name: <input type="text" name="name" id="name"><br>
            Adr.: <input type="text" name="adr" id="adr"><br>
            Tel.: <input type="text" name="tel" id="tel"><br>
            Mail: <input type="text" name="mail" id="mail"><br>
            <input type="submit" value="OK">
        </form>
    </body>
</html>

def insert(request):
    name = request.POST.get("name")
    adr = request.POST.get("adr")
    tel = request.POST.get("tel")
    mail = request.POST.get("mail")
    if name and adr and tel and mail:
        # Alle Felder sind gefüllt
        b = models.Gast(name=name, adresse=adr, telefon=tel)
        b.save()
        return redirect(reverse("gast:detail", args=[gast.id]))
    elif not "@" in mail:
        return render(request, "gast/eingabe.html",{"error":"Mail-Adresse nicht korrekt"})
    elif len(tel) < 5:
        return render(request, "gast/eingabe.html",{"error":"Telefonnummer zu kurz"})
    else:
        # Da fehlt ein Feld. Zurück in die Eingabemaske
        return render(request, "gast/eingabe.html",{"error":"Alle Eingabefelder füllen"))

def insert(request):
    name = request.POST.get("name")
    adr = request.POST.get("adr")
    tel = request.POST.get("tel")
    mail = request.POST.get("mail")
    context = {'name': name, 'adr': adr, 'tel':tel, 'mail':mail}
    if name and adr and tel and mail:
        # Alle Felder sind gefüllt
        b = models.Gast(name=name, adresse=adr, telefon=tel)
        b.save()
        return redirect(reverse("gast:detail", args=[gast.id]))
    elif not "@" in mail:
        context.update({'error':"Mail-Adresse nicht korrekt"})
        return render(request, "gast/eingabe.html",context)
    elif len(tel) < 5:
        context.update({"error":"Telefonnummer zu kurz"})
        return render(request, "gast/eingabe.html", context)
    else:
        # Da fehlt ein Feld. Zurück in die Eingabemaske
        context.update({"error":"Alle Eingabefelder füllen"})
        return render(request, "gast/eingabe.html", context)

<html>
    <body>
        <h1>Gast erfassen</h1>
        <form action="{% url 'gast:insert' %}" method="post">
            {% csrf_token %}
            {% if error %}
                <p>Fehler: {{error}}</p>
            {% endif %}
            Name: <input type="text" name="name" id="name" value={{name}}><br>
            Adr.: <input type="text" name="adr" id="adr" value={{adr}}><br>
            Tel.: <input type="text" name="tel" id="tel" value={{tel}}><br>
            Mail: <input type="text" name="mail" id="mail" value={{mail}}><br>
            <input type="submit" value="OK">
        </form>
    </body>
</html>

Mehrere Tabellen/Objekte

In der Welt der Datenbanktabellen erreicht man solch eine Beziehung, indem die Buchung einen Eintrag für den eindeutigen Schlüssel des Gastes enthält, der bucht. Man spricht von einem Fremdschlüssel oder foreign key.

class Buchung(models.Model):
    gast = models.ForeignKey(Gast, on_delete=models.DO_NOTHING)
    wohnung = models.CharField(max_length=30)
    von = models.DateField()
    bis = models.DateField()
    preis = models.DecimalField(decimal_places=8, max_digits=11)

    def __str__(self) -> str:
        return f"{self.von} bis {self.bis} Gast {self.gast.name} Wohnung {self.wohnung.bez}"

class Wohnung(models.Model):
    bez = models.CharField(max_length=30)
    adr = models.CharField(max_length=70)
    preis = models.DecimalField(decimal_places=8, max_digits=11)
    preis_hs = models.DecimalField(decimal_places=8, max_digits=11)

    def __str__(self) -> str:
        return self.bez

Gast und Wohnung werden durch eine Buchung verbunden. Ein Gast kann nicht nur eine Wohnungen buchen. Er kann gern jedes Jahr wiederkommen und wieder eine Wohnung buchen. Und auch eine Wohnung ist nicht nur für einen Gast da, sondern wird im Laufe der Zeit von mehreren Gästen gebucht werden. Man spricht von einer m:n-Beziehung.

class Buchung(models.Model):
    gast = models.ForeignKey(Gast, on_delete=models.DO_NOTHING)
    wohnung = models.ForeignKey(Wohnung, on_delete=models.CASCADE)
    von = models.DateField()
    bis = models.DateField()
    preis = models.DecimalField(decimal_places=8, max_digits=11)

    def __str__(self) -> str:
        return f"{self.von} bis {self.bis} Gast {self.gast.name} Wohnung {self.wohnung.bez}"

Die Forms von Django

Es wird eine neue Datei forms.py in der App angelegt. Diese bindet die Django-Klasse ModelForm und das lokal definierte Modell ein.

from django.forms import ModelForm
from .models import Gast

class GastForm(ModelForm):
    class Meta:
        model = Gast
        fields = ('name', 'adresse','telefon','email')

from .forms import GastForm

# ...

def eingabe(request):
    form = GastForm()
    return render(request, "gast/eingabe.html", {'form': form})

<html>
    <body>
        <h1>Gast erfassen</h1>
        <form method="post" action="{% url 'gast:insert' %}" >
            {% csrf_token %}
            {{ form }}
            <button type="submit" class="save btn btn-default">Erfassen</button>
        </form>
    </body>
</html>

Das Eingabeformular von Wohnung kann ähnlich realisiert werden, da die Tabelle ebenfalls keine Fremdschlüssel enthält.

Form mit Fremdschlüssel

class Buchung(models.Model):
    gast = models.ForeignKey(Gast, on_delete=models.DO_NOTHING)
    wohnung = models.ForeignKey(Wohnung, on_delete=models.CASCADE)
    von = models.DateField()
    bis = models.DateField()
    preis = models.DecimalField(decimal_places=8, max_digits=11)

    def __str__(self) -> str:
        return f"{self.von} bis {self.bis} Gast {self.gast.name} Wohnung {self.wohnung.bez}"

from django.forms import ModelForm, DateInput
# ...
class BuchForm(ModelForm):
    class Meta:
        model = Buchung
        fields = ('von', 'bis', 'preis', 'gast', 'wohnung')
        widgets = {
            'von': DateInput(attrs={'class':'form-control', 'type':'date'}),
             'bis': DateInput(attrs={'class':'form-control', 'type':'date'}), 
        }

Für die Datumsfelder sind die widgets besonders interessant. Ohne diese würde Django für die Datumsfelder ganz normale Texteingaben erstellen. Der Benutzer müsste dort ein zulässiges Datumsformat eingeben, ohne darauf hingewiesen zu werden, wie dieses aussieht.

Das DateInput-Element sorgt dafür, dass das Datumsformat angezeigt und beim Klicken eines Feldes ein Auswahldialog aufgeht, das die Auswahl des Tages aus einem Kalender erlaubt.

Um eine Buchung zu erfassen, wird eine Funktion zum Aufruf der Formular-Webseite (buchform) benötigt und eine weitere Funktion für die spätere Auswertung (buchinsert). Beides sollte gleich in der urls.py vorgemerkt werden.

# urls.py der App
urlpatterns = [
# ...
    path('buchform/', views.buchform, name='buchform'),
    path('buchinsert/', views.buchinsert, name='buchinsert'),
]

def buchform(request):
    gast = models.Gast.objects.all()
    wohnung = models.Wohnung.objects.all()
    form = BuchForm()
    context = { 'gast': gast, 'wohnung': wohnung, 'form': form }
    return render(request, "gast/buchform.html", context)

<html>
    <body>
        <h1>Buchen</h1>
            <form method="post" action="{% url 'gast:buchinsert' %}" >
                {% csrf_token %}
                {{ form }}
                <button type="submit" class="save btn btn-default">Erfassen</button>
            </form>
    </body>
</html>

Die action der form leitet weiter auf die Funktion buchinsert. Sobald der Anwender also das Formular ausgefüllt hat, geht es dort weiter. Diese Funktion liest aus der POST-Liste der Request die einzelnen Felder aus. Dabei wird deutlich, dass für Gast und Wohnung nicht das komplette Objekt, sondern nur die id übertragen wird.

In der Annahme, dass der Anwender beim Ausfüllen des Formulars schön artig war, können aus den ids die Objekte gewonnen werden und mit den anderen Eingaben über den Konstruktor zur Erzeugung einer Buchung genutzt werden. Durch den anschließenden Aufruf der Methode save() wird alles in die Datenbank geschrieben.

def buchinsert(request):
    von = request.POST.get("von")
    bis = request.POST.get("bis")
    preis = request.POST.get("preis")
    gid = request.POST.get("gast")
    gast = models.Gast.objects.get(id=gid)
    wid = request.POST.get("wohnung")
    wohnung = models.Wohnung.objects.get(id=wid)
    buchung = models.Buchung(von=von, bis=bis, preis=preis, gast=gast, wohnung=wohnung)
    buchung.save()
    return redirect(reverse("gast:detail", args=[gast.id]))

Django Admin

from django.contrib import admin
from django.urls import path, include
urlpatterns = [
    path('buchform/', views.buchform, name='buchform'),
    ...
    path('admin/', admin.site.urls),
]

python manage.py createsuperuser

• Der Name des Aministrationskonto muss angegeben werden. Dazu wird der Username des Entwicklers vorgeschlagen. Hier ist admin aber passender.
• Es wird eine E-Mail-Adresse eingefordert.
• Es muss zwei Mal ein Passwort mit mindestens acht Zeichen eingegeben werden. Die Sicherheitskriterien können aber übergangen werden.

Benutzer und Gruppen verwalten

Durch den Klick auf +Add hinter Users kann ein Benutzer angelegt werden. Es wird ein Benutzername und ein Passwort benötigt. Dabei prüft Django sehr genau, dass das Passwort dem Benutzer nicht zu ähnlich ist und auch mindestens acht Buchstaben groß ist.

In einem weiteren Dialog können weitere Informationen für den Benutzer definiert werden, insbesondere seine Berechtigung, bestimmte Modelle zu bearbeiten.

Verwaltung der Modelle per Admindialog

# admin.py
from django.contrib import admin
from .models import Gast
# Register your models here.
admin.site.register(Gast)

Abbildung: Administrationsbildschirm mit Modell

Die Darstellung der Admin-Modelle kann durch Vererbung erweitert werden. In der folgenden admin.py wird die Buchung durch eine BuchAdmin ersetzt. Die Klasse erweitert admin.ModelAdmin und trägt in fields die Feldnamen und in list_display diejenigen Elemente von fields, die in der Listendarstellung auftreten sollen. Dabei wird der Fremdschlüssel gast wieder durch die __str__-Methode, diesmal von Gast dargestellt.

from django.contrib import admin
from .models import Gast, Buchung, Wohnung
# Register your models here.
admin.site.register(Gast)
admin.site.register(Wohnung)

class BuchAdmin(admin.ModelAdmin):
    fields = ('gast', 'wohnung', 'von', 'bis')
    list_display = ('gast', 'wohnung', 'von', 'bis')

#admin.site.register(Buchung)
admin.site.register(Buchung, BuchAdmin)

Ein weiteres Element von BuchAdmin kann readonly_fields sein. Dieses sollte alle Felder enthalten, die nicht änderbar sein sollen, sondern nur lesbar. Das betrifft beispielsweise Datumsfelder, die automatisch gesetzt werden.

Mit dem Element list_filter kann die Liste durch Setzen eines Filters eingegrenzt werden, mit dem Element search_fields kann in den angeführten Spalten gesucht werden.

Für alle diese Elemente gilt, dass sie ein Tupel oder eine Liste darstellen müssen. Ist nur ein Element vorhanden, muss ein Komma dahinter gesetzt werden.

Authentifizierung

Berechtigungen

In einer Anwendung würde zunächst der Benutzer angefordert und dann mit has_perm geprüft, ob die Berechtigung vorliegt.

from django.contrib.auth.models import User, Permission

user = User.objects.get(username = "wirt")
if user.has_perm(gast.add_wohnung'):

from django.contrib.auth import authenticate

user = authenticate(username='wirt', password='geheim')
if user is not None:
    user.set_password('ganzgeheim')
    user.save()

User einer Request abfragen

def tudochwas(request):
   if request.user.is_authenticated:
       return HttpResponse("Ach, Du bist's, "+user.username)
   else:
       return HttpResponse("Nur Mitglieder!")

from django.contrib.auth.decorators import login_required

@login_required
def eingabe(request):

# ...
from django.contrib.auth import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('gast/', include("gast.urls")),
    path('accounts/login/', views.LoginView.as_view(), name='login'),
]

{% if form.errors %}
<p>Benutzer und Passwort passen nicht.</p>
{% endif %}
<form method="post" action="{% url 'login' %}">
{% csrf_token %}
<table>
<tr>
    <td>{{ form.username.label_tag }}</td>
    <td>{{ form.username }}</td>
</tr>
<tr>
    <td>{{ form.password.label_tag }}</td>
    <td>{{ form.password }}</td>
</tr>
</table>
<input type="submit" value="Anmelden" />
<input type="hidden" name="next" value="{{ next }}" />
</form>

• Django Girls Tutorial: Extensions

Zugriff auf APIs von REST-Datenquellen

pip install requests

from django.http import HttpResponse

def index(request):
    r = requests.get('https://official-joke-api.appspot.com/random_joke')
    if r.status_code == 200:
        js = r.json()
        frage = js.get("setup")
        antwort = js.get("punchline")
        text = "<h2>"+frage+"</h2><h3>"+antwort+"</h3>"
        response = HttpResponse(text)
    else:
        response = HpptResponse(f"Fehler mit Status-Code {response.status_code}")
    return response

JSON-Struktur

$ curl https://official-joke-api.appspot.com/random_joke
{"id":187,"type":"general","setup":"What did the late
tomato say to the early tomato?","punchline":"I’ll ketch up"}
$ 

Links und Literatur

• Django Girls Tutorial
• Django Documentation
• Elman, Lavin: Lightweight Django. 2015, S. 4.
• How to use Django with Apache and mod_wsgi