Construire votre première application CRUD avec Django

Vous avez exploré les modèles, les vues et les templates. Il est temps de tout assembler pour construire quelque chose de concret ! Ce tutoriel vous guidera, étape par étape, dans la création de votre première application web complète avec Django.

Nous allons construire un mini-système de gestion de notes, une application CRUD simple.

Que signifie CRUD ?

CRUD est un acronyme qui désigne les quatre opérations de base pour la gestion de données :

• Create : Créer de nouvelles données.
• Read : Lire (afficher) des données existantes.
• Update : Mettre à jour des données existantes.
• Delete : Supprimer des données existantes.

Maîtriser le CRUD, c’est maîtriser la base de la plupart des applications web dynamiques.

Pour suivre ce guide, vous devez avoir Python et Django installés et une compréhension de base des modèles, des vues et des templates.

Étape 1 : Création du projet et de l’application

Ouvrez votre terminal et créons la structure de base.

1. Créez le projet Django :

   django-admin startproject mynotesproject
   cd mynotesproject

2. Créez l’application “notes” :

   python manage.py startapp notes

3. Enregistrez l’application : Ouvrez mynotesproject/settings.py et ajoutez 'notes' à votre liste INSTALLED_APPS :

   # mynotesproject/settings.py
   INSTALLED_APPS = [
       # ... autres apps
       'notes.apps.NotesConfig',
   ]

Étape 2 : Le modèle de données

Définissons la structure de nos notes.

Dans notes/models.py, créez le modèle Note :

# notes/models.py
from django.db import models
from django.urls import reverse

class Note(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

    def get_absolute_url(self):
        return reverse('note-detail', kwargs={'pk': self.pk})

La méthode get_absolute_url est une convention Django très utile. Elle retourne l’URL canonique pour un objet, ce qui permet à Django de savoir où rediriger l’utilisateur après une opération de création ou de mise à jour.

Appliquez ce modèle à la base de données :

python manage.py makemigrations
python manage.py migrate

Étape 3 : READ - afficher les notes

Commençons par afficher les notes existantes.

La Vue (Liste et Détail)

Nous utiliserons des Class-Based Views (CBV) génériques, car elles sont parfaites pour le CRUD.

Modifiez notes/views.py :

# notes/views.py
from django.views.generic import ListView, DetailView
from .models import Note

class NoteListView(ListView):
    model = Note
    template_name = 'notes/note_list.html'
    context_object_name = 'notes'

class NoteDetailView(DetailView):
    model = Note
    template_name = 'notes/note_detail.html'
    context_object_name = 'note'

Les templates (liste et détail)

Créez un dossier templates/notes dans votre application notes.

notes/templates/notes/note_list.html

<h1>Mes Notes</h1>
<a href="{% url 'note-create' %}">Ajouter une note</a>
<ul>
  {% for note in notes %}
  <li><a href="{{ note.get_absolute_url }}">{{ note.title }}</a></li>
  {% empty %}
  <li>Aucune note pour le moment.</li>
  {% endfor %}
</ul>

notes/templates/notes/note_detail.html

<h1>{{ note.title }}</h1>
<p>{{ note.content|linebreaks }}</p>
<small>Créé le: {{ note.created_at }}</small>
<hr />
<a href="{% url 'note-update' note.pk %}">Modifier</a>
<a href="{% url 'note-delete' note.pk %}">Supprimer</a>
<a href="{% url 'note-list' %}">Retour à la liste</a>

Le filtre |linebreaks transforme les sauts de ligne du texte en balises <p> et <br>.

Les URLs

Créez un fichier notes/urls.py :

# notes/urls.py
from django.urls import path
from .views import NoteListView, NoteDetailView

urlpatterns = [
    path('', NoteListView.as_view(), name='note-list'),
    path('note/<int:pk>/', NoteDetailView.as_view(), name='note-detail'),
]

Incluez ces URLs dans le projet principal mynotesproject/urls.py:

# mynotesproject/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('notes.urls')), # Inclure les URLs de l'app notes
]

Lancez le serveur (python manage.py runserver) et visitez http://127.0.0.1:8000/. Vous devriez voir votre liste de notes (vide pour le moment).

Étape 4 : CREATE - créer une note avec ModelForm

Pour créer des notes, nous avons besoin de formulaires. Django excelle à ce niveau avec les ModelForm.

Le formulaire

Créez un fichier notes/forms.py :

# notes/forms.py
from django import forms
from .models import Note

class NoteForm(forms.ModelForm):
    class Meta:
        model = Note
        fields = ['title', 'content']

C’est tout ! Django va automatiquement générer un formulaire basé sur les champs title et content de notre modèle Note.

La vue (CreateView)

Ajoutez CreateView à notes/views.py :

# notes/views.py
from django.views.generic import ListView, DetailView, CreateView
from .models import Note
from .forms import NoteForm

# ... NoteListView et NoteDetailView ...

class NoteCreateView(CreateView):
    model = Note
    form_class = NoteForm
    template_name = 'notes/note_form.html'
    # success_url sera géré par get_absolute_url sur le modèle

Le template du formulaire

Créez notes/templates/notes/note_form.html. Ce template servira à la fois pour la création et la modification.

<h1>{% if object %}Modifier la note{% else %}Nouvelle Note{% endif %}</h1>
<form method="post">
  {% csrf_token %} {{ form.as_p }}
  <button type="submit">Enregistrer</button>
</form>

• {% csrf_token %} est une mesure de sécurité obligatoire pour les formulaires en POST.
• {{ form.as_p }} affiche chaque champ du formulaire dans un paragraphe <p>.

L’URL

Ajoutez le chemin dans notes/urls.py :

# notes/urls.py
# ...
from .views import NoteListView, NoteDetailView, NoteCreateView

urlpatterns = [
    # ...
    path('note/new/', NoteCreateView.as_view(), name='note-create'),
]

Vous pouvez maintenant créer des notes !

Étape 5 : UPDATE - mettre à jour une note

La vue de mise à jour est très similaire à la vue de création.

La vue (UpdateView)

Ajoutez UpdateView à notes/views.py :

# notes/views.py
from django.views.generic import ListView, DetailView, CreateView, UpdateView
# ...

class NoteUpdateView(UpdateView):
    model = Note
    form_class = NoteForm
    template_name = 'notes/note_form.html'

Nous réutilisons le même template note_form.html.

L’URL

Ajoutez le chemin dans notes/urls.py :

# notes/urls.py
# ...
from .views import NoteListView, NoteDetailView, NoteCreateView, NoteUpdateView

urlpatterns = [
    # ...
    path('note/<int:pk>/edit/', NoteUpdateView.as_view(), name='note-update'),
]

Maintenant, le lien “Modifier” sur la page de détail fonctionne.

Étape 6 : DELETE - supprimer une note

La dernière opération du CRUD. Django demande une confirmation avant de supprimer.

La vue (DeleteView)

Ajoutez DeleteView à notes/views.py :

# notes/views.py
from django.urls import reverse_lazy
from django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView
# ...

class NoteDeleteView(DeleteView):
    model = Note
    template_name = 'notes/note_confirm_delete.html'
    success_url = reverse_lazy('note-list')

reverse_lazy est utilisé ici car l’URL n’est évaluée qu’au moment de l’exécution, pas au chargement du fichier.

Le template de confirmation

Créez notes/templates/notes/note_confirm_delete.html :

<h1>Supprimer la note</h1>
<p>Êtes-vous sûr de vouloir supprimer la note : "{{ note.title }}" ?</p>
<form method="post">
  {% csrf_token %}
  <button type="submit">Confirmer la suppression</button>
  <a href="{{ note.get_absolute_url }}">Annuler</a>
</form>

L’URL

Ajoutez le chemin dans notes/urls.py :

# notes/urls.py
# ...
from .views import (
    NoteListView,
    NoteDetailView,
    NoteCreateView,
    NoteUpdateView,
    NoteDeleteView
)

urlpatterns = [
    # ...
    path('note/<int:pk>/delete/', NoteDeleteView.as_view(), name='note-delete'),
]

Votre application CRUD est complète !

Conclusion

Félicitations ! Vous venez de construire une application web entièrement fonctionnelle avec Django, en maîtrisant les quatre opérations CRUD. En utilisant les vues génériques (ListView, DetailView, CreateView, UpdateView, DeleteView) et les ModelForm, vous pouvez construire la base de n’importe quelle application de gestion de données avec une rapidité et une efficacité remarquables.

Les prochaines étapes pourraient être :

• Styliser les templates avec du CSS.
• Ajouter l’authentification pour que chaque utilisateur ait ses propres notes.
• Déployer votre application en production.