Ao usar uma tecnologia ou estrutura de back-end como Django, Laravel ou Node.js para escrever APIs REST, você precisa ter uma habilidade adicional de frontend usando frameworks como React, Angular e Vue para consumir a API pontos finais. Mas nem sempre é o caso, você pode consumir as APIs no próprio Django usando templates do Django.

Configurando um projeto Django e endpoints de API

O primeiro passo será criar um diretório de projeto. Abra seu terminal e crie um diretório para seu projeto.

mkdir payment_wallet_project
cd payment_wallet_project

Neste tutorial, você criará APIs para uma carteira de pagamento.

O código-fonte completo está disponível em um Repositório GitHub.

Começar por criando um ambiente virtual. Neste caso, você usará a biblioteca Pipenv.

pipenv install django djangorestframework

Este comando instala as bibliotecas necessárias e também cria um ambiente virtual.

Ative o ambiente virtual usando o comando abaixo:

pipenv shell

Crie um novo projeto Django nomeado PayApp.

django-admin startproject PayApp .

Usando o ponto final (.) no final de django-admin O comando garante que o projeto evite a criação de um diretório duplicado do diretório do projeto.

Criar uma novo aplicativo Django dentro do diretório do projeto.

python manage.py startapp wallet

Agora, prossiga para construir seu aplicativo API usando as etapas abaixo.

Criando uma API REST de carteira de pagamento

Abra o carteira/modelos.py arquivo e definir os modelos de carteira e transação.

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)

No carteira diretório, crie um novo arquivo serializadores.pye escreva os serializadores de modelo de carteira e transação.

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

Os serializadores consideram todos os campos dos modelos de carteira e transação.

Em carteira/views.py, escreva as visualizações para lidar com a lógica de implementação da funcionalidade da carteira. Isso inclui as capacidades de depósito e retirada.

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

A seguir, defina o roteamento de URL para a API criando um carteira/urls.py arquivo:

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

No seu projeto urls.py, inclua os URLs do aplicativo:

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

No PayApp/settings.py arquivo, adicione o carteira e aplicativos rest_framwork para o INSTALLED_APPS 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
]

Isso registrará os aplicativos wallet e rest_framework no aplicativo do projeto Django.

Consumindo a API com modelos Django

Agora, você usará os templates do Django para criar um frontend simples para consumir a API. Criar uma carteira.html arquivo no carteira/modelos/ diretório e adicione o código HTML abaixo.

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

O arquivo HTML renderiza as APIs de depósito e retirada em uma bela interface de usuário projetada usando Bootstrap.

Interação do usuário com formulários

No arquivo HTML, crie uma tag de script e adicione o código a seguir ao ouvinte do evento de envio do formulário de depósito.

Em seguida, adicione o ouvinte de evento para envio do formulário de retirada usando o código abaixo:

O ouvinte do evento é responsável por lidar com o depósito e retirada (#formulário-depósito e #formulário de retirada) envios de formulários.

O URL para a solicitação de busca serve para combinar os URLs para ações de depósito e retirada.

As respostas JSON para depósitos e retiradas são então analisadas para obter o saldo atualizado (dados.saldo). Eles são então formatados e exibidos na página.

A seguir, no carteira/views.py, adicione a seguinte atualização para renderizar a página 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})

Neste exemplo, você usará o primeiro() método de consulta para selecionar a carteira de um único usuário para fins de demonstração.

Atualize o urls.py arquivo adicionando um caminho ao carteira_view do seguinte modo:

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

Acesse a página da carteira a partir do URL: http://127.0.0.1:8000/home/.

Com tudo configurado e funcionando conforme o esperado, execute o fazer migrações e migrar comandos. Por fim, execute o aplicativo:

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

Para acessar os endpoints da API, navegue até http://127.0.0.1:8000/api/.

Resultado esperado:

Navegue até o host local para interagir com a carteira.

Resultado esperado:

A carteira mostra o saldo e oferece a opção de depositar ou sacar.

Compreendendo os modelos Django e seu papel no consumo de API

Apesar de serem excelentes para apresentar conteúdo estático, os templates do Django possuem certas restrições ao usar APIs:

• Flexibilidade limitada: Os modelos do Django são menos flexíveis que aqueles criados usando Jinja2 ou Twig, pois são usados ​​para exibir estruturas especificadas. Por exemplo, você teria que analisar manualmente o JSON e inserir os dados no modelo se precisasse consumir uma API que retornasse dados JSON. Isto pode ser um desafio, principalmente se a API fornecer estruturas de dados complexas.
• Sem suporte para solicitações assíncronas: Os modelos do Django não possuem nativamente a capacidade de lidar com solicitações assíncronas. Os modelos ainda precisam de processamento síncrono, embora as estruturas da web contemporâneas async/await, como Flask e Django, suportem sintaxe. Isso significa que você teria que esperar que todas as solicitações terminassem antes de produzir o modelo se precisasse adquirir dados de diversas fontes antes de renderizar uma página.
• Tratamento de erros limitado: erros podem ocorrer regularmente ao usar APIs. Não há mecanismos integrados para tratamento elegante de erros nos modelos do Django. Você precisaria capturar a exceção e gerenciá-la dentro do próprio modelo se uma chamada de API falhar, o que poderia resultar em um código desajeitado e difícil de manter.

Crie aplicativos escalonáveis

Ao fornecer uma maneira de separar a camada de apresentação da lógica de negócios, os modelos do Django permitem que os desenvolvedores se concentrem na criação de código reutilizável e de fácil manutenção. No entanto, devido às suas limitações, os modelos Django podem não ser a melhor escolha ao consumir APIs em escala. Estruturas de cliente como React ainda são úteis na construção de aplicativos escalonáveis.