GUIA BÁSICO de Aplicação de API com Django Rest Framework

O Django REST Framework utiliza toda a facilidade do framework web Django juntamente com todo o poder da linguagem Python fazendo disso uma combinação perfeita para criação de APIs modernas. 

API’s REST

Muitas APIs encontradas na internet utilizam do conceito de REST (Representational State Transfer), ou Transferência Representacional de Estado. Trata-se da criação de uma interface de comunicação utilizando puramente HTTP.

OBS: Antes de criar a API é necessário criar a Aplicação padrão Django

Sem mais delongas...

< - VAMOS CODAR - >

Instalação e Configuração do Django Rest Framework:

Antes de tudo é necessário a criação de um projeto Django.

pip3 install django==2.2.9 ou 3.2.12

Essa versão foi escolhida por ser LTS, porque é Long Term Support. Ou seja, vai continuar tendo atualizações por mais tempo.

django-admin startproject escola . 
django-admin startapp cursos

Em seguida é importante fazer as configurações necessárias no settings.py

INSTALLED_APPS = [ “cursos”, ] 
LANGUAGE_CODE = “pt-br” 
TIME_ZONE = “America/Sao_Paulo” 
STATIC_ROOT= os.path.join(BASE_DIR, ‘staticfiles’) 
MEDIA_URL = ‘/media/’ 
MEDIA_ROOT = os.path,join(BASE_DIR, ‘media’)

Em seguida a configuração é realizada no arquivo models.py

from django.db import models 

class Base (models.Model): 
criacao = models.DateTimeField (auto_now_add= True) 
atualizacao = models.DateTimeField(auto_now= True) 
ativo = models.BooleanField(default=True_ 

class Meta: 
abstract = True

O class Base determina que quando criado e sempre que for atualizado também irá pegar a data automática do sistema.

As novas funções que carregam da função Base também são criadas dentro de models.py

class Curso(Base): 
titulo = models.Charfield(max_lenght= 200) 
url = models.URLField(unique= True) 

class Meta: 
verbose_name = “Curso” 
verbose_name_plural = “Cursos” 

def __str__(self): 
return self.titulo 


class Avaliacao(Base): 
curso = models.ForeignKey(Curso, related_name='avaliacoes', on_delete=models.CASCADE) 
nome = models.CharField(max_length=255) 
email = models.EmailField() 
comentario = models.TextField(blank=True, default='') 
avaliacao = models.DecimalField(max_digits=2, decimal_places=1) 

class Meta: 
verbose_name = 'Avaliação' 
verbose_name_plural = 'Avaliações' 
unique_together = ['email', 'curso'] 

def _str_(self): 
return f'{self.nome} avaliou o curso {self.curso} com nota = {self.avaliacao}'

O próximo passo é registrar o model criado no admin.py 

from django.contrib import admin 
from .models import Curso, Avaliacao 

@admin.register(Curso) 
class CursoAdmin(admin.ModelAdmin): 
list_display = ('titulo', 'url', 'criacao', 'atualizacao', 'ativo') 

@admin.register(Avaliacao) 
class AvaliacaoAdmin(admin.ModelAdmin): 
list_display = ('curso', 'nome', 'email', 'avaliacao', 'criacao', 'avaliacao', 'ativo')

Depois dos models registrados no admin. Por via do terminal, executar as migrations:

python3 manage.py makemigrations 
python3 manage.py migrate 

Para a manipulação dos dados, criar um super usuário.

python3 manage.py createsuperuser 

Para testar as funcionalidades, executar o servidor.

python3 manage.py runserver 

Realizar o cadastro de alguns personagens para tratar os dados na API

Após o cadastro a aplicação Django está pronta...

AGORA IREMOS FINALMENTE PARA A CRIAÇÃO DA API

Criando a API com Django Rest Framework

pip3 install djangorestframework markdown django-filter

O markdown é utilizado para fazer páginas de documentação.

O django-filter é utilizado para facilitar a utilização de filtros nos projetos.

pip3 freeze > requirements.txt 

Vai criar um documento txt mapeando todas as bibliotecas utilizadas no projeto. 

No settings.py

INSTALLED_APPS = 
[ “cursos”, 
  “django_filters”, 
  “rest_framework” 
]

Ainda no mesmo arquivo - No final aplicar:

# DRF 
REST_FRAMEWORK = 
{ ‘DEFAULT_AUTHENTICATION_CLASSES’: ( 
    ‘rest_framework.authentication.SessionAuthentication’, 
  ) 

  ‘DEFAULT_PERMISSION_CLASSES’: ( 
    ‘rest_framwork.permissions.IsAuthenticatedOrReadOnly’, 
  ) 
}

Isso significa que se o cliente logou na API, ele pode fazer todas a manutenções (criar, deletar, update ou consultar dados). Caso ele não esteja autenticado (anônimo) ele pode fazer apenas a leitura dos dados.

No arquivo url.py

from django.urls import path, include 

urlpatterns = [ 
  path(‘admin/’, admin.site.urls), 
  path(‘auth/’, include(‘rest_framework.urls’)), 
]

Para iniciar o servidor:

python3 manage.py runserver 

Na pagina Web:

.../auth/login 

Após realizar o login vai cair na página /account/profile/ que é o redirect padrão do django. 

Usando o Model Serializers

É um recurso do DRF capaz de transformar os models em estruturas JSON e também o contrario. Ou seja, ele faz a transformação de objetos python. Isso se dá porque o JSON é o formato ideal para troca de dados entre APIs na internet.

Criar um novo arquivo python denominado serializers.py

from rest_framework import serializers 
from .models import Curso, Avaliacao 

class AvaliacaoSerializer(serializers.ModelSerializer): 
  class Meta: 
      extra_kwargs = { 
            'email': {'write_only': True} 
      } 
      model = Avaliacaofields = ( 
            'id', 
            'curso', 
            'nome', 
            'email', 
            'comentario', 
            'avaliacao', 
            'criacao', 
            'ativo' 
      )

A classe é criada com um nomeSerializer que herda serializers.modelSerializer.

Onde são feitas as configurações do model. Que recebe o nome do model importado.

Nesse caso é Avaliacao.

Dentro dos campo fields são indicados tudo que é necessário apresentar, puxando o atributo do model indicado.

extra_kargs = { 
  'email': {'write_only': True} 
}

OBS: Esse parâmetro extra adicionado impede que os e-mails sejam coletados para envios de spam. São feitos visando a privacidade do usuário da API.

O WriteOnly significa que o e-mail será exigido apenas quando for feito o cadastro, ou seja, na hora de consultar o e-mail ficará oculto.

Criando APIViews para o método HTTP GET

A criação do serializer.py foi de fato o 1° passo para a construção da API.

No arquivo views.py

from rest.framework.views import APIView
from rest.framework.response import Response

Class CursoAPIView(APIView):
  def get(self, request):
      cursos = Cursos.objects.all()
      serializer = CursoSerializer(cursos, many = True)
      return Response(serializer.data)

Class AvaliacaAPIView(APIView):
  def get(self, request):
      avaliacoes = Avaliacao.objects.all()
      serializer = AvaliacaoSerializer(avaliacoes, many = True)
      return Response(serializer.data)

Após a criação das views, é necessária a criação das rotas.

Seu projeto possui 2 pastas pilotos: Cursos e Escola

Criar um arquivo urls.py na aplicação(pasta) cursos

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
  path('api/v1/', include(('cursos.urls')),
  path('admin/', admin.site.urls),
  path('auth/', include('rest_framework.urls')),
]

É importante indicar a versão da api (v1) para facilitar nas atualizações e melhorias da API e para mapear quais clientes ainda não atualizaram para a versão nova.

Após esse processo sua API com método GET já está criada e ficou assim:

Curioso com o método POST?

Está aqui:

from rest_framework import status

from .models import Curso, Avaliacao
from .serializers import CursoSerializer, AvaliacaoSerializer

Class CursoAPIView(APIView):
   def get(self, request):
      cursos = Curso.objects.all()
      serializer = CursoSerializer(cursos, many=True)
      return Response(serializer.data)

   def post(self, request):
      serializer = CursoSerializer(data= request.data)
      serializer.is_valid(raise_exception= True)
      serializer.save()
      return Response(serializer.data, tatus=status.HTTP_201_CREATED)   

O método Post também recebe um request. Que irá criar os dados, serializar para criar um novo recurso. Irá verificar se os dados são válidos e salvar os dados. E preparar uma resposta enviando os dados salvos e uma resposta HTTP.

Finalizamos aqui o método básico de criação de API com Python e Django.

OBS. Existe uma forma mais simples de criar a API sem utilizar o tempo inteiro a função def para separar, o CRUD.

Mas isso é feito com a parte de Django RESTful Framework intermediário. =)