Aflați cum să creați o aplicație de manager de activități utilizând principiile CRUD și vizualizările bazate pe clasă în Django.

Una dintre caracteristicile cheie ale Django este suportul său încorporat pentru crearea de proiecte pe lângă operațiunile CRUD (Creare, Read, Update, Delete). În timp ce vizualizările bazate pe clasă ale Django oferă o modalitate rapidă, ușoară și flexibilă de a crea aplicații web, mulți dezvoltatori încă folosesc vizualizări bazate pe funcții.

Vizualizările bazate pe clasă oferă mai multe avantaje față de vizualizările bazate pe funcții, inclusiv moștenirea, structurarea codului, reutilizarea codului și multe altele. În timp ce implementarea vizualizărilor bazate pe clasă poate părea ușor complexă, acest ghid vă va ajuta să înțelegeți conceptul prin construirea unei aplicații de manager de activități și furnizarea de instrucțiuni pas cu pas.

Ce sunt vizualizările bazate pe clasă în Django?

În Django, vizualizările sunt Funcții Python care preiau o solicitare web și returnează un răspuns web. Vizualizările bazate pe clasă (CBV) sunt o modalitate alternativă de a defini vizualizările în Django folosind clase Python în loc de funcții.

instagram viewer

CBV-urile au mai multe avantaje, cum ar fi o organizare mai bună a codului, reutilizarea mai ușoară a codului și capacitatea de a folosi moștenirea pentru a crea variații ale vederilor existente. CBV-urile oferă, de asemenea, metode încorporate, cum ar fi obține() și post() metode pe care le puteți suprascrie pentru comportamente personalizate.

Codul folosit în acest articol este disponibil în acest articol Depozitul GitHub.

Vizualizări bazate pe clasă disponibile în Django

Django oferă câteva CBV-uri încorporate pentru cazuri de utilizare populare, cum ar fi afișarea listelor de obiecte sau crearea altora noi. Unele dintre aceste CBV-uri încorporate sunt:

  1. ListView: Această vizualizare redă o listă de obiecte preluate dintr-un model. De exemplu, o pagină care listează toate postările disponibile într-un blog va folosi a ListView.
  2. Vedere Detaliată: Această vizualizare redă o vedere detaliată a unui singur obiect preluat dintr-un model. Puteți folosi a Vedere Detaliată pentru a afișa detaliile unor postări specifice într-o aplicație de blog.
  3. CreateView: Această vizualizare redă un formular pentru a crea un obiect nou și se ocupă de trimiterea formularului. De exemplu, într-o aplicație de manager de activități, veți folosi această vizualizare pentru a crea sarcini noi.
  4. DeleteView: Această vizualizare redă o pagină de confirmare pentru ștergerea unui obiect și gestionează ștergerea paginii.
  5. UpdateView: Această vizualizare redă un formular pentru a actualiza un obiect existent și se ocupă de trimiterea formularului.

Django oferă și alte vizualizări, inclusiv TemplateView, RedirectView, și FormView. Vă puteți referi la documentația lui Django pentru informații detaliate despre vizualizările bazate pe clasă.

Creați o aplicație Task Manager cu vizualizări bazate pe clasă Django

Crearea unei aplicații, cum ar fi o aplicație de manager de activități, vă va permite să înțelegeți cum să implementați operațiuni CRUD cu CBV. Un manager de activități are caracteristici care permit utilizatorilor să creeze, să actualizeze, să șteargă și să citească sarcini. Aceste caracteristici sunt în conformitate cu operațiunile CRUD. Următorii pași vă vor ajuta să creați o aplicație de manager de activități cu Django CBV.

Configurați un proiect Django

Pentru a crea o aplicație de manager de activități cu Django, ar trebui să începeți prin a urma acești pași:

  1. Instalați Django în dvs Mediul virtual Python cu aceasta comanda:
    pip install django
  2. Creați un proiect Django. Următoarea comandă va crea un proiect numit miez_proiect.
    django-admin startproject project_core .
  3. Creați o aplicație numită gestionar de sarcini.
    python manage.py startapp task_manager
  4. În dumneavoastră setări.py adăugați numele aplicației dvs. la INSTALLED_APPS listă.
    INSTALLED_APPS = [
    'gestionar de sarcini',
    ]
  5. Deschide urls.py fișier în directorul de proiect și configurați adresele URL pentru dvs gestionar de sarcini aplicatie:
    din django.urls import cale, include
    urlpatterns = [
     cale('', include(„task_manager.urls”)),
    ]

Creați un model pentru aplicația dvs. Manager de activități

În directorul aplicației dvs. (sau gestionar de sarcini folder), deschideți modele.py fișier și creați un model pentru aplicația dvs. de manager de activități. Iată un exemplu de model pe care îl puteți folosi:

din django.db import modele
clasăSarcină(modele. Model):
 titlu = modele. CharField (lungime_max =200)
 descriere = modele. TextField()
 completat = modele. BooleanField (implicit=Fals)
 create_at = modele. DateTimeField (auto_now_add=Adevărat)

Migrați-vă modelul cu această comandă:

python manage.py makemigrations && python manage.py migra

Creați un formular Django pentru aplicația dvs

Ar trebui să aveți un formular pentru manipulare Crea și Actualizați operațiuni. În directorul aplicației, creați un fișier numit forme.py. Iată un exemplu:

din django import forme
din .modele import Sarcină
clasăTaskForm(forme. ModelForm):
clasăMeta:
 model = Sarcina
 câmpuri = ['titlu', 'Descriere', 'efectuat']
 widget-uri = {
'titlu': forme. TextInput (attrs={'clasă': „controlul formei”,}),
'Descriere': forme. Textarea (attrs={'clasă': „controlul formei”,}),
'efectuat': forme. CheckboxInput (atrs={'clasă': „formular-verificare-intrare”}),
 }

Codul de mai sus are o clasă numită TaskForm care definește câmpurile și widget-urile formularului. De asemenea, specifică modelul de utilizat.

Creați vizualizări Django pentru fiecare operațiune CRUD

O aplicație CRUD de bază cu CBV necesită cel puțin patru vizualizări pentru a gestiona toate operațiunile în mod eficient. Următorii câțiva pași vă vor arăta cum să le creați.

Importați modulele și pachetele necesare

Deschide-ți vederi.py fișier și efectuați următoarele importuri:

din django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView
din django.urls import reverse_lenes
din .modele import Sarcină
din .forme import TaskForm

Codul de mai sus importă cinci CBV-uri. De asemenea, importă reverse_lenes pentru a redirecționa utilizatorul către o adresă URL specificată după trimiterea unui formular. În cele din urmă, importă Sarcină modelul, iar cel TaskForm creat mai devreme.

Creați o vizualizare pentru a lista obiectele model

O aplicație de manager de activități ar trebui să aibă o pagină care listează toate sarcinile create de utilizator. Pentru a crea o vizualizare pentru aceasta, ar trebui să utilizați ListView. Iată un exemplu:

clasăTaskListView(Vizualizare listă):
 model = Sarcina
 template_name = „task_manager/task_list.html”
 nume_obiect_context = 'sarcini'

Vederea de mai sus definește trei atribute care sunt:

  1. model: Acest atribut definește ce model de utilizat pentru acea vizualizare specifică.
  2. Nume șablon: Acest atribut îi spune lui Django ce șablon să reda browserului.
  3. nume_obiect_context: Acest atribut definește numele care permite șablonului să acceseze lista de obiecte din model.

Majoritatea CBV-urilor vor conține aceste trei atribute.

Creați o vizualizare pentru a gestiona detaliile sarcinii

Fiecare sarcină creată de un utilizator ar trebui să aibă o pagină care să arate detaliile acesteia. CBV ideal pentru a face față asta este DetaliuVedere. Iată un exemplu simplu:

clasăTaskDetailView(Vedere Detaliată):
 model = Sarcina
 template_name = „task_manager/task_detail.html”

Creați o vizualizare pentru crearea sarcinilor

Creați o vizualizare pentru a gestiona crearea sau adăugarea de sarcini noi. Acesta este Crea parte a operațiunilor CRUD, iar vederea potrivită pentru aceasta este CreateView. Iată cum să-l folosești:

clasăTaskCreateView(CreateView):
 model = Sarcina
 form_class = TaskForm
 template_name = „task_manager/task_form.html”
 succes_url = reverse_lazy(„listă_de sarcini”)

Codul de mai sus introduce două atribute noi: form_class și succes_url.

The form_class Atributul indică vederii ce clasă de formulare trebuie redată și utilizată pentru operațiunile sale.

The succes_url specifică cum să redirecționeze utilizatorul după trimiterea formularului. Acesta folosește reverse_lenes funcție care ia numele unei căi URL.

Creați o vizualizare pentru editarea sarcinilor

Pentru a permite utilizatorilor să-și editeze sau să-și actualizeze sarcinile, ar trebui să creați o vizualizare care să arate astfel:

clasăTaskUpdateView(UpdateView):
 model = Sarcina
 form_class = TaskForm
 template_name = „task_manager/task_form.html”
 succes_url = reverse_lazy(„listă_de sarcini”)

Vederea de mai sus este similară cu cea TaskCreateView creat mai devreme. Singura diferență este utilizarea UpdateView.

Creați o vizualizare pentru a gestiona operațiunile de ștergere

Pentru a permite utilizatorilor să șteargă sarcini oricând doresc, ar trebui să utilizați DeleteView CBV. Iată un exemplu:

clasăTaskDeleteView(DeleteView):
 model = Sarcina
 template_name = „task_manager/task_confirm_delete.html”
 succes_url = reverse_lazy(„listă_de sarcini”)

Configurați adresele URL ale aplicației dvs

În directorul aplicației dvs., creați un urls.py fișier și configurați modelele URL astfel:

din django.urls import cale
din .vizualizări import TaskListView, TaskDetailView, TaskCreateView, TaskUpdateView, TaskDeleteView
urlpatterns = 
 cale('', TaskListView.as_view(), nume=„listă_de sarcini”),
 cale('crea/', TaskCreateView.as_view(), name='task_create'),
 cale('sarcini//', TaskDetailView.as_view(), nume='task_detail'),
 cale('sarcini//update/', TaskUpdateView.as_view(), nume='task_update'),
 cale('sarcini//delete/', TaskDeleteView.as_view(), nume='task_delete'),
]

Modelele URL de mai sus sunt similare cu adresele URL create cu vizualizări bazate pe funcții. Diferența este ca_view() funcție atașată la sfârșitul fiecărui nume de vizualizare.

Puteți utilizați slug-uri Django pentru a crea adrese URL în locul cheii primare utilizate mai sus.

Creați șabloane pentru vizualizările dvs

Permiterea utilizatorilor să efectueze acțiunile definite în vizualizările de mai sus sugerează să oferiți o interfață cu care să interacționeze. Din vizualizările create mai devreme, aplicația manager de activități ar trebui să aibă patru interfețe de utilizator.

În directorul aplicației, creați patru șabloane HTML. De asemenea, ar trebui să creați baza.html fişier. Puteți stilați șabloanele Django cu Bootstrap pentru a salva timp.

Șablon de listă de activități

Acest șablon ar trebui să includă cod care listează toate sarcinile din model. Un exemplu scheletic al codului este acesta:

{% extins 'base.html' %}
{% block content %}
<centru>
<h1>Sarcinile dvsh1>
<Ahref=„{% url 'task_create' %}”>Adăugați o sarcinăA>
 {% pentru sarcina din sarcini %}
<div>
<div>
<h5>{{ task.title }}h5>
<p>{{ task.description|truncatechars: 50 }}p>
<p>
<puternic>Efectuat:puternic>
 {% if task.completed %}Da{% else %}Nu{% endif %}
p>
<Ahref=„{% url 'task_detail' task.pk %}”>
 Citeşte mai mult
A>
<Ahref=„{% url 'task_delete' task.pk %}”>
 Ștergeți sarcina
A>
div>
div>
 {% gol %}
<h3>Nicio sarcină încă.h3>
<Ahref=„{% url 'task_create' %}”>Adăugați o sarcinăA>
 {% endfor %}
centru>
{% endblock %}

Cu unele clase Bootstrap, puteți face pagina dvs. să arate astfel:

Șablon de detaliu sarcini

Această pagină ar trebui să arate detaliile complete ale fiecărei sarcini create. Iată un exemplu de șablon pe care îl puteți folosi:

{% extins 'base.html' %}
{% block content %}
<h1>{{ task.title }}h1>
<p>{{ descrierea sarcinii }}p>
<p>Finalizat: {% if task.completed %}Da{% else %}Nu{% endif %}p>
<Ahref=„{% url 'task_update' task.pk %}”>Editați sarcinaA>
<Ahref=„{% url 'task_delete' task.pk %}”>Ștergeți sarcinaA>
{% endblock %}

În funcție de abordarea de stil, pagina ar trebui să arate astfel:

Șablon de formular de activitate

Acest șablon ar trebui să conțină un formular care să permită utilizatorului să creeze sau să actualizeze o sarcină.

{% extins 'base.html' %}
{% block content %}
<h1>Creați sarcinăh1>
<formămetodă="post">
 {% csrf_token %}
 {{ form.as_p }}
<butontip="Trimite">Salvațibuton>
formă>
{% endblock %}

Șablonul va arăta astfel:

Ștergeți șablonul de activitate

Acest șablon ar trebui să fie o pagină de confirmare pentru a preveni ștergerea accidentală a sarcinilor.

{% extins 'base.html' %}
{% block content %}
<h1>Confirmă ștergereah1>
<p>Sigur doriți să ștergeți „{{ object.title }}”?p>
<formămetodă="post">
 {% csrf_token %}
<butontip="Trimite">Ștergebuton>
<Ahref=„{% url 'task_list' %}”>AnulareA>
formă>
{% endblock %}

Cu ceva Bootstrap, pagina ta ar trebui să arate astfel:

Utilizați vizualizările bazate pe clasă pentru a vă crește productivitatea

Vizualizările bazate pe clasă sunt o modalitate excelentă de a scrie cod curat și organizat într-o perioadă scurtă de timp, crescând astfel productivitatea. Ar trebui să le folosiți în proiectele dvs. cât mai mult posibil. De asemenea, puteți integra în continuare funcții precum funcționalitatea de căutare, notificările și așa mai departe, pentru a face din aplicația dvs. de gestionare de activități o aplicație funcțională completă.