Jeśli do pisania interfejsów API REST używasz technologii lub frameworka typu backend, takiego jak Django, Laravel lub Node.js, potrzebujesz posiadanie dodatkowej umiejętności frontendowej przy użyciu frameworków takich jak React, Angular i Vue w celu korzystania z API punkty końcowe. Ale nie zawsze tak jest, możesz korzystać z interfejsów API w samym Django, używając szablonów Django.

Konfigurowanie projektu Django i punktów końcowych API

Pierwszym krokiem będzie utworzenie katalogu projektu. Otwórz terminal i utwórz katalog dla swojego projektu.

mkdir payment_wallet_project
cd payment_wallet_project

W tym samouczku zbudujesz interfejsy API dla portfela płatniczego.

Pełny kod źródłowy jest dostępny w formacie a Repozytorium GitHuba.

Zacząć od tworzenie środowiska wirtualnego. W tym przypadku użyjesz biblioteki Pipenv.

pipenv install django djangorestframework

To polecenie instaluje niezbędne biblioteki, a także tworzy środowisko wirtualne.

Aktywuj środowisko wirtualne za pomocą poniższego polecenia:

pipenv shell

Utwórz nowy projekt Django o imieniu Aplikacja płatnicza.

django-admin startproject PayApp .

Używanie kropki (.) na końcu administrator django polecenie gwarantuje, że projekt uniknie tworzenia zduplikowanego katalogu katalogu projektu.

Stwórz nowa aplikacja Django w katalogu projektu.

python manage.py startapp wallet

Teraz przejdź do tworzenia aplikacji API, wykonując poniższe czynności.

Tworzenie API REST Portfela Płatniczego

Otworzyć portfel/models.py plik i zdefiniuj modele portfela i transakcji.

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)

w portfel katalogu, utwórz nowy plik serializers.pyi napisz serializatory portfela i modelu transakcji.

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

Serializatory uwzględniają wszystkie pola w modelach portfela i transakcji.

W portfel/views.py, napisz widoki obsługujące logikę implementacji funkcjonalności portfela. Obejmuje to możliwości wpłat i wypłat.

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

Następnie zdefiniuj routing adresu URL dla interfejsu API, tworząc plik portfel/urls.py plik:

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

W Twoim projekcie urls.py, podaj adresy URL aplikacji:

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

w PayApp/settings.py plik, dodaj plik portfel I aplikacje rest_framwork do ZAINSTALOWANE_APLIKACJE lista.

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
]

Spowoduje to zarejestrowanie aplikacji portfela i rest_framework w aplikacji projektu Django.

Korzystanie z API za pomocą szablonów Django

Teraz użyjesz szablonów Django, aby utworzyć prosty interfejs do korzystania z interfejsu API. Stwórz portfel.html plik w portfel/szablony/ katalog i dodaj poniższy kod HTML.

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

Plik HTML renderuje interfejsy API wpłat i wypłat w pięknym interfejsie użytkownika zaprojektowanym przy użyciu Bootstrap.

Interakcja użytkownika z formularzami

W pliku HTML utwórz znacznik skryptu i dodaj następujący kod do detektora zdarzeń przesłania formularza wpłaty.

Następnie dodaj detektor zdarzeń do przesłania formularza wypłaty, korzystając z poniższego kodu:

Odbiornik zdarzeń jest odpowiedzialny za obsługę wpłat i wypłat (#formularz-wpłaty I #formularz wypłaty) zgłoszenia w formularzu.

Adres URL żądania pobrania służy do dopasowania adresów URL operacji wpłat i wypłat.

Odpowiedzi JSON dotyczące wpłat i wypłat są następnie analizowane w celu uzyskania zaktualizowanego salda (saldo danych). Następnie są one formatowane i wyświetlane na stronie.

Dalej w portfel/views.py, dodaj następującą aktualizację, aby wyrenderować stronę portfel.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})

W tym przykładzie użyjesz Pierwszy() metoda zapytania służąca do wybrania portfela pojedynczego użytkownika do celów demonstracyjnych.

Zaktualizuj urls.py plik, dodając ścieżkę do pliku widok_portfela następująco:

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

Uzyskaj dostęp do strony portfela z adresu URL: http://127.0.0.1:8000/home/.

Gdy wszystko jest skonfigurowane i działa zgodnie z oczekiwaniami, wykonaj polecenie dokonać migracji I migrować polecenia. Na koniec uruchom aplikację:

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

Aby uzyskać dostęp do punktów końcowych interfejsu API, przejdź do http://127.0.0.1:8000/api/.

Oczekiwany wynik:

Przejdź do Lokalny Gospodarz do interakcji z portfelem.

Oczekiwany wynik:

Portfel pokazuje saldo i daje możliwość wpłaty lub wypłaty.

Zrozumienie szablonów Django i ich roli w zużyciu API

Pomimo tego, że doskonale nadają się do prezentowania treści statycznych, szablony Django mają pewne ograniczenia podczas korzystania z interfejsów API:

• Ograniczona elastyczność: Szablony Django są mniej elastyczne niż te utworzone przy użyciu Jinja2 lub Twig, ponieważ są używane do wyświetlania określonych struktur. Na przykład musiałbyś ręcznie przeanalizować kod JSON i wstawić dane do szablonu, jeśli chcesz skorzystać z interfejsu API, który zwrócił dane JSON. Może to stanowić wyzwanie, głównie jeśli interfejs API udostępnia skomplikowane struktury danych.
• Brak obsługi żądań asynchronicznych: Szablony Django natywnie nie mają możliwości obsługi żądań asynchronicznych. Szablony nadal wymagają przetwarzania synchronicznego, mimo że współczesne platformy internetowe async/await, takie jak Flask i Django, obsługują składnię. Oznacza to, że jeśli przed wyświetleniem strony konieczne było uzyskanie danych z wielu źródeł, przed utworzeniem szablonu trzeba było poczekać na zakończenie wszystkich żądań.
• Ograniczona obsługa błędów: Podczas korzystania z interfejsów API mogą regularnie pojawiać się błędy. W szablonach Django nie ma wbudowanych mechanizmów płynnej obsługi błędów. Będziesz musiał przechwycić wyjątek i zarządzać nim w samym szablonie, jeśli wywołanie API nie powiedzie się, co może skutkować niezdarnym i trudnym w utrzymaniu kodem.

Twórz skalowalne aplikacje

Zapewniając sposób na oddzielenie warstwy prezentacji od logiki biznesowej, szablony Django pozwalają programistom skupić się na tworzeniu kodu wielokrotnego użytku i łatwego w utrzymaniu. Jednak ze względu na swoje ograniczenia szablony Django mogą nie być najlepszym wyborem w przypadku korzystania z interfejsów API na dużą skalę. Frameworki klienckie, takie jak React, są nadal przydatne w budowaniu skalowalnych aplikacji.