Opérations CRUD en Python et Django - Partie 2

Dans notre article précédent, nous avons couvert les bases de la mise en place d'un projet Django et créé notre modèle d'exercice, que nous avons affiché sur le front-end sous forme de liste. Dans cet article, nous aborderons la réalisation d'opérations CRUD. Pour ceux qui ne le connaissent pas, CRUD signifie Créer, Lire, Mettre à jour et Supprimer : il s'agit essentiellement des quatre actions fondamentales que vous pouvez effectuer sur vos données.

Maintenant que notre API est configurée dans le dossier app , nous allons simplement étendre la vue d'index pour gérer les demandes de création, de mise à jour et de suppression.

Le formulaire

Créons un formulaire qui permet aux utilisateurs de créer des exercices. Nous utiliserons à nouveau des modèles HTML à cette fin. Pour commencer, créez un nouveau modèle appelé add_exercise.html dans le dossier app/templates.

<form method="POST" action="/">
    {% csrf_token %}
    <input type="text" name="title" placeholder="Enter the title" />
    <input type="date" name="date"  placeholder="Enter the date" />
    <button type="submit">Save</button>
</form>

Ensuite, dans notre modèle index.html , nous inclurons le modèle add_exercise.html en utilisant la méthode suivante :

{% extends "base.html" %} {% block content %}
    <h2>Exercises</h2>
    {% include 'add_exercise.html' %}
...
{% endblock %}

Nous utilisons ici la balise include, qui favorise la composabilité entre les modèles HTML, rendant notre code plus facile à maintenir et à comprendre. Si vous actualisez la page dans votre navigateur, vous devriez voir le formulaire apparaître à l'écran.

Dans notre HTML, nous utilisons le 

 balise avec l'attribut method défini sur POST et l'attribut action pointant vers /, qui est le même point de terminaison que nous utilisons pour récupérer la liste des exercices.

Dans ce contexte, csrf_token est une fonctionnalité de sécurité représentée par une valeur secrète générée de manière aléatoire. Il aide à protéger nos envois de formulaires contre les attaques de falsification, ce que CSRF signifie : Cross-Site Request Forgery. Un jeton unique est généré pour chaque session utilisateur et il n'est pas accessible par les sites tiers, empêchant ainsi les modifications non autorisées.

Notre formulaire comprend deux champs de saisie : un pour le titre et un autre pour la date, suivant le schéma de notre modèle d'exercice. Lorsque le formulaire est soumis, les valeurs du titre et de la date seront envoyées via une requête POST au point de terminaison /, qui sera ensuite traitée par notre vue d'index dans app/views.py.

Le modèle

Dans Django, nous pouvons améliorer notre modèle d'exercice (essentiellement une classe Python) en ajoutant des méthodes spécifiques qui correspondent aux opérations CRUD. Dans le fichier app/models.py , nous inclurons les éléments suivants :

class Exercise(models.Model):
    ...

    def create(request):
        title = request.POST.get('title')
        date = request.POST.get('date')

        exercise = Exercise.objects.create(title=title, date=date)

        return exercise

Nous pouvons accéder au titre et à la date à partir de la requête POST, comme indiqué dans le code ci-dessus. Ensuite, nous pouvons utiliser l'ORM intégré de Django pour créer un nouvel exercice et renvoyer l'instance créée.

Nous exploiterons la même vue d'index que celle que nous utilisons pour récupérer les exercices, en l'étendant pour vérifier si la méthode de requête est POST. Si tel est le cas, nous transmettrons l’objet de requête à la méthode de classe que nous avons définie précédemment. Une fois l'exercice créé, nous redirigerons l'utilisateur vers la page d'accueil ou effectuerons une actualisation de la page, en veillant à ce que l'exercice nouvellement ajouté apparaisse à l'écran.

from django.http import HttpResponseRedirect

from app import models

...

def index(request):
    if request.method == 'POST':
        models.Exercise.create(request)
        return redirect('/')

    exercises = (
        models.Exercise.objects.all().order_by("created_at")
    )
    return render(request, "index.html", context={'exercises': exercises})

Essayez de créer un nouvel exercice maintenant et vous devriez le voir apparaître au bas de la liste.

Exercice de mise à jour

Refactorisons un peu notre code avant d'ajouter une fonctionnalité de mise à jour aux exercices. Nous allons déplacer les exercices vers leur propre modèle appelé exercise.html.

<h2>Exercises</h2>
{% include 'add_exercise.html' %}
<ul style="margin: 0; list-style: none; padding: 0">
    {% for exercise in exercises %}
        <li style="margin-top: 4px">
            {% include 'exercise.html' %}
        </li>
    {% endfor %}
</ul>

Créez un modèle pour exercise.html dans le dossier app/templates , et nous y ajouterons le HTML suivant :

<form method="POST" action="/">
    {% csrf_token %}
    <input hidden name="id" value="{{exercise.id}}" />
    <input
        type="text"
        name="title"
        value="{{exercise.title}}"
        placeholder="Enter the title"
    />
    <input
        type="date"
        name="date"
        placeholder="Enter the date"
        value="{{exercise.date | date:'Y-m-d'}}"
    />
    <button type="submit" name="update">Update</button>
</form>

Nous utilisons le  balisez à nouveau pour chaque exercice de la liste et ajoutez une entrée masquée pour exercise.id, qui sera utilisée pour mettre à jour l'exercice. Revenez au navigateur et actualisez la page ; vous devriez voir un formulaire pour chaque exercice de la liste, avec chaque entrée pré-remplie avec les données d'exercice correspondantes.

Notez que nous n'utilisons pas PUT comme méthode de formulaire ; à la place, nous utilisons POST. En effet, les gestionnaires de vues ne peuvent analyser que les données envoyées via les requêtes GET et POST , sans prise en charge intégrée de PUT et DELETE. Lorsque nous avons créé la méthode create class dans la classe Exercise, vous avez peut-être remarqué que nous utilisions request.POST.get('title'). Bien que cela fonctionne pour les requêtes POST, aucune méthode PUT ou DELETE n'est disponible dans l'objet de requête.

Mais comment différencier une requête POST d'une requête PUT ? Si vous consultez le formulaire que nous avons créé précédemment, vous remarquerez que nous avons attribué un attribut de nom au bouton d'envoi. Nous pouvons accéder à cet attribut de la même manière que nous avons accédé au titre et à la date, en utilisant request.POST.get('update').

Mettons à jour le formulaire de création d'exercice pour inclure le même changement.

<form method="POST" action="/">
    ...
    <button type="submit" name="create">Save</button>
</form>

Et dans notre vue Exercices , nous apporterons les modifications suivantes pour différencier les demandes.

def index(request):
    if request.method == 'POST':
        create = 'create' in request.POST
        update = 'update' in request.POST

        if create == True:
            models.Exercise.create(request)
        elif update == True:
            models.Exercise.update(request)

        return redirect('/')

    exercises = (
        models.Exercise.objects.all().order_by("created_at")
    )
    return render(request, "index.html", context={'exercises': exercises})

We check for the button name and forward the request to the appropriate Exercise method accordingly.

Let's add an update class method to the Exercise model in app/models.py.

def update(request):
    id = request.POST.get('id')
    title = request.POST.get('title')
    date = request.POST.get('date')

    exercise = Exercise.objects.filter(pk=id).update(title=title, date=date)

    return exercise

To update a row in the database, we can use the update method available on the Exercise model. However, before updating, we need to ensure that we are updating the correct exercise. To do this, we filter the exercises by the primary key, which is id, and update only that specific exercise.

Delete Exercise

Similarly, we’ll add a delete button next to each exercise in the exercise.html template.

<form method="POST" action="/">
    ...
    <button type="submit" name="update">Update</button>
    <button type="submit" name="delete">Delete</button>
</form>

We’ll set delete as the value of the name attribute, and in views.py, we’ll extend the if...elif statements to handle the delete operation.

def index(request):
    if request.method == 'POST':
        create = 'create' in request.POST
        update = 'update' in request.POST
        delete = 'delete' in request.POST

        if create == True:
            models.Exercise.create(request)
        elif update == True:
            models.Exercise.update(request)
        elif delete == True:
            models.Exercise.delete(request)

        return redirect('/')

    exercises = (
        models.Exercise.objects.all().order_by("created_at")
    )
    return render(request, "index.html", context={'exercises': exercises})

And in the Exercise model, we'll add the class method delete.

def delete(request):
    id = request.POST.get('id')
    is_deleted = Exercise.objects.filter(pk=id).delete()

    if is_deleted == 1:
        return True

    return False

With this addition, we've successfully implemented CRUD operations in our Python and Django application.

Key Takeaways

1. Django view handlers do not support PUT and DELETE requests, as they do not parse the query parameters or request body for those HTTP methods. As a result, we must rely on POST requests and differentiate between them by passing an additional field in the request body.
2. Noticed that I'm making the POST request to the same route from which I'm fetching the exercises. This is important because if you were to create an endpoint like /api/exercises to handle requests, you would need to manage redirection manually. Otherwise, the behavior of the tag after the request is to redirect the user to the endpoint specified in the action attribute. Therefore, you will need to manually redirect the user back to the desired page, or in our case, keep the user on the same page.

from django.http import HttpResponseRedirect

def index(request):
    ...

    return redirect('/')
    # or
    return HttpResponseRedirect(request.META['HTTP_REFERER'])

In summary, by effectively managing our POST requests and ensuring proper redirection, we can create a seamless user experience while implementing CRUD operations in our Django application.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!