Når du bruger en backend-teknologi eller -ramme som Django, Laravel eller Node.js til at skrive REST API'er, skal du at have en ekstra frontend-færdighed ved at bruge rammer som React, Angular og Vue til at forbruge API'en endepunkter. Men det er ikke altid tilfældet, du kan forbruge API'erne i selve Django ved hjælp af Django-skabeloner.

Opsætning af et Django-projekt og API-endepunkter

Det første trin vil være at oprette en projektmappe. Åbn din terminal og opret en mappe til dit projekt.

mkdir payment_wallet_project
cd payment_wallet_project

Til denne tutorial skal du bygge API'er til en betalingspung.

Den fulde kildekode er tilgængelig i en GitHub-depot.

Start med skabe et virtuelt miljø. I dette tilfælde vil du bruge Pipenv-biblioteket.

pipenv install django djangorestframework

Denne kommando installerer de nødvendige biblioteker og opretter et virtuelt miljø.

Aktiver det virtuelle miljø ved hjælp af kommandoen nedenfor:

pipenv shell

Opret et nyt Django-projekt som hedder PayApp.

django-admin startproject PayApp .

Brug af punktum (.) i slutningen af django-admin kommandoen sikrer, at projektet undgår at oprette en dubletmappe af projektmappen.

Lave en ny Django app i projektkataloget.

python manage.py startapp wallet

Fortsæt nu med at bygge din API-applikation ved at bruge nedenstående trin.

Oprettelse af en Payment Wallet REST API

Åbn wallet/models.py fil og definere tegnebogen og transaktionsmodellerne.

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)

I den pung mappe, skal du oprette en ny fil serializers.py, og skriv tegnebogen og transaktionsmodellens serializers.

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

Serializerne overvejer alle felterne i tegnebogen og transaktionsmodellerne.

I wallet/views.py, skriv synspunkterne til håndtering af logikken i implementeringen af ​​tegnebogens funktionalitet. Dette inkluderer indbetalings- og udbetalingsmuligheder.

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

Derefter skal du definere URL-routing for API'et ved at oprette en wallet/urls.py fil:

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

I dit projekt urls.py, inkludere appens webadresser:

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

I den PayApp/settings.py fil, tilføj pung og rest_framwork apps til INSTALLERET_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
]

Dette vil registrere tegnebogen og rest_framework-apps til Django-projektapplikationen.

Forbrug af API med Django-skabeloner

Nu skal du bruge Django-skabelonerne til at skabe en simpel frontend til at forbruge API'en. Lave en tegnebog.html fil i tegnebog/skabeloner/ mappe og tilføje HTML-koden nedenfor.

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

HTML-filen gengiver indbetalings- og udbetalings-API'erne i en smuk brugergrænseflade designet ved hjælp af Bootstrap.

Brugerinteraktion med formularer

I HTML-filen skal du oprette et script-tag og tilføje følgende kode til indsendelsesformularens indsendelseshændelseslytter.

Tilføj derefter begivenhedslytteren til indsendelse af fortrydelsesformularen ved hjælp af koden nedenfor:

Begivenhedslytteren er ansvarlig for at håndtere indbetaling og udbetaling (#indbetalingsformular og #tilbagetrækningsformular) formularindsendelser.

URL'en til hentningsanmodningen er til at matche URL'erne for ind- og udbetalingshandlinger.

JSON-svarene for indbetalinger og udbetalinger analyseres derefter for at få den opdaterede saldo (data.balance). De formateres derefter og vises på siden.

Dernæst i wallet/views.py, tilføj følgende opdatering for at gengive siden 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})

I dette eksempel vil du bruge først() forespørgselsmetode til at vælge en enkelt brugers tegnebog til demonstrationsformål.

Opdater urls.py fil ved at tilføje en sti til wallet_view som følger:

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

Få adgang til tegnebogens side fra URL'en: http://127.0.0.1:8000/home/.

Med alt sat op og fungerer som forventet, skal du udføre makemigrationer og migrere kommandoer. Kør endelig applikationen:

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

For at få adgang til API-endepunkterne skal du navigere til http://127.0.0.1:8000/api/.

Forventet output:

Naviger til lokal vært at interagere med tegnebogen.

Forventet output:

Pungen viser saldoen og giver dig mulighed for enten at indbetale eller hæve.

Forståelse af Django-skabeloner og deres rolle i API-forbrug

På trods af at de er fremragende til at præsentere statisk indhold, har Django-skabeloner visse begrænsninger ved brug af API'er:

• Begrænset fleksibilitet: Django-skabeloner er mindre fleksible end dem, der er oprettet ved hjælp af Jinja2 eller Twig, da de bruges til at vise specificerede strukturer. For eksempel skal du manuelt parse JSON og indsætte dataene i skabelonen, hvis du skulle bruge en API, der returnerede JSON-data. Dette kan være udfordrende, primært hvis API'en leverer indviklede datastrukturer.
• Ingen understøttelse af asynkrone anmodninger: Django-skabeloner mangler oprindeligt evnen til at håndtere asynkrone anmodninger. Skabeloner har stadig brug for synkron behandling, selvom de asynkroniserede/afventende moderne web-frameworks som Flask og Django understøtter syntaks. Dette betyder, at du skal vente på, at alle anmodninger er færdige, før du producerer skabelonen, hvis du havde brug for at hente data fra adskillige kilder, før du gengiver en side.
• Begrænset fejlhåndtering: Der kan opstå fejl regelmæssigt ved brug af API'er. Der er ingen indbyggede mekanismer til yndefuld fejlhåndtering i Django-skabeloner. Du bliver nødt til at fange undtagelsen og administrere den i selve skabelonen, hvis et API-kald mislykkes, hvilket kan resultere i klodset og udfordrende at vedligeholde kode.

Byg skalerbare applikationer

Ved at give en måde at adskille præsentationslaget fra forretningslogikken giver Django-skabeloner udviklere mulighed for at fokusere på at skabe genbrugelig og vedligeholdelig kode. Men på grund af deres begrænsninger er Django-skabeloner muligvis ikke det bedste valg, når du bruger API'er i stor skala. Klientrammer som React er stadig nyttige til at bygge skalerbare applikationer.