Apprenez à créer une application de gestionnaire de tâches en utilisant les principes de CRUD et les vues basées sur les classes dans Django.

L'une des principales caractéristiques de Django est sa prise en charge intégrée de la création de projets en plus des opérations CRUD (Créer, Lire, Mettre à jour, Supprimer). Alors que les vues basées sur les classes de Django offrent un moyen rapide, facile et flexible de créer des applications Web, de nombreux développeurs utilisent encore des vues basées sur les fonctions.

Les vues basées sur les classes offrent plusieurs avantages par rapport aux vues basées sur les fonctions, notamment l'héritage, la structuration du code, la réutilisation du code, etc. Bien que la mise en œuvre des vues basées sur les classes puisse sembler légèrement complexe, ce guide vous aidera à comprendre le concept en créant une application de gestionnaire de tâches et en fournissant des instructions étape par étape.

Que sont les vues basées sur les classes dans Django?

instagram viewer

Dans Django, les vues sont Fonctions Python qui prennent une requête Web et renvoient une réponse Web. Les vues basées sur les classes (CBV) sont une autre façon de définir des vues dans Django en utilisant des classes Python au lieu de fonctions.

Les CBV présentent plusieurs avantages, tels qu'une meilleure organisation du code, une réutilisation plus facile du code et la possibilité d'utiliser l'héritage pour créer des variantes de vues existantes. Les CBV fournissent également des méthodes intégrées telles que le obtenir() et poste() méthodes que vous pouvez écraser pour les comportements personnalisés.

Le code utilisé dans cet article est disponible dans ce Référentiel GitHub.

Vues basées sur les classes disponibles dans Django

Django fournit des CBV intégrés pour les cas d'utilisation courants, tels que l'affichage de listes d'objets ou la création de nouveaux objets. Certains de ces CBV intégrés sont :

  1. AffichageListe: Cette vue affiche une liste d'objets extraits d'un modèle. Par exemple, une page qui répertorie tous les articles disponibles dans un blog utilisera un ListView.
  2. Vue détaillée: Cette vue affiche une vue détaillée d'un seul objet extrait d'un modèle. Vous pouvez utiliser un Vue détaillée pour afficher les détails de messages spécifiques dans une application de blog.
  3. Créer une vue: Cette vue rend un formulaire pour créer un nouvel objet et gère la soumission du formulaire. Par exemple, dans une application de gestionnaire de tâches, vous utiliserez cette vue pour créer de nouvelles tâches.
  4. SupprimerAfficher: Cette vue affiche une page de confirmation pour supprimer un objet et gère la suppression de la page.
  5. Mettre à jour la vue: Cette vue rend un formulaire pour mettre à jour un objet existant et gère la soumission du formulaire.

Django fournit également d'autres vues, y compris ModèleAffichage, RedirectView, et FormView. Vous pouvez vous référer à Documentation de Django pour des informations détaillées sur les vues basées sur les classes.

Créer une application de gestion des tâches avec les vues basées sur les classes de Django

La création d'une application telle qu'une application de gestionnaire de tâches vous permettra de comprendre comment mettre en œuvre des opérations CRUD avec des CBV. Un gestionnaire de tâches possède des fonctionnalités qui permettent aux utilisateurs de créer, mettre à jour, supprimer et lire des tâches. Ces fonctionnalités sont conformes aux opérations CRUD. Les étapes suivantes vous aideront à créer une application de gestionnaire de tâches avec Django CBV.

Configurer un projet Django

Pour créer une application de gestionnaire de tâches avec Django, vous devez commencer par suivre ces étapes :

  1. Installez Django dans votre Environnement virtuel Python avec cette commande :
    pip installer Django
  2. Créez un projet Django. La commande suivante créera un projet appelé project_core.
    django-admin startproject project_core .
  3. Créez une application appelée Gestionnaire des tâches.
    python manage.py startapp task_manager
  4. Dans ton paramètres.py ajoutez le nom de votre application au INSTALLED_APPS liste.
    INSTALLED_APPS = [
    'Gestionnaire des tâches',
    ]
  5. Ouvrez le urls.py fichier dans votre répertoire de projet et configurez les URL de votre Gestionnaire des tâches application :
    depuis django.urls importer chemin, inclure
    modèles d'url = [
     chemin('', inclure('task_manager.urls')),
    ]

Créer un modèle pour votre application de gestionnaire de tâches

Dans votre répertoire d'applications (ou Gestionnaire des tâches dossier), ouvrez votre modèles.py fichier et créez un modèle pour votre application de gestionnaire de tâches. Voici un exemple de modèle que vous pouvez utiliser :

depuis django.db importer des modèles
classeTâche(des modèles. Modèle):
 titre = modèles. CharField (max_length=200)
 description = modèles. Champ de texte()
 terminé = modèles. BooleanField (par défaut=FAUX)
 created_at = modèles. DateTimeField (auto_now_add=Vrai)

Migrez votre modèle avec cette commande :

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

Créer un formulaire Django pour votre application

Vous devriez avoir un formulaire pour le traitement Créer et Mise à jour opérations. Dans votre répertoire d'application, créez un fichier appelé formulaires.py. Voici un exemple :

depuis Django importer formes
depuis .des modèles importer Tâche
classeFormulaire de tâche(formes. ModelForm):
classeMéta:
 modèle = Tâche
 champs = ['titre', 'description', 'complété']
 widgets = {
'titre': formes. TextInput (attrs={'classe': 'contrôle de formulaire',}),
'description': formes. Zone de texte (attrs={'classe': 'contrôle de formulaire',}),
'complété': formes. CheckboxInput (attrs={'classe': 'formulaire-vérification-entrée'}),
 }

Le code ci-dessus a une classe appelée Formulaire de tâche qui définit les champs et widgets du formulaire. Il précise également le modèle à utiliser.

Créer des vues Django pour chaque opération CRUD

Une application CRUD de base avec CBV nécessite au moins quatre vues pour gérer efficacement toutes les opérations. Les prochaines étapes vous montreront comment les créer.

Importer les modules et packages nécessaires

Ouvrez votre vues.py fichier et effectuez les importations suivantes :

depuis django.views.générique importer ListView, DetailView, CreateView, UpdateView, DeleteView
depuis django.urls importer reverse_lazy
depuis .des modèles importer Tâche
depuis .formes importer Formulaire de tâche

Le code ci-dessus importe cinq CBV. Il importe également reverse_lazy pour rediriger l'utilisateur vers une URL spécifiée après la soumission d'un formulaire. Enfin, il importe le Tâche modèle, et le Formulaire de tâche créé plus tôt.

Créer une vue pour répertorier les objets du modèle

Une application de gestionnaire de tâches doit avoir une page répertoriant toutes les tâches créées par l'utilisateur. Pour créer une vue pour cela, vous devez utiliser le AffichageListe. Voici un exemple :

classeVueListedesTâches(Vue Liste):
 modèle = Tâche
 nom_modèle = 'gestionnaire_tâches/liste_tâches.html'
 context_object_name = 'Tâches'

La vue ci-dessus définit trois attributs qui sont :

  1. modèle: cet attribut définit le modèle à utiliser pour cette vue spécifique.
  2. nom_modèle: Cet attribut indique à Django quel modèle rendre au navigateur.
  3. context_object_name: Cet attribut définit le nom qui permet au modèle d'accéder à la liste des objets du modèle.

La plupart des CBV contiendront ces trois attributs.

Créer une vue pour gérer les détails des tâches

Chaque tâche créée par un utilisateur doit avoir une page affichant ses détails. Le CBV idéal pour gérer cela est DétailVue. Voici un exemple simple :

classeTaskDetailView(Vue détaillée):
 modèle = Tâche
 nom_modèle = 'gestionnaire_de_tâches/détail_de_tâches.html'

Créer une vue pour la création de tâches

Créez une vue pour gérer la création ou l'ajout de nouvelles tâches. C'est le Créer partie des opérations CRUD, et la bonne vue pour cela est la Créer une vue. Voici comment l'utiliser :

classeTâcheCréerVue(CréerVue):
 modèle = Tâche
 form_class = TaskForm
 nom_modèle = 'gestionnaire_de_tâches/formulaire_de_tâches.html'
 success_url = reverse_lazy('liste de tâches')

Le code ci-dessus introduit deux nouveaux attributs: classe de formulaire et success_url.

Le classe de formulaire L'attribut indique à la vue quelle classe de formulaire rendre et utiliser pour ses opérations.

Le success_url spécifie comment rediriger l'utilisateur après avoir soumis le formulaire. Il utilise le reverse_lazy fonction qui prend le nom d'un chemin URL.

Créer une vue pour les tâches d'édition

Pour permettre à vos utilisateurs de modifier ou de mettre à jour leurs tâches, vous devez créer une vue qui ressemble à ceci :

classeTaskUpdateViewTaskUpdateView(Mettre à jour la vue):
 modèle = Tâche
 form_class = TaskForm
 nom_modèle = 'gestionnaire_de_tâches/formulaire_de_tâches.html'
 success_url = reverse_lazy('liste de tâches')

La vue ci-dessus est similaire à la TâcheCréerVue créé plus tôt. La seule différence est l'utilisation du Mettre à jour la vue.

Créer une vue pour gérer les opérations de suppression

Pour permettre à vos utilisateurs de supprimer des tâches quand ils le souhaitent, vous devez utiliser le SupprimerAfficher VCB. Voici un exemple :

classeTâcheSupprimerVue(SupprimerAfficher):
 modèle = Tâche
 nom_modèle = 'task_manager/task_confirm_delete.html'
 success_url = reverse_lazy('liste de tâches')

Configurez les URL de votre application

Dans votre répertoire d'applications, créez un urls.py fichier et configurez vos modèles d'URL comme ceci :

depuis django.urls importer chemin
depuis .vues importer TaskListView, TaskDetailView, TaskCreateView, TaskUpdateView, TaskDeleteView
modèles d'url = 
 chemin('', TaskListView.as_view(), nom='liste de tâches'),
 chemin('créer/', TaskCreateView.as_view(), nom='task_create'),
 chemin('Tâches//', TaskDetailView.as_view(), nom='détail_tâche'),
 chemin('Tâches//update/', TaskUpdateView.as_view(), nom='task_update'),
 chemin('Tâches//delete/', TaskDeleteView.as_view(), nom='task_delete'),
]

Les modèles d'URL ci-dessus sont similaires aux URL créées avec des vues basées sur les fonctions. La différence est la as_view() fonction ajoutée à la fin de chaque nom de vue.

Tu peux utiliser les slugs Django pour créer des URL au lieu de la clé primaire utilisée ci-dessus.

Créez des modèles pour vos vues

Permettre à vos utilisateurs d'effectuer les actions définies dans les vues ci-dessus suggère que vous leur fournissiez une interface avec laquelle interagir. À partir des vues créées précédemment, l'application du gestionnaire de tâches doit avoir quatre interfaces utilisateur.

Dans votre répertoire d'applications, créez quatre modèles HTML. Vous devez également créer base.html déposer. Tu peux stylisez vos modèles Django avec Bootstrap gagner du temps.

Modèle de liste de tâches

Ce modèle doit inclure du code qui répertorie toutes les tâches du modèle. Un exemple squelettique du code est celui-ci :

{% étend 'base.html' %}
{% bloque le contenu %}
<centre>
<h1>Vos tâchesh1>
<unhref="{% url 'task_create' %}">Ajouter une tâcheun>
 {% pour la tâche dans les tâches %}
<div>
<div>
<h5>{{ tâche.titre }}h5>
<p>{{ tâche.description|truncatechars: 50 }}p>
<p>
<fort>Complété:fort>
 {% if task.completed %}Oui{% else %}Non{% endif %}
p>
<unhref="{% url 'task_detail' tâche.pk %}">
 En savoir plus
un>
<unhref="{% url 'task_delete' tâche.pk %}">
 Supprimer la tâche
un>
div>
div>
 {% vide %}
<h3>Aucune tâche pour le moment.h3>
<unhref="{% url 'task_create' %}">Ajouter une tâcheun>
 {% endfor %}
centre>
{% endblock %}

Avec certaines classes Bootstrap, vous pouvez faire en sorte que votre page ressemble à ceci :

Modèle de détail de tâche

Cette page doit afficher les détails complets de chaque tâche créée. Voici un exemple de modèle que vous pouvez utiliser :

{% étend 'base.html' %}
{% bloque le contenu %}
<h1>{{ tâche.titre }}h1>
<p>{{ description de la tâche }}p>
<p>Terminé: {% if task.completed %}Oui{% else %}Non{% endif %}p>
<unhref="{% url 'task_update' tâche.pk %}">Modifier la tâcheun>
<unhref="{% url 'task_delete' tâche.pk %}">Supprimer la tâcheun>
{% endblock %}

Selon votre approche stylistique, votre page devrait ressembler à ceci :

Modèle de formulaire de tâche

Ce modèle doit contenir un formulaire permettant à l'utilisateur de créer ou de mettre à jour une tâche.

{% étend 'base.html' %}
{% bloque le contenu %}
<h1>Créer une tâcheh1>
<formerméthode="poste">
 {% csrf_token %}
 {{ form.as_p }}
<boutontaper="soumettre">Sauvegarderbouton>
former>
{% endblock %}

Le modèle ressemblera à ceci :

Supprimer le modèle de tâche

Ce modèle doit être une page de confirmation pour éviter la suppression accidentelle de tâches.

{% étend 'base.html' %}
{% bloque le contenu %}
<h1>Confirmation de la suppressionh1>
<p>Voulez-vous vraiment supprimer "{{ object.title }}" ?p>
<formerméthode="poste">
 {% csrf_token %}
<boutontaper="soumettre">Supprimerbouton>
<unhref="{% url 'task_list' %}">Annulerun>
former>
{% endblock %}

Avec du Bootstrap, votre page devrait ressembler à ceci :

Utilisez des vues basées sur les classes pour augmenter votre productivité

Les vues basées sur les classes sont un excellent moyen d'écrire du code propre et organisé en peu de temps, augmentant ainsi votre productivité. Vous devez les utiliser dans vos projets autant que possible. En outre, vous pouvez intégrer davantage de fonctionnalités telles que la fonctionnalité de recherche, les notifications, etc. pour faire de votre application de gestionnaire de tâches une application fonctionnelle à part entière.