GUIA INTERMEDIÁRIO de Aplicação de API com Django Rest Framework
"Simplifique o desenvolvimento de APIs no Django Rest Framework com um CRUD genérico, aprenda a personalizar ViewSets, lidar com relações e implementar paginação - tudo de forma clean e eficiente!"
Para realizar esse passo a passo, é importante ter realizado o método básico antes... Se ainda não fez, clique aqui
Criando CRUD genérico com Django Rest Framework:
A melhoria de inserção de códigos é feita para evitar a repetição da estrutura no momento de adicionar as funções CRUD.
Para substituir todas as funções criadas no views.py utiliza-se:
from rest_framework import generics
from .models import Curso, Avaliacao
from .serializers import CursoSerializer, AvaliacaoSerializer
class CursosAPIView(generics.ListCreateAPIView):
queryset = Curso.objects.all()
serializer_class = CursoSerializer
class CursoAPIView(generics.RetrieveUpdateDestroyAPIView):
queryset = Curso.objects.all()
serializer_class = CursoSerializer
Assim como no Django avançado existe o Class Based View o Django Rest também conta com melhorias de otimização de código.
OBS: Repita o mesmo esquema para Avaliação
O ListCreate indicado em genérico indica que é possível listar e criar os métodos, ou seja, as funções GET e POST já estão ativas.
No queryset todos os objetos estão sendo passados, através do objects.all() e o serializer_class informa qual a classe vai sofrer serialização.
Agora além de manter o módulo raw de registro, também possui o formulário (HTML Form).
Atualizando e Deletando os dados da API
A única mudança na estrutura do código é a adição de RetrieveUpdateDestroyAPIView essa indicação na construção da classe ativa os elementos de CRUD de Update e Delete dos dados de uma API.
class CursoAPIView(generics.RetrieveUpdateDestroyAPIView):
queryset = Curso.objects.all()
serializer_class = CursoSerializer
OBS. O nome das classes de criação e de deleção precisa ser diferente também (sugestão: usar um no plural).
Dessa forma, o arquivo de rotas (urls.py) também precisa ser atualizado.
urlpatterns = [
path('cursos/', CursosAPIView.as_view(), name='cursos'),
path('cursos/<int:pk>/', CursoAPIView.as_view(), name='curso'),
path('cursos/<int:curso_pk>/avaliacoes/', AvaliacoesAPIView.as_view(), name='curso_avaliacoes'),
path('cursos/<int:curso_pk>/avaliacoes/<int:avaliacao_pk>/', AvaliacaoAPIView.as_view(), name='curso_avaliacao'),
]
Na rota do elemento CRUD de deleção é adicionado o primary key, que é uma ID, através de <int:pk>.
Sobrescrevendo os métodos genéricos
Trata-se de formas de sobrescrever os métodos para mudar o comportamento das funções da API.
O objetivo é criar uma rota para associar duas APIs que são complementares… Ou seja, o curso e suas respectivas avaliações.
urlpatterns = [
path('cursos/', CursosAPIView.as_view(), name='cursos'),
path('cursos/<int:pk>/', CursoAPIView.as_view(), name='curso'),
path('cursos/<int:curso_pk>/avaliacoes/', AvaliacoesAPIView.as_view(), name='curso_avaliacoes'),
path('cursos/<int:curso_pk>/avaliacoes/<int:avaliacao_pk>/', AvaliacaoAPIView.as_view(), name='curso_avaliacao'),
path('avaliacoes/', AvaliacoesAPIView.as_view(), name='avaliacoes'),
path('avaliacoes/<int:avaliacao_pk>/', AvaliacaoAPIView.as_view(), name='avaliacao')
]
O elemento <int:curso_pk> indica que a ID extraída é do curso. Assim como, o elemento <int:avaliacao_pk> indica que a ID extraída é da avaliação.
Dessa forma a url gerada vai numerar a ID do curso seguida da ID da avaliação.
EX. api/v1/cursos/3/2 Isso significa que estamos observando a 2º avaliação do curso de ID 3.
Com as rotas alteradas o arquivo views.py também precisa sofrer alterações:
class AvaliacoesAPIView(generics.ListCreateAPIView):
queryset = Avaliacao.objects.all()
serializer_class = AvaliacaoSerializer
def get_queryset(self):
if self.kwargs.get('curso_pk'):
return self.queryset.filter(curso_id=self.kwargs.get('curso_pk'))
return self.queryset.all()
O self.kwargs.get vai pegar os valores das pk (urls.py), e se tiver esse valor, retorna o queryset das avaliações filtradas para aquele curso. Caso não tenha, retorna todas as avaliações.
Cursos representa uma coleção, mas a avaliação é individual. Portanto, a função para sobrescrever tem que ser o get_object() para tratar do objeto (avaliação) de forma individual.
class AvaliacaoAPIView(generics.RetrieveUpdateDestroyAPIView):
queryset = Avaliacao.objects.all()
serializer_class = AvaliacaoSerializer
def get_object(self):
if self.kwargs.get('curso_pk'):
return get_object_or_404(self.get_queryset(), curso_id=self.kwargs.get('curso_pk'), pk=self.kwargs.get('avaliacao_pk'))
return get_object_or_404(self.get_queryset(), pk=self.kwargs.get('avaliacao_pk'))
No tratamento do objeto individual a função get_object_or_404 vai buscar o objeto através do (‘curso_pk’) se positivo vai buscar as ID das avaliações. Ou automaticamente vai exibir o erro de 404 error caso não encontre ou haja erro de solicitação de dados.
Utilizando ViewSets e Routers:
O objetivo dos ViewSets e Router é diminuir a poluição visual dos endpoints, assim como facilitar na construção da estrutura da API.
É muito utilizado nas melhorias e no versionamento das API, ou seja, manter a antiga funcionando e criar uma atualizada contendo melhorias que não estão presentes na versão anterior.
OBS. Por isso a importância de indicar a versão (v1) na url de acesso da API.
O ViewSets e Routers é uma melhoria que serve para automatizar a criação de endpoints nas API’s.
O ViewSet consiste em agrupar toda a lógica de um determinado recurso em apenas uma classe,
Contextualizando:
from rest_framework import viewsets no arquivo views.py
class CursoViewSet(viewsets.ModelViewSet):
queryset = Curso.objects.all()
serializer_class = CursoSerializer
class AvaliacaoViewSet(viewsets.ModelViewSet):
queryset = Avaliacao.objects.all()
serializer_class = AvaliacaoSerializer
Essa estrutura de dados faz a mesma coisa que aquela sequencia de dados separadas de curso e avaliação construídas no CRUD anteriormente.
No arquivo url.py da aplicação cursos:
from rest_framework.routers import SimpleRouter
from django.urls import path
from rest_framework.routers import SimpleRouter
from .views import (
CursoAPIView,
CursosAPIView,
AvaliacaoAPIView,
AvaliacoesAPIView,
CursoViewSet,
AvaliacaoViewSet)
router = SimpleRouter()
router.register('cursos', CursoViewSet)
router.register('avaliacoes', AvaliacaoViewSet)
Note que a todo momento você está modificando o arquivo urls.py da sua aplicação... Agora...
No arquivo urls.py do projeto:
from django.contrib import admin
from django.urls import path, include
from cursos.urls import router
urlpatterns = [
path('api/v1/', include('cursos.urls')),
path('api/v2/', include(router.urls)),
path('admin/', admin.site.urls),
path('auth/', include('rest_framework.urls')),
]
Ou seja, não há necessidade de construção manual das rotas. O router cria essas rotas de forma automatizada.
OBS: Entretanto usando esse método a rota conjunta não irá funcionar. Porque o SimpleRouter só gera o CRUD para um único model.
Até esse ponto você já utilizou 3 métodos de aplicação de API com Django... O Básico, o CRUD e o Simple Router :)
Até breve!
