0

CRUD DJango

#Django #Python
Lucas Lima
Lucas Lima

Olá, eu me chamo Lucas, desenvolvedor fullstack júnior e eu vou ensinar uma forma de criar um CRUD em DRF (Django Rest Framework).

Eu vou tentar deixar o mais simples possível, mas caso não entenda algo, eu recomendo fortemente ler a documentação tanto do rest framework tanto do próprio Django.

Para começar, crie seu ambiente virtual com os seguintes comandos:

virtualenv venv --python=/usr/bin/python3.8
source venv/bin/activate
pip install django djangorestframework

Após criar seu ambiente virtual, você vera no terminal que ele ficara assim:

Isso significa que você já está no ambiente virtual e já tá instalada a dependencia do django rest framework.

Agora vamos criar o projeto em si, para você criar o que será a pasta "raiz" do seu projeto Django você roda o seguinte comando:

django-admin startproject NOME-DO-SEU-PROJETO (você pode por o . após o fim do nome do seu projeto para não criar uma outra pasta)

Com isso, você terá criado a pasta raiz do seu projeto django, agora vamos criar o que vai ser nosso pequeno "microserviço" que no caso, será nosso app.

django-admin startapp NOME-DO-SEU-APP

A estrutura devera ficar assim:

Estrutura do projeto:


Na pasta raiz do seu projeto temos algumas pastas muito importantes.

A pasta "settings"é um pouco intuitiva, nesse arquivo terá todas as configurações do seu projeto, ela que fará boa parte da "mágica".

A pasta "urls" é aonde ficara todas as rotas principais de sua aplicação, no caso, cada app terá suas próprias rotas, mas nessa pasta raiz você vai precisar conectar as rotas de cada app nela para poder funcionar seu app.

As outras partes são partes da configuração do framework, caso queira se aprofundar mais nelas o recomendado é ler a documentação.

Beleza, continuando as explicações das pastas, vamos para a pasta "Lib" que é o nome do meu app, nela já tem mais pastas que na aplicação raiz, pois nela que faremos toda a lógica, nós podemos trabalhar com template no django, mas sinceramente, é muito melhor você consumir um front-end a parte e fazer o django apenas como back-end, sem enrolação, vamos lá!

A primeira pasta que cria é a "Migrations" que é uma forma de versionar o schemas de sua aplicação, quando você cria ela vai vir vazia, mas nela que vai ficar as "versões" de sua base de dados, é um conceito um pouco complexo, mas ele vai ser responsável por subir suas alterações para o banco ,mas isso vamos ver mais para frente.

O segundo arquivo importante é o "admin.py" ele serve para você utilizar o administrador do django, no momento, ainda vai estar vazio, mas quando criarmos a model, vamos usar ele para subir as coisas para o administrador do Django para podermos manipular usando uma interface gráfica que o próprio Django dispõe.

O terceiro arquivo importante é o "models.py", nele é onde vamos por o ORM(Mapeamento Objeto-Relacional) do Django, é basicamente aonde vamos modelar nosso banco de dados, as informações que vamos utilizar em toda a API, é muito importante, a modelagem de seu banco de dados é o que vai definir sua aplicação e se você der um esmero maior para essa parte, você não vai ficar enfrentando bugs (só de pensar eu tenho dor de cabeça).

Se você leu até aqui deve estar se perguntando "Ué, cade o urls que você tinha dito no começo?" Por padrão, o projeto django não vem com o urls, então vamos ter que criar na "unha".

Na pasta do seu app, botão direito, primeira opção para criar um novo arquivo e vamos chamar ele de : "urls.py", sim, ela vai ser um arquivo vazio, mas vamos como jackestripador ,por partes.

Então, o arquivo de urls.py vai receber a rota de sua aplicação, é nela que vamos criar a rota de get, post, put e delete.

O último arquivo que também vamos precisar criar é o "serialializers.py" Serializer, ele transforma as informações que vem do queryset e de instâncias de classe em informações web como JSON e XML. O DRF deixa disponível 3 tipos de serializers que são os serializers;

BaseSerializer : É usado para classes de serializers mais genéricos.

ModelSerializer: Cria serializers baseado em modelos.

HyperLinkedModelSerializer: Também cria serializers baseado em modelos, mas ao invés de retornar um ID, retorna um link.(Eu nunca utilizei isso, eu realmente não sei como aplicar esse em específico)

O Serializer também serve para deserializar, no caso, fazer o processo inverso, transformar json e xml em informações de queryset e de instâncias de classe.

-----------------------------------------------------

Depois de explicar tudo isso, vamos codar?!

Beleza, a primeira parte, como eu falei antes, é adicionar dentro da minha pasta raiz, vamos no arquivo: "urls" a rota da minha aplicação, no caso, apontar para o Django que existe a minha aplicação.

Por padrão, o django não importa o include, então você precisa importar também o include.

Depois você coloca uma vírgula no fim do primeiro path, adiciona path('nome da rota'), eu deixei vazio para a rota principal apontar para minha rota da livraria. Mas só isso não será necessário para dizer ao django que existe meu projeto, precisamos importa-los no meu settings.

Lá em "settings.py" da nossa aplicação raiz, adicionaremos uma vírgula, entre aspas simples colocaremos o nome da pasta do nosso app(o que foi criado depois da pasta raiz) No meu caso, é Lib, e abaixo dele vamos adicionar o rest_framework.

---------------------------------------

Agora ta coisa linda, ta coisa maravilhosa, vamos mexer no nosso app, a gente precisa mexer na pasta urls se não vai dar problema e você não vai conseguir utilizar o runserver.

Dentro da pasta urls do seu app, deixe assim:

------------------------------

Pronto, você pode tentar rodar o comando python3 manage.py runserver e ver ele rodar no seu localhost:8000. Mas ainda estamos só começando.

Quando eu faço uma API, eu costumo começar pela model dela, eu quero ter uma ideia de como vou fazer o resto das cosias, então vamos lá fazer o model da minha "livraria".

------------------------

Essa vai ser a minha modelagem, você precisa definir uma classe com o nome da sua model, por parâmetro ele vai receber models.Model, que é um paramêtro que vai fazer essa classe se comportar como um banco de dados.

Mas o que ta acontecendo ai?

Eu to criando um campo chamado título que vai ser um campo de de CharField (Que são campos para receber apenas uma linha de texto), com o tamanho de 100 caracteres.

Um campo publicadora com a mesma regra

Um campo resumo recebendo TextField, que no caso, é um campo de texto, não apenas uma linha, com o tamanho máximo de 255 linhas.

Um campo author com a mesma regra de charfield.

-----------------------------

Com nossa model pronta, ta na hora de subir isso para o banco.

Você deve estar se perguntando: "eu não vi você configurar banco nenhum, como você vai subir para um banco? Docker?" Não, o django ele roda um sqlite no admin, então a gente vai subir para ele, você pode ver a configuração de ambiente de banco lá no settings, é possível altera-lo, mas não tem necessidade para esse projeto aqui.

------------------------

O primeiro comando para a gente criar a migrations é: python3 manage.py makemigrations:

----

E agora, para subir vamos rodar o python3 manage.py migrate:

~Nerd fact~

Se você for agora na sua paste de migrations e for no arquivo "0001_initial.py" você vai ver mais ou menos como é sua model na íntegra, como é o ORM dela, enfim, vamos trabaia que falta um pouco ainda

--------------

Vamos agora mexer no serializers:

Sim, esse código super complexo é nossa serialização. Você precisa se atentar as importações, eu no caso, da minhas pasta "Lib"eu to importando as models, importando especificamente a model Lib, e uma lib do rest_framework que é a serializers, ela que vai servir para fazer a serialização.

Eu defino uma classe "LibSerializer" que vai receber por parâmetro (serializers.ModelSerializer) que funciona da mesma forma do model.models, ele vai ser responsável por transformas as linhas de código em serializer, é OBRIGATÓRIO ter a classe Meta, dentro dessa sub-classe você vai ter a model que você vai quererer serializar e os campos.

-----

Poxa Lucas, isso ai ta muito abstrato, eu não to conseguindo ver isso ainda, por mais que pá, esteja ai e tals, como eu posso ver isso? Eu tenho como saber se ta funcionando?

Sim! Tem, no caso, vamos primeiro criar o superuser.

Abra seu terminal e rode um python3 manage.py createsuperuser

Se você deixar em branco, ele usa o nome que ta no seu PC.

Defina um nome, depois aperte enter para pular o campo do email (não é obrigatório)

Depois defina um senha, aperte enter e escreva ela novamente, pronto, você criou o usuario administrador

-----

Vamos agora trazer essas informações para o admin, cuidado, é muito complexo e exige atenção.

Dentro do arquivo admin ponha o seguinte o código:

Sim, só isso, você vai importar TODAS suas models e vai fazer assim, só seguir o import de "from NOME DO SEU APP import models"

Enfim, vamos finalmente ver o admin do django.

--------------------

No seu terminal, rode os comandos:

python3 manage.py runserver

Caso tenha dado certo, vai ficar assim:

Beleza, com nosso localhost online, vamos usar ele, no seu navegador digite:

localhost:8000/admin

Agora, logue com seu superuser


Após estar logado, vai estar assim:

Se não ficou muito claro como usar o admin, exclui la no seu arquivo o "admin.site.register"e da um f5, vai ter sumido a sua futura api.

Mas calma, vamos terminar essa API.

------------

View:

Vamos mexer no que seria o controller, eu vou evitar usar o based view, o based view é a forma mais SIMPLES de fazer uma API porque vem tudo completo, mas eu vou fazer utilizando o API_VIEW porque é a forma mais descritiva e menos abstrata possível de você fazer um crud.

------------------

Antes de tudo, os imports, você vai precisar fazer os imports na sua view, eu vou usar todos esses:

O primeiro import vem por padrão.

O segundo import é sua model

O terceiro é sua serializer.

Do quarto em diante são propriedades do rest_framework

----------

GET:

A requisição de GET, é para pegas as informações da API, no caso, ela vai trazer as informações.

Eu defino que essa variável lib vai receber tudo que vem da minha model. Depois eu defino que a variável serializer vai receber tudo que vem serializado, podendo trazer muitas informações.

Depois eu retorno um Response com os dados serializados.

------------------------

POST:

O POST é enviar uma informação, mesmo que possamos fazer isso pelo próprio admin do Django, é bom termos uma rota para consumir ela no front-end, mas vamos lá

A diferença é que aqui vamos direto no serializer, já que vamos salvar a informação já serializada, não precisamos dar um get nos objetos da model, caso o serializer seja valido, ele salva a informação e retorna o serializando as informações, caso não seja vai tomar um código 400 de bad_request.

--------------------

PUT:

A rota delete e put são muito parecidos, o PUT você também insere informações, mas você precisa que a informação seja igual ao ID, então, a gente não vai pegar todos os objetos, apenas os objetos aonde o id for igual a uma primary key, é uma forma de filtrar, de resto se repete da rota de post.

-------------

Delete:

É a mesma lógica do PUT, porém aqui você vai deletar uma informação, essa questão de ID vai ficar mais claro na parte das rotas que será a seguinte.

---------------------------------------

ROTAS:

Bom, cada rota vai ser referente a uma ação, eu deixei bem explicito o que cada uma é, você vai precisar definir a rota, depois chamar de qual view é aquela rota, eu declaro que a rota getLivraria vai receber a view LibList. Essa rota vai ser a da sua api, no caso vai ser "Localhost:8000/ROTA-DEFINIDA-NA-RAIZ/ROTA-DA-APLICAÇÃO"

No meu caso: localhost:8000/livraria/rotas-da-aplicação.

É importante lembrar, nas rotas de put e delete é preciso passar o PK que é vai ser o ID que vai permitir editar e deletar.

-----------

AOS TESTES!!!!!!!!!!!!!

Lembre, ligue o servidor : python3 manage.py runserver

Vamos testar a rota de GET:

Eu estou utilizando o insomnia para testar a API.

Vocês estão vendo que está retornando um objeto vazio? É Porque não temos informações registradas ainda, vamos adicionar via rota post.

Você pode adicionar pelo Django admin caso queira ser mais rápido.

---------

POST:


Se você foi curioso e tentou dar um post, você vai retornar um erro, você não tem como dar post em nada, então, passe os parâmetros como um json e envie o post.

Quando conseguir ficara como abaixo: