Come creare un'app CRUD con viste basate su classi Django

Una delle caratteristiche principali di Django è il supporto integrato per la creazione di progetti oltre alle operazioni CRUD (Create, Read, Update, Delete). Sebbene le visualizzazioni basate su classi di Django forniscano un modo rapido, semplice e flessibile per creare applicazioni Web, molti sviluppatori utilizzano ancora visualizzazioni basate su funzioni.

Le visualizzazioni basate su classi offrono diversi vantaggi rispetto alle visualizzazioni basate su funzioni, tra cui l'ereditarietà, la strutturazione del codice, la riusabilità del codice e altro ancora. Sebbene l'implementazione delle visualizzazioni basate sulla classe possa sembrare leggermente complessa, questa guida ti aiuterà a comprendere il concetto creando un'app di gestione attività e fornendo istruzioni dettagliate.

Cosa sono le visualizzazioni basate sulla classe in Django?

In Django, le visualizzazioni sono

Funzioni Python che accettano una richiesta web e restituiscono una risposta web. Le viste basate su classi (CBV) sono un modo alternativo per definire le viste in Django usando le classi Python invece delle funzioni.

I CBV presentano numerosi vantaggi, come una migliore organizzazione del codice, un riutilizzo più semplice del codice e la possibilità di utilizzare l'ereditarietà per creare variazioni delle viste esistenti. I CBV forniscono anche metodi integrati come il Ottenere() E inviare() metodi che puoi sovrascrivere per i comportamenti personalizzati.

Il codice utilizzato in questo articolo è disponibile in this Deposito GitHub.

Visualizzazioni basate sulla classe disponibili in Django

Django fornisce alcuni CBV integrati per casi d'uso popolari, come la visualizzazione di elenchi di oggetti o la creazione di nuovi. Alcuni di questi CBV integrati sono:

1. Visualizzazione elenco: Questa vista esegue il rendering di un elenco di oggetti recuperati da un modello. Ad esempio, una pagina che elenca tutti i post disponibili in un blog utilizzerà a Visualizzazione elenco.
2. Vista dettagliata: Questa vista rende una vista dettagliata di un singolo oggetto recuperato da un modello. Puoi usare un Vista dettagliata per visualizzare i dettagli di post specifici in un'app blog.
3. CreaVista: Questa vista esegue il rendering di un modulo per creare un nuovo oggetto e gestisce l'invio del modulo. Ad esempio, in un'app di gestione attività, utilizzerai questa vista per creare nuove attività.
4. EliminaVisualizza: questa visualizzazione esegue il rendering di una pagina di conferma per eliminare un oggetto e gestisce l'eliminazione della pagina.
5. UpdateView: Questa vista esegue il rendering di un modulo per aggiornare un oggetto esistente e gestisce l'invio del modulo.

Django fornisce anche altre visualizzazioni, tra cui TemplateView, ReindirizzaVisualizza, E Visualizzazione modulo. Puoi fare riferimento a La documentazione di Django per informazioni dettagliate sulle viste basate sulla classe.

Crea un'app Task Manager con viste basate su classi Django

La creazione di un'app come un'app di task manager ti consentirà di capire come implementare le operazioni CRUD con i CBV. Un task manager ha funzionalità che consentono agli utenti di creare, aggiornare, eliminare e leggere attività. Queste funzionalità sono in linea con le operazioni CRUD. I seguenti passaggi ti aiuteranno a creare un'app di task manager con Django CBV.

Imposta un progetto Django

Per creare un'app di task manager con Django, dovresti iniziare seguendo questi passaggi:

1. Installa Django nel tuo Ambiente virtuale Python con questo comando:

   pip installa django

2. Crea un progetto Django. Il seguente comando creerà un progetto chiamato core_progetto.

   django-admin startproject project_core .

3. Crea un'app chiamata task_manager.

   python manage.py startapp task_manager

4. Nel tuo impostazioni.py aggiungi il nome della tua app al file APP_INSTALLATE elenco.

   APP_INSTALLATE = [
   'gestore_attività',
   ]

5. Apri il URL.py file nella directory del tuo progetto e configura gli URL per il tuo task_manager applicazione:

   da django.urls importare percorso, includere
   schemi URL = [
    sentiero('', includere('task_manager.urls')),
   ]

Crea un modello per la tua app Task Manager

Nella directory dell'app (o task_manager cartella), apri il tuo file modelli.py file e crea un modello per la tua app di task manager. Ecco un modello di esempio che puoi utilizzare:

da django.db importare Modelli
classeCompito(Modelli. Modello):
 titolo = modelli. CharField (lunghezza_max=200)
 descrizione = modelli. Campo di testo()
 completato = modelli. Campo booleano (predefinito=Falso)
 created_at = modelli. DateTimeField (auto_now_add=VERO)

Migra il tuo modello con questo comando:

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

Crea un modulo Django per la tua app

Dovresti avere un modulo per la gestione Creare E Aggiornamento operazioni. Nella directory dell'app, crea un file chiamato form.py. Ecco un esempio:

da django importare forme
da .Modelli importare Compito
classeTaskForm(forme. ModelloForm):
classeMeta:
 modello = Compito
 campi = ['titolo', 'descrizione', 'completato']
 widget = {
'titolo': forme. TextInput (attrs={'classe': 'controllo della forma',}),
'descrizione': forme. Area di testo (attrs={'classe': 'controllo della forma',}),
'completato': forme. CheckboxInput (attrs={'classe': 'form-check-input'}),
 }

Il codice sopra ha una classe chiamata TaskForm che definisce i campi e i widget del form. Specifica anche il modello da utilizzare.

Crea viste Django per ogni operazione CRUD

Un'app CRUD di base con CBV richiede almeno quattro viste per gestire tutte le operazioni in modo efficace. I prossimi passaggi ti mostreranno come crearli.

Importa i moduli e i pacchetti necessari

Apri i tuoi viste.py file ed effettuare le seguenti importazioni:

da django.views.generic importare ListView, DetailView, CreateView, UpdateView, DeleteView
da django.urls importare reverse_lazy
da .Modelli importare Compito
da .forme importare TaskForm

Il codice sopra importa cinque CBV. Importa anche reverse_lazy per reindirizzare l'utente a un URL specificato dopo l'invio di un modulo. Infine, importa il file Compito modello, e il TaskForm creato in precedenza.

Creare una vista per elencare gli oggetti del modello

Un'app di task manager dovrebbe avere una pagina che elenca tutte le attività create dall'utente. Per creare una vista per questo, dovresti usare il file Visualizzazione elenco. Ecco un esempio:

classeTaskListView(Visualizzazione elenco):
 modello = Compito
 nome_modello = 'gestore_attività/elenco_attività.html'
 contesto_nome_oggetto = 'compiti'

La vista sopra definisce tre attributi che sono:

1. modello: Questo attributo definisce quale modello utilizzare per quella vista specifica.
2. Nome modello: questo attributo indica a Django quale modello visualizzare nel browser.
3. contesto_nome_oggetto: Questo attributo definisce il nome che consente al modello di accedere all'elenco di oggetti nel modello.

La maggior parte dei CBV conterrà questi tre attributi.

Crea una vista per gestire i dettagli dell'attività

Ogni attività creata da un utente dovrebbe avere una pagina che ne mostri i dettagli. Il CBV ideale per gestire questo è DettaglioVew. Ecco un semplice esempio:

classeTaskDetailView(Vista dettagliata):
 modello = Compito
 nome_modello = 'gestore_attività/dettaglio_attività.html'

Crea una vista per la creazione di attività

Crea una vista per gestire la creazione o l'aggiunta di nuove attività. Questo è il Creare parte delle operazioni CRUD, e la vista giusta per questo è il CreaVista. Ecco come usarlo:

classeTaskCreateView(Crea vista):
 modello = Compito
 form_class = TaskForm
 nome_modello = 'gestore_attività/modulo_attività.html'
 successo_url = reverse_lazy('elenco delle attività')

Il codice precedente introduce due nuovi attributi: form_class E URL_successo.

IL form_class L'attributo indica alla vista quale classe di form eseguire il rendering e utilizzare per le sue operazioni.

IL URL_successo specifica come reindirizzare l'utente dopo aver inviato il modulo. Utilizza il reverse_lazy funzione che prende il nome di un percorso URL.

Crea una vista per le attività di modifica

Per consentire ai tuoi utenti di modificare o aggiornare le loro attività, dovresti creare una vista simile a questa:

classeTaskUpdateView(Aggiorna vista):
 modello = Compito
 form_class = TaskForm
 nome_modello = 'gestore_attività/modulo_attività.html'
 successo_url = reverse_lazy('elenco delle attività')

La vista sopra è simile al TaskCreateView creato in precedenza. L'unica differenza è l'uso del UpdateView.

Creare una vista per gestire le operazioni di eliminazione

Per consentire ai tuoi utenti di eliminare le attività ogni volta che lo desiderano, dovresti utilizzare il file EliminaVisualizza CBV. Ecco un esempio:

classeTaskDeleteView(EliminaVista):
 modello = Compito
 nome_modello = 'task_manager/task_confirm_delete.html'
 successo_url = reverse_lazy('elenco delle attività')

Configura gli URL della tua app

Nella directory dell'app, crea un file URL.py file e configura i tuoi pattern URL in questo modo:

da django.urls importare sentiero
da .visualizzazioni importare TaskListView, TaskDetailView, TaskCreateView, TaskUpdateView, TaskDeleteView
schemi URL = 
 sentiero('', TaskListView.as_view(), nome='elenco delle attività'),
 sentiero('creare/', TaskCreateView.as_view(), nome='attività_create'),
 sentiero('compiti//', TaskDetailView.as_view(), nome='dettaglio_attività'),
 sentiero('compiti//update/', TaskUpdateView.as_view(), name='aggiornamento_attività'),
 sentiero('compiti//delete/', TaskDeleteView.as_view(), name='task_delete'),
]

I pattern URL di cui sopra sono simili agli URL creati con viste basate sulle funzioni. La differenza è la come_vista() funzione aggiunta alla fine di ogni nome di vista.

Puoi usa gli slug Django per creare URL invece della chiave primaria usata sopra.

Crea modelli per le tue viste

Consentire agli utenti di eseguire le azioni definite nelle viste precedenti suggerisce di fornire loro un'interfaccia con cui interagire. Dalle viste create in precedenza, l'app Task Manager dovrebbe avere quattro interfacce utente.

Nella directory dell'app, crea quattro modelli HTML. Dovresti anche creare base.html file. Puoi modella i tuoi modelli Django con Bootstrap per risparmiare tempo.

Modello di elenco attività

Questo modello dovrebbe includere il codice che elenca tutte le attività nel modello. Un esempio scheletrico del codice è questo:

{% estende 'base.html' %}
{% blocca contenuto %}
<centro>
<h1>I tuoi compitih1>
<UNhref="{% url 'task_create' %}">Aggiungi attivitàUN>
 {% per attività nelle attività %}
<div>
<div>
<h5>{{attività.titolo}}h5>
<P>{{ task.description|troncacaratteri: 50 }}P>
<P>
<forte>Completato:forte>
 {% if task.completed %}Sì{% else %}No{% endif %}
P>
<UNhref="{% url 'task_detail' task.pk %}">
 Per saperne di più
UN>
<UNhref="{% url 'task_delete' task.pk %}">
 Elimina attività
UN>
div>
div>
 {% vuoto %}
<h3>Ancora nessuna attività.h3>
<UNhref="{% url 'task_create' %}">Aggiungi attivitàUN>
 {% fine per %}
centro>
{% blocco finale %}

Con alcune classi Bootstrap, puoi far apparire la tua pagina così:

Modello di dettaglio dell'attività

Questa pagina dovrebbe mostrare i dettagli completi di ogni attività creata. Ecco un modello di esempio che puoi utilizzare:

{% estende 'base.html' %}
{% blocca contenuto %}
<h1>{{attività.titolo}}h1>
<P>{{ descrizione del compito }}P>
<P>Completato: {% if task.completed %}Sì{% else %}No{% endif %}P>
<UNhref="{% url 'task_update' task.pk %}">Modifica attivitàUN>
<UNhref="{% url 'task_delete' task.pk %}">Elimina attivitàUN>
{% blocco finale %}

A seconda del tuo approccio stilistico, la tua pagina dovrebbe apparire così:

Modello di modulo di attività

Questo modello deve contenere un modulo che consente all'utente di creare o aggiornare un'attività.

{% estende 'base.html' %}
{% blocca contenuto %}
<h1>Crea attivitàh1>
<modulometodo="inviare">
 {% csrf_token %}
 {{ form.as_p }}
<pulsantetipo="invia">Salvapulsante>
modulo>
{% blocco finale %}

Il modello sarà simile a questo:

Elimina modello attività

Questo modello dovrebbe essere una pagina di conferma per impedire la cancellazione accidentale delle attività.

{% estende 'base.html' %}
{% blocca contenuto %}
<h1>Conferma cancellazioneh1>
<P>Sei sicuro di voler eliminare "{{ object.title }}"?P>
<modulometodo="inviare">
 {% csrf_token %}
<pulsantetipo="invia">Eliminarepulsante>
<UNhref="{% url 'task_list' %}">AnnullaUN>
modulo>
{% blocco finale %}

Con alcuni Bootstrap, la tua pagina dovrebbe apparire così:

Usa le viste basate sulle classi per aumentare la tua produttività

Le visualizzazioni basate su classi sono un ottimo modo per scrivere codice pulito e organizzato in un breve lasso di tempo, aumentando così la produttività. Dovresti usarli nei tuoi progetti il ​​più possibile. Inoltre, puoi integrare ulteriormente funzionalità come la funzionalità di ricerca, le notifiche e così via per rendere la tua app di task manager un'applicazione funzionale a tutti gli effetti.