Lær, hvordan du bygger en task manager-app ved at bruge principperne for CRUD og klassebaserede visninger i Django.

En af nøglefunktionerne i Django er dens indbyggede understøttelse af oprettelse af projekter oven på CRUD-operationer (Create, Read, Update, Delete). Mens Djangos klassebaserede visninger giver en hurtig, nem og fleksibel måde at bygge webapplikationer på, bruger mange udviklere stadig funktionsbaserede visninger.

Klassebaserede visninger tilbyder adskillige fordele i forhold til funktionsbaserede visninger, herunder nedarvning, kodestrukturering, kodegenanvendelighed og meget mere. Selvom implementering af klassebaserede visninger kan virke lidt kompleks, hjælper denne vejledning dig med at forstå konceptet ved at bygge en task manager-app og give trin-for-trin instruktioner.

Hvad er klassebaserede visninger i Django?

I Django er synspunkter Python funktioner der tager en webanmodning og returnerer et websvar. Klassebaserede visninger (CBV'er) er en alternativ måde at definere visninger i Django ved hjælp af Python-klasser i stedet for funktioner.

instagram viewer

CBV'er har flere fordele, såsom bedre kodeorganisering, lettere genbrug af kode og muligheden for at bruge arv til at skabe variationer af eksisterende visninger. CBV'er giver også indbyggede metoder som f.eks få() og stolpe() metoder, som du kan overskrive for tilpasset adfærd.

Koden brugt i denne artikel er tilgængelig i denne GitHub-depot.

Klassebaserede visninger tilgængelige i Django

Django leverer nogle indbyggede CBV'er til populære brugstilfælde, såsom at vise lister over objekter eller oprette nye. Nogle af disse indbyggede CBV'er er:

  1. Listevisning: Denne visning gengiver en liste over objekter hentet fra en model. For eksempel vil en side, der viser alle de tilgængelige indlæg i en blog, bruge en Listevisning.
  2. DetailView: Denne visning gengiver en detaljeret visning af et enkelt objekt hentet fra en model. Du kan bruge en DetailView for at vise detaljerne for specifikke indlæg i en blog-app.
  3. CreateView: Denne visning gengiver en formular til at oprette et nyt objekt og håndterer formularafsendelsen. For eksempel vil du i en task manager-app bruge denne visning til at oprette nye opgaver.
  4. DeleteView: Denne visning gengiver en bekræftelsesside for at slette et objekt og håndterer sidesletningen.
  5. UpdateView: Denne visning gengiver en formular til opdatering af et eksisterende objekt og håndterer indsendelsen af ​​formularen.

Django giver også andre synspunkter, bl.a Skabelonvisning, RedirectView, og FormView. Du kan henvise til Djangos dokumentation for detaljerede oplysninger om klassebaserede visninger.

Byg en Task Manager-app med Django klassebaserede visninger

Opbygning af en app, såsom en task manager-app, giver dig mulighed for at forstå, hvordan du implementerer CRUD-operationer med CBV'er. En opgavehåndtering har funktioner, der giver brugerne mulighed for at oprette, opdatere, slette og læse opgaver. Disse funktioner er i overensstemmelse med CRUD-operationer. De følgende trin hjælper dig med at bygge en task manager-app med Django CBV'er.

Opsæt et Django-projekt

For at oprette en task manager-app med Django skal du starte med at følge disse trin:

  1. Installer Django i din Python virtuelt miljø med denne kommando:
    pip installer django
  2. Opret et Django-projekt. Følgende kommando vil oprette et projekt kaldet projekt_kerne.
    django-admin startproject project_core .
  3. Opret en app kaldet Jobliste.
    python manage.py startapp task_manager
  4. I din settings.py tilføje dit app navn til INSTALLERET_APPS liste.
    INSTALLED_APPS = [
    'Jobliste',
    ]
  5. Åbn urls.py fil i din projektmappe og konfigurer URL'erne til din Jobliste app:
    fra django.urls importere sti, medtage
    urlpatterns = [
     sti('', inkluderer ('task_manager.urls')),
    ]

Opret en model til din Task Manager-app

I din app-mappe (eller Jobliste mappe), åbne din models.py fil og opret en model til din task manager-app. Her er en eksempelmodel, du kan bruge:

fra django.db importere modeller
klasseOpgave(modeller. Model):
 titel = modeller. CharField (max_length=200)
 beskrivelse = modeller. Tekstfelt()
 færdiggjort = modeller. BooleanField (standard=Falsk)
 oprettet_at = modeller. DateTimeField (auto_now_add=Rigtigt)

Migrer din model med denne kommando:

python manage.py makemigrationer && python manage.py migrere

Opret en Django-formular til din app

Du skal have en formular til håndtering skab og Opdatering operationer. I din app-mappe skal du oprette en fil kaldet forms.py. Her er et eksempel:

fra django importere formularer
fra .modeller importere Opgave
klasseOpgaveformular(former. ModelForm):
klasseMeta:
 model = Opgave
 felter = ['titel', 'beskrivelse', 'afsluttet']
 widgets = {
'titel': former. TextInput (attrs={'klasse': 'form-kontrol',}),
'beskrivelse': former. Tekstområde (attrs={'klasse': 'form-kontrol',}),
'afsluttet': former. CheckboxInput (attrs={'klasse': 'form-check-input'}),
 }

Ovenstående kode har en klasse kaldet Opgaveformular som definerer formularens felter og widgets. Den specificerer også den model, der skal bruges.

Opret Django-visninger for hver CRUD-operation

En grundlæggende CRUD-app med CBV'er kræver mindst fire visninger for at håndtere alle operationer effektivt. De næste par trin viser dig, hvordan du opretter dem.

Importer de nødvendige moduler og pakker

Åben din views.py fil og foretag følgende importer:

fra django.views.generic importere ListView, DetailView, CreateView, UpdateView, DeleteView
fra django.urls importere omvendt_doven
fra .modeller importere Opgave
fra .former importere Opgaveformular

Koden ovenfor importerer fem CBV'er. Den importerer også omvendt_doven at omdirigere brugeren til en specificeret URL efter en formularindsendelse. Endelig importerer den Opgave model, og Opgaveformular oprettet tidligere.

Opret en visning for at liste modelobjekter

En task manager-app skal have en side med alle de opgaver, der er oprettet af brugeren. For at oprette en visning til dette, skal du bruge Listevisning. Her er et eksempel:

klasseTaskListView(Listevisning):
 model = Opgave
 skabelon_navn = 'task_manager/task_list.html'
 kontekst_objekt_navn = 'opgaver'

Visningen ovenfor definerer tre attributter, som er:

  1. model: Denne attribut definerer, hvilken model der skal bruges til den specifikke visning.
  2. skabelon_navn: Denne attribut fortæller Django, hvilken skabelon der skal gengives til browseren.
  3. kontekstobjekt_navn: Denne attribut definerer navnet, der giver skabelonen adgang til listen over objekter i modellen.

De fleste CBV'er vil indeholde disse tre attributter.

Opret en visning for at håndtere opgavedetaljer

Hver opgave, en bruger opretter, skal have en side, der viser dens detaljer. Den ideelle CBV til at håndtere dette er DetailVew. Her er et simpelt eksempel:

klasseTaskDetailView(Detaljevisning):
 model = Opgave
 skabelon_navn = 'task_manager/task_detail.html'

Opret en visning til opgaveoprettelse

Opret en visning til at håndtere oprettelse eller tilføjelse af nye opgaver. Dette er skab del af CRUD-operationerne, og det rigtige syn på dette er CreateView. Sådan bruger du det:

klasseTaskCreateView(CreateView):
 model = Opgave
 form_class = TaskForm
 skabelon_navn = 'task_manager/task_form.html'
 success_url = reverse_lazy('opgaveliste')

Ovenstående kode introducerer to nye attributter: form_klasse og success_url.

Det form_klasse attribut fortæller visningen, hvilken formklasse den skal gengive og bruge til dens operationer.

Det success_url angiver, hvordan brugeren omdirigeres efter indsendelse af formularen. Den bruger omvendt_doven funktion, som tager navnet på en URL-sti.

Opret en visning til redigering af opgaver

For at give dine brugere mulighed for at redigere eller opdatere deres opgaver, skal du oprette en visning, der ser sådan ud:

klasseTaskUpdateView(UpdateView):
 model = Opgave
 form_class = TaskForm
 skabelon_navn = 'task_manager/task_form.html'
 success_url = reverse_lazy('opgaveliste')

Ovenstående visning ligner TaskCreateView oprettet tidligere. Den eneste forskel er brugen af UpdateView.

Opret en visning for at håndtere sletningshandlinger

For at give dine brugere mulighed for at slette opgaver, når de vil, skal du bruge DeleteView CBV. Her er et eksempel:

klasseTaskDeleteView(DeleteView):
 model = Opgave
 skabelon_navn = 'task_manager/task_confirm_delete.html'
 success_url = reverse_lazy('opgaveliste')

Konfigurer din apps URL'er

I din app-mappe skal du oprette en urls.py fil og konfigurer dine URL-mønstre som dette:

fra django.urls importere sti
fra .visninger importere TaskListView, TaskDetailView, TaskCreateView, TaskUpdateView, TaskDeleteView
urlpatterns = 
 sti('', TaskListView.as_view(), navn='opgaveliste'),
 sti('skab/', TaskCreateView.as_view(), navn='opgave_opret'),
 sti('opgaver//', TaskDetailView.as_view(), navn='task_detail'),
 sti('opgaver//update/', TaskUpdateView.as_view(), navn='task_update'),
 sti('opgaver//delete/', TaskDeleteView.as_view(), navn='opgave_slet'),
]

URL-mønstrene ovenfor ligner URL'er oprettet med funktionsbaserede visninger. Forskellen er as_view() funktion tilføjet til slutningen af ​​hvert visningsnavn.

Du kan brug Django-snegle til at oprette URL'er i stedet for den primære nøgle, der er brugt ovenfor.

Opret skabeloner til dine visninger

At tillade dine brugere at udføre de handlinger, der er defineret i visningerne ovenfor, tyder på, at du giver dem en grænseflade at interagere med. Ud fra de visninger, der er oprettet tidligere, bør task manager-appen have fire brugergrænseflader.

Opret fire HTML-skabeloner i din app-mappe. Du bør også oprette base.html fil. Du kan style dine Django-skabeloner med Bootstrap for at spare tid.

Opgaveliste skabelon

Denne skabelon skal indeholde kode, der viser alle opgaverne i modellen. Et skeleteksempel på koden er dette:

{% udvider 'base.html' %}
{% bloker indhold %}
<centrum>
<h1>Dine opgaverh1>
<-enhref="{% url 'task_create' %}">Tilføj opgave-en>
 {% for opgave i opgaver %}
<div>
<div>
<h5>{{ task.title }}h5>
<s>{{ task.description|truncatechars: 50 }}s>
<s>
<stærk>Fuldført:stærk>
 {% if task.completed %}Ja{% else %}Nej{% endif %}
s>
<-enhref="{% url 'task_detail' task.pk %}">
 Læs mere
-en>
<-enhref="{% url 'task_delete' task.pk %}">
 Slet opgave
-en>
div>
div>
 {% tom %}
<h3>Ingen opgaver endnu.h3>
<-enhref="{% url 'task_create' %}">Tilføj opgave-en>
 {% endfor %}
centrum>
{% slutblok %}

Med nogle Bootstrap-klasser kan du få din side til at se sådan ud:

Opgavedetaljerskabelon

Denne side skal vise de fulde detaljer for hver oprettet opgave. Her er en eksempelskabelon, du kan bruge:

{% udvider 'base.html' %}
{% bloker indhold %}
<h1>{{ task.title }}h1>
<s>{{ task.description }}s>
<s>Fuldført: {% if task.completed %}Ja{% else %}Nej{% endif %}s>
<-enhref="{% url 'task_update' task.pk %}">Rediger opgave-en>
<-enhref="{% url 'task_delete' task.pk %}">Slet opgave-en>
{% slutblok %}

Afhængigt af din stylingtilgang skal din side se sådan ud:

Opgaveformular skabelon

Denne skabelon skal indeholde en formular, der lader brugeren oprette eller opdatere en opgave.

{% udvider 'base.html' %}
{% bloker indhold %}
<h1>Opret opgaveh1>
<formmetode="stolpe">
 {% csrf_token %}
 {{ form.as_p }}
<knaptype="Indsend">Gemmeknap>
form>
{% slutblok %}

Skabelonen vil se sådan ud:

Slet opgaveskabelon

Denne skabelon skal være en bekræftelsesside for at forhindre utilsigtet sletning af opgaver.

{% udvider 'base.html' %}
{% bloker indhold %}
<h1>Bekræft sletningh1>
<s>Er du sikker på, at du vil slette "{{ object.title }}"?s>
<formmetode="stolpe">
 {% csrf_token %}
<knaptype="Indsend">Sletknap>
<-enhref="{% url 'task_list' %}">Afbestille-en>
form>
{% slutblok %}

Med noget Bootstrap skulle din side se sådan ud:

Brug klassebaserede visninger til at øge din produktivitet

Klassebaserede visninger er en fantastisk måde at skrive ren, organiseret kode på på kort tid og derved øge din produktivitet. Du bør bruge dem i dine projekter så meget som muligt. Du kan også yderligere integrere funktioner som søgefunktionalitet, meddelelser og så videre for at gøre din task manager-app til en fuldt udbygget funktionel applikation.