CRUD alkalmazás létrehozása Django osztályalapú nézetekkel

A Django egyik legfontosabb jellemzője a projektek létrehozásának beépített támogatása a CRUD (Create, Read, Update, Delete) műveleteken felül. Míg a Django osztályalapú nézetei gyors, egyszerű és rugalmas módot biztosítanak a webalkalmazások létrehozására, sok fejlesztő továbbra is funkcióalapú nézeteket használ.

Az osztályalapú nézetek számos előnnyel rendelkeznek a függvényalapú nézetekkel szemben, beleértve az öröklődést, a kódstrukturálást, a kód újrafelhasználhatóságát és még sok mást. Bár az osztályalapú nézetek megvalósítása kissé bonyolultnak tűnhet, ez az útmutató segít a koncepció megértésében egy feladatkezelő alkalmazás létrehozásával és lépésről lépésre szóló utasításokkal.

Mik azok az osztályalapú nézetek a Django-ban?

A Djangoban a nézetek vannak Python függvények amelyek fogadnak egy webes kérést és webes választ adnak vissza. Az osztályalapú nézetek (CBV-k) egy alternatív módja a nézetek meghatározásának a Django-ban, függvények helyett Python-osztályok használatával.

A CBV-k számos előnnyel rendelkeznek, mint például a jobb kódszervezés, a kód könnyebb újrafelhasználása, valamint az öröklődés felhasználásának lehetősége a meglévő nézetek variációinak létrehozására. A CBV-k beépített módszereket is biztosítanak, mint például a kap() és post() módszereket, amelyeket felülírhat az egyéni viselkedésekhez.

A cikkben használt kód itt érhető el GitHub adattár.

Osztályalapú nézetek elérhetők a Django-ban

A Django néhány beépített CBV-t kínál népszerű felhasználási esetekre, például objektumok listájának megjelenítésére vagy újak létrehozására. Néhány ilyen beépített CBV:

1. Lista nézet: Ez a nézet megjeleníti a modellből lekért objektumok listáját. Például egy oldal, amely felsorolja a blogban elérhető összes bejegyzést, az a Lista nézet.
2. DetailView: Ez a nézet egy modellből lekért egyetlen objektum részletes nézetét jeleníti meg. Használhatja a DetailView adott bejegyzések részleteinek megjelenítéséhez egy blogalkalmazásban.
3. CreateView: Ez a nézet egy űrlapot jelenít meg egy új objektum létrehozásához, és kezeli az űrlap elküldését. Például egy feladatkezelő alkalmazásban ezt a nézetet használja új feladatok létrehozásához.
4. DeleteView: Ez a nézet egy megerősítő oldalt jelenít meg egy objektum törléséhez, és kezeli az oldal törlését.
5. Frissítésnézet: Ez a nézet egy űrlapot jelenít meg egy meglévő objektum frissítéséhez, és kezeli az űrlap elküldését.

A Django más nézeteket is kínál, többek között TemplateView, RedirectView, és FormView. Lehet hivatkozni Django dokumentációja az osztályalapú nézetek részletes információiért.

Készítsen Feladatkezelő alkalmazást Django osztályalapú nézetekkel

Egy alkalmazás, például egy feladatkezelő alkalmazás elkészítésével megértheti, hogyan lehet CRUD-műveleteket végrehajtani a CBV-kkel. A feladatkezelő olyan funkciókkal rendelkezik, amelyek lehetővé teszik a felhasználók számára feladatok létrehozását, frissítését, törlését és olvasását. Ezek a funkciók összhangban vannak a CRUD-műveletekkel. A következő lépések segítenek felépíteni egy feladatkezelő alkalmazást Django CBV-kkel.

Django projekt létrehozása

Ha feladatkezelő alkalmazást szeretne létrehozni a Django segítségével, kövesse az alábbi lépéseket:

1. Telepítse a Django-t a számítógépére Python virtuális környezet ezzel a paranccsal:

   pip install django

2. Hozzon létre egy Django projektet. A következő parancs egy projektet hoz létre projekt_mag.

   django-admin startproject project_core .

3. Hozzon létre egy alkalmazást feladatkezelő.

   python manage.py startapp task_manager

4. A tiédben settings.py adja hozzá az alkalmazás nevét a INSTALLED_APPS lista.

   INSTALLED_APPS = [
   'feladatkezelő',
   ]

5. Nyissa meg a urls.py fájlt a projektkönyvtárba, és konfigurálja a saját URL-címeit feladatkezelő alkalmazás:

   tól től django.urls import út, tartalmazza
   urlpatterns = [
    pálya('', include('task_manager.urls')),
   ]

Hozzon létre egy modellt a Feladatkezelő alkalmazáshoz

Az alkalmazáskönyvtárban (vagy feladatkezelő mappa), nyissa meg a sajátját modellek.py fájlt, és hozzon létre egy modellt a feladatkezelő alkalmazáshoz. Íme egy használható mintamodell:

tól től django.db import modellek
osztályFeladat(modellek. Modell):
 cím = modellek. CharField (max_length=200)
 leírás = modellek. Szövegmező()
 elkészült = modellek. BooleanField (alapértelmezett =Hamis)
 Created_at = modellek. DateTimeField (auto_now_add=Igaz)

Állítsa át a modellt ezzel a paranccsal:

python manage.py makemigrations && python manage.py migrate

Hozzon létre egy Django űrlapot az alkalmazásához

Legyen egy nyomtatvány a kezeléshez Teremt és Frissítés tevékenységek. Az alkalmazáskönyvtárban hozzon létre egy nevű fájlt forms.py. Íme egy példa:

tól től django import formák
tól től .modellek import Feladat
osztályTaskForm(űrlapok. Modellforma):
osztályMeta:
 modell = Feladat
 mezők = ['cím', 'leírás', 'befejezve']
 widgetek = {
'cím': formák. Szövegbevitel (attrs={'osztály': 'form-control',}),
'leírás': formák. Szövegterület (attrs={'osztály': 'form-control',}),
'befejezve': formák. CheckboxInput (attrs={'osztály': 'form-check-input'}),
 }

A fenti kódnak van egy nevű osztálya TaskForm amely az űrlap mezőit és widgetjeit határozza meg. Meghatározza a használandó modellt is.

Hozzon létre Django nézeteket minden CRUD művelethez

A CBV-kkel rendelkező alap CRUD-alkalmazásokhoz legalább négy nézetre van szükség az összes művelet hatékony kezeléséhez. A következő néhány lépés megmutatja, hogyan hozhatja létre őket.

Importálja a szükséges modulokat és csomagokat

Nyissa meg views.py fájlt, és végezze el a következő importálást:

tól től django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView
tól től django.urls import fordított_lusta
tól től .modellek import Feladat
tól től .formák import TaskForm

A fenti kód öt CBV-t importál. Importál is fordított_lusta a felhasználó átirányítása egy megadott URL-re az űrlap elküldése után. Végül importálja a Feladat modell, és a TaskForm korábban létrehozott.

Hozzon létre egy nézetet a modellobjektumok listázásához

A feladatkezelő alkalmazásnak rendelkeznie kell egy oldallal, amely felsorolja a felhasználó által létrehozott összes feladatot. Nézet létrehozásához ehhez használja a Lista nézet. Íme egy példa:

osztályTaskListView(Lista nézet):
 modell = Feladat
 sablon_neve = 'task_manager/task_list.html'
 kontextus_objektum_neve = 'feladatok'

A fenti nézet három attribútumot határoz meg, amelyek a következők:

1. modell: Ez az attribútum határozza meg, hogy melyik modellt kell használni az adott nézethez.
2. Sablonnév: Ez az attribútum mondja meg a Django-nak, hogy melyik sablont jelenítse meg a böngészőben.
3. kontextus_objektum_neve: Ez az attribútum határozza meg azt a nevet, amely lehetővé teszi a sablon számára, hogy hozzáférjen a modellben lévő objektumok listájához.

A legtöbb CBV ezt a három attribútumot tartalmazza.

Hozzon létre egy nézetet a feladat részleteinek kezeléséhez

Minden felhasználó által létrehozott feladatnak rendelkeznie kell egy oldallal, amelyen a részletek láthatók. Az ideális CBV ennek kezelésére DetailVew. Íme egy egyszerű példa:

osztályTaskDetailView(Részletes nézet):
 modell = Feladat
 sablon_neve = "task_manager/task_detail.html"

Hozzon létre egy nézetet a feladat létrehozásához

Hozzon létre egy nézetet az új feladatok létrehozásának vagy hozzáadásának kezelésére. Ez a Teremt a CRUD műveletek része, és ehhez a megfelelő nézet a CreateView. A következőképpen használhatja:

osztályTaskCreateView(Nézet létrehozása):
 modell = Feladat
 form_class = Feladatűrlap
 sablon_neve = 'task_manager/task_form.html'
 siker_url = fordított_lusta('feladat lista')

A fenti kód két új attribútumot vezet be: form_class és siker_url.

A form_class Az attribútum megmondja a nézetnek, hogy melyik űrlaposztályt kell megjelenítenie és használnia a műveletekhez.

A siker_url meghatározza, hogyan kell átirányítani a felhasználót az űrlap elküldése után. Használja a fordított_lusta függvény, amely egy URL-útvonal nevét veszi fel.

Hozzon létre egy nézetet a feladatok szerkesztéséhez

Ahhoz, hogy a felhasználók szerkeszthessék vagy frissíthessék feladataikat, hozzon létre egy nézetet, amely így néz ki:

osztályTaskUpdateView(UpdateView):
 modell = Feladat
 form_class = Feladatűrlap
 sablon_neve = 'task_manager/task_form.html'
 siker_url = fordított_lusta('feladat lista')

A fenti nézet hasonló a TaskCreateView korábban létrehozott. Az egyetlen különbség a használata Frissítésnézet.

Hozzon létre egy nézetet a törlési műveletek kezeléséhez

Ahhoz, hogy a felhasználók bármikor törölhessenek feladatokat, használja a DeleteView CBV. Íme egy példa:

osztályTaskDeleteView(Nézet törlése):
 modell = Feladat
 sablon_neve = "task_manager/task_confirm_delete.html"
 siker_url = fordított_lusta('feladat lista')

Konfigurálja az alkalmazás URL-címeit

Az alkalmazáskönyvtárban hozzon létre a urls.py fájlt, és állítsa be az URL-mintákat az alábbiak szerint:

tól től django.urls import pálya
tól től .nézetek import TaskListView, TaskDetailView, TaskCreateView, TaskUpdateView, TaskDeleteView
urlpatterns = 
 pálya('', TaskListView.as_view(), név='feladat lista'),
 pálya('teremt/', TaskCreateView.as_view(), név='task_create'),
 pálya('feladatok//', TaskDetailView.as_view(), név='task_detail'),
 pálya('feladatok//update/', TaskUpdateView.as_view(), név='task_update'),
 pálya('feladatok//delete/', TaskDeleteView.as_view(), név='task_delete'),
]

A fenti URL-minták hasonlóak a függvényalapú nézetekkel létrehozott URL-ekhez. A különbség az as_view() függvény minden nézetnév végéhez fűződik.

tudsz használja a Django slugokat az URL-ek létrehozásához a fent használt elsődleges kulcs helyett.

Hozzon létre sablonokat a nézeteihez

Ha lehetővé teszi a felhasználók számára, hogy a fenti nézetekben meghatározott műveleteket hajtsák végre, akkor azt javasolja, hogy biztosítson egy felületet, amellyel kapcsolatba léphetnek. A korábban létrehozott nézetekből a feladatkezelő alkalmazásnak négy felhasználói felülettel kell rendelkeznie.

Az alkalmazáskönyvtárban hozzon létre négy HTML-sablont. Létrehoznod is kellene base.html fájlt. tudsz stílusozd Django-sablonjaidat a Bootstrap segítségével időt spórolni.

Feladatlista sablon

Ennek a sablonnak tartalmaznia kell a modellben szereplő összes feladatot felsoroló kódot. A kód vázlatos példája a következő:

{% extends 'base.html' %}
{% blokktartalom %}
<központ>
<h1>Az Ön feladataih1>
<ahref="{% url 'task_create' %}">Feladat hozzáadásaa>
 {% a feladatokhoz a feladatokhoz %}
<div>
<div>
<h5>{{ feladat.cím }}h5>
<p>{{ task.description|truncatechars: 50 }}p>
<p>
<erős>Elkészült:erős>
 {% if task.completed %}Igen{% else %}Nem{% endif %}
p>
<ahref="{% url 'task_detail' task.pk %}">
 Olvass tovább
a>
<ahref="{% url 'task_delete' task.pk %}">
 Feladat törlése
a>
div>
div>
 {% üres %}
<h3>Még nincsenek feladatok.h3>
<ahref="{% url 'task_create' %}">Feladat hozzáadásaa>
 {% endfor %}
központ>
{% endblock %}

Egyes Bootstrap osztályokkal így alakíthatja ki oldalát:

Feladat részletes sablon

Ezen az oldalon minden létrehozott feladat teljes részletét meg kell jeleníteni. Íme egy példa sablon, amelyet használhat:

{% extends 'base.html' %}
{% blokktartalom %}
<h1>{{ feladat.cím }}h1>
<p>{{ feladatleírás }}p>
<p>Befejezve: {% if task.completed %}Igen{% else %}Nem{% endif %}p>
<ahref="{% url 'task_update' task.pk %}">Feladat szerkesztésea>
<ahref="{% url 'task_delete' task.pk %}">Feladat törlésea>
{% endblock %}

A stílus megközelítésétől függően oldalának így kell kinéznie:

Feladat űrlap sablon

Ennek a sablonnak tartalmaznia kell egy űrlapot, amely lehetővé teszi a felhasználó számára egy feladat létrehozását vagy frissítését.

{% extends 'base.html' %}
{% blokktartalom %}
<h1>Feladat létrehozásah1>
<formamódszer="posta">
 {% csrf_token %}
 {{ form.as_p }}
<gombtípus="Beküldés">Megmentgomb>
forma>
{% endblock %}

A sablon így fog kinézni:

Feladatsablon törlése

Ennek a sablonnak egy megerősítő oldalnak kell lennie a feladatok véletlen törlésének megelőzése érdekében.

{% extends 'base.html' %}
{% blokktartalom %}
<h1>Törlés jóváhagyásah1>
<p>Biztosan törli a következőt: "{{ object.title }}"?p>
<formamódszer="posta">
 {% csrf_token %}
<gombtípus="Beküldés">Törölgomb>
<ahref="{% url 'task_list' %}">Megszüntetia>
forma>
{% endblock %}

Néhány Bootstrap használatával az oldalának így kell kinéznie:

Használja az osztályalapú nézeteket a termelékenység növeléséhez

Az osztályalapú nézetek nagyszerű módja annak, hogy rövid idő alatt tiszta, rendezett kódot írjon, ezáltal növelve a termelékenységet. A lehető legtöbbet kell használnia projektjei során. Ezenkívül további funkciókat, például keresési funkciókat, értesítéseket és így tovább integrálhat, hogy feladatkezelő alkalmazását teljes értékű funkcionális alkalmazássá tegye.