Lorsque vous utilisez une technologie ou un framework backend comme Django, Laravel ou Node.js pour écrire des API REST, vous avez besoin avoir une compétence frontend supplémentaire en utilisant des frameworks comme React, Angular et Vue pour utiliser l'API points finaux. Mais ce n'est pas toujours le cas, vous pouvez utiliser les API dans Django lui-même à l'aide des modèles Django.

Configuration d'un projet Django et de points de terminaison d'API

La première étape sera de créer un répertoire de projet. Ouvrez votre terminal et créez un répertoire pour votre projet.

mkdir payment_wallet_project
cd payment_wallet_project

Pour ce didacticiel, vous allez créer des API pour un portefeuille de paiement.

Le code source complet est disponible dans un Dépôt GitHub.

Commence par créer un environnement virtuel. Dans ce cas, vous utiliserez la bibliothèque Pipenv.

pipenv install django djangorestframework

Cette commande installe les bibliothèques nécessaires et crée un environnement virtuel.

Activez l'environnement virtuel à l'aide de la commande ci-dessous :

pipenv shell

Créer un nouveau projet Django nommé PayApp.

django-admin startproject PayApp .

En utilisant le point (.) à la fin de Django-admin La commande garantit que le projet évite de créer un répertoire en double du répertoire du projet.

Créer un nouvelle application Django dans le répertoire du projet.

python manage.py startapp wallet

Maintenant, continuez à créer votre application API en suivant les étapes ci-dessous.

Création d'une API REST de portefeuille de paiement

Ouvrez le portefeuille/modèles.py fichier et définir les modèles de portefeuille et de transaction.

from django.db import models
classWallet(models.Model):
 user = models.CharField(max_length=100)
 balance = models.DecimalField(max_digits=10, decimal_places=2)
 date_created = models.DateTimeField(auto_now_add=True)
 date_modified = models.DateTimeField(auto_now=True)
def__str__(self):
return self.user
classTransaction(models.Model):
 wallet = models.ForeignKey(Wallet, on_delete=models.CASCADE)
 amount = models.DecimalField(max_digits=10, decimal_places=2)
 timestamp = models.DateTimeField(auto_now_add=True)

Dans le portefeuille répertoire, créez un nouveau fichier sérialiseurs.py, et écrivez les sérialiseurs de portefeuille et de modèle de transaction.

from rest_framework import serializers
from .models import Wallet, Transaction
classWalletSerializer(serializers.ModelSerializer):
classMeta:
 model = Wallet
 fields = '__all__'
classTransactionSerializer(serializers.ModelSerializer):
classMeta:
 model = Transaction 
 fields = '__all__'

Les sérialiseurs prennent en compte tous les champs des modèles de portefeuille et de transaction.

Dans portefeuille/views.py, écrivez les vues pour gérer la logique de mise en œuvre de la fonctionnalité du portefeuille. Cela inclut les capacités de dépôt et de retrait.

from rest_framework import generics, status
from rest_framework.response import Response
from rest_framework.decorators import action
from decimal import Decimal
from .models import Wallet, Transaction
from .serializers import WalletSerializer, TransactionSerializer
classWalletViewSet(viewsets.ModelViewSet):
 queryset = Wallet.objects.all()
 serializer_class = WalletSerializer
 @action(detail=True, methods=['post'])
defdeposit(self, request, pk=None):
 wallet = self.get_object()
 amount = Decimal(request.data['amount'])
 wallet.balance += amount
 wallet.save() 
 serializer = WalletSerializer(wallet)
return Response(serializer.data)

 @action(detail=True, methods=['post'])
defwithdraw(self, request, pk=None):
 wallet = self.get_object()
 amount = Decimal(request.data['amount'])
if wallet.balance < amount:
return Response({'error': 'Insufficient funds'},
 status=status.HTTP_400_BAD_REQUEST)
 wallet.balance -= amount
 wallet.save()
 serializer = WalletSerializer(wallet)
return Response(serializer.data)'
classTransactionViewSet(viewsets.ModelViewSet):
 queryset = Transaction.objects.all()
 Serializer_class = TransactionSerializer

Ensuite, définissez le routage des URL pour l'API en créant un portefeuille/urls.py déposer:

from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import WalletViewSet, TransactionViewSet, wallet_view
router = DefaultRouter()
router.register(r'wallets', WalletViewSet, basename='wallets')
router.register(r'transactions', TransactionViewSet, basename='transactions')
urlpatterns = [
 path('api/', include(router.urls)),
 path('wallets//deposit/', WalletViewSet.as_view({'post': 'deposit'}),
 name='wallet-deposit'),
 path('wallets//withdraw/', WalletViewSet.as_view({'post': 'withdraw'}),
 name='wallet-withdraw'),
]

Dans votre projet URL.py, incluez les URL de l'application :

from django.contrib import admin
from django.urls import path, include
urlpatterns = [
 path('admin/', admin.site.urls),
 path('', include('wallet.urls')),
]

Dans le PayApp/settings.py fichier, ajoutez le portefeuille et applications rest_framwork au INSTALLED_APPS liste.

INSTALLED_APPS = [
"django.contrib.admin",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.messages",
"django.contrib.staticfiles",
"rest_framework", # new
"wallet", # new
]

Cela enregistrera les applications wallet et rest_framework dans l'application du projet Django.

Consommer l'API avec les modèles Django

Vous allez maintenant utiliser les modèles Django pour créer une interface simple permettant d'utiliser l'API. Créer un portefeuille.html fichier dans le portefeuille/modèles/ répertoire et ajoutez le code HTML ci-dessous.

"en">

"UTF-8">
"viewport" content="width=device-width, initial-scale=1">


"stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/
 css/bootstrap.min.css">



class="container">
Wallets

class="table">

















User
Balance
Actions






{{ wallet.user }}
"balance">{{ wallet.balance }}


"loading-indicator"class="d-none">

class="spinner-bordertext-primary" role="status">
class="sr-only">Loading...span>



Please wait while the deposit is being processed.




"deposit-form" method="post">
 {% csrf_token %}
"number" name="amount" step="0.01" min="0" required>
"submit"class="btnbtn-success">Depositbutton>



"post" id="withdraw-form">
 {% csrf_token %}
"number" name="amount" step="0.01" min="0" required>
"submit"class="btnbtn-danger">Withdrawbutton>

Le fichier HTML restitue les API de dépôt et de retrait dans une belle interface utilisateur conçue à l'aide de Bootstrap.

Interaction utilisateur avec les formulaires

Dans le fichier HTML, créez une balise de script et ajoutez le code suivant à l'écouteur d'événement de soumission du formulaire de dépôt.

Ensuite, ajoutez l'écouteur d'événement pour la soumission du formulaire de rétractation en utilisant le code ci-dessous :

L'auditeur d'événement est responsable du traitement du dépôt et du retrait (#formulaire-de-dépôt et #formulaire-de-retrait) formulaire de soumissions.

L'URL de la demande de récupération sert à faire correspondre les URL des actions de dépôt et de retrait.

Les réponses JSON pour les dépôts et les retraits sont ensuite analysées pour obtenir le solde mis à jour (data.balance). Ils sont ensuite formatés et affichés sur la page.

Ensuite, dans le portefeuille/views.py, ajoutez la mise à jour suivante pour afficher la page wallet.html :

from django.shortcuts import render
defwallet_view(request):
# Retrieve the wallet to display
 wallet = Wallet.objects.first() 
return render(request, 'wallet.html', {'wallet': wallet})

Dans cet exemple, vous utiliserez le d'abord() méthode de requête pour sélectionner le portefeuille d’un seul utilisateur à des fins de démonstration.

Mettre à jour le URL.py fichier en ajoutant un chemin au vue_portefeuille comme suit:

from .views import wallet_view
urlpatterns = [
 ...
 path('home/', wallet_view, name='wallet-page'),
]

Accédez à la page du portefeuille à partir de l'URL: http://127.0.0.1:8000/home/.

Une fois que tout est configuré et fonctionne comme prévu, exécutez le faire des migrations et émigrer commandes. Enfin, lancez l'application :

python manage.py makemigrations
python manage.py migrate
python manage.py runserver

Pour accéder aux points de terminaison de l'API, accédez à http://127.0.0.1:8000/api/.

Production attendue:

Accédez au hôte local pour interagir avec le portefeuille.

Production attendue:

Le portefeuille affiche le solde et vous donne la possibilité de déposer ou de retirer.

Comprendre les modèles Django et leur rôle dans la consommation des API

Bien qu'ils soient excellents pour présenter du contenu statique, les modèles Django ont certaines restrictions lors de l'utilisation des API :

• Flexibilité limitée: Les modèles Django sont moins flexibles que ceux créés avec Jinja2 ou Twig puisqu'ils sont utilisés pour afficher des structures spécifiées. Par exemple, vous devrez analyser manuellement le JSON et insérer les données dans le modèle si vous devez utiliser une API qui renvoie des données JSON. Cela peut s'avérer difficile, surtout si l'API fournit des structures de données complexes.
• Pas de support pour les requêtes asynchrones: Les modèles Django n'ont pas nativement la capacité de gérer les requêtes asynchrones. Les modèles nécessitent toujours un traitement synchrone même si les frameworks Web contemporains async/wait comme Flask et Django prennent en charge la syntaxe. Cela signifie que vous devrez attendre la fin de toutes les requêtes avant de produire le modèle si vous deviez acquérir des données provenant de nombreuses sources avant de rendre une page.
• Gestion des erreurs limitée: Des erreurs peuvent survenir régulièrement lors de l'utilisation des API. Il n'existe aucun mécanisme intégré pour une gestion gracieuse des erreurs dans les modèles Django. Vous devrez intercepter l'exception et la gérer dans le modèle lui-même si un appel d'API échoue, ce qui pourrait entraîner un code maladroit et difficile à maintenir.

Créez des applications évolutives

En fournissant un moyen de séparer la couche de présentation de la logique métier, les modèles Django permettent aux développeurs de se concentrer sur la création de code réutilisable et maintenable. Cependant, en raison de leurs limites, les modèles Django ne constituent peut-être pas le meilleur choix lors de la consommation d'API à grande échelle. Les frameworks clients comme React sont toujours utiles pour créer des applications évolutives.