Při použití backendové technologie nebo frameworku, jako je Django, Laravel nebo Node.js k psaní REST API, potřebujete mít další dovednost frontendu pomocí rámců jako React, Angular a Vue pro používání API koncové body. Ale to není vždy případ, API můžete konzumovat v samotném Django pomocí šablon Django.

Nastavení projektu Django a koncových bodů API

Prvním krokem bude vytvoření adresáře projektu. Otevřete svůj terminál a vytvořte adresář pro svůj projekt.

mkdir payment_wallet_project
cd payment_wallet_project

V tomto tutoriálu vytvoříte rozhraní API pro platební peněženku.

Úplný zdrojový kód je k dispozici v a úložiště GitHub.

Začněte tím vytváření virtuálního prostředí. V tomto případě použijete knihovnu Pipenv.

pipenv install django djangorestframework

Tento příkaz nainstaluje potřebné knihovny a vytvoří virtuální prostředí.

Aktivujte virtuální prostředí pomocí příkazu níže:

pipenv shell

Vytvořte nový projekt Django jmenoval PayApp.

django-admin startproject PayApp .

Použití tečky (.) na konci django-admin příkaz zajistí, že se projekt vyvaruje vytvoření duplicitního adresáře adresáře projektu.

Vytvořit nová aplikace Django v adresáři projektu.

python manage.py startapp wallet

Nyní pokračujte v sestavování aplikace API pomocí níže uvedených kroků.

Vytvoření REST API pro platební peněženku

Otevři wallet/models.py a definovat modely peněženky a transakcí.

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)

V peněženka adresář, vytvořte nový soubor serializers.pya napište serializátory peněženky a transakčního modelu.

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

Serializátory berou v úvahu všechna pole v peněžence a transakční modely.

v wallet/views.py, napište pohledy pro zpracování logiky implementace funkce peněženky. To zahrnuje možnosti vkladu a výběru.

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

Dále definujte směrování URL pro API vytvořením a wallet/urls.py soubor:

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

Ve vašem projektu urls.py, zahrnout adresy URL aplikace:

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

V PayApp/settings.py soubor, přidejte peněženka a aplikace rest_framwork k INSTALLED_APPS seznam.

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
]

Tím se zaregistrují aplikace peněženka a rest_framework do aplikace projektu Django.

Spotřeba API se šablonami Django

Nyní použijete šablony Django k vytvoření jednoduchého rozhraní pro používání API. Vytvořit peněženka.html soubor v peněženka/šablony/ adresář a přidejte níže uvedený HTML kód.

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

Soubor HTML vykresluje rozhraní API pro vklad a výběr v krásném uživatelském rozhraní navrženém pomocí Bootstrap.

Uživatelská interakce s formuláři

V souboru HTML vytvořte značku skriptu a přidejte následující kód do posluchače události odeslání formuláře vkladu.

Dále přidejte posluchač události pro odeslání formuláře pro odstoupení od smlouvy pomocí kódu níže:

Posluchač události je zodpovědný za zpracování vkladu a výběru (#vkladový formulář a #formulář pro výběr) odeslání formuláře.

Adresa URL žádosti o načtení slouží ke shodě adres URL pro akce vkladu a výběru.

Odpovědi JSON pro vklady a výběry jsou poté analyzovány, aby se získal aktualizovaný zůstatek (data.bilance). Poté jsou naformátovány a zobrazeny na stránce.

Dále v wallet/views.py, přidejte následující aktualizaci k vykreslení stránky 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})

V tomto příkladu použijete První() dotazovací metoda pro výběr peněženky jednoho uživatele pro demonstrační účely.

Aktualizujte urls.py přidáním cesty k souboru wallet_view jak následuje:

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

Přejděte na stránku peněženky z adresy URL: http://127.0.0.1:8000/home/.

Když je vše nastaveno a funguje podle očekávání, spusťte migrace a migrovat příkazy. Nakonec spusťte aplikaci:

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

Chcete-li získat přístup ke koncovým bodům API, přejděte na http://127.0.0.1:8000/api/.

Očekávaný výstup:

Přejděte na localhost pro interakci s peněženkou.

Očekávaný výstup:

Peněženka zobrazuje zůstatek a dává vám možnost buď vložit, nebo vybrat.

Pochopení šablon Django a jejich role ve spotřebě API

Přestože jsou šablony Django vynikající pro prezentaci statického obsahu, mají určitá omezení při používání rozhraní API:

• Omezená flexibilita: Šablony Django jsou méně flexibilní než šablony vytvořené pomocí Jinja2 nebo Twig, protože se používají pro zobrazení specifikovaných struktur. Například byste museli ručně analyzovat JSON a vložit data do šablony, pokud byste potřebovali využívat rozhraní API, které vrátilo data JSON. To může být náročné, zejména pokud API poskytuje složité datové struktury.
• Žádná podpora pro asynchronní požadavky: Šablony Django nativně postrádají schopnost zpracovávat asynchronní požadavky. Šablony stále potřebují synchronní zpracování, i když současné webové rámce async/wait jako Flask a Django podporují syntaxi. To znamená, že byste museli před vytvořením šablony čekat na dokončení všech požadavků, pokud byste před vykreslením stránky potřebovali získat data z mnoha zdrojů.
• Omezené zpracování chyb: Při používání rozhraní API se mohou pravidelně vyskytovat chyby. V šablonách Django nejsou žádné vestavěné mechanismy pro elegantní zpracování chyb. Pokud volání API selže, budete muset zachytit výjimku a spravovat ji v samotné šabloně, což by mohlo mít za následek neohrabaný a náročný na údržbu kódu.

Vytvářejte škálovatelné aplikace

Tím, že poskytují způsob, jak oddělit prezentační vrstvu od obchodní logiky, umožňují šablony Django vývojářům soustředit se na vytváření opakovaně použitelného a udržovatelného kódu. Vzhledem ke svým omezením však šablony Django nemusí být tou nejlepší volbou při používání API ve velkém měřítku. Klientské rámce jako React jsou stále užitečné při vytváření škálovatelných aplikací.