Wanneer u een backend-technologie of -framework zoals Django, Laravel of Node.js gebruikt om REST API's te schrijven, heeft u om een ​​extra frontend-vaardigheid te hebben met behulp van frameworks zoals React, Angular en Vue om de API te gebruiken eindpunten. Maar dat is niet altijd het geval: u kunt de API's in Django zelf gebruiken met behulp van Django-sjablonen.

Een Django-project en API-eindpunten opzetten

De eerste stap is het maken van een projectmap. Open uw terminal en maak een map voor uw project.

mkdir payment_wallet_project
cd payment_wallet_project

Voor deze zelfstudie bouwt u API's voor een betalingsportemonnee.

De volledige broncode is beschikbaar in een GitHub-opslagplaats.

Start op het creëren van een virtuele omgeving. In dit geval gebruikt u de Pipenv-bibliotheek.

pipenv install django djangorestframework

Met deze opdracht worden de benodigde bibliotheken geïnstalleerd en wordt een virtuele omgeving gecreëerd.

Activeer de virtuele omgeving met behulp van de onderstaande opdracht:

pipenv shell

Maak een nieuw Django-project genaamd BetaalApp.

django-admin startproject PayApp .

Gebruik de punt (.) aan het einde van de django-admin opdracht zorgt ervoor dat het project voorkomt dat er een dubbele map van de projectmap wordt aangemaakt.

Maak een nieuwe Django-app binnen de projectmap.

python manage.py startapp wallet

Ga nu verder met het bouwen van uw API-applicatie met behulp van de onderstaande stappen.

Een Payment Wallet REST API maken

Open de portemonnee/modellen.py bestand en definieer de portemonnee- en transactiemodellen.

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)

In de portemonnee map, maak een nieuw bestand serializers.pyen schrijf de serializers van het portemonnee- en transactiemodel.

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

De serializers houden rekening met alle velden in de portemonnee- en transactiemodellen.

In portemonnee/views.py, schrijf de views voor het omgaan met de logica van het implementeren van de portemonneefunctionaliteit. Dit omvat de stortings- en opnamemogelijkheden.

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

Definieer vervolgens de URL-routering voor de API door een portemonnee/urls.py bestand:

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

In uw project URL's.py, vermeld de URL's van de app:

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

In de PayApp/settings.py bestand, voeg de portemonnee En rest_framework-apps naar de GEÏNSTALLEERDE_APPS lijst.

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
]

Hiermee worden de portemonnee- en rest_framework-apps geregistreerd bij de Django-projecttoepassing.

De API gebruiken met Django-sjablonen

Nu gebruikt u de Django-sjablonen om een ​​eenvoudige frontend te maken voor het gebruik van de API. Maak een portemonnee.html bestand in de portemonnee/sjablonen/ directory en voeg de onderstaande HTML-code toe.

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

Het HTML-bestand geeft de stortings- en opname-API's weer in een prachtige gebruikersinterface die is ontworpen met Bootstrap.

Gebruikersinteractie met formulieren

Maak in het HTML-bestand een scripttag en voeg de volgende code toe aan de gebeurtenislistener voor het indienen van het stortingsformulier.

Voeg vervolgens de gebeurtenislistener toe voor het indienen van het herroepingsformulier met behulp van de onderstaande code:

De gebeurtenislistener is verantwoordelijk voor het afhandelen van de storting en opname (#aanbetalingsformulier En #herroepingsformulier) formulierinzendingen.

De URL voor het ophaalverzoek is bedoeld om de URL's voor stortings- en opnameacties te matchen.

De JSON-antwoorden voor de stortingen en opnames worden vervolgens geparseerd om het bijgewerkte saldo te verkrijgen (data.balans). Ze worden vervolgens opgemaakt en weergegeven op de pagina.

Vervolgens in de portemonnee/views.py, voeg de volgende update toe om de wallet.html-pagina weer te geven:

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 dit voorbeeld gebruik je de Eerst() querymethode om de portemonnee van één gebruiker te selecteren voor demonstratiedoeleinden.

Update de URL's.py bestand door een pad toe te voegen aan het portemonnee_weergave als volgt:

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

Ga naar de portemonneepagina via de URL: http://127.0.0.1:8000/home/.

Nadat alles is ingesteld en werkt zoals verwacht, voert u het migraties maken En migreren opdrachten. Voer ten slotte de applicatie uit:

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

Voor toegang tot de API-eindpunten navigeert u naar http://127.0.0.1:8000/api/.

Verwachte resultaten:

Navigeer naar de lokalehost om met de portemonnee te communiceren.

Verwachte resultaten:

De portemonnee toont het saldo en geeft u de mogelijkheid om te storten of op te nemen.

Inzicht in Django-sjablonen en hun rol in het API-verbruik

Ondanks dat ze uitstekend zijn voor het presenteren van statische inhoud, hebben Django-sjablonen bepaalde beperkingen bij het gebruik van API's:

• Beperkte flexibiliteit: Django-sjablonen zijn minder flexibel dan die gemaakt met Jinja2 of Twig, omdat ze worden gebruikt voor het weergeven van specifieke structuren. U zou bijvoorbeeld de JSON handmatig moeten parseren en de gegevens in de sjabloon moeten invoegen als u een API nodig heeft die JSON-gegevens retourneert. Dit kan een uitdaging zijn, vooral als de API ingewikkelde datastructuren levert.
• Geen ondersteuning voor asynchrone verzoeken: Django-sjablonen missen standaard de mogelijkheid om asynchrone verzoeken af ​​te handelen. Sjablonen hebben nog steeds synchrone verwerking nodig, ook al ondersteunen de async/await hedendaagse webframeworks zoals Flask en Django syntaxis. Dit betekent dat u zou moeten wachten tot alle verzoeken zijn voltooid voordat u de sjabloon kunt maken als u gegevens uit talloze bronnen moet verzamelen voordat u een pagina kunt weergeven.
• Beperkte foutafhandeling: Er kunnen regelmatig fouten optreden bij het gebruik van API's. Er zijn geen ingebouwde mechanismen voor een correcte foutafhandeling in Django-sjablonen. U moet de uitzondering opvangen en binnen de sjabloon zelf beheren als een API-aanroep mislukt, wat kan resulteren in onhandige en lastig te onderhouden code.

Bouw schaalbare applicaties

Door een manier te bieden om de presentatielaag te scheiden van de bedrijfslogica, zorgen Django-sjablonen ervoor dat ontwikkelaars zich kunnen concentreren op het creëren van herbruikbare en onderhoudbare code. Vanwege hun beperkingen zijn Django-sjablonen echter mogelijk niet de beste keuze bij het op grote schaal gebruiken van API's. Clientframeworks zoals React zijn nog steeds nuttig bij het bouwen van schaalbare applicaties.