[PYTHON] Django Tutorial (Blog-App erstellen) ⑤ - Artikelerstellungsfunktion

Beim letzten Mal habe ich in Django Tutorial (Blog-App erstellen) ④ - Einheitentest gelernt, wie ein Komponententest implementiert wird.

Ursprünglich möchte ich es in einem testgetriebenen Entwicklungsstil implementieren, der zuerst den erwarteten Test schreibt, weil es eine große Sache ist. In diesem Tutorial lernen wir, was Django kann, also implementieren wir es zuerst und schreiben dann den Unit-Test.

Von nun an werden wir die folgenden Funktionen dieses Mal in mehreren Teilen hinzufügen.

1. Erstellen Sie einen Artikel
2. Artikeldetails (Lesen)
3. Artikel bearbeiten (Update)
4. Artikel löschen

Wir werden das Akronym für diese Funktionen nehmen und sie hier "CRUD" nennen. (Genau genommen kann es anders sein, weil Sie bereits mit blog_list lesen können)

Fügen wir nun die Funktion ** Artikelerstellung ** hinzu, die diesmal als Basis bezeichnet werden kann. Bisher wurden Artikel mit Superuser-Berechtigungen über die Verwaltungssite hinzugefügt. Es wäre jedoch bequemer, wenn Sie Artikel in der App erstellen könnten.

Formularvorbereitung

Beim Hinzufügen von Daten aus der App verwenden wir einen Mechanismus namens form. Das Formular kann Eingabedaten vom Benutzer akzeptieren, die Daten über die Ansicht an das Modell übergeben und in der Datenbank registrieren.

Erstellen Sie zunächst eine Datei mit dem Namen forms.py unter der Blog-App.

.
├── blog
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── forms.py #hinzufügen
│   ├── migrations
│   │   ├── 0001_initial.py
│   │   └── __init__.py
│   ├── models.py
│   ├── tests
│   │   ├── __init__.py
│   │   ├── test_forms.py
│   │   ├── test_models.py
│   │   ├── test_urls.py
│   │   └── test_views.py
│   ├── urls.py
│   └── views.py
├── db.sqlite3
├── manage.py
├── mysite
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── templates
    └── blog
        ├── index.html
        └── post_list.html

Der Inhalt der erstellten forms.py sieht folgendermaßen aus.

forms.py

from django import forms
from .models import Post

class PostCreateForm(forms.ModelForm): #Djangos ModelForm verfügt über eine leistungsstarke Validierung

    class Meta:
        model = Post #Stellt eine Verbindung zum Post-Modell her und erstellt ein Formular entsprechend dem Inhalt des Post-Modells
        fields = ('title', 'text') #Geben Sie die einzugebende Spalte an

Ich denke, dass Sie bis zu einem gewissen Grad verstehen können, da die Erklärung auch enthalten ist. Wenn Sie das Modell angeben, in das Sie Daten eingeben möchten, bereitet form das entsprechende Eingabeformular vor.

Obwohl die Spalte zur Dateneingabe als Feld in der letzten Zeile angegeben ist, Sie können auch festlegen, dass alle Spalten manuell eingegeben werden sollen, indem Sie ** fields = '__ all __' ** definieren.

Korrigieren Sie urls.py

Die Klasse, die neu zur Ansicht hinzugefügt werden soll, heißt im Voraus ** PostCreateView. Fügen wir in urls.py das Routing wie folgt hinzu.

urls.py

from django.urls import path
from . import views

app_name = 'blog'

urlpatterns = [
    path('', views.IndexView.as_view(), name='index'),
    path('post_list', views.PostListView.as_view(), name='post_list'),
    path('post_create', views.PostCreateView.as_view(), name='post_create'), #hinzufügen
]

success_url gibt die Seite an, zu der umgeleitet werden soll, wenn die Datenbankänderung erfolgreich ist. Geben Sie es in Form von "App-Name: Name der umgekehrten URL" an. Infolgedessen werden Sie zu der in urls.py angegebenen "post_list" weitergeleitet.

• Reverse_lazy gibt die "URL-Zeichenfolge" zurück, die der Ansicht entspricht. Dieses Mal wird / blog / post_list zurückgegeben

Ändern Sie views.py

Sie haben beschlossen, den Klassennamen PostCreateView früher hinzuzufügen. Ich habe auch eine Klasse für das Eingabeformular in Form erstellt.

Erstellen Sie als Nächstes eine Klasse in views.py und verwenden Sie erneut die generische Klassenansicht.

views.py

from django.views import generic
from django.urls import reverse_lazy
from .forms import PostCreateForm # forms.Importieren Sie eine mit py erstellte Klasse
from .models import Post

class IndexView(generic.TemplateView):
    template_name = 'blog/index.html'

class PostListView(generic.ListView):
    model = Post

class PostCreateView(generic.CreateView): #hinzufügen
    model = Post #Geben Sie das Modell an, das Sie erstellen möchten
    form_class = PostCreateForm #Geben Sie die erstellte Formularklasse an
    success_url = reverse_lazy('blog:post_list') #Geben Sie das Umleitungsziel an, wenn der Artikel erfolgreich erstellt wurde

Das ist alles, was Sie tun müssen, dank Djangos leistungsstarker klassenbasierter generischer Ansicht. Sie müssen lediglich das Modell angeben, das Sie erstellen möchten, die von Ihnen erstellte Formularklasse und das Umleitungsziel, als der Artikel erfolgreich erstellt wurde.

Vorbereitung der Vorlage

Ich habe das HTML zum Erstellen (Veröffentlichen) von Artikeln noch nicht erstellt. Erstellen wir es also unter Vorlagen / Blog. Nennen Sie es post_form.html.

• Wenn Sie die Namenskonvention klassenbasierter Allzweckansichten befolgen, ist dies auch dann in Ordnung, wenn Sie den Vorlagennamen nicht angeben.

└── templates
    └── blog
        ├── index.html
        ├── post_form.html #hinzufügen
        └── post_list.html

post_create.html

<form action="" method="POST">
  <table class="table">
      <tr>
        <th>Titel</th>
        <td>{{ form.title }}</td>
      </tr>
      <tr>
        <th>Text</th>
        <td>{{ form.text }}</td>
      </tr>
  </table>
  <button type="submit" class="btn btn-primary">Senden</button>
  {% csrf_token %}
</form>

Da das in den Feldern von forms.py angegebene Eingabefeld von einer Variablen namens form empfangen werden kann, Auf der Vorlagenseite kann es in Form von form.title und form.text abgerufen werden.

Es wird auch als CSRF (Cross-Site Request Forgery) bezeichnet, um Angriffe mithilfe von Eingabeformularen zu verhindern. Stellen Sie sicher, dass Sie es einschließen, wenn Sie das Eingabeformular in HTML anzeigen.

Wenn Sie den Server mit dem Befehl runserver in diesem Status starten, wird ein Eingabeformular angezeigt, das jedoch schrecklich aussieht. (Oft beginne ich mit den Grundlagen von Django und passe dann das Aussehen an.)

Geben Sie einen Wert ein und senden Sie ihn.

Durch Drücken von "Senden" werden Sie zu "post_list" weitergeleitet. Und Sie können sehen, dass der Artikel, den ich zuvor gepostet habe, hinzugefügt wurde.

Sie haben die Artikelbuchungsfunktion erfolgreich hinzugefügt.

Fix test_views.py

Lassen Sie uns abschließend einen Test für diese Funktion implementieren.

Erstellen Sie die folgende Testklasse in test_views.py.

test_views.py

...
class PostCreateTests(TestCase):
    """Testklasse für PostCreate-Ansicht."""

    def test_get(self):
        """Bestätigen Sie, dass der Statuscode 200 zurückgegeben wird, indem Sie mit der GET-Methode zugreifen."""
        response = self.client.get(reverse('blog:post_create'))
        self.assertEqual(response.status_code, 200)

    def test_post_with_data(self):
        """Bestätigen Sie, dass Sie erfolgreich umgeleitet werden, wenn Sie mit den entsprechenden Daten POSTEN"""
        data = {
            'title': 'test_title',
            'text': 'test_text',
        }
        response = self.client.post(reverse('blog:post_create'), data=data)
        self.assertEqual(response.status_code, 302)
    
    def test_post_null(self):
        """Stellen Sie sicher, dass POSTing mit leeren Daten nur 200 ohne Umleitung zurückgibt"""
        data = {}
        response = self.client.post(reverse('blog:post_create'), data=data)
        self.assertEqual(response.status_code, 200)

Wir betrachten die grundlegende GET-Bestätigung, die entsprechende Dateneingabe- und Umleitungsbestätigung und die Antwort, wenn leere Daten eingegeben werden.

Lassen Sie uns zum Schluss den Test ausführen.

Du bist sicher gegangen.

Das nächste Mal werde ich sofort den Bildschirm mit den Artikeldetails erstellen.

→ Nächstes Mal Django-Tutorial (Blog-App erstellen) ⑥ - Artikeldetails / Funktion bearbeiten / löschen