[PYTHON] Django-Anfänger erstellen einfache Apps 3

Einführung

Eine Fortsetzung von 2, in der Django-Anfänger einfache Apps erstellen. Beim letzten Mal habe ich urls.py, views.py, template und R of CRUD erstellt, dh Teil lesen. Dieses Mal möchte ich das Teil "Erstellen" mit klassenbasierter Ansicht erstellen.

Serientabelle für Anfänger zum Erstellen einfacher Apps

Django-Anfänger erstellen einfache Apps 1 --Vorbereitungsübersicht über Django-Erstellung von models.py
Django-Anfänger erstellen einfache Apps 2
Implementierung des Leseteils (Erstellung von urls.py, views.py, Vorlagendatei)
Django-Anfänger machen einfache Apps 3 (← Jetzt hier) --Implementierung von Create part (Erstellung von form.py etc.) --Django Anfänger machen einfache Apps 4
Vergleich von klassenbasierter Ansicht und Funktionsansicht --Django Anfänger machen einfache Apps 5 (Abgeschlossen)
Implementierung des Update-Teils und des Delete-Teils

Umgebung

Ubuntu 20.04 LTS Python 3.8.2 Django 3.02

Annahme

Der Projektname lautet config und der App-Name lautet myapp. Mit anderen Worten, die folgenden zwei Befehle wurden ausgeführt

(myenv)$ django-admin startproject config .
(myenv)$ python manage.py startapp myapp

Das Vorlagenverzeichnis wird in derselben Hierarchie wie manage.py erstellt, und settings.py wurde ebenfalls geändert. (Siehe "Anfänger erstellen einfache Apps 1")

0. Grobes Design

Eigentlich wollte ich den Filmtitel, den Namen des Regisseurs, das Anzeigedatum und die Impressionen gleichzeitig auf einem Bildschirm eingeben können ... Es stellt sich heraus, dass es nicht so einfach ist, eine Verbindung zu ForeignKey herzustellen (Sie können die Unannehmlichkeiten sehen, nachdem Sie tatsächlich so etwas gemacht haben ...). Obwohl es mit einem "Inline-Formularsatz" implementiert werden kann, ist es für Anfänger etwas schwierig. Daher haben wir eine Methode angewendet, um den Namen, den Film und den Eindruck des Regisseurs separat zu registrieren. Das Bild ist unten dargestellt.

1. Implementierung von Create

Bisher wurden alle Daten von der Verwaltungssite "127.0.0.1: 8000 / admin /" eingegeben, aber ich möchte eine Seite für die Eingabe aus dem Web erstellen. Das ist der Teil Erstellen. Die Reihenfolge der Herstellung ist wie folgt.

Erstellen Sie forms.py
Bestimmen Sie die Adresse in urls.py
Schreiben Sie, wie Sie den Namen des Regisseurs und die Filminformationen in views.py eingeben
Erstellen Sie eine HTML-Datei für die Seite, die Sie eingeben möchten

Dieses Formular ist der Eingang zur Eingabe in die Datenbank namens Modell. Es scheint vielmehr eine Schnittstelle zu sein, die das Modell und das HTML-Formular verbindet. Als ich anfing, mit Django zu spielen, hatte ich keine Ahnung, was ich tat, weil ich dachte, dass Djangos Form und HTML-Form dasselbe waren. ** Form und Form sind unterschiedlich. ** Ich habe mich immer gefragt, warum es ein Formular gibt, aber ** die gewaschenen Kleidungsstücke (Daten) können nicht ohne Erlaubnis in das Modell aufgenommen werden. Ich brauche eine Person, die es richtig falten kann, und das ist Form + Ansicht ** und Selbstlösung.

Schreiben Sie das Formular in die Mitte der obigen Abbildung in form.py.

Code in form.py.

`myapp/form.py`


from django.forms import ModelForm
from myapp.models import Movie, Director, Log

class DirectorForm(ModelForm):
    class Meta:
        model = Director
        fields = ('name',)

class MovieForm(ModelForm):
    class Meta:
        model = Movie
        fields = ('title','watch_date', 'director')

class LogForm(ModelForm):
    class Meta:
        model = Log
        fields = ('movie','text')

Da es 3 Modelle gibt, werden auch 3 Formulare beschrieben. Es gibt zwei Arten von Formularklassen: forms.Form und forms.ModelForm und ModelForm ist einfacher. Da Form der Eingang zu den Eingabedaten ist, ist sie direkt mit dem Modell verbunden. Beschreiben Sie einfach, was "Modell" (Datenbank) verwendet und welches "Feld" (Element) unter "Klasse Meta" verwendet werden soll. Schreiben Sie als Nächstes die Adresse der Eingabeseite in urls.py.

Code in urls.py

`myapp/urls.py`


from django.urls import path, include
from myapp import views

app_name = 'myapp'
urlpatterns = [
    path('', views.IndexView.as_view(), name='index'),
    path('movie/<int:pk>/', views.MovieDetailView.as_view(), name='movie_detail'),
    path('register/director/', views.RegisterDirectorView.as_view(), name='registerdirector'), #Füge das hinzu
    path('register/movie/', views.RegisterMovieView.as_view(), name='registermovie'), #Füge das hinzu
    path('writing/log/', views.WritingLogView.as_view(), name='writinglog'), #Füge das hinzu
]

Erstellen Sie dann eine klassenbasierte Ansicht (hier "RegisterDirectorView", "RegisterMovieView" und "WritingLogView"), wie in urls.py angegeben.

Views.py-Code

Zuerst Ansicht, um den Namen des Regisseurs zu registrieren.

`myapp/views.py`



class RegisterDirectorView(generic.CreateView):
    model = Director
    form_class = DirectorForm
    template_name = 'myapp/register.html'
    def get_success_url(self):
        return reverse('myapp:registermovie')

Klicken Sie anschließend auf Anzeigen, um Filminformationen zu registrieren.

`myapp/views.py`



class RegisterMovieView(generic.CreateView):
    model = Movie
    form_class = MovieForm
    template_name = 'myapp/register.html'
    def get_success_url(self):
        return reverse('myapp:movie_detail', kwargs={'pk': self.object.pk })

Zum Schluss Ansicht, um den Eindruck des Films zu schreiben.

`myapp/views.py`


class WritingLogView(generic.CreateView):
    model = Log
    form_class = LogForm
    template_name = 'myapp/register.html'
    def get_success_url(self):
        return reverse('myapp:movie_detail', kwargs={'pk': self.object.movie.pk })

Die folgenden vier Elemente gelten für die oben genannten drei CreateViews.

In welcher Datenbank werden die Eingabedaten gespeichert (Modell = Teil)?
Welches Formular soll verwendet werden (form_class = part)
In welcher HTML-Datei wird der Eingabebildschirm angezeigt (Vorlagenname = Teil)
Wenn die Dateneingabe und -speicherung in der Datenbank erfolgreich ist, welche Seite soll angezeigt werden (def get_success_url part)

Wenn Sie sich für diese 4 Elemente entscheiden, führt CreateView verschiedene Dinge automatisch aus.

Erläutern Sie die letzte Zeile der drei Ansichten

return reverse('myapp:registermovie')

RegisterDirectorView. Die Umkehrfunktion bedeutet, zu der in () geschriebenen Adresse zu springen. Dieses Mal entspricht "myapp: registermovie" dem letzten Teil des Pfads ("register / movie /", views.RegisterMovieView.as_view (), name = "registermovie"), "beschrieben in urls.py. Mit anderen Worten, gehen Sie zu 127.0.0.1: 8000 / myapp / register / movie /.

return reverse('myapp:movie_detail', kwargs={'pk': self.object.pk })

RegisterMovieView. kwargs = {'pk': self.object.pk} ist ein Schlüsselwortargument und ein Wörterbuchtyp. Nach meinem Verständnis ... werden die Eingabedaten in ein Objekt (eine Instanz) instanziiert. Das ist Selbstobjekt. Das Ding hat automatisch ein "pk" (Primärschlüssel: eine ID-Nummer, die beliebig zugewiesen werden kann), und dieses "pk" (self.object.pk) ist mit dem "pk" (Schlüsselteil des Wörterbuchs) von movie_detail verknüpft. Getan werden. Verwenden Sie diese Option, um zur Seite movie_detail zu gelangen. Mit anderen Worten, wenn der pk des Objekts "Sonatine: Takeshi Kitano: 2020-05-01" 1 ist, bedeutet dies, zu 127.0.0.1: 8000 / myapp / movie / 1 / zu fliegen.

return reverse('myapp:movie_detail', kwargs={'pk': self.object.movie.pk })

WritingLogView. Schlüsselwortargumentteil. Früher war es "self.object.pk" und diesmal ist es "self.object.movie.pk". Warum. Das self.object von RegisterMovieView war ein Filmobjekt, das self.object von WritingLogView ist jedoch ein Impression-Objekt. Es wird zu "self.object.movie.pk", um den Teil des Films zu ziehen, der dem Eindruck zugeordnet ist. Übrigens bedeutet dieser "Film" -Teil den Film, der in "Klasse Log (models.Model)" von models.py beschrieben ist.

Erstellen Sie eine HTML-Datei

Erstellen Sie "retister.html", wie im vorherigen Code beschrieben (Vorlagenname = Teil). Erstellen Sie eine register.html-Datei im Vorlagenverzeichnis und im myapp-Verzeichnis darunter und schreiben Sie den folgenden Code.

`templates/myapp/register.html`


<form method="POST">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">save</button>
</form>

Dies ist das HTML-Formular. Schreiben Sie "{% csrf_token%}", da dies keine magische Sicherheitsanforderung ist. Das folgende {{form.as_p}} erstellt automatisch den Inhalt des Formulars und zeigt ihn an. Es wird gesagt, dass ein Code für drei Formulare erforderlich ist: Eingabe des Regisseurnamens, Eingabe von Filminformationen und Eingabe von Impressionen. Es ist wunderbar. Es ist wirklich klug.

Ergebnis von register.html anzeigen

Geben Sie "http: //127.0.0.1: 8000 / myapp / register / Director /" direkt in den Browser ein, um zum "Bildschirm zur Eingabe des Direktors" zu gelangen. Wenn es sich um "http: //127.0.0.1: 8000 / myapp / register / movie /" handelt, gehen Sie zum "Filminformations-Eingabebildschirm". Wenn es "http: //127.0.0.1: 8000 / myapp / writing / log /" ist, springt es zum "Impression Input Screen". Das Director-Feld des "Filminformations-Eingabebildschirms" und das Titelfeld des "Impression-Eingabebildschirms" sind Dropdown-Auswahlformeln (da sie durch einen Fremdschlüssel verknüpft sind).

Eingabebildschirm für den Namen des Direktors	Eingabebildschirm für Filminformationen	Impressionseingabebildschirm

Mit dem oben genannten wurde der Teil Erstellen implementiert.

Nachwort

Jetzt, da wir die Hälfte des CRUD erreicht haben, sind die restlichen UPDATE und DELETE. Aber beim nächsten Mal habe ich vor, einen Umweg zu machen und den Code, den ich in der klassenbasierten Ansicht mit der Funktionsansicht geschrieben habe, neu zu schreiben und den Mechanismus von Django zu betrachten, während ich beide vergleiche. Wenn Sie Fehler haben, weisen Sie uns bitte darauf hin und geben Sie uns eine Anleitung.