Când utilizați o tehnologie de backend sau un cadru precum Django, Laravel sau Node.js pentru a scrie API-uri REST, aveți nevoie de pentru a avea o abilitate frontală suplimentară folosind cadre precum React, Angular și Vue pentru a consuma API-ul puncte finale. Dar nu este întotdeauna cazul, puteți consuma API-urile în Django în sine folosind șabloane Django.

Configurarea unui proiect Django și a punctelor finale API

Primul pas va fi crearea unui director de proiect. Deschideți terminalul și creați un director pentru proiectul dvs.

mkdir payment_wallet_project
cd payment_wallet_project

Pentru acest tutorial, veți crea API-uri pentru un portofel de plăți.

Codul sursă complet este disponibil în a Depozitul GitHub.

Începe prin crearea unui mediu virtual. În acest caz, veți folosi biblioteca Pipenv.

pipenv install django djangorestframework

Această comandă instalează bibliotecile necesare, precum și creează un mediu virtual.

Activați mediul virtual folosind comanda de mai jos:

pipenv shell

Creați un nou proiect Django numit PayApp.

django-admin startproject PayApp .

Folosind punctul (.) la sfârșitul django-admin comanda asigură că proiectul evită crearea unui director duplicat al directorului de proiect.

Creeaza o noua aplicație Django în directorul de proiect.

python manage.py startapp wallet

Acum, continuați să vă creați aplicația API utilizând pașii de mai jos.

Crearea unui API REST pentru portofel de plăți

Deschide portofel/modele.py arhivați și definiți modelele de portofel și tranzacții.

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)

În portofel director, creați un fișier nou serializatoare.pyși scrieți serializatoarele pentru portofel și modelul de tranzacție.

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

Serializatoarele iau în considerare toate câmpurile din modelele de portofel și tranzacții.

În portofel/views.py, scrieți vederile pentru gestionarea logicii implementării funcționalității portofel. Aceasta include abilitățile de depunere și retragere.

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

Apoi, definiți ruta URL pentru API creând un wallet/urls.py fişier:

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

În proiectul tău urls.py, includeți adresele URL ale aplicației:

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

În PayApp/settings.py fișier, adăugați portofel și aplicații rest_framwork la INSTALLED_APPS listă.

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
]

Aceasta va înregistra aplicațiile wallet și rest_framework în aplicația de proiect Django.

Utilizarea API-ului cu șabloane Django

Acum, veți folosi șabloanele Django pentru a crea o interfață simplă pentru consumarea API-ului. Creeaza o wallet.html dosar în portofel/şabloane/ director și adăugați codul HTML de mai jos.

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

Fișierul HTML redă API-urile de depunere și retragere într-o interfață de utilizator frumoasă concepută folosind Bootstrap.

Interacțiunea utilizatorului cu formularele

În fișierul HTML, creați o etichetă de script și adăugați următorul cod la ascultatorul evenimentului de trimitere a formularului de depunere.

Apoi, adăugați ascultătorul evenimentului pentru trimiterea formularului de retragere folosind codul de mai jos:

Ascultătorul evenimentului este responsabil pentru gestionarea depunerii și retragerii (#form-depozit și #form-retragere) depuneri de formulare.

Adresa URL pentru cererea de preluare este pentru potrivirea adreselor URL pentru acțiunile de depunere și retragere.

Răspunsurile JSON pentru depuneri și retrageri sunt apoi analizate pentru a obține soldul actualizat (date.balans). Acestea sunt apoi formatate și afișate pe pagină.

În continuare, în portofel/views.py, adăugați următoarea actualizare pentru a reda 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})

În acest exemplu, veți folosi primul() metoda de interogare pentru a selecta portofelul unui singur utilizator în scopuri demonstrative.

Actualizați urls.py fișier prin adăugarea unei căi la wallet_view după cum urmează:

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

Accesați pagina portofel de la adresa URL: http://127.0.0.1:8000/home/.

Cu totul configurat și funcționând conform așteptărilor, executați face migrații și migra comenzi. În cele din urmă, rulați aplicația:

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

Pentru a accesa punctele finale API, navigați la http://127.0.0.1:8000/api/.

Rezultat așteptat:

Navigați la gazdă locală pentru a interacționa cu portofelul.

Rezultat așteptat:

Portofelul arată soldul și vă oferă opțiunea fie de a depune, fie de a retrage.

Înțelegerea șabloanelor Django și a rolului lor în consumul API

În ciuda faptului că sunt excelente pentru prezentarea conținutului static, șabloanele Django au anumite restricții atunci când folosesc API-uri:

• Flexibilitate limitată: Șabloanele Django sunt mai puțin flexibile decât cele create folosind Jinja2 sau Twig, deoarece sunt folosite pentru afișarea structurilor specificate. De exemplu, ar trebui să analizați manual JSON și să introduceți datele în șablon dacă ați nevoie să consumați un API care a returnat date JSON. Acest lucru poate fi o provocare, mai ales dacă API-ul oferă structuri complexe de date.
• Nu există suport pentru solicitările asincrone: șabloanele Django nu au în mod nativ capacitatea de a gestiona solicitările asincrone. Șabloanele încă au nevoie de procesare sincronă, chiar dacă cadrele web asincrone/așteaptă, cum ar fi Flask și Django, acceptă sintaxa. Acest lucru înseamnă că ar trebui să așteptați ca toate solicitările să se termine înainte de a produce șablonul, dacă aveți nevoie să achiziționați date din numeroase surse înainte de a randa o pagină.
• Gestionarea limitată a erorilor: Pot apărea în mod regulat erori atunci când utilizați API-uri. Nu există mecanisme încorporate pentru gestionarea grațioasă a erorilor în șabloanele Django. Ar trebui să prindeți excepția și să o gestionați în cadrul șablonului însuși dacă un apel API eșuează, ceea ce ar putea duce la un cod neîndemânatic și dificil de întreținut.

Creați aplicații scalabile

Oferind o modalitate de a separa stratul de prezentare de logica de afaceri, șabloanele Django permit dezvoltatorilor să se concentreze pe crearea de cod reutilizabil și care poate fi întreținut. Cu toate acestea, din cauza limitărilor lor, șabloanele Django pot să nu fie cea mai bună alegere atunci când se consumă API-uri la scară. Cadrele client precum React sunt încă utile în construirea de aplicații scalabile.