Quando utilizzi una tecnologia o un framework backend come Django, Laravel o Node.js per scrivere API REST, devi avere competenze frontend aggiuntive utilizzando framework come React, Angular e Vue per utilizzare l'API endpoint. Ma non è sempre così, puoi utilizzare le API nello stesso Django utilizzando i modelli Django.

Configurazione di un progetto Django e di endpoint API

Il primo passo sarà creare una directory di progetto. Apri il tuo terminale e crea una directory per il tuo progetto.

mkdir payment_wallet_project
cd payment_wallet_project

Per questo tutorial creerai API per un portafoglio di pagamento.

Il codice sorgente completo è disponibile in a Repositorio GitHub.

A partire da creando un ambiente virtuale. In questo caso utilizzerai la libreria Pipenv.

pipenv install django djangorestframework

Questo comando installa le librerie necessarie e crea un ambiente virtuale.

Attiva l'ambiente virtuale utilizzando il comando seguente:

pipenv shell

Crea un nuovo progetto Django di nome PayApp.

django-admin startproject PayApp .

Utilizzando il punto (.) alla fine di django-admin Il comando garantisce che il progetto eviti di creare una directory duplicata della directory del progetto.

Creare un nuova app Django all'interno della directory del progetto.

python manage.py startapp wallet

Ora procedi a creare la tua applicazione API utilizzando i passaggi seguenti.

Creazione di un'API REST del portafoglio di pagamento

Apri il portafoglio/models.py archiviare e definire i modelli di portafoglio e transazione.

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)

Nel portafoglio directory, creare un nuovo file serializers.pye scrivere i serializzatori del portafoglio e del modello di transazione.

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__'

I serializzatori considerano tutti i campi nel portafoglio e nei modelli di transazione.

In portafoglio/views.py, scrivere le visualizzazioni per gestire la logica di implementazione della funzionalità del portafoglio. Ciò include le capacità di deposito e prelievo.

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

Successivamente, definisci il routing dell'URL per l'API creando un file portafoglio/urls.py file:

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'),
]

Nel tuo progetto urls.py, includi gli URL dell'app:

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

Nel PayApp/settings.py file, aggiungi il file portafoglio E app rest_framwork al APP_INSTALLATE elenco.

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
]

Ciò registrerà le app wallet e rest_framework nell'applicazione del progetto Django.

Utilizzo dell'API con i modelli Django

Ora utilizzerai i modelli Django per creare un semplice frontend per utilizzare l'API. Creare un portafoglio.html file nel portafoglio/modelli/ directory e aggiungi il codice HTML qui sotto.

"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>

Il file HTML esegue il rendering delle API di deposito e prelievo in una bellissima interfaccia utente progettata utilizzando Bootstrap.

Interazione dell'utente con i moduli

Nel file HTML, crea un tag script e aggiungi il seguente codice al listener dell'evento di invio del modulo di deposito.

Successivamente, aggiungi il listener di eventi per l'invio del modulo di recesso utilizzando il codice seguente:

L'ascoltatore di eventi è responsabile della gestione del deposito e del prelievo (#modulo-deposito E #modulo-recesso) moduli di invio.

L'URL per la richiesta di recupero serve per abbinare gli URL per le azioni di deposito e prelievo.

Le risposte JSON per depositi e prelievi vengono quindi analizzate per ottenere il saldo aggiornato (bilanciamento.dati). Vengono quindi formattati e visualizzati nella pagina.

Successivamente, nel portafoglio/views.py, aggiungi il seguente aggiornamento per eseguire il rendering della pagina 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})

In questo esempio utilizzerai il file Primo() metodo di query per selezionare il portafoglio di un singolo utente a scopo dimostrativo.

Aggiorna il urls.py file aggiungendo un percorso al file portafoglio_vista come segue:

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

Accedi alla pagina del portafoglio dall'URL: http://127.0.0.1:8000/home/.

Con tutto configurato e funzionante come previsto, esegui il file faremigrazioni E migrare comandi. Infine, esegui l'applicazione:

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

Per accedere agli endpoint API, vai a http://127.0.0.1:8000/api/.

Risultato previsto:

Passare a localhost per interagire con il portafoglio.

Risultato previsto:

Il portafoglio mostra il saldo e ti dà la possibilità di depositare o prelevare.

Comprensione dei modelli Django e del loro ruolo nel consumo dell'API

Nonostante siano eccellenti per presentare contenuti statici, i modelli Django presentano alcune restrizioni quando si utilizzano le API:

• Flessibilità limitata: i modelli Django sono meno flessibili di quelli creati utilizzando Jinja2 o Twig poiché vengono utilizzati per visualizzare strutture specifiche. Ad esempio, dovresti analizzare manualmente il JSON e inserire i dati nel modello se avessi bisogno di utilizzare un'API che restituisca dati JSON. Questo può essere complicato, soprattutto se l'API fornisce strutture dati complesse.
• Nessun supporto per le richieste asincrone: i modelli Django non hanno nativamente la capacità di gestire richieste asincrone. I modelli necessitano ancora di un'elaborazione sincrona anche se i framework web contemporanei asincroni come Flask e Django supportano la sintassi. Ciò significa che dovresti attendere il completamento di tutte le richieste prima di produrre il modello se avessi bisogno di acquisire dati da numerose fonti prima di eseguire il rendering di una pagina.
• Gestione degli errori limitata: Gli errori possono verificarsi regolarmente durante l'utilizzo delle API. Non esistono meccanismi integrati per una gestione corretta degli errori nei modelli Django. Dovresti rilevare l'eccezione e gestirla all'interno del modello stesso se una chiamata API fallisce, il che potrebbe risultare in un codice goffo e difficile da mantenere.

Crea applicazioni scalabili

Fornendo un modo per separare il livello di presentazione dalla logica aziendale, i modelli Django consentono agli sviluppatori di concentrarsi sulla creazione di codice riutilizzabile e gestibile. Tuttavia, a causa delle loro limitazioni, i modelli Django potrebbero non essere la scelta migliore quando si utilizzano API su larga scala. I framework client come React sono ancora utili nella creazione di applicazioni scalabili.