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 de l'application, nous allons simplement étendre la vue d'index pour gérer les demandes de création, de mise à jour et de suppression.

La forme

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.

 {% csrf_token %}   Save 

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 %} 
Exercises
 {% 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

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

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})

Exercises
 {% include 'add_exercise.html' %} 
 {% for exercise in exercises %} 
 {% include 'exercise.html' %} 
 {% endfor %} 

 {% csrf_token %}    Update 

Nous utilisons lebalisez à 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 dans 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.

 ... Save 

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.

 ... Update Delete 

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 thetag 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!