CRUD-Operationen in Python und Django – Teil 2

In unserem vorherigen Artikel haben wir die Grundlagen der Einrichtung eines Django-Projekts behandelt und unser Übungsmodell erstellt, das wir im Frontend als Liste angezeigt haben. In diesem Artikel befassen wir uns intensiv mit der Durchführung von CRUD-Vorgängen. Für diejenigen, die es nicht kennen: CRUD steht für Erstellen, Lesen, Aktualisieren und Löschen – im Wesentlichen die vier grundlegenden Aktionen, die Sie mit Ihren Daten durchführen können.

Da wir nun unsere API im App-Ordner eingerichtet haben, erweitern wir einfach die Indexansicht, um Erstellungs-, Aktualisierungs- und Löschanfragen zu verarbeiten.

Das Formular

Lassen Sie uns ein Formular einrichten, mit dem Benutzer Übungen erstellen können. Zu diesem Zweck werden wir wieder HTML-Vorlagen verwenden. Erstellen Sie zunächst eine neue Vorlage mit dem Namen add_exercise.html im Ordner app/templates.

<form method="POST" action="/">
    {% csrf_token %}
    <input type="text" name="title" placeholder="Enter the title" />
    <input type="date" name="date"  placeholder="Enter the date" />
    <button type="submit">Save</button>
</form>

Als nächstes fügen wir in unsere Vorlage „index.html“ die Vorlage „add_exercise.html“ mit der folgenden Methode ein:

{% extends "base.html" %} {% block content %}
    <h2>Exercises</h2>
    {% include 'add_exercise.html' %}
...
{% endblock %}

Wir verwenden hier das „include“-Tag, das die Zusammensetzbarkeit über HTML-Vorlagen hinweg fördert und die Pflege und das Verständnis unseres Codes erleichtert. Wenn Sie die Seite in Ihrem Browser aktualisieren, sollte das Formular auf dem Bildschirm erscheinen.

In unserem HTML verwenden wir das 

 Tag mit dem Methodenattribut auf POST und dem Aktionsattribut, das auf / verweist. Dies ist derselbe Endpunkt, den wir zum Abrufen der Übungsliste verwenden.

In diesem Zusammenhang ist das csrf_token ein Sicherheitsmerkmal, das durch einen zufällig generierten geheimen Wert dargestellt wird. Es trägt dazu bei, unsere Formulareinsendungen vor Fälschungsangriffen zu schützen, wofür CSRF steht – Cross-Site Request Forgery. Für jede Benutzersitzung wird ein eindeutiges Token generiert, auf das Websites Dritter nicht zugreifen können, wodurch unbefugte Änderungen verhindert werden.

Unser Formular enthält zwei Eingabefelder: eines für den Titel und eines für das Datum, entsprechend dem Schema unseres Übungsmodells. Wenn das Formular gesendet wird, werden die Werte für Titel und Datum über eine POST-Anfrage an den Endpunkt / gesendet, der dann von unserer Indexansicht in app/views.py verarbeitet wird.

Das Modell

In Django können wir unser Übungsmodell – im Wesentlichen eine Python-Klasse – erweitern, indem wir spezifische Methoden hinzufügen, die CRUD-Operationen entsprechen. In die Datei „app/models.py“ fügen wir Folgendes ein:

class Exercise(models.Model):
    ...

    def create(request):
        title = request.POST.get('title')
        date = request.POST.get('date')

        exercise = Exercise.objects.create(title=title, date=date)

        return exercise

Wir können über die POST-Anfrage auf Titel und Datum zugreifen, wie im obigen Code gezeigt. Dann können wir Djangos integriertes ORM nutzen, um eine neue Übung zu erstellen und die erstellte Instanz zurückzugeben.

Wir nutzen dieselbe Indexansicht, die wir zum Abrufen von Übungen verwenden, und erweitern sie, um zu prüfen, ob die Anforderungsmethode POST ist. Wenn ja, übergeben wir das Anforderungsobjekt an die zuvor definierte Klassenmethode. Sobald die Übung erstellt ist, leiten wir den Benutzer zurück zur Startseite oder führen eine Seitenaktualisierung durch, um sicherzustellen, dass die neu hinzugefügte Übung auf dem Bildschirm angezeigt wird.

from django.http import HttpResponseRedirect

from app import models

...

def index(request):
    if request.method == 'POST':
        models.Exercise.create(request)
        return redirect('/')

    exercises = (
        models.Exercise.objects.all().order_by("created_at")
    )
    return render(request, "index.html", context={'exercises': exercises})

Versuchen Sie jetzt, eine neue Übung zu erstellen. Sie sollte dann unten in der Liste angezeigt werden.

Update-Übung

Lassen Sie uns unseren Code ein wenig umgestalten, bevor wir den Übungen Aktualisierungsfunktionen hinzufügen. Wir verschieben die Übungen in eine eigene Vorlage namens exercise.html.

<h2>Exercises</h2>
{% include 'add_exercise.html' %}
<ul style="margin: 0; list-style: none; padding: 0">
    {% for exercise in exercises %}
        <li style="margin-top: 4px">
            {% include 'exercise.html' %}
        </li>
    {% endfor %}
</ul>

Erstellen Sie eine Vorlage für „exercise.html“ im Ordner „app/templates“ und wir fügen ihr den folgenden HTML-Code hinzu:

<form method="POST" action="/">
    {% csrf_token %}
    <input hidden name="id" value="{{exercise.id}}" />
    <input
        type="text"
        name="title"
        value="{{exercise.title}}"
        placeholder="Enter the title"
    />
    <input
        type="date"
        name="date"
        placeholder="Enter the date"
        value="{{exercise.date | date:'Y-m-d'}}"
    />
    <button type="submit" name="update">Update</button>
</form>

Wir verwenden das  Markieren Sie jede Übung in der Liste erneut und fügen Sie eine versteckte Eingabe für „exercise.id“ hinzu, die zum Aktualisieren der Übung verwendet wird. Gehen Sie zurück zum Browser und aktualisieren Sie die Seite. Sie sollten für jede Übung in der Liste ein Formular sehen, in dem jede Eingabe mit den entsprechenden Übungsdaten vorab ausgefüllt ist.

Beachten Sie, dass wir PUT nicht als Formularmethode verwenden. Stattdessen verwenden wir POST. Dies liegt daran, dass die View-Handler nur Daten analysieren können, die über GET- und POST-Anfragen gesendet werden, ohne integrierte Unterstützung für PUT und DELETE. Als wir die Methode „Klasse erstellen“ in der Klasse „Übung“ erstellt haben, ist Ihnen vielleicht aufgefallen, dass wir „request.POST.get('title')“ verwendet haben. Während dies für POST-Anfragen funktioniert, sind im Anfrageobjekt keine PUT- oder DELETE-Methoden verfügbar.

Aber wie unterscheiden wir zwischen einer POST- und einer PUT-Anfrage? Wenn Sie das Formular überprüfen, das wir zuvor erstellt haben, werden Sie feststellen, dass wir der Schaltfläche „Senden“ ein Namensattribut zugewiesen haben. Wir können auf dieses Attribut auf die gleiche Weise zugreifen, wie wir auf Titel und Datum zugegriffen haben, indem wir request.POST.get('update') verwenden.

Aktualisieren wir das Formular zum Erstellen einer Übung, um dieselbe Änderung aufzunehmen.

<form method="POST" action="/">
    ...
    <button type="submit" name="create">Save</button>
</form>

Und in unserer Übungsansicht werden wir die folgenden Änderungen vornehmen, um zwischen Anfragen zu unterscheiden.

def index(request):
    if request.method == 'POST':
        create = 'create' in request.POST
        update = 'update' in request.POST

        if create == True:
            models.Exercise.create(request)
        elif update == True:
            models.Exercise.update(request)

        return redirect('/')

    exercises = (
        models.Exercise.objects.all().order_by("created_at")
    )
    return render(request, "index.html", context={'exercises': exercises})

We check for the button name and forward the request to the appropriate Exercise method accordingly.

Let's add an update class method to the Exercise model in app/models.py.

def update(request):
    id = request.POST.get('id')
    title = request.POST.get('title')
    date = request.POST.get('date')

    exercise = Exercise.objects.filter(pk=id).update(title=title, date=date)

    return exercise

To update a row in the database, we can use the update method available on the Exercise model. However, before updating, we need to ensure that we are updating the correct exercise. To do this, we filter the exercises by the primary key, which is id, and update only that specific exercise.

Delete Exercise

Similarly, we’ll add a delete button next to each exercise in the exercise.html template.

<form method="POST" action="/">
    ...
    <button type="submit" name="update">Update</button>
    <button type="submit" name="delete">Delete</button>
</form>

We’ll set delete as the value of the name attribute, and in views.py, we’ll extend the if...elif statements to handle the delete operation.

def index(request):
    if request.method == 'POST':
        create = 'create' in request.POST
        update = 'update' in request.POST
        delete = 'delete' in request.POST

        if create == True:
            models.Exercise.create(request)
        elif update == True:
            models.Exercise.update(request)
        elif delete == True:
            models.Exercise.delete(request)

        return redirect('/')

    exercises = (
        models.Exercise.objects.all().order_by("created_at")
    )
    return render(request, "index.html", context={'exercises': exercises})

And in the Exercise model, we'll add the class method delete.

def delete(request):
    id = request.POST.get('id')
    is_deleted = Exercise.objects.filter(pk=id).delete()

    if is_deleted == 1:
        return True

    return False

With this addition, we've successfully implemented CRUD operations in our Python and Django application.

Key Takeaways

1. Django view handlers do not support PUT and DELETE requests, as they do not parse the query parameters or request body for those HTTP methods. As a result, we must rely on POST requests and differentiate between them by passing an additional field in the request body.
2. Noticed that I'm making the POST request to the same route from which I'm fetching the exercises. This is important because if you were to create an endpoint like /api/exercises to handle requests, you would need to manage redirection manually. Otherwise, the behavior of the tag after the request is to redirect the user to the endpoint specified in the action attribute. Therefore, you will need to manually redirect the user back to the desired page, or in our case, keep the user on the same page.

from django.http import HttpResponseRedirect

def index(request):
    ...

    return redirect('/')
    # or
    return HttpResponseRedirect(request.META['HTTP_REFERER'])

In summary, by effectively managing our POST requests and ensuring proper redirection, we can create a seamless user experience while implementing CRUD operations in our Django application.

Das obige ist der detaillierte Inhalt vonCRUD-Operationen in Python und Django – Teil 2. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!