Lär dig hur du bygger en Task Manager-app som använder principerna för CRUD och klassbaserade vyer i Django.

En av nyckelfunktionerna i Django är dess inbyggda stöd för att skapa projekt ovanpå CRUD-operationer (Create, Read, Update, Delete). Även om Djangos klassbaserade vyer ger ett snabbt, enkelt och flexibelt sätt att bygga webbapplikationer, använder många utvecklare fortfarande funktionsbaserade vyer.

Klassbaserade vyer erbjuder flera fördelar jämfört med funktionsbaserade vyer, inklusive arv, kodstrukturering, kodåteranvändbarhet och mer. Även om implementering av klassbaserade vyer kan verka lite komplicerad, hjälper den här guiden dig att förstå konceptet genom att bygga en Task Manager-app och ge steg-för-steg-instruktioner.

Vad är klassbaserade vyer i Django?

I Django, åsikter är Python funktioner som tar en webbförfrågan och returnerar ett webbsvar. Klassbaserade vyer (CBV) är ett alternativt sätt att definiera vyer i Django med Python-klasser istället för funktioner.

CBV har flera fördelar, såsom bättre kodorganisation, enklare återanvändning av kod och möjligheten att använda arv för att skapa varianter av befintliga vyer. CBVs tillhandahåller också inbyggda metoder som t.ex

instagram viewer
skaffa sig() och posta() metoder som du kan skriva över för anpassade beteenden.

Koden som används i den här artikeln är tillgänglig i denna GitHub-förråd.

Klassbaserade vyer tillgängliga i Django

Django tillhandahåller några inbyggda CBV för populära användningsfall, som att visa listor med objekt eller skapa nya. Några av dessa inbyggda CBV är:

  1. Listvy: Den här vyn återger en lista över objekt som hämtats från en modell. Till exempel kommer en sida som listar alla tillgängliga inlägg i en blogg att använda en Listvy.
  2. Detaljerad vy: Den här vyn återger en detaljerad vy av ett enstaka objekt hämtat från en modell. Du kan använda en Detaljerad vy för att visa information om specifika inlägg i en bloggapp.
  3. SkapaVisa: Denna vy renderar ett formulär för att skapa ett nytt objekt och hanterar formulärinlämningen. Till exempel, i en Task Manager-app kommer du att använda den här vyn för att skapa nya uppgifter.
  4. DeleteView: Den här vyn återger en bekräftelsesida för att ta bort ett objekt och hanterar sidans radering.
  5. UpdateView: Denna vy renderar ett formulär för att uppdatera ett befintligt objekt och hanterar inlämningen av formuläret.

Django ger också andra synpunkter, inklusive Mallvy, RedirectView, och FormView. Du kan hänvisa till Djangos dokumentation för detaljerad information om klassbaserade vyer.

Bygg en Task Manager-app med Django klassbaserade vyer

Att bygga en app som en Task Manager-app låter dig förstå hur du implementerar CRUD-operationer med CBV. En aktivitetshanterare har funktioner som tillåter användare att skapa, uppdatera, ta bort och läsa uppgifter. Dessa funktioner är i linje med CRUD-operationer. Följande steg hjälper dig att bygga en Task Manager-app med Django CBVs.

Skapa ett Django-projekt

För att skapa en Task Manager-app med Django bör du börja med att följa dessa steg:

  1. Installera Django i din Python virtuell miljö med detta kommando:
    pip installera django
  2. Skapa ett Django-projekt. Följande kommando kommer att skapa ett projekt som heter project_core.
    django-admin startproject project_core .
  3. Skapa en app som heter Aktivitetshanteraren.
    python manage.py startapp task_manager
  4. I din settings.py lägg till ditt appnamn i INSTALLERADE_APPAR lista.
    INSTALLED_APPS = [
    'Aktivitetshanteraren',
    ]
  5. Öppna urls.py fil i din projektkatalog och konfigurera webbadresserna för din Aktivitetshanteraren app:
    från django.urls importera väg, inkludera
    urlpatterns = [
     väg('', inkludera('task_manager.urls')),
    ]

Skapa en modell för din Task Manager-app

I din appkatalog (eller Aktivitetshanteraren mapp), öppna din models.py fil och skapa en modell för din Task Manager-app. Här är en exempelmodell du kan använda:

från django.db importera modeller
klassUppgift(modeller. Modell):
 titel = modeller. CharField (max_length=200)
 beskrivning = modeller. Textfält()
 färdigställd = modeller. BooleanField (standard=Falsk)
 create_at = modeller. DateTimeField (auto_now_add=Sann)

Migrera din modell med detta kommando:

python manage.py makemigrations && python manage.py migrera

Skapa ett Django-formulär för din app

Du bör ha en blankett för hantering Skapa och Uppdatering operationer. Skapa en fil som heter i din appkatalog forms.py. Här är ett exempel:

från django importera formulär
från .modeller importera Uppgift
klassTaskForm(formulär. ModelForm):
klassMeta:
 modell = Uppgift
 fält = ['titel', 'beskrivning', 'avslutad']
 widgets = {
'titel': former. TextInput (attrs={'klass': 'form-kontroll',}),
'beskrivning': former. Textarea (attrs={'klass': 'form-kontroll',}),
'avslutad': former. CheckboxInput (attrs={'klass': "formulär-check-inmatning"}),
 }

Koden ovan har en klass som heter TaskForm som definierar fälten och widgetarna för formuläret. Den anger också vilken modell som ska användas.

Skapa Django-vyer för varje CRUD-operation

En grundläggande CRUD-app med CBVs kräver minst fyra vyer för att hantera alla operationer effektivt. De nästa stegen visar hur du skapar dem.

Importera nödvändiga moduler och paket

Öppna din views.py fil och gör följande importer:

från django.views.generic importera ListView, DetailView, CreateView, UpdateView, DeleteView
från django.urls importera omvänd_lat
från .modeller importera Uppgift
från .formulär importera TaskForm

Koden ovan importerar fem CBV. Den importerar också omvänd_lat för att omdirigera användaren till en angiven URL efter ett formulär. Slutligen importerar den Uppgift modell och TaskForm skapat tidigare.

Skapa en vy för att lista modellobjekt

En Task Manager-app bör ha en sida som listar alla uppgifter som skapats av användaren. För att skapa en vy för detta bör du använda Listvy. Här är ett exempel:

klassTaskListView(Listvy):
 modell = Uppgift
 mallnamn = 'task_manager/task_list.html'
 context_object_name = "uppgifter"

Vyn ovan definierar tre attribut som är:

  1. modell: Det här attributet definierar vilken modell som ska användas för den specifika vyn.
  2. mallnamn: Det här attributet talar om för Django vilken mall som ska renderas till webbläsaren.
  3. context_object_name: Det här attributet definierar namnet som låter mallen komma åt listan över objekt i modellen.

De flesta CBV kommer att innehålla dessa tre attribut.

Skapa en vy för att hantera uppgiftsdetaljer

Varje uppgift som en användare skapar bör ha en sida som visar dess detaljer. Den idealiska CBV för att hantera detta är DetailVew. Här är ett enkelt exempel:

klassTaskDetailView(Detaljerad vy):
 modell = Uppgift
 mallnamn = 'task_manager/task_detail.html'

Skapa en vy för att skapa uppgift

Skapa en vy för att hantera skapandet eller tillägget av nya uppgifter. Det här är Skapa del av CRUD-verksamheten, och den rätta synen för detta är SkapaVisa. Så här använder du det:

klassTaskCreateView(CreateView):
 modell = Uppgift
 form_class = TaskForm
 mallnamn = 'task_manager/task_form.html'
 success_url = reverse_lazy('uppgiftslista')

Koden ovan introducerar två nya attribut: form_class och success_url.

De form_class attribut talar om för vyn vilken formklass som ska renderas och användas för dess operationer.

De success_url anger hur man omdirigerar användaren efter att ha skickat formuläret. Den använder omvänd_lat funktion som tar namnet på en URL-sökväg.

Skapa en vy för redigeringsuppgifter

För att tillåta dina användare att redigera eller uppdatera sina uppgifter bör du skapa en vy som ser ut så här:

klassTaskUpdateView(UpdateView):
 modell = Uppgift
 form_class = TaskForm
 mallnamn = 'task_manager/task_form.html'
 success_url = reverse_lazy('uppgiftslista')

Ovanstående vy liknar TaskCreateView skapat tidigare. Den enda skillnaden är användningen av UpdateView.

Skapa en vy för att hantera borttagningsåtgärder

För att tillåta dina användare att ta bort uppgifter när de vill, bör du använda DeleteView CBV. Här är ett exempel:

klassTaskDeleteView(DeleteView):
 modell = Uppgift
 mallnamn = 'task_manager/task_confirm_delete.html'
 success_url = reverse_lazy('uppgiftslista')

Konfigurera appens webbadresser

Skapa en i din appkatalog urls.py fil och konfigurera dina URL-mönster så här:

från django.urls importera väg
från .visningar importera TaskListView, TaskDetailView, TaskCreateView, TaskUpdateView, TaskDeleteView
urlpatterns = 
 väg('', TaskListView.as_view(), name='uppgiftslista'),
 väg('skapa/', TaskCreateView.as_view(), namn='task_create'),
 väg('uppgifter//', TaskDetailView.as_view(), name='task_detail'),
 väg('uppgifter//update/', TaskUpdateView.as_view(), name='task_update'),
 väg('uppgifter//delete/', TaskDeleteView.as_view(), name='task_delete'),
]

URL-mönstren ovan liknar webbadresser som skapats med funktionsbaserade vyer. Skillnaden är as_view() funktion som läggs till i slutet av varje vynamn.

Du kan använd Django-sniglar för att skapa webbadresser istället för primärnyckeln som används ovan.

Skapa mallar för dina vyer

Om du låter dina användare utföra de åtgärder som definieras i vyerna ovan föreslår du att du tillhandahåller ett gränssnitt för dem att interagera med. Från de vyer som skapats tidigare bör Task Manager-appen ha fyra användargränssnitt.

Skapa fyra HTML-mallar i din appkatalog. Du bör också skapa base.html fil. Du kan styla dina Django-mallar med Bootstrap för att spara tid.

Mall för uppgiftslista

Denna mall bör innehålla kod som listar alla uppgifter i modellen. Ett skelettexempel på koden är detta:

{% utökar 'base.html' %}
{% block content %}
<Centrum>
<h1>Dina uppgifterh1>
<ahref="{% url 'task_create' %}">Lägg till uppgifta>
 {% för uppgift i uppgifter %}
<div>
<div>
<h5>{{ task.title }}h5>
<sid>{{ task.description|truncatechars: 50 }}sid>
<sid>
<stark>Avslutad:stark>
 {% if task.completed %}Ja{% else %}Nej{% endif %}
sid>
<ahref="{% url 'task_detail' task.pk %}">
 Läs mer
a>
<ahref="{% url 'task_delete' task.pk %}">
 Ta bort uppgift
a>
div>
div>
 {% tom %}
<h3>Inga uppgifter ännu.h3>
<ahref="{% url 'task_create' %}">Lägg till uppgifta>
 {% slutför %}
Centrum>
{% slutblock %}

Med vissa Bootstrap-klasser kan du få din sida att se ut så här:

Uppgiftsdetaljmall

Den här sidan ska visa alla detaljer för varje skapad uppgift. Här är en exempelmall som du kan använda:

{% utökar 'base.html' %}
{% block content %}
<h1>{{ task.title }}h1>
<sid>{{ uppgifts beskrivning }}sid>
<sid>Slutfört: {% if task.completed %}Ja{% else %}Nej{% endif %}sid>
<ahref="{% url 'task_update' task.pk %}">Redigera uppgifta>
<ahref="{% url 'task_delete' task.pk %}">Ta bort uppgifta>
{% slutblock %}

Beroende på din stylingstrategi bör din sida se ut så här:

Uppgiftsformulärmall

Denna mall bör innehålla ett formulär som låter användaren skapa eller uppdatera en uppgift.

{% utökar 'base.html' %}
{% block content %}
<h1>Skapa uppgifth1>
<formmetod="posta">
 {% csrf_token %}
 {{ form.as_p }}
<knapptyp="Skicka in">Sparaknapp>
form>
{% slutblock %}

Mallen kommer att se ut så här:

Ta bort uppgiftsmall

Denna mall bör vara en bekräftelsesida för att förhindra oavsiktlig radering av uppgifter.

{% utökar 'base.html' %}
{% block content %}
<h1>Bekräfta raderingh1>
<sid>Är du säker på att du vill ta bort "{{ object.title }}"?sid>
<formmetod="posta">
 {% csrf_token %}
<knapptyp="Skicka in">Raderaknapp>
<ahref="{% url 'task_list' %}">Annulleraa>
form>
{% slutblock %}

Med lite Bootstrap bör din sida se ut så här:

Använd klassbaserade vyer för att öka din produktivitet

Klassbaserade vyer är ett utmärkt sätt att skriva ren, organiserad kod på kort tid, och därigenom öka din produktivitet. Du bör använda dem i dina projekt så mycket som möjligt. Dessutom kan du ytterligare integrera funktioner som sökfunktioner, aviseringar och så vidare för att göra din Task Manager-app till en fullfjädrad funktionell applikation.