Leer hoe u een taakbeheer-app bouwt met behulp van de principes van CRUD en op klassen gebaseerde weergaven in Django.

Een van de belangrijkste kenmerken van Django is de ingebouwde ondersteuning voor het maken van projecten bovenop CRUD-bewerkingen (Create, Read, Update, Delete). Hoewel de op klassen gebaseerde weergaven van Django een snelle, gemakkelijke en flexibele manier bieden om webapplicaties te bouwen, gebruiken veel ontwikkelaars nog steeds op functies gebaseerde weergaven.

Op klasse gebaseerde weergaven bieden verschillende voordelen ten opzichte van functiegebaseerde weergaven, waaronder overerving, codestructurering, herbruikbaarheid van code en meer. Hoewel het implementeren van op klassen gebaseerde weergaven enigszins ingewikkeld kan lijken, zal deze gids u helpen het concept te begrijpen door een taakbeheer-app te bouwen en stapsgewijze instructies te geven.

Wat zijn op klassen gebaseerde weergaven in Django?

In Django zijn weergaven Python-functies die een webverzoek aannemen en een webantwoord retourneren. Op klassen gebaseerde weergaven (CBV's) zijn een alternatieve manier om weergaven in Django te definiëren met behulp van Python-klassen in plaats van functies.

instagram viewer

CBV's hebben verschillende voordelen, zoals een betere organisatie van de code, gemakkelijker hergebruik van code en de mogelijkheid om overerving te gebruiken om variaties op bestaande weergaven te creëren. CBV's bieden ook ingebouwde methoden zoals de krijgen() En na() methoden die u kunt overschrijven voor aangepast gedrag.

De code die in dit artikel wordt gebruikt, is hierin beschikbaar GitHub-opslagplaats.

Op klassen gebaseerde weergaven beschikbaar in Django

Django biedt een aantal ingebouwde CBV's voor populaire use-cases, zoals het weergeven van lijsten met objecten of het maken van nieuwe. Sommige van deze ingebouwde CBV's zijn:

  1. Lijstweergave: Deze weergave geeft een lijst weer van objecten die uit een model zijn opgehaald. Een pagina met alle berichten die beschikbaar zijn in een blog, gebruikt bijvoorbeeld een Lijstweergave.
  2. Detailweergave: Deze weergave geeft een gedetailleerd beeld weer van een enkel object dat uit een model is opgehaald. U kunt een Detailweergave om de details van specifieke berichten in een blog-app weer te geven.
  3. CreateView: Deze weergave geeft een formulier weer om een ​​nieuw object te maken en handelt de indiening van het formulier af. In een app voor taakbeheer gebruikt u deze weergave bijvoorbeeld voor het maken van nieuwe taken.
  4. View verwijderen: Deze weergave geeft een bevestigingspagina weer om een ​​object te verwijderen en handelt de verwijdering van de pagina af.
  5. UpdateView: Deze weergave geeft een formulier weer om een ​​bestaand object bij te werken en handelt de indiening van het formulier af.

Django biedt ook andere weergaven, waaronder Sjabloonweergave, RedirectView, En Formulierweergave. U kunt verwijzen naar Django's documentatie voor gedetailleerde informatie over op klassen gebaseerde weergaven.

Bouw een Task Manager-app met Django Class-Based Views

Door een app te bouwen, zoals een app voor taakbeheer, kunt u begrijpen hoe u CRUD-bewerkingen met CBV's kunt implementeren. Een taakbeheerder heeft functies waarmee gebruikers taken kunnen maken, bijwerken, verwijderen en lezen. Deze functies zijn in overeenstemming met CRUD-operaties. De volgende stappen helpen u bij het bouwen van een taakbeheer-app met Django CBV's.

Zet een Django-project op

Om een ​​taakbeheer-app met Django te maken, moet u beginnen met het volgen van deze stappen:

  1. Installeer Django in uw Python virtuele omgeving met dit commando:
    pip installeer django
  2. Maak een Django-project. Met de volgende opdracht wordt een project gemaakt met de naam project_kern.
    django-admin startproject project_core .
  3. Maak een app genaamd Taakbeheer.
    python manage.py startapp task_manager
  4. In uw instellingen.py voeg uw app-naam toe aan de GEÏNSTALLEERDE_APPS lijst.
    GEÏNSTALLEERDE_APPS = [
    'Taakbeheer',
    ]
  5. Open de URL.py bestand in uw projectdirectory en configureer de URL's voor uw Taakbeheer app:
    van django.urls importeren pad, omvatten
    urlpatronen = [
     pad('', erbij betrekken('task_manager.urls')),
    ]

Maak een model voor uw Task Manager-app

In uw app-directory (of Taakbeheer map), open je modellen.py bestand en maak een model voor uw taakbeheer-app. Hier is een voorbeeldmodel dat u kunt gebruiken:

van django.db importeren modellen
klasTaak(modellen. Model):
 titel = modellen. CharField (max_length=200)
 omschrijving = modellen. TekstVeld()
 voltooid = modellen. Booleaans veld (standaard=Vals)
 create_at = modellen. DateTimeField (auto_now_add=WAAR)

Migreer uw model met deze opdracht:

python manage.py makemigrations && python manage.py migreren

Maak een Django-formulier voor uw app

U dient een formulier te hebben voor afhandeling Creëren En Update activiteiten. Maak in uw app-directory een bestand met de naam vormen.py. Hier is een voorbeeld:

van django importeren formulieren
van .modellen importeren Taak
klasTaakformulier(formulieren. modelformulier):
klasMeta:
 model = Taak
 velden = ['titel', 'beschrijving', 'voltooid']
 widgets = {
'titel': formulieren. Tekstinvoer (attrs={'klas': 'vorm-controle',}),
'beschrijving': formulieren. Tekstgebied (attrs={'klas': 'vorm-controle',}),
'voltooid': formulieren. CheckboxInvoer (attrs={'klas': 'formulier-controle-invoer'}),
 }

De bovenstaande code heeft een klasse genaamd Taakformulier die de velden en widgets van het formulier definieert. Het specificeert ook het te gebruiken model.

Maak Django-weergaven voor elke CRUD-bewerking

Een eenvoudige CRUD-app met CBV's vereist ten minste vier weergaven om alle bewerkingen effectief af te handelen. In de volgende paar stappen wordt uitgelegd hoe u ze kunt maken.

Importeer de benodigde modules en pakketten

Open je weergaven.py bestand en maak de volgende imports:

van django.views.generic importeren ListView, DetailView, CreateView, UpdateView, DeleteView
van django.urls importeren omgekeerde_lui
van .modellen importeren Taak
van .formulieren importeren Taakformulier

De bovenstaande code importeert vijf CBV's. Het importeert ook omgekeerde_lui om de gebruiker om te leiden naar een opgegeven URL na het indienen van een formulier. Ten slotte importeert het de Taak model, en de Taakformulier eerder gemaakt.

Maak een weergave om modelobjecten weer te geven

Een app voor taakbeheer moet een pagina hebben met alle taken die door de gebruiker zijn gemaakt. Om hiervoor een weergave te maken, moet u de Lijstweergave. Hier is een voorbeeld:

klasTaskListView(Lijstweergave):
 model = Taak
 sjabloonnaam = 'task_manager/task_list.html'
 context_object_name = 'taken'

De bovenstaande weergave definieert drie attributen die zijn:

  1. model: Dit attribuut definieert welk model moet worden gebruikt voor die specifieke weergave.
  2. sjabloon_naam: Dit attribuut vertelt Django welke sjabloon moet worden weergegeven in de browser.
  3. context_object_naam: Dit attribuut definieert de naam waarmee de sjabloon toegang krijgt tot de lijst met objecten in het model.

De meeste CBV's bevatten deze drie kenmerken.

Maak een weergave om taakdetails af te handelen

Elke taak die een gebruiker maakt, moet een pagina hebben met de details. De ideale CBV om dit aan te pakken is DetailVew. Hier is een eenvoudig voorbeeld:

klasTaakDetailView(Detailweergave):
 model = Taak
 sjabloonnaam = 'taak_manager/taak_detail.html'

Maak een weergave voor het maken van taken

Maak een weergave om het maken of toevoegen van nieuwe taken te verwerken. Dit is de Creëren onderdeel van de CRUD-operaties, en de juiste weergave hiervoor is de CreateView. Hier is hoe het te gebruiken:

klasTaakCreateView(CreateView):
 model = Taak
 form_class = Taakformulier
 sjabloonnaam = 'taak_manager/taak_formulier.html'
 success_url = reverse_lazy('takenlijst')

De bovenstaande code introduceert twee nieuwe attributen: vorm klasse En succes_url.

De vorm klasse attribuut vertelt de weergave welke formulierklasse moet worden weergegeven en gebruikt voor zijn bewerkingen.

De succes_url geeft aan hoe de gebruiker moet worden omgeleid na het indienen van het formulier. Het gebruikt de omgekeerde_lui functie die de naam van een URL-pad aanneemt.

Maak een weergave voor het bewerken van taken

Om uw gebruikers toe te staan ​​hun taken te bewerken of bij te werken, moet u een weergave maken die er als volgt uitziet:

klasTaskUpdateView(UpdateView):
 model = Taak
 form_class = Taakformulier
 sjabloonnaam = 'taak_manager/taak_formulier.html'
 success_url = reverse_lazy('takenlijst')

De bovenstaande weergave is vergelijkbaar met de TaakCreateView eerder gemaakt. Het enige verschil is het gebruik van de UpdateView.

Maak een weergave om verwijderbewerkingen af ​​te handelen

Om uw gebruikers toe te staan ​​taken te verwijderen wanneer ze maar willen, moet u de View verwijderen CBV. Hier is een voorbeeld:

klasTaakDeleteView(Verwijderweergave):
 model = Taak
 sjabloonnaam = 'task_manager/task_confirm_delete.html'
 success_url = reverse_lazy('takenlijst')

Configureer de URL's van uw app

Maak in uw app-directory een URL.py bestand en configureer uw URL-patronen als volgt:

van django.urls importeren pad
van .keer bekeken importeren TaskListView, TaskDetailView, TaskCreateView, TaskUpdateView, TaskDeleteView
urlpatronen = 
 pad('', TaskListView.as_view(), naam='takenlijst'),
 pad('creëren/', TaskCreateView.as_view(), naam='taak_creëren'),
 pad('taken//', TaskDetailView.as_view(), naam='taak_detail'),
 pad('taken//update/', TaskUpdateView.as_view(), naam='taak_update'),
 pad('taken//delete/', TaskDeleteView.as_view(), naam='taak_verwijderen'),
]

De bovenstaande URL-patronen zijn vergelijkbaar met URL's die zijn gemaakt met op functies gebaseerde weergaven. Het verschil is de as_view() functie toegevoegd aan het einde van elke weergavenaam.

Jij kan gebruik Django-slakken om URL's te maken in plaats van de hierboven gebruikte primaire sleutel.

Maak sjablonen voor uw weergaven

Als u uw gebruikers toestaat de acties uit te voeren die in de bovenstaande weergaven zijn gedefinieerd, suggereert u dat u een interface biedt waarmee ze kunnen communiceren. Uit de eerder gemaakte weergaven zou de taakbeheer-app vier gebruikersinterfaces moeten hebben.

Maak in uw app-directory vier HTML-sjablonen. Je moet ook creëren basis.html bestand. Jij kan style je Django-sjablonen met Bootstrap tijd besparen.

Takenlijst sjabloon

Deze sjabloon moet code bevatten die alle taken in het model opsomt. Een skeletachtig voorbeeld van de code is dit:

{% breidt 'base.html' uit %}
{% blokinhoud %}
<centrum>
<h1>Jouw Takenh1>
<Ahref="{% url 'task_create' %}">Voeg taak toeA>
 {% voor taak in taken %}
<div>
<div>
<h5>{{ taak.titel }}h5>
<P>{{ task.description|truncatechars: 50 }}P>
<P>
<sterk>Voltooid:sterk>
 {% if task.completed %}Ja{% else %}Nee{% endif %}
P>
<Ahref="{% url 'task_detail' task.pk %}">
 Lees verder
A>
<Ahref="{% url 'task_delete' task.pk %}">
 Taak verwijderen
A>
div>
div>
 {% leeg %}
<h3>Nog geen taken.h3>
<Ahref="{% url 'task_create' %}">Voeg taak toeA>
 {% endfor %}
centrum>
{% eindblok %}

Met sommige Bootstrap-klassen kunt u uw pagina er zo uit laten zien:

Sjabloon voor taakdetail

Deze pagina zou de volledige details van elke aangemaakte taak moeten tonen. Hier is een voorbeeldsjabloon dat u kunt gebruiken:

{% breidt 'base.html' uit %}
{% blokinhoud %}
<h1>{{ taak.titel }}h1>
<P>{{ taakomschrijving }}P>
<P>Voltooid: {% if task.completed %}Ja{% else %}Nee{% endif %}P>
<Ahref="{% url 'task_update' task.pk %}">Taak bewerkenA>
<Ahref="{% url 'task_delete' task.pk %}">Taak verwijderenA>
{% eindblok %}

Afhankelijk van uw stijlbenadering, zou uw pagina er als volgt uit moeten zien:

Taakformulier sjabloon

Deze sjabloon moet een formulier bevatten waarmee de gebruiker een taak kan maken of bijwerken.

{% breidt 'base.html' uit %}
{% blokinhoud %}
<h1>Taak makenh1>
<formuliermethode="na">
 {% csrf_token %}
 {{ formulier.as_p }}
<knoptype="indienen">Reddenknop>
formulier>
{% eindblok %}

Het sjabloon ziet er als volgt uit:

Taaksjabloon verwijderen

Dit sjabloon moet een bevestigingspagina zijn om te voorkomen dat taken per ongeluk worden verwijderd.

{% breidt 'base.html' uit %}
{% blokinhoud %}
<h1>Bevestig verwijderenh1>
<P>Weet u zeker dat u "{{ object.title }}" wilt verwijderen?P>
<formuliermethode="na">
 {% csrf_token %}
<knoptype="indienen">Verwijderenknop>
<Ahref="{% url 'task_list' %}">AnnulerenA>
formulier>
{% eindblok %}

Met wat Bootstrap zou je pagina er zo uit moeten zien:

Gebruik op klassen gebaseerde weergaven om uw productiviteit te verhogen

Op klasse gebaseerde weergaven zijn een geweldige manier om in korte tijd schone, georganiseerde code te schrijven, waardoor uw productiviteit toeneemt. Gebruik ze zoveel mogelijk in uw projecten. U kunt ook functies zoals zoekfunctionaliteit, meldingen enzovoort verder integreren om van uw taakbeheer-app een volwaardige functionele toepassing te maken.