Lær hvordan du bygger en oppgavebehandlingsapp ved å bruke prinsippene for CRUD og klassebaserte visninger i Django.

En av nøkkelfunksjonene til Django er dens innebygde støtte for å lage prosjekter på toppen av CRUD-operasjoner (Create, Read, Update, Delete). Mens Djangos klassebaserte visninger gir en rask, enkel og fleksibel måte å bygge nettapplikasjoner på, bruker mange utviklere fortsatt funksjonsbaserte visninger.

Klassebaserte visninger tilbyr flere fordeler i forhold til funksjonsbaserte visninger, inkludert arv, kodestrukturering, gjenbruk av kode og mer. Selv om implementering av klassebaserte visninger kan virke litt komplisert, vil denne veiledningen hjelpe deg med å forstå konseptet ved å bygge en oppgavebehandlingsapp og gi trinnvise instruksjoner.

Hva er klassebaserte visninger i Django?

I Django er utsikten Python-funksjoner som tar en nettforespørsel og returnerer et nettsvar. Klassebaserte visninger (CBV) er en alternativ måte å definere visninger i Django ved å bruke Python-klasser i stedet for funksjoner.

CBV-er har flere fordeler, som bedre kodeorganisering, enklere gjenbruk av kode og muligheten til å bruke arv til å lage varianter av eksisterende visninger. CBV-er tilbyr også innebygde metoder som f.eks få() og post() metoder som du kan overskrive for tilpasset atferd.

Koden som brukes i denne artikkelen er tilgjengelig i denne GitHub-depot.

Klassebaserte visninger tilgjengelig i Django

Django har noen innebygde CBV-er for populære brukstilfeller, for eksempel å vise lister over objekter eller lage nye. Noen av disse innebygde CBV-ene er:

  1. Listevisning: Denne visningen gjengir en liste over objekter hentet fra en modell. For eksempel vil en side som viser alle innleggene som er tilgjengelige i en blogg bruke en Listevisning.
  2. Detaljvisning: Denne visningen gjengir en detaljert visning av et enkelt objekt hentet fra en modell. Du kan bruke en Detaljvisning for å vise detaljene for spesifikke innlegg i en bloggapp.
  3. CreateView: Denne visningen gjengir et skjema for å opprette et nytt objekt og håndterer skjemainnsendingen. I en oppgavebehandlingsapp vil du for eksempel bruke denne visningen til å lage nye oppgaver.
  4. DeleteView: Denne visningen gjengir en bekreftelsesside for å slette et objekt og håndterer sideslettingen.
  5. UpdateView: Denne visningen gjengir et skjema for å oppdatere et eksisterende objekt og håndterer innsendingen av skjemaet.

Django gir også andre synspunkter, inkludert Malvisning, RedirectView, og FormView. Du kan henvise til Djangos dokumentasjon for detaljert informasjon om klassebaserte visninger.

Bygg en Task Manager-app med Django klassebaserte visninger

Å bygge en app, for eksempel en oppgavebehandlingsapp, lar deg forstå hvordan du implementerer CRUD-operasjoner med CBV-er. En oppgavebehandling har funksjoner som lar brukere opprette, oppdatere, slette og lese oppgaver. Disse funksjonene er i tråd med CRUD-operasjoner. Følgende trinn vil hjelpe deg med å bygge en oppgavebehandlingsapp med Django CBV-er.

Sett opp et Django-prosjekt

For å lage en oppgavebehandlingsapp med Django, bør du begynne med å følge disse trinnene:

  1. Installer Django i din Python virtuelt miljø med denne kommandoen:
    pip installer django
  2. Lag et Django-prosjekt. Følgende kommando vil opprette et prosjekt kalt prosjektkjerne.
    django-admin startproject project_core .
  3. Lag en app som heter oppgavebehandling.
    python manage.py startapp task_manager
  4. I din settings.py legg til appnavnet ditt i INSTALLERT_APPS liste.
    INSTALLED_APPS = [
    'oppgavebehandling',
    ]
  5. Åpne urls.py fil i prosjektkatalogen og konfigurer URL-ene for din oppgavebehandling app:
    fra django.urls import sti, inkludere
    urlpatterns = [
     sti('', inkluderer ('task_manager.urls')),
    ]

Lag en modell for Task Manager-appen din

I appkatalogen din (eller oppgavebehandling mappe), åpne din models.py fil og lag en modell for oppgavebehandlingsappen din. Her er en eksempelmodell du kan bruke:

fra django.db import modeller
klasseOppgave(modeller. Modell):
 tittel = modeller. CharField (max_length=200)
 beskrivelse = modeller. Tekstfelt()
 fullført = modeller. BooleanField (standard=Falsk)
 opprettet_at = modeller. DateTimeField (auto_now_add=ekte)

Migrer modellen din med denne kommandoen:

python manage.py makemigrations && python manage.py migrere

Lag et Django-skjema for appen din

Du bør ha et skjema for håndtering Skape og Oppdater operasjoner. Opprett en fil som heter i appkatalogen din forms.py. Her er et eksempel:

fra django import skjemaer
fra .modeller import Oppgave
klasseOppgaveskjema(skjemaer. ModelForm):
klasseMeta:
 modell = Oppgave
 felt = ['tittel', 'beskrivelse', "fullført"]
 widgets = {
'tittel': former. TextInput (attrs={'klasse': 'skjemakontroll',}),
'beskrivelse': former. Tekstområde (attrs={'klasse': 'skjemakontroll',}),
"fullført": former. CheckboxInput (attrs={'klasse': 'skjema-sjekk-inndata'}),
 }

Koden ovenfor har en klasse kalt Oppgaveskjema som definerer feltene og widgetene til skjemaet. Den spesifiserer også modellen som skal brukes.

Lag Django-visninger for hver CRUD-operasjon

En grunnleggende CRUD-app med CBV-er krever minst fire visninger for å håndtere alle operasjoner effektivt. De neste trinnene viser deg hvordan du lager dem.

Importer de nødvendige modulene og pakkene

Åpne din views.py fil og foreta følgende importer:

fra django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView
fra django.urls import reverse_lat
fra .modeller import Oppgave
fra .skjemaer import Oppgaveskjema

Koden ovenfor importerer fem CBV-er. Den importerer også reverse_lat for å omdirigere brukeren til en spesifisert URL etter en skjemainnsending. Til slutt importerer den Oppgave modell, og Oppgaveskjema opprettet tidligere.

Opprett en visning for å liste modellobjekter

En oppgavebehandlingsapp bør ha en side som viser alle oppgavene som er opprettet av brukeren. For å lage en visning for dette, bør du bruke Listevisning. Her er et eksempel:

klasseTaskListView(Listevisning):
 modell = Oppgave
 malnavn = 'task_manager/task_list.html'
 kontekstobjektnavn = "oppgaver"

Visningen ovenfor definerer tre attributter som er:

  1. modell: Dette attributtet definerer hvilken modell som skal brukes for den spesifikke visningen.
  2. mal_navn: Dette attributtet forteller Django hvilken mal som skal gjengis til nettleseren.
  3. kontekstobjekt_navn: Dette attributtet definerer navnet som gir malen tilgang til listen over objekter i modellen.

De fleste CBV-er vil inneholde disse tre attributtene.

Opprett en visning for å håndtere oppgavedetaljer

Hver oppgave en bruker oppretter bør ha en side som viser detaljene. Den ideelle CBV for å håndtere dette er DetailVew. Her er et enkelt eksempel:

klasseTaskDetailView(Detaljvisning):
 modell = Oppgave
 malnavn = 'task_manager/task_detail.html'

Opprett en visning for oppgaveoppretting

Opprett en visning for å håndtere opprettelse eller tillegg av nye oppgaver. Dette er Skape del av CRUD-operasjonene, og det riktige synet for dette er CreateView. Slik bruker du det:

klasseTaskCreateView(CreateView):
 modell = Oppgave
 form_class = Oppgaveskjema
 malnavn = 'task_manager/task_form.html'
 suksess_url = omvendt_lat('liste over gjøremål')

Koden ovenfor introduserer to nye attributter: form_class og suksess_url.

De form_class attributt forteller visningen hvilken formklasse som skal gjengis og brukes til operasjonene.

De suksess_url spesifiserer hvordan brukeren skal omdirigeres etter å ha sendt inn skjemaet. Den bruker reverse_lat funksjon som tar navnet på en URL-bane.

Opprett en visning for redigeringsoppgaver

For å la brukerne dine redigere eller oppdatere oppgavene sine, bør du opprette en visning som ser slik ut:

klasseTaskUpdateView(UpdateView):
 modell = Oppgave
 form_class = Oppgaveskjema
 malnavn = 'task_manager/task_form.html'
 suksess_url = omvendt_lat('liste over gjøremål')

Visningen ovenfor ligner på TaskCreateView opprettet tidligere. Den eneste forskjellen er bruken av UpdateView.

Opprett en visning for å håndtere sletteoperasjoner

For å la brukerne dine slette oppgaver når de vil, bør du bruke DeleteView CBV. Her er et eksempel:

klasseTaskDeleteView(DeleteView):
 modell = Oppgave
 malnavn = 'task_manager/task_confirm_delete.html'
 suksess_url = omvendt_lat('liste over gjøremål')

Konfigurer appens nettadresser

Opprett en i appkatalogen din urls.py fil og konfigurer URL-mønstrene dine slik:

fra django.urls import sti
fra .visninger import TaskListView, TaskDetailView, TaskCreateView, TaskUpdateView, TaskDeleteView
urlpatterns = 
 sti('', TaskListView.as_view(), navn='liste over gjøremål'),
 sti('skape/', TaskCreateView.as_view(), navn='task_create'),
 sti('oppgaver//', TaskDetailView.as_view(), navn='oppgavedetalj'),
 sti('oppgaver//update/', TaskUpdateView.as_view(), navn='task_update'),
 sti('oppgaver//delete/', TaskDeleteView.as_view(), navn='task_delete'),
]

URL-mønstrene ovenfor ligner på URL-er opprettet med funksjonsbaserte visninger. Forskjellen er as_view() funksjon lagt til på slutten av hvert visningsnavn.

Du kan bruk Django-snegler til å lage URL-er i stedet for primærnøkkelen som er brukt ovenfor.

Lag maler for visningene dine

Hvis du lar brukerne utføre handlingene som er definert i visningene ovenfor, antyder det at du tilbyr et grensesnitt de kan samhandle med. Fra visningene opprettet tidligere, bør oppgavebehandlingsappen ha fire brukergrensesnitt.

Lag fire HTML-maler i appkatalogen din. Du bør også lage base.html fil. Du kan stil Django-malene dine med Bootstrap for å spare tid.

Oppgavelistemal

Denne malen skal inneholde kode som viser alle oppgavene i modellen. Et skjeletteksempel på koden er dette:

{% utvider 'base.html' %}
{% blokker innhold %}
<senter>
<h1>Dine oppgaverh1>
<enhref="{% url 'task_create' %}">Legg til oppgaveen>
 {% for oppgave i oppgaver %}
<div>
<div>
<h5>{{ task.title }}h5>
<s>{{ task.description|truncatechars: 50 }}s>
<s>
<sterk>Fullført:sterk>
 {% if task.completed %}Ja{% else %}Nei{% endif %}
s>
<enhref="{% url 'task_detail' task.pk %}">
 Les mer
en>
<enhref="{% url 'task_delete' task.pk %}">
 Slett oppgave
en>
div>
div>
 {% tom %}
<h3>Ingen oppgaver ennå.h3>
<enhref="{% url 'task_create' %}">Legg til oppgaveen>
 {% endfor %}
senter>
{% sluttblokk %}

Med noen Bootstrap-klasser kan du få siden din til å se slik ut:

Oppgavedetaljmal

Denne siden skal vise alle detaljene for hver oppgave som er opprettet. Her er en eksempelmal du kan bruke:

{% utvider 'base.html' %}
{% blokker innhold %}
<h1>{{ task.title }}h1>
<s>{{ Oppgavebeskrivelse }}s>
<s>Fullført: {% if task.completed %}Ja{% else %}Nei{% endif %}s>
<enhref="{% url 'task_update' task.pk %}">Rediger oppgaveen>
<enhref="{% url 'task_delete' task.pk %}">Slett oppgaveen>
{% sluttblokk %}

Avhengig av stylingtilnærmingen din, bør siden din se slik ut:

Oppgaveskjemamal

Denne malen skal inneholde et skjema som lar brukeren opprette eller oppdatere en oppgave.

{% utvider 'base.html' %}
{% blokker innhold %}
<h1>Opprett oppgaveh1>
<formmetode="post">
 {% csrf_token %}
 {{ form.as_p }}
<knapptype="sende inn">Lagreknapp>
form>
{% sluttblokk %}

Malen vil se slik ut:

Slett oppgavemal

Denne malen skal være en bekreftelsesside for å forhindre utilsiktet sletting av oppgaver.

{% utvider 'base.html' %}
{% blokker innhold %}
<h1>Bekreft slettingh1>
<s>Er du sikker på at du vil slette "{{ object.title }}"?s>
<formmetode="post">
 {% csrf_token %}
<knapptype="sende inn">Slettknapp>
<enhref="{% url 'task_list' %}">Avbryten>
form>
{% sluttblokk %}

Med noen Bootstrap bør siden din se slik ut:

Bruk klassebaserte visninger for å øke produktiviteten

Klassebaserte visninger er en fin måte å skrive ren, organisert kode på kort tid, og dermed øke produktiviteten. Du bør bruke dem i prosjektene dine så mye som mulig. Du kan også integrere funksjoner som søkefunksjonalitet, varsler og så videre for å gjøre oppgavebehandlingsappen din til en fullverdig funksjonell applikasjon.