Category: django

Noções Basicas de Models no Django e Como Usá-los Para Interagir Com o Banco de Dados.

Django models são simplemente a definição e representação de dados em uma aplicação Django.

Com isso, caso você queira trabalhar e implementar interações com algum banco de dados e essencial que você entenda como trabalhar com essa ferramenta no qual ira te ajudar muito no seu desenvolvimento.

Vamos lá! Irei explicar sobre os models do django de uma forma simplificada, no qual esperofacilitar o seu entendimento.

Ok, mas o que são django models de uma forma mais técnica?

Bem, se você ja tem uma noção do que é um banco de dados relacional. Onde existem tabelas especificas que se pode se inserir dados, ficará muito facil te explicar.

No caso, os models do Django são usados para criar e representar tabelas de um banco de dados como objetos em Python.

Em outras palavras, você poderá criar um model no Django (que representa uma tabela) herdando uma classe do Django chamada Model.

Como cada tabela de um banco de dados tem tipos de campos diferentes, você também poderá aplicar essa tipificação aos campos da mesma maneira, porém utilizando o Django.

Exemplo de uma tabela simples no SQL:

id	titulo	descricao
1	Como fazer molho de tomate caseiro	Nessa postagem iremos falar sobre um dos…
2	10 maneiras de criar massas de pizza caseira	Voce ira aprender quais são as dez maneira…
3	Quais os melhores sistemas de restaurante	Trabalhando a 15 anos como gestor de resta..

Tabela: Postagens

Agora, como uma tabela seria representada em uma aplicação Django?

from django.db import models # <-- Herdando toda a lógica pronta do Django

class Postagen(models.Model):
    titulo = models.CharField(max_length=120)
    descricao = models.TextField()
    
    def __str__(self):
      return self.titulo

Python

Como podemos notar, temos uma tabela (vamos dizer que é uma tabela em um banco de dados 😄) chamada Postagens. Logo abaixo, temos um model no Django que representa essa tabela com o mesmo número de colunas: título e descrição.

Ah, só para lembrar que, no Django, não é necessário adicionar o campo ID. Ele é adicionado por padrão nos modelos do Django. 😉

Dessa forma, com uma explicação um pouco mais técnica que a introdução, você já consegue entender melhor qual é o propósito inicial de um model no Django.

Campos Comuns Usados em Modelo do Django

Como existem vários tipos de dados para colunas em um banco de dados, como strings, caracteres, booleanos, numéricos (inteiros, flutuantes e especiais), etc., no próprio model do Django você terá a possibilidade de criar diferentes colunas com diferentes tipos de dados.

No exemplo acima, vemos duas colunas: título e descrição. Essas duas colunas têm tipos de dados praticamente iguais: CharField() e TextField().

O CharField traz a capacidade de criar textos com um número limitado de caracteres (no exemplo acima, com 120 caracteres) e será traduzido como VARCHAR no banco de dados.

Já o TextField é basicamente a representação de uma string, sem limitação de caracteres, e será traduzido como TEXT no banco de dados.

Além dessas existe uma gama de campos usados em models no Django.

Porém as mais comuns são os campos:

Para textos temos os CharField (cujo e obrigatorio usar o parametro max_length) e o TextField.
Tipo numéricos temos o IntegerField (que armazena numeros inteiros), FloatField e o DecimalField que tambem adiciona numeros flutuantes porem com casas decimais definidas como a adição de casas decimais com o parametro decimal_places, e o numero total de digitos com o parametro max_digits.
Também temos campos que representam data e hora. Com os campos, DateField que apenas armazena (ano, mes e dia). O TimeField que apenas armazena horas e o DateTimeField que armazen data e horas.
Alem disso também temos campos do tipo booleanos como o BooleanField no qual e usado para adicionar valores como True ou False.
E por fim, temos os campos de relacionamentos: ForeignKey onde se cria um relacionamento de “muitos para um” onde se é necessario adicionar para qual tabela ou modelo esta sendo relacionado e o parametro on_delete no qual será setado o que acontecerá ao deletar a row com o relacionamento. O campo de relacionamento OneToOneField no qual cria um relacionamento de “um para um” entre duas tabelas. E por fim o campo de relacionamento ManyToManyField que criar relacionamentos de “mutos para muitos” entre duas tabelas.

Os campos citados acima são apenas os mais comuns usados para a criação de um model no django. Existem varios outros no qual voce pode pesquisar para uso mais especificos e tambem pode ate criar um campo especifico para seu uso especifico, porem eu não irei entrar em muitos detalhes nesta postagem.

Conectando com bancos de dados em uma aplicação django

Antes de iniciar qualquer explicação aqui sobre a criação de objetos usando a ORM do django através dos models, ficaria sem sentido fazer isso sem a explicação da conexão de uma aplicação django com um banco de dados. Com isso explicarei brevemente como uma conexão do django e feita com o banco de dados:

Por padrão o django tem um arquivo de configuração chamado settings.py onde vários arquivos de conexão e configurações estão alocadas, e uma delas é a conexão com o banco de dados.

# settings.py

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.sqlite3",
        "NAME": "mydatabase",
    }
}

Python

No código acima podemos ver qual é a constante que representa a conexão com o banco de dados chamada DATABASES. Neste exemplo é representado com uma configuração padrão de uma aplicação inicial do Django.

Por outro lado, também podemos usar esta mesma constante para se conectar com diferente bancos de dados:

# settings.py

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "NAME": "mydatabase",
        "USER": "mydatabaseuser",
        "PASSWORD": "mypassword",
        "HOST": "127.0.0.1",
        "PORT": "5432",
    }
}

Python

Com o exemplo acima criando a conexão com um banco de dados “ENGINE” postgresql e suas variaveis necessarias para conexão.

Migrando as Tabelas

Quando você define os models (modelos de dados) no Django, eles ainda não existem no banco de dados. Para criar as tabelas no banco, você usa o comando python manage.py migrate. O Django então traduz os models em tabelas SQL e as cria no banco de dados.

Realizando a Conexão

Quando você executa o Django (comandos como runserver ou migrate), o Django usa essas informações para se conectar ao banco de dados. Ele cria uma conexão automática por meio de sua camada de abstração de banco de dados, chamada ORM (Object-Relational Mapping). Com o ORM, o Django traduz o código Python em consultas SQL para interagir com o banco de dados.

Interagindo com o Banco de Dados

Com a conexão estabelecida, o Django permite que você faça operações como criar, ler, atualizar e deletar registros no banco de dados usando código Python. Basicamente, Você não precisa escrever consultas SQL manualmente, o Django faz isso por você com seu ORM.

Passo-a-passo de iteração com banco de dados usando django models e ORM

Vamos supor que iremos criar uma aplicação django onde iremos adicionar postagens (da mesma maneira que fizemos no topo desta postagem). Porém iremos usar esta tabela para iteragir com o banco de dados.

# models.py
from django.db import models
from django.contrib.auth.models import User

class Postagem(models.Model):
    titulo = models.CharField(max_length=120)
    descricao = models.TextField()
    data_criacao = models.DateField(auto_now_add=True)
    autor = models.ForeignKey(User, on_delete=models.DO_NOTHING)
    
    def __str__(self):
        return self.titulo

Python

Ao criar esta tabela devemos rodar o comando:

python manage.py makemigrations # cria um arquivo de migrations
python manage.py migrate # reflete o model no banco de dados

Bash

Ao ativar os dois comandos acima, por padrão, será criado um banco de dados sqlite3 no django (em caso você não fazer conexão com outro banco de dados). É refletida todas as migrations padrão do django e a desse modelo para o banco de dados.

Interagindo Com o Banco de Dados Usando ORM do Django

Agora que temos toda configuração feita podemos testar nosso modelo de postagens em usuarios usando o ORM do django.

No terminal adicione o seguinte comando:

python manage.py shell

Bash

Com isso voce terá acesso ao shell da aplicação django que voce esta trabalhando. Então se tudo correu bem você terá acesso ao shell da aplicação como a seguir:

(venv) C:\software_projects\projeto_de_configuração> python manage.py shell
Python 3.10.11 (...) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> # seu codigo ira ser adicionado aqui

Bash

Agora vamos iniciar a criação dos dados usando os models que criamos e a ORM do django.

>>> # imports
>>> from postagens.models import Postagem       
>>> from django.contrib.auth.models import User
>>> 
>>> # criação de usuario --
>>> user = User.objects.create(username="Elias", password="Aprendendo123")
>>> 
>>> # testando se usuario foi criado
>>> user
<User: Elias>
>>>
>>> # criacao de postagem --
>>> postagem = Postagem.objects.create(
... titulo="Noções Basicas de Models no Django..",
... descricao="Models é simplemente a definição e representação de dados em...",
... autor=user
... )
>>> # checagem se a postagem foi criada
>>> postagem
<Postagem: Noções Basicas de Models no Django..>
>>>
>>> # checagem de campos.     
>>> postagem.autor
<User: Elias>
>>> postagem.data_criacao
datetime.date(2024, 9, 27)
>>>

Python

Como vemos acima, usamos um sub-framework do Django ORM para interagir com o banco de dados. Explicando o que foi feito: assim que entrei no shell com o comando python manage.py shell, fiz o import dos models que irei usar, o model Postagem e o User (que é padrão do Django).

Em seguida, foi usado o comando para criar um único usuário com apenas username e password. Só para lembrar que foi criado o usuário porque seria necessário para a criação de uma postagem.

Sem um usuário, não seria possível criar uma postagem. Dessa forma, a postagem foi criada, associando o usuário criado anteriormente ao campo autor.

Por último, foi verificado se a postagem havia sido criada corretamente, também checando os campos como postagem.autor e postagem.data_criacao.

Checando Os Dados Diretamente No Banco de Dados

Caso você esteja usando o VSCode, poderá instalar uma extensão chamada SQLite Viewer.

Com essa extensão você poderá acessar o banco de dados de teste sqlite clicando no icone do sqlite para acessar os dados que foram criados usando os comandos do shell.

Como voce vê acima, para visualizar as tabelas criadas você poderá seguir os passos que foram feitos acima (logo após você instalar o SQLite Viewer).

Então nesse caso, você poderá iniciar clicando no icone do banco db.sqlite3.
Ja na sequência você terá acesso a todas as tabelas que existem no sistema.
Ache a tabela que precisa saber onde estão os dados criados (lembrando que o django segue um padrão de nomeação de tabelas (<app-name>_<model-name>)). Então nesse caso precisa-se clicar em postagens_postagem.
Ao clicar na tabela você terá o acesso aos dados que você criou com os dados como id, titulo, descricao, data_criacao e autor_id.

Conclusão

Nesta postagem poderia ser explicado tudo que sei sobre ORM, como criação de diferente relacionamentos, criação de campos customizaveis ou até mesmo te explicar outros tipos de campos como o JSONField() porém o foco é você entender as noções basicas de models no django.

Nesta postagem eu gostaria apenas de te apresentar como podemos trabalhar com models de uma forma simples e se conectar com o banco, criando alguns objetos, com inserção dos dados no banco de dados.

Caso você precise de uma postagem mais complexa futuramente irei iniciar uma postagem com detalhes a fundo de django ORM, olhando por de baixo do capô do django e entendendo como esse framework funciona por de baixo dos panos.

September 27, 2024

Como instalar o Django e iniciar um novo projeto.
Se você está começando no Django, com certeza deve estar querendo aprender como iniciar um novo projeto. E por que não dizer, qual é a forma correta de iniciar um projeto no Django?

Sendo assim, neste tutorial, vou te explicar de forma simples quais são os passos necessários para configurar um novo projeto Django, do início ao fim.

Se você está começando na programação, não se preocupe. Talvez você se perca aqui ou ali no processo de configuração, mas, repetindo os passos que vou te mostrar, verá que não é tão difícil assim.

Tecnologias necessarias para criar o projeto

Para iniciar a configuração do projeto sera necessario as seguintes tecnologias para você iniciar a configuração do projeto usando django.
1. Ter o python instalado na sua maquina.
2. Ter um IDE como o VSCode ou Pycharm para facilitar a configuração do projeto.
Certifique-se de que o Python esteja instalado na sua máquina. Agora, não é necessário usar especificamente o VSCode ou o PyCharm para configurar o projeto. Esses são os IDEs mais utilizados para essa configuração, mas fique à vontade para usar qualquer IDE de sua preferência.

Iniciando a configuração

Antes de iniciar o projeto, a primeira coisa que eu indicaria você fazer é checar se o python realmente esta instalado na sua maquina.

Com isso, abra o terminal do seu sistema operacional, como o bash do linux ou o powershel do windows e adicione a palavra “python” na mesma:
```
O Windows PowerShell
Copyright (C) Microsoft Corporation. Todos os direitos reservados.

Instale o PowerShell mais recente para obter novos recursos e aprimoramentos! https://aka.ms/PSWindows

PS C:\Users\User> Python
Python 3.10.11 (tags/v3.10.11:7d4cc5a, Apr  5 2023, 00:38:17) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
```
PowerShell
Caso ao adicionar a palavra chave “python” os valores acima aparecer ja podemos iniciar a configuração.

Iniciando o projeto

Ja no seu terminal, use o comando “mkdir” que significa (make a directory) para criar uma nova pasta onde você mais preferir adicionando o nome da pasta onde ficara o projeto django:
```
PS C:\Users\User\desktop\software_projects> mkdir projeto_de_configuração


    Diretório: C:\Users\User\desktop\software_projects


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d-----        26/06/2024     02:08                projeto_de_configuração
```
PowerShell
No caso acima eu coloquei o nome da pasta como “projeto_de_configuração”. Ao criar a pasta, entre na mesma usando o comando “cd <nome_da_pasta_que_voce_colocou>”:
```
PS C:\Users\User\desktop\software_projects> cd projeto_de_configuração
PS C:\Users\User\desktop\software_projects\projeto_de_configuração> 
```
PowerShell
Se você seguiu os passos corretamente, verá que, no terminal, o nome da pasta aparecerá, indicando que você está dentro da pasta correta.

Muito bem! Já que estamos na pasta, podemos abri-la usando o comando code . para abrir o projeto no VSCode (caso você tenha o VSCode instalado, claro).

Se você instalou o VSCode, basta digitar o comando code . no terminal (estando dentro da pasta), e ela será aberta automaticamente no VSCode.

Você pode usar esta postagem para configurar o seu VScode com este comando

Ao abrir o VSCode, você verá o editor completamente vazio (sem os quadrados e números, inicialmente).

Para verificar se você está realmente dentro do projeto, o nome dele aparecerá em diferentes partes do VSCode. Por exemplo, no quadrado número 1, você verá a representação do que está dentro da pasta “projeto_de_configuração”.

No quadrado número 2, será exibido o espaço onde faremos a edição do código selecionado no quadrado número 1. E, finalmente, o quadrado número 3 representa o terminal, que utilizaremos para adicionar os comandos necessários para instalar o Django dentro da pasta que criamos anteriormente.

Criando o ambiente virtual para o projeto

Antes de adicionar os comandos para criar o projeto Django, será necessário criarmos um ambiente virtual.

Você deve estar se perguntando: o que é um ambiente virtual no Python?

Basicamente, um ambiente virtual permite criar um ambiente Python isolado, separado do Python principal instalado na sua máquina.

Por exemplo, ao instalar o Python na sua máquina, ele estará “limpo”, sem nenhuma biblioteca adicional. Com isso, você poderá utilizá-lo para criar outros ambientes sem causar nenhum efeito colateral no sistema ou em outros projetos.

No exemplo acima, eu tento explicar como isso funciona. O circulo vermelho representa o python padrão que voce tem instalado na sua maquina (sem nenhuma instalação).

E logo ao lado, um novo ambiente virtual onde iremos sem medo, instalar o que quizermos pois não ira interferir no ambiente padrão do python que ja esta instalado na sua maquina.

Com isso, va em frente e coloque o comando que estara listado abaixo. Só não se esqueça de ter certeza que voce esta dentro do diretorio (pasta) que voce criou 😉.

Sendo assim, adicione o comando python3 -m venv venv no terminal do VSCode e voce vera uma nova pasta chamada “venv” dentro da pasta do projeto.

Em um exemplo pratico, voce literalmente fez uma copia do python para dentro do seu projeto para poder usa-lo da forma que voce quizer.

Agora, ja que você criou a pasta do ambiente virtual com o comando adicionado acima, e hora de ativa-lo para ter um ambiente virtual ativado no nosso projeto.

Vá em frente e adicione o comando a seguir no terminal para ativar o ambiente virtual:
```
PS C:\Users\User\Desktop\software_projects\projeto_de_configuração> python3 -m venv venv
PS C:\Users\User\Desktop\software_projects\projeto_de_configuração> venv/Scripts/activate
(venv) PS C:\Users\User\Desktop\software_projects\projeto_de_configuração> 
```
PowerShell
Muito bem, o comando para ativar o ambiente virtual no seu diretorio e venv/scripts/activate.

Com isso estamos prontos para instalar o django dentro deste novo ambiente virtual.

Instalando o django no ambiente virtual do projeto

Antes de instalar o Django no nosso ambiente virtual, você precisa entender o que gerencia a instalação de pacotes dentro de um ambiente virtual: o pip.

Pip é a abreviação de “Preferred Installer Program”, que em português significa “programa de instalação preferido”. Ele é usado como um comando de linha para instalar novos pacotes dentro do ambiente Python.

Em resumo, um pacote Python pode ser desde um pequeno pedaço de código reutilizável até um framework completo, como o Django.

Para instalar um programa, este é o comando que você precisará usar:
```
pip install <NOME_DO_PACOTE>
```
PowerShell
Bom, agora que você entendeu como se cria um ambiente virtual isolado, como ativa-lo em um diretorio e sabe qual o comando para se instalar um novo pacote, esse e o momento para instalarmos o django usando o pip.
```
pip install django
```
PowerShell
Em seguida, va em frente e adicione o mesmo comando no seu ambiente virtual e veja o processo de instalação.

Checando a instalação do pacote no nosso ambiente virtual

Ja que seguimos com a instalação do django no nosso ambiente virtual esse e o momento de checagem, e saber se o django foi instalado corretamente.

Com isso, existem inicialmente duas maneiras de se saber se o mesmo foi instalado corretamente.
1. Usando o comando pip list
2. Checando dentro da pasta Lib/ do ambiente virtual
Checando com o comando pip list

Para checar se os pacotes que voce instalou adicione o comando pip list no terminal onde o ambiente virtual foi instalado.

Se tudo saiu bem, você pode ver todos os pacotes que foram instalados com a instalação do django.

Checando dentro da pasta Lib/ do ambiente virtual

Agora, a segunda maneira seria entrar dentro da pasta do ambiente virtual, e logo em seguida ir para a pasta Lib/:

Se o django foi instalado corretamente você o verá dentro da pasta venv/Lib/.

Iniciando um projeto django

Agora que entendemos a criação de um ambiente virtual e como o pip funciona como linha de comando, além da instalação do Django no nosso ambiente virtual, este é o momento de iniciarmos a instalação do Django no diretório que criamos para o nosso projeto.

Uma vez que instalamos o Django no ambiente virtual, temos à disposição uma ferramenta de linha de comando chamada django-admin, assim como o pip.

Com essa ferramenta, podemos executar vários comandos no nosso projeto. No entanto, iremos abordá-los em mais detalhes em outras postagens, ok?! 😉

Mas, caso queira saber quais são os subcomandos do django-admin, basta adicionar o seguinte comando:
```
django-admin help
```
PowerShell
Criando o projeto

Vamos la, no terminal do IDE do ambiente virtual adicione o comando a seguir para criar os diretórios do projeto django.
```
django-admin startproject blog .
```
PowerShell
Adicionando o comando django-admin, você pode seguir o segundo comando para iniciar um projeto (core/núcleo do projeto). Logo em seguida o nome que será dado pelo django ao projeto, e o “.” que significa que ele não será criado com uma sub-pasta.

Va em frente e rode o comando acima.

Caso você conseguiu usar o comando corretamente no terminal, você terá uma pasta do projeto chamada blog/ e um arquivo chamado manage.py.

Instalando um app para o nosso projeto django

Muito bem, você ja fez a maioria da configuração do projeto. Porém é preciso adicionar mais uma parte da configuração, o “app” que será necessario para adicionar a logica de negóscio. Como a criação de modelos, views, templates, urls e até uma API Restful se for o caso.

Mas antes de eu te mostrar o comando no qual criará a aplicação, entenda que, como disse antes, voce tera que adicionar um nome para esta aplicação. Com isso, pense bem qual será o dominio que essa aplicação terá.

Nesse caso, como exemplo, eu irei adicionar o nome/dominio “postagens”. Entao vamos la, iremos adicionar o comando de criação de uma nova aplicação:

Como vocês viram acima, perceberam que eu usei o seguinte comando:
```
 python manage.py startapp postagens
```
PowerShell
E não usei o comando django-admin <nome do comando> mas sim o comando python manage.py <nome do comando>.

Isso é por que o python manage.py tem a mesma funcionalidade que o django-admin que no caso seria o poder de gerenciar o projeto django que você está trabalhando. Porem o django-admin e usado para criar o arquivo manage.py (que significa: gerenciar) e também tem acesso ao projeto a nível global.

Conectando a nova aplicação ao projeto django

Com o projeto e a aplicação criados, é hora de conecta-los. Nesse caso, todas as aplicações criadas seram conectadas no projeto no arquivo setttings.py.

Então, abra o projeto, nesse caso se chama “blog/” e vá até o arquivo settings.py. Neste arquivo, va até a variavel de tipo lista com nome INSTALLED_APPS, e adicione o nome da aplicação que voce criou no final da lista (como string).

Exemplo:
```
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'postagens', # <-------------- AQUI
]
```
Python
De uma forma bem simplificada, ao adicionar o nome exato da aplicação que você criou com o comando “startapp” você tem que adiciona-lo desta maneira em settings.py do projeto. Caso contrario o django não sabera que a aplicação existe.

Conclusão

Seguindo todos os passos adicionados nesta postagens, você ficará craque ao criar novas aplicações. É bem provavel que você esteja achando o Django bem difícil de entender, eu concordo. Porém, olhe isso com bons olhos.

O Django e difícil, porém raramente você precisará fazer as coisas diferente, principalmente o setup do projeto. Isso que você aprendeu é um padrão para 80% dos projetos locais que voce ira criar.

Essa e a parte boa deste framework, ele e pragmatico. E quando voce aprende a trabalhar com ele, o fóco sempre será em construir a lógica de negócio e pouco em configurações.
September 26, 2024
Dockerizando Uma Aplicação Django
A dockerização de uma aplicação Django representa um avanço significativo na forma como desenvolvedores lidam com ambientes de desenvolvimento e implantação. Em vez de enfrentar problemas de compatibilidade entre sistemas operacionais, versões de bibliotecas ou configurações locais, o Docker permite encapsular toda a aplicação Django — junto com suas dependências, banco de dados, configurações e bibliotecas — dentro de um contêiner leve, portátil e padronizado.

Esse processo assegura que a aplicação funcione de maneira idêntica em qualquer ambiente, seja no computador do desenvolvedor, em um servidor de teste ou em um ambiente de produção na nuvem. Além disso, a dockerização oferece uma maneira eficiente de gerenciar múltiplos serviços, como o servidor web, o banco de dados e o cache, dentro de uma única estrutura controlada.

Com o uso do Docker Compose, por exemplo, é possível orquestrar todos os componentes de uma aplicação Django com apenas um comando, facilitando o processo de inicialização, integração e manutenção do projeto. Essa abordagem promove maior consistência, escalabilidade e agilidade no ciclo de desenvolvimento.

Em suma, a dockerização de uma aplicação Django é uma prática moderna e essencial para desenvolvedores que buscam ambientes previsíveis, implantações rápidas e colaboração eficiente entre equipes, reduzindo erros e simplificando a jornada entre o desenvolvimento e a produção.

Benefícios do Docker Para Uma Aplicação Django:

O Docker oferece uma infinidade de vantagens para desenvolvedores Django. Um benefício chave é a garantia de consistência em vários ambientes. Ao empacotar o aplicativo Django com todas as suas dependências, o Docker elimina o dilema “mas funciona na minha máquina”. Esta uniformidade se estende desde configurações de desenvolvimento local até implantações em produção, promovendo uma colaboração mais suave e reduzindo problemas de compatibilidade.

Além disso, o Docker simplifica significativamente o processo de implantação. Sua abordagem baseada em contêineres simplifica o fluxo de trabalho de implantação, permitindo que os desenvolvedores empacotem a aplicação Django junto com suas configurações e dependências em uma única unidade, facilmente implantável em diferentes servidores ou plataformas na nuvem.

Configurando o Docker para Django

Passos para Instalação do Docker:

Instalar o Docker é o primeiro passo para dockerizar sua aplicação Django. O Docker fornece guias de instalação abrangentes para vários sistemas operacionais em seu site oficial. Para a maioria dos sistemas, o Docker Desktop é a opção preferida para um processo de instalação direto.
1. Selecione Seu Sistema Operacional: Visite o site do Docker e baixe o Docker Desktop para o seu sistema operacional específico. Siga as instruções na tela para completar a instalação.
2. Verifique a Instalação: Uma vez instalado, verifique a instalação do Docker executando docker –version no seu terminal ou prompt de comando. Este comando deve exibir a versão instalada do Docker, confirmando uma instalação bem-sucedida.
Configurando o Docker para uma Aplicação Django:

Após instalar o Docker, você terá que criar um arquivo chamado Dockerfile dentro do projeto Django, onde a configuração atual será adicionada, criando como resultado a imagem que posteriormente será usada para criar o container…
1. Crie um Dockerfile: No diretório raiz do seu projeto Django, crie um arquivo chamado Dockerfile. Este arquivo conterá instruções para construir a imagem Docker para seu aplicativo Django.
```
project_directory/
│
├── Dockerfile # <-------------
├── DjangoProject/
├── DjangoApp/
└── manage.py
```
Bash
Criando um Dockerfile para a Aplicação Django:

Um Dockerfile é um arquivo de texto que contém um conjunto de instruções necessárias para construir uma imagem Docker. Ele especifica o ambiente e a configuração necessária para que sua aplicação Django seja executada dentro de um contêiner Docker.

Os componentes necessarios para o Dockerfile para nossa Aplicação Django:

1 – Declaração da Imagem Base: Comece seu Dockerfile declarando a imagem base. Tipicamente, a imagem base para aplicações Django é uma imagem oficial do Python.

Por exemplo:
```
FROM python:3.9
```
Dockerfile
2 – Definindo o Diretório de Trabalho na Aplicação Django: Defina o diretório de trabalho dentro do contêiner onde seu projeto Django residirá:
```
WORKDIR /app
```
Dockerfile
3 – Copiando Requisitos e Instalando Dependências: Copie o arquivo requirements.txt para dentro do contêiner e instale as dependências. Este passo garante que os pacotes Python necessários para seu aplicativo Django sejam instalados dentro do contêiner Docker:
```
# Instale as dependências
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
```
Dockerfile
4 – Copiando Arquivos da Aplicação Django: Copie todo o diretório do projeto Django para dentro do contêiner:
```
COPY . /app/
```
Dockerfile
5 – Definindo Variáveis de Ambiente e Executando a Aplicação Django: Defina quaisquer variáveis de ambiente necessárias e o comando para iniciar a aplicação Django:
```
# Exponha a porta que a aplicação usará
EXPOSE 8000
```
Dockerfile
Guia Passo a Passo:

Aqui está um guia passo a passo para escrever um Dockerfile especificamente adaptado para aplicações Django:
1. Crie um novo arquivo chamado Dockerfile no diretório raiz do seu projeto Django.
2. Declare a imagem base usando FROM python:3.9.
3. Defina o diretório de trabalho dentro do contêiner com WORKDIR /app.
4. Copie o arquivo requirements.txt e instale as dependências.
5. Copie todo o diretório do projeto Django para dentro do contêiner COPY . /app/.
6. Exponha a porta que a aplicação usará EXPOSE 8000.
Com isso o arquivo Dockerfile precisa estar desta maneira:
```
FROM python:3.9

# Defina o diretorio que ira copiar os arquivos 
WORKDIR /app

# Instale as dependências no container
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copie os dados do diretorio local para o diretorio do container que foi criado acima
COPY . /app/

# Exponha a porta que a aplicação usará
EXPOSE 8000
```
Dockerfile
Docker Compose para Aplicações Multi-Contêiner

O Docker Compose é uma ferramenta que permite aos desenvolvedores definir e gerenciar aplicações Docker multi-contêiner. Ele simplifica o processo de definição, execução e conexão de múltiplos contêineres Docker, sendo particularmente útil para aplicações complexas com serviços interconectados, como aplicações Django que dependem de bancos de dados ou outros serviços.

Neste exemplo, criaremos um arquivo docker-compose.yml para gerenciar dois contêineres: o contêiner da aplicação Python + Django e um contêiner de banco de dados para PostgreSQL.

Papel do Docker Compose em uma Aplicação Django:

Em uma configuração típica de aplicação Django, serviços adicionais como bancos de dados (por exemplo, PostgreSQL, MySQL) ou sistemas de cache (por exemplo, Redis) complementam o servidor central Django. O Docker Compose ajuda a orquestrar esses serviços, definindo suas configurações e interconexões dentro de um único arquivo YAML.

Criando um docker-compose.yml para nossa aplicação Django:

Para criar um arquivo docker-compose.yml adaptado para nossa aplicação Django, siga estes passos:
1. Crie um Novo Arquivo: Comece criando um novo arquivo chamado docker-compose.yml no diretório raiz do seu projeto Django (mesmo lugar onde voce criou o arquivo Dockerfile).
2. Definindo Serviços Django e Banco de Dados: Defina os serviços necessários para sua aplicação Django, como web para o servidor Django e db para o banco de dados. Especifique as configurações necessárias para cada serviço. Um exemplo do arquivo:
```
version: '3'

services:
  web:
    build: .
    command: python manage.py runserver 0.0.0.0:8000
    ports:
      - "8000:8000"
    volumes:
      - .:/app
    depends_on:
      - db

  db:
    image: postgres:latest # <--- pegando a imagem direto do docker 
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
```
YAML
Explicação da Configuração YAML:

O serviço web constrói a imagem Docker a partir do diretório atual, executa o servidor de desenvolvimento Django na porta 8000 dentro do container e configura um volume para recarregamento de código em tempo real.

Ah, ja iria me esquecer voce viu que o projeto django dentro do container esta 8000? Lembra que nos espomos a porta 8000 no dockerfile tambem? Pois bem no codigo acima voce ve que estamos apontando a porta interna onde o django esta se comunicando para a porta host do container. Assim podemos ter acesso na nossa maquina.

O serviço db usa a imagem do PostgreSQL e define variáveis de ambiente para configuração do banco de dados que serão usadas para inserir nas configurações do Django posteriormente.

Executando o Docker Compose:

Execute o comando docker-compose up no mesmo diretório onde seu arquivo docker-compose.yml está localizado. O Docker Compose lê o arquivo e inicia os serviços definidos.

E qual é a relação entre Dockerfile e docker-compose.yml?

A relação entre o Dockerfile e o arquivo docker-compose.yml está em seus papéis dentro de uma aplicação baseada em Docker:
- Dockerfile: Define as instruções de configuração para construir uma única imagem Docker. Ele foca na configuração de um serviço contêinerizado específico (por exemplo, um aplicativo Django, um banco de dados). Este arquivo descreve como criar uma imagem de contêiner individual.
- docker-compose.yml: Orquestra e gerencia múltiplos contêineres como uma aplicação coesa. Este arquivo descreve as relações entre diferentes serviços, especificando como vários contêineres interagem, suas configurações, dependências, rede e volumes.
Estrutura de uma aplicação django:

Se você ja esta acostumado com a estrutura de arquivos de um projeto django. Assim que deve ficar o mesmo depois de adicionar os arquivos Docker e docker-compose.yml..
```
project_directory/
│
├── manage.py
├── DjangoApp/
|   └── ...
├── DjangoProject/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── ...
├── Dockerfile
├── requirements.txt
└── docker-compose.yml
```
Bash
Conclusão

Dockerizar uma aplicação Django fornece uma maneira eficiente de encapsular, implantar e gerenciar seus projetos. Através deste passo-a-passo, nos aprofundamos nos conceitos fundamentais do Docker e demonstramos como conteinerizar um aplicativo Django usando Docker e docker-compose.

Ao aproveitar a tecnologia de conteinerização do Docker, os desenvolvedores podem garantir consistência em ambientes de desenvolvimento, teste e produção, promovendo uma colaboração mais fácil e fluxos de trabalho de implantação mais suaves.

O Docker simplifica o processo de empacotamento do seu aplicativo Django e suas dependências em um contêiner portátil, eliminando problemas relacionados ao ambiente e facilitando a escalabilidade contínua.

Ao navegar em seu aprendizado de Docker e Django, lembre-se de que este guia serve como ponto de partida. Experimente recursos adicionais do Docker, ajuste suas configurações e mergulhe em estratégias avançadas de implantação para otimizar seu pipeline de desenvolvimento.
June 1, 2024
Introdução ao Framework Django: Compreendendo o Framework e Sua Arquitetura
O Django, um poderoso framework web escrito em Python, tem desempenhado um papel significativo no panorama do desenvolvimento de aplicações web.

Desde sua criação por Adrian Holovaty e Simon Willison, o Django tem sido uma ferramenta essencial para desenvolvedores que buscam construir aplicações robustas, eficientes e escaláveis.

Nesta postagem introdutória, exploraremos os fundamentos do Django. Trazendo a essência de sua arquitetura e destacando os princípios-chave que o tornam uma escolha preferencial para projetos web.

Ao compreender o funcionamento interno do framework Django, você estará preparando o terreno para um aprendizado que abrange desde a definição de modelos até a criação de interfaces de usuário dinâmicas.

História da Criação do Framework Django

O framework Django foi criado por Adria e Simon quando os mesmos trabalhavam em uma radio chamada Lawrence Journal-World.

Com alta demanda de novas funcionalidades os desenvolvedores perceberam que estavam fazendo serviços repetitivos. E com isso muitas funcionalidades foram criadas para resolver esses tipos de demanda.

Por exemplo, inicialmente o django foi criado para criar sites complexos com conectividade para bancos de dados. Porem ao passar o tempo e com diferentes demandas, o projeto teve a necessidade de se focar em reutilização e a componentização do codigo.

Com isso, o django se tornou literalmente um framework com desenvolvimento rapido e sem a necessidade de repetição de código.

Estrutura MVC (Model-View-Controller) do Framework Django

MVC (Model-View-Controller) é um padrão de arquitetura de software que organizam o código de uma aplicação de maneira eficiente, separando as responsabilidades e melhorando a manutenção do código. Utilizados em contextos de desenvolvimento web, sendo MVC associado a muitos frameworks, assim como o framework Django, Ruby on Rails e Laravel por exemplo.

MVC (Model-View-Controller):

Framework Django: MVC

Model (Modelo):

Representa a estrutura de dados e a lógica da aplicação. Responsável por interagir com o banco de dados, realizar cálculos e processar dados.

View (Visão):

É responsável pela apresentação e exibição dos dados para o usuário. Recebe informações do modelo e apresenta ao usuário final.

Controller (Controlador):

Gerencia a interação entre o modelo e a visão. Responde a eventos do usuário e atualiza o modelo ou a visão conforme necessário.

O fluxo típico em um modelo MVC é o seguinte:
1. O usuário interage com a View.
2. A View notifica o Controller sobre a interação.
3. O Controller atualiza o Model conforme necessário.
4. O Model notifica a View sobre as alterações.
5. A View é atualizada para refletir as mudanças no Model.
Porem o django tem uma pequena variação deste padrão de arquitetura de software colocando o como MVT (Model-View-Template).

MVT (Model-View-Template):

Framework Django: MVT

Model (Modelo):

Similar ao MVC, representa a lógica de negócios e interage com o banco de dados.

View (Visão):

Lida com a apresentação dos dados e interação do usuário, mas, no contexto do Django, a View é mais fina que no MVC. Ela se concentra em processar a entrada e saída.

Template (Modelo de Apresentação):

Diferentemente do MVC, o MVT introduz o conceito de Template. O Template lida com a representação visual dos dados e é responsável pela geração do HTML final.

Provavelmente você percebeu que o django não tem necessariamente a camada controller em sua arquitetura. Essa é uma discussão comum na comunidade. Porém eu posso te dizer que realmente existe mas esta acoplada dentro do view.

Como assim? Como você viu acima o controller gerencia a interação entre o modelo e a visão. Responde a eventos do usuário e atualiza o modelo ou a visão conforme necessário. E é isso que o view do django faz, recebendo também a reponsabilidade do controller.

Resumindo, o view do django, ao receber a requisição pela url, faz a logica de apresentação, caso necessario a busca de dados se comunica com o model (que se comunica com o banco de dados). ao receber os dados, envia-os ao template no qual e renderizado o html e finalmente o envia como resposta para o usuario final.

Principais Componentes do Framework Django

O django, sendo um framework web Python, é composto por vários componentes que simplificam o desenvolvimento de aplicações web.

Estes são os principais componentes do framework django:

Models (Modelos):

Define a estrutura do banco de dados usando classes Python. Os modelos são mapeados para tabelas no banco de dados, proporcionando uma abstração conveniente para interação com o banco de dados.

Exemplo de codigo de models no django (models.py):
from django.db import models class Customer(models.Model): customer_id = models.UUIDField(primary_key=True, editable=False) first_name = models.CharField(max_length=120) last_name = models.CharField(max_length=120) phone = models.CharField(max_length=20, blank=True, null=True) email = models.EmailField(max_length=255, **options) street = models.CharField(max_length=255) street = models.CharField(max_length=120) state = models.CharField(max_length=120) zip_code = models.CharField(max_length=120) def __str__(self): return self.first_name
```
from django.db import models

class Customer(models.Model):
  customer_id = models.UUIDField(primary_key=True, editable=False)
  first_name = models.CharField(max_length=120)
  last_name = models.CharField(max_length=120)
  phone = models.CharField(max_length=20, blank=True, null=True)
  email = models.EmailField(max_length=255, **options)
  street = models.CharField(max_length=255)
  street = models.CharField(max_length=120)
  state = models.CharField(max_length=120)
  zip_code = models.CharField(max_length=120)
  
  def __str__(self):
    return self.first_name
```
Python
Ao migrar o codigo criado acima será criado uma tabela no banco de dados SQL onde o django poderá acessa-lo usando o seu ORM.

ORM (Object-relational-mapping)

O framework django, por meio do seu ORM (Mapeamento Objeto-Relacional), adiciona uma camada de abstração ao desenvolvimento de aplicações web. Ao representar modelos Python como entidades do banco de dados.

Framework Django: ORM

Essa ferramenta facilita a interação com dados, permitindo operações de banco de dados sem a necessidade de consultas SQL diretas.
from .models import Customer >>> Customer.objects.all() # retorna todos os customers (clientes) # resultado: [<Customer: Debra>, <Customer: Kasha>, <Customer: Tameka> ...] >>> Customer.objects.filter(state='CA') # retorna todos os customers do estado 'CA' # resultado: [<Customer: Kasha>, <Customer: Tameka>, <Customer: Charolette> ...] >>> Customer.objects.get(customer_id=9) # retorna um customer especifico pelo id # resultado: <Customer: Genoveva>
```
from .models import Customer

>>> Customer.objects.all() # retorna todos os customers (clientes)
# resultado: [<Customer: Debra>, <Customer: Kasha>, <Customer: Tameka> ...]

>>> Customer.objects.filter(state='CA') # retorna todos os customers do estado 'CA'
# resultado: [<Customer: Kasha>, <Customer: Tameka>, <Customer: Charolette> ...]

>>> Customer.objects.get(customer_id=9) # retorna um customer especifico pelo id
# resultado: <Customer: Genoveva>
```
Python
Essa integração transparente entre a programação orientada a objetos e as consultas ao bancos de dados relacionais é fundamental para a eficiência e simplicidade que o framework django oferece aos desenvolvedores.

Views (Visões):

Processa a lógica da aplicação, interagindo com o modelo e gerando uma resposta para o usuário. As Views podem renderizar templates, retornar JSON para APIs ou executar outras ações com base nas solicitações do usuário.
```
from django.shortcuts import render
from .models import Customer

def index(request):
    customers = Customer.objects.all() # --> retorno dos dados.
    context = {'customers': customers} # --> contexto que será passado para template.
    return render(request, 'myapp/index.html', context) # --> junção dos dados com a template.
```
Python
Logo no exemplo acima, você pode perceber toda a junção da listagem dos customers, a passagem desta listagem para o contexto que será passado para ser resera passado e renderizado na template.

Templates (Modelos de Apresentação):

Define a camada de apresentação da aplicação. Os templates utilizam a linguagem de template do framework django para criar páginas HTML dinâmicas, incorporando dados fornecidos pela View.
 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Customer List</title> </head> <body> <h1>Customer List</h1> <div class="container"> {% for customer in customers %} <h3>{{ customer.first_name }} {{ customer.last_name }}</h3> <h4>Email: {{ customer.email }}</h4> <h4>Phone: {{ customer.phone }}</h4> {% endfor %} </div> </body> </html>
```

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Customer List</title>
</head>
<body>
    <h1>Customer List</h1>
    
    <div class="container">
        {% for customer in customers %}
            <h3>{{ customer.first_name }} {{ customer.last_name }}</h3>
            <h4>Email: {{ customer.email }}</h4>
            <h4>Phone: {{ customer.phone }}</h4>
        {% endfor %}
    </div>
    
</body>
</html>
```
HTML
Ja no exemplo acima, você pode notar o uso da linguagem de template do framework django como tags {% %}. Onde será usada logica para renderizar os dados passados da view para a template, retornando como HTML puro.

URLs (Roteamento de URL):

Mapeia URLs da aplicação para funções ou classes de View específicas. O roteamento é configurado no arquivo urls.py e ajuda a direcionar as solicitações do usuário para as Views apropriadas.
```
# myapp/urls.py
from django.urls import path
from .views import index

urlpatterns = [
    path('', index, name='customer_list'),
]
```
Python
Admin Site (Site de Administração):

Oferece uma interface administrativa pronta para uso. Os modelos registrados no admin site podem ser gerenciados de forma fácil e intuitiva, facilitando a administração do sistema.

Forms (Formulários):

Facilita a manipulação e validação de dados de formulários. Os formulários no Django podem ser gerados automaticamente a partir de modelos ou criados manualmente para processar entradas do usuário.
```
# myapp/forms.py
from django import forms
from .models import Customer

class CustomerForm(forms.ModelForm):
    class Meta:
        model = Customer
        fields = [
        'customer_id', 
        'first_name', 
        'last_name', 
        'email', 
        'street', 
        'state', 
        'zip_code'
      ]
```
Python
Usando o CustomerForm poderemos criar em uma nova template um formulario para criação de novos customers ou update de um customer especifico.

Com isso poderemos criar uma nova url e uma nova view para gerenciar esta criação.
# myapp/views.py from django.shortcuts import render, redirect from .models import Customer from .forms import CustomerForm def index(request): customers = Customer.objects.all() context = {'customers': customers} return render(request, 'myapp/index.html', context) def create_customer(request): # --> NOVO CODIGO para gestão e controle do formulario. if request.method == 'POST': form = CustomerForm(request.POST) # --> Contexto que tambem sera passado para template if form.is_valid(): form.save() return redirect('customer_list') else: form = CustomerForm() # --> Caso a requisição seja GET. return render(request, 'myapp/create_customer.html', {'form': form}) # --> contexto
```
# myapp/views.py
from django.shortcuts import render, redirect
from .models import Customer
from .forms import CustomerForm

def index(request):
    customers = Customer.objects.all()
    context = {'customers': customers}
    return render(request, 'myapp/index.html', context)

def create_customer(request): # --> NOVO CODIGO para gestão e controle do formulario.
    if request.method == 'POST':
        form = CustomerForm(request.POST) # --> Contexto que tambem sera passado para template
        if form.is_valid():
            form.save()
            return redirect('customer_list')
    else:
        form = CustomerForm() # --> Caso a requisição seja GET.

    return render(request, 'myapp/create_customer.html', {'form': form}) # --> contexto
```
Python
Ao criar o formulario e a view com o contexto que sera enviado para o template, podemos criar a url para você entender como ira ficar:
```
# myapp/urls.py
from django.urls import path
from .views import index, create_customer

urlpatterns = [
    path('', index, name='customer_list'),
    path('create_customer/', create_customer, name='create_customer'), # --> nova url
]
```
Python
E com isso ficamos com a template onde será renderizado como um formulario HTML.
```

{% extends 'base.html' %}

{% block content %}
  <h2>Create Customer</h2>
  <form method="post" action="{% url 'create_customer' %}">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Save</button>
  </form>
{% endblock %}
```
HTML
Middleware:

No framework django, middlewares são componentes que processam requisições HTTP antes de chegarem às views e também processam respostas antes de serem enviadas de volta ao cliente.

Eles fornecem uma maneira flexível de modificar o comportamento do framework django, adicionando ou removendo funcionalidades em diferentes partes do processo de processamento de uma requisição.

No django, ja existe algumas middlewares que cuidam da segurança das requisições e trata sessões para autenticação por exemplo.

E muito raro a necessidade de criar um novo middleware no framework django. Com isso, inicialmente você não precisa se preocupar com isso agora.

Static Files (Arquivos Estáticos):

Gerencia arquivos estáticos, como CSS, JavaScript e imagens. O django fornece uma estrutura organizada para armazenar e servir esses arquivos durante o desenvolvimento e produção.

Test Framework (Framework de Testes):

O django também oferece ferramentas robustas para escrever e executar testes automatizados. Os testes são fundamentais para garantir a qualidade e integridade do código.

No exemplo abaixo são criados testes do model Customer e também da view index() para entender se as funcionalidades adiciona a mesma estão funcionando corretamente.
# myapp/tests.py from django.test import TestCase from django.urls import reverse from .models import Customer class CustomerModelTest(TestCase): # testa o model Customer. def setUp(self): Customer.objects.create( first_name="John", last_name="Doe", email="john.doe@example.com", street="123 Main St", state="CA", zip_code="12345" ) def test_customer_str_method(self): customer = Customer.objects.get(customer_id=1) self.assertEqual(customer.first_name, "John") self.assertEqual(customer.last_name, "Doe") class CustomerViewTest(TestCase): # testa se a view esta funcionando corretamente. def setUp(self): # criação de um objeto <Customer: Jhon> Customer.objects.create( first_name="John", last_name="Doe", email="john.doe@example.com", street="123 Main St", state="CA", zip_code="12345" ) def test_index_view(self): # teste se a view retorna como requerida. response = self.client.get(reverse('index')) self.assertEqual(response.status_code, 200) self.assertContains(response, "John") self.assertTemplateUsed(response, 'myapp/index.html')
```
# myapp/tests.py
from django.test import TestCase
from django.urls import reverse
from .models import Customer

class CustomerModelTest(TestCase):
    # testa o model Customer.
    
    def setUp(self):
        Customer.objects.create(
            first_name="John",
            last_name="Doe",
            email="john.doe@example.com",
            street="123 Main St",
            state="CA",
            zip_code="12345"
        )

    def test_customer_str_method(self):
        customer = Customer.objects.get(customer_id=1)
        self.assertEqual(customer.first_name, "John")
        self.assertEqual(customer.last_name, "Doe")

class CustomerViewTest(TestCase):
    # testa se a view esta funcionando corretamente.
    
    def setUp(self):
        # criação de um objeto <Customer: Jhon>
        Customer.objects.create(
            first_name="John",
            last_name="Doe",
            email="john.doe@example.com",
            street="123 Main St",
            state="CA",
            zip_code="12345"
        )

    def test_index_view(self):
        # teste se a view retorna como requerida.
        response = self.client.get(reverse('index'))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "John")
        self.assertTemplateUsed(response, 'myapp/index.html')
```
Python
Conclusão

Em síntese, o framework django representa a essência da eficiência no desenvolvimento web.

Criado a partir da necessidade de superar tarefas repetitivas, evoluiu para um framework ágil e descomplicado.

Sua arquitetura, inicialmente associada ao padrão MVC, adotou a abordagem MVT, simplificando a estrutura e centralizando responsabilidades na camada View.

Explorando os principais componentes, como Models, Views e Templates, percebemos uma engrenagem coesa que impulsiona a eficiência no desenvolvimento.

O framework django não é apenas um framework; é uma jornada técnica que capacita desde a definição de modelos até a criação de interfaces dinâmicas, redefine o cenário do desenvolvimento web de maneira pragmática e inteligente.
March 4, 2024
Como Criar Uma Aplicação Blog Com Django
Django é um framework full-stack que permite aos desenvolvedores criar novas aplicações rapidamente usando seus padrões MVT/MVC.

Portanto, este post irá exemplificar como você pode criar uma aplicação de blog utilizando Django e todas as suas funcionalidades, permitindo entender como model, view e controller funcionam em conjunto com templates.

O que voce ira aprender nesta postagem:
- Como criar um ambiente virtual python.
- Instalação do Django no ambiente virtual.
- Inicio de um projeto Django.
- Criação de um Model.
- Views para exibir os dados.
- URLs, templates e muito mais…
Você precisara das seguintes ferramentas instaladas no seu computador para seguir este tutorial:
- Python3 e Pip3
- Um IDE como o VSCode
Iniciando o projeto com django

Para iniciar este projeto Django você precisará abrir seu IDE e adicionar uma pasta vazia a ele. Chamei essa pasta de blog-project, mas você pode nomeá-la como desejar.

Depois de adicionar o projeto ao seu IDE, certifique-se de que o terminal esteja no diretório correto para iniciar o projeto. Já que precisamos adicionar o código dentro dele pelo terminal usando pip.

1 – Preparando o ambiente virtual do projeto django
```
$ python3 -m venv venv
```
Bash
Assim que este comando criar a pasta venv você precisara adicionar novamente o seguinte comando para ativar o ambiente virtual (venv).

Unix OS: Linux ou MacOS:
```
$ source venv/bin/activate
```
Bash
Windows OS:
```
venv\Script\activate
```
PowerShell
Se você executou a abordagem e seguiu corretamente, seu diretório de caminho terá o nome do ambiente virtual no início dele. Por exemplo, se o diretório do caminho for nome do caminho-para-projeto/blog-project $, ele será alterado para (venv) nome-do-computador/projeto-blog $.

2 – Instalando o framework Django no ambiente virtual

Agora que você tem o ambiente pronto, você precisa instalar o framework Django nele. Em seu terminal adicione o seguinte comando:
```
$ pip install django
```
Bash
Feito isso, o django será instalado, e você só precisa criar o blog-project dentro do diretório raiz.

3 – Criando projeto principal no Django

Agora que toda a configuração inicial está feita, vamos iniciar o projeto. Você precisará adicionar o seguinte comando para criar o projeto no diretório principal:
```
$ django-admin startproject blog_project
```
Bash
Assim que você adicionar o seguinte comando ao seu terminal, uma pasta chamada blog_project será adicionada ao seu diretório com outra pasta blog_project como o controlador do Django e o arquivo manage.py.

Portanto, se você seguiu todos os passos explicados até agora, seu diretório deverá ficar assim:
```
blog-project/ 
 |
 |__blog_project/
 |   |
 |   |__blog_project/
 |   |     |___ __init__.py
 |   |     |____settings.py
 |   |     |____urls.py
 |   |     |____wsgy.py
 |   | 
 |   |__manage.py   
 |
 |__venv/
```
Bash
4 – Iniciando seu projeto

Agora que todas as configurações principais já foram feitas, você pode iniciar seu projeto. Vá para a pasta blog_project/root com o comando:
```
$ cd blog_project
```
Bash
Apenas um ponto aqui: Para quem é iniciante, certifique-se de ter três pastas diferentes: a pasta raiz chamada blog-project/, a pasta raiz do projeto django chamada também de blog_project/ e a pasta controllers dentro da pasta raiz django que também é chamada blog_project/. O comando acima irá direcioná-lo para a próxima pasta, a raiz do django blog_project/.

Portanto, uma vez dentro da pasta raiz do projeto Django, (a mesma que contém o arquivo manager.py), você pode executar o comando para iniciar seu projeto Django com o seguinte comando:
```
$ python manage.py runserver
```
Bash
Com o seguinte comando seu projeto será iniciado e no terminal ele irá rodar e mostrar qual porta o projeto está rodando:
```
(venv) computer-name/blog_project $ python manage.py runserver
Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).

You have 18 unapplied migration(s). Your project may not work properly 
until you apply the migrations for app(s): admin, auth, contenttypes, 
sessions.
Run 'python manage.py migrate' to apply them.
February 07, 2021 - 17:52:22
Django version 3.1.6, using settings 'blog_project.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.
```
Bash
No meu caso o endereço é https://127.0.0.1:8000. Clique nele ou copie e cole em seu navegador para ver o resultado:

Se tudo correr bem você poderá ver a imagem acima no endereço fornecido pelo terminal.

5 – Criando um novo app para o seu projeto django

Agora é hora de criar seu primeiro aplicativo para o seu projeto Django. Mas antes de adicionar o comando para criar o aplicativo, você precisa abrir um novo terminal para executar o projeto, já que o último terminal está sendo usado para executar o aplicativo.

Portanto, abra um novo terminal no IDE, ative novamente o ambiente virtual no diretório raiz e mude o diretório para a raiz do Django, que é uma pasta à frente.

Então, após ativar seu ambiente virtual e alterar o diretório novamente em seu segundo terminal, adicione o seguinte comando para criar o app:
```
$ python manage.py startapp blog
```
Bash
Agora que você criou o diretorio/pasta chamada blog o seu diretório deve parecer desta maneira:
```
blog-project/ # <---------- primeiro diretorio criado manualmente
 |   
 |___blog_project/ # <----- diretorio criado pelo comando django-admin startapp ...
 |   | 
 |   |__blog_project/ # <----- diretorio criado pelo comando django-admin startapp ...
 |   |    |__ __init__.py
 |   |    |__settings.py
 |   |    |__urls.py
 |   |    |__wsgy.py
 |   |
 |   |
 |   |___blog/ # <------ diretorio criado agóra
 |   |   |
 |   |   |__migrations/
 |   |   |___ __init__.py
 |   |   |___admin.py
 |   |   |___apps.py
 |   |   |___models.py
 |   |   |___views.py
 |   |
 |   |__manage.py
 |
 |__venv/
```
Bash
Agora, você precisa adicionar o aplicativo blog criado recentemente nas configurações do projeto. Portanto, em blog_project/settings.py adicione o blog na configuração INSTALLED_APP:
```
INSTALLED_APPS = [
  'django.contrib.admin',
  'Django.contrib.auth',
  'django.contrib.contenttypes', 
  'django.contrib.sessions', 
  'Django.contrib.messages',
  'Django.contrib.staticfiles',
  'blog', # <------ Novo
 ]
```
Python
Adicionando o app blog no INSTALLED_APPS o django irá reconhecer o aplicativo que iremos trabalhar.

6 – Migrando as tabelas padrão do django

Antes de entrarmos no código, precisamos criar um superusuário para o projeto.

O superusuário tem a capacidade de gerenciar modelos na parte administrativa do site.

Muito bem, vamos criá-lo, no seu terminal adicione o seguinte comando:
```
$ python manage.py createsuperuser
```
Bash
Porém ao rodar este comando você receberá uma menssagem de error:
```
You have 18 unapplied migration(s). Your project may not work properly 
until you apply the migrations for app(s): admin, auth, contenttypes, 
sessions.

Run 'python manage.py migrate' to apply them.
```
Bash
Que traduzido diz:
```
Você tem 18 migrações não aplicadas. O seu projeto talvez não ira funcionar perfeitamente ate você aplicar as migrações para os apps: admin, auth, contenttypes, session.

Rode o comando python manage.py migrate para aplica-as.
```
Então vamos la, vamos fazer isso. Se você ler a mensagem, ela diz para executar um comando, que é:
```
$ python manage.py migrate
```
Bash
Deixei essa questão acima para você entender como é desenvolver uma aplicação.

Às vezes será normal receber alguns erros como esse para dizer o que não está certo. Portanto, fique sempre de olho no terminal para ver o que o Django e o python dirão se houver algo errado.

Ok, vamos voltar à criação do superusuário.

Então, após corrigir o problema de migração, adicione novamente o comando de criação de superusuário em seu terminal, logo em seguida adicione um nome para ele, eu usei o nome admin mas você pode escolher o que quiser. Você tambem terá que adicionar o seu e-mail e senha duas vezes.

NOTA: Se for a primeira vez que você cria um projeto Django, entenda que a senha não aparecerá no terminal. Basta adicioná-lo e pressionar Enter. <—————–

Agora que você já criou o superusuário, acesse o site /admin para fazer o login. Portanto, você só precisa adicionar /admin na frente da url do projeto e ele o redirecionará para a página de login.

http://127.0.0.1:8000/admin/

Depois de ser redirecionado, você verá a página de login:

Em seguida, faça login usando o nome de usuário e senha que você criou anteriormente e você será redirecionado para o site de administração.

Muito bem, agora você tem acesso a pagina de administrador como superusuário e pode fazer futuras edições em seus futuros modelos.

7 – Enviando nossa primeira mensagem para o frontend

Ótimo, agora você verá parte da funcionalidade do que o Django é capaz. Enviaremos uma mensagem de “hello world” para o frontend. Então, assim você terá uma ideia de como o Django funciona com a arquitetura MVC (model, view, controller).

No seu aplicativo blog, acesse o arquivo views.py e adicione o seguinte código:

blog/views.py
```
from django.shortcuts import render 
from django.http import HttpResponse 

# Create your views here. 
def index(request): #<------ Novo
    return HttpResponse('hello world')
```
Python
A área destacada é o novo código que você deve adicionar ao arquivo views.py. Agora que você adicionou este código em seu blog/views.py, você deve dizer ao Django onde esta resposta deve aparecer. Portanto, vá para blog_project/urls.py e adicione o caminho da visualização que você criou em blog/views.py.

blog_project/urls.py:
```
from django.contrib import admin
from django.urls import path 
from blog.views import index #<------ Novo

urlpatterns = [ 
  path('', index, name='index'), #<------ Novo
  path('admin/', admin.site.urls)
]
```
Python
Nesta seção, você precisará importar a função index que criou em blog/views.py e adicioná-la ao caminho como o nome index. Você também pode ver que há uma string vazia no início do caminho. Isso significa que a função e a página serão executadas como o URL principal.

Agora, depois de configurar views.py e urls.py, vá para a url principal: http://127.0.0.1:8000/ e atualize a página. Se você fez tudo certo, deverá ver um texto “hello world” no canto superior direito da tela.

NOTA: Se você encontrou algum erro, verifique o código acima e tente encontrar algum erro de ortografia, caso tenha esquecido de importar a função index para o urls.py. Além disso, verifique a última mensagem na parte inferior da mensagem de erro em seu terminal. Lá você verá o que há de errado. Se não houver erro, vamos para a próxima parte.

8 – Criando o seu primeiro model no seu projeto django

Agora é hora de você criar seu primeiro model para esta aplicação. No aplicativo blog, acesse models.py e adicione o seguinte código.

blog/modelos.py:
```
from django.db import models 

# Create your models here.
class Article(models.Model): 
    title = models.CharField(max_length=100) 
    body = models.TextField() 
    date = models.DateTimeField(auto_now_add=True) 
    thumb = models.ImageField(blank=True)
  
    def __str__(self): 
        return self.title
```
Python
O código acima é um comando para criar uma tabela chamada Article (Artigo) no django sqlite, com title (título), body (corpo), date (data), thub (imagem) e a função __str__ para exibir o título do blog na página de administração. Olhando atentamente para esta classe, você verá que cada um desses campos possui métodos diferentes.

Por exemplo:
- Para o title (título) você verá um método Charfield() com comprimento de 100 caracteres. Este método permitirá adicionar caracteres simples (string), como títulos, nomes ou frases.
- O body (corpo) possui um método diferente chamado TextField(). Como o próprio nome já diz, ele serve para armazenar maiores quantidades de caracteres, como textos.
- A variável de date (data) é atribuída ao método DateTimeField(). Este método armazena a data e hora em que um novo objeto é criado.
- Para o thumb (imagem), o método utilizado é ImageField(). Este campo é criado para armazenar uma imagem do objeto.
NOTA: Para o método ImageField(), você precisará instalar o Pillow para manipular as imagens adicionadas ao criar o objeto.

8.1 – Instalando o pacote Pillow para gerenciar imagens no django

Ao salvar o arquivo models.py com o qual você criou o modelo Article, você receberá um erro (caso a aplicação esteja rodando):

Terminal:
```
ERRORS: 
blog.Article.thumb: (fields.E210) Cannot use ImageField because Pillow is not 
installed.
HINT: Get Pillow at https://pypi.org/project/Pillow/ or run 
command "python -m pip install Pillow".
```
Bash
Portanto, seguindo a dica da mensagem acima, você precisará instalar o Pillow para poder adicionar imagens aos seus artigos. Adicione o seguinte código em seu terminal:
```
$ pip install Pillow
```
Bash
Depois de instalá-lo, você precisará configurar o settings.py para apontar (programar o caminho no django) onde as imagens serão colocadas quando você adicioná-lo no formulário do artigo.

8.2 – Configurando o caminho das imagens

No arquivo settings.py adicione o código a seguir:

blog_project/settings.py:
```
# No topo do arquivo.
Import os

...

# No final do arquivo.

# caminho onde devera inserir os arquivos de imagem.
MEDIA_URL = '/media/' 

# especificando o arquivo.
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
```
Python
Após essa configuração ser feita, você precisa registrar o artigo modelo em sua página de administração.

8.3 – Registrando o modelo no site de administrador

Vá até a pasta do seu blog e no arquivo admin.py adicione o seguinte código para cadastrar o modelo Article:

blog/admin.py
```
from django.contrib import admin
from .models import Article #<------ Nova linha

# Register your models here. 
admin.site.register(Article) #<------ Nova linha
```
Python
Você precisará importar o modelo Article do arquivo .models e registrá-lo na página de administração.

8.4 – Criando o seu primeiro artigo na aplicação blog

Agora que você já criou o modelo Article, cadastra-lo na página de administração, vá para a página de administração e verá uma nova seção adicionada à página de administração chamada Articles:

Clique no link Articles e na próxima página, no canto superior direito clique no botão ADD ARTICLE + para adicionar uma nova postagem no blog:

Adicione um título, um corpo de texto, uma imagem e salve. Você verá que o artigo com o nome Hello World foi adicionado ao seu banco de dados e uma nova pasta chamada media foi adicionada ao seu diretório blog_project/ como blog_project/media com a imagem que você escolheu para o seu artigo.

Como você adicionou uma nova pasta, seu diretório deve ficar assim:
```
blog-project/ 
 |   
 |___blog_project/
 |   | 
 |   |__blog_project/
 |   |    |__ __init__.py
 |   |    |__settings.py
 |   |    |__urls.py
 |   |    |__wsgy.py
 |   |
 |   |
 |   |___blog/
 |   |   |
 |   |   |__migrations/
 |   |   |___ __init__.py
 |   |   |___admin.py
 |   |   |___apps.py
 |   |   |___models.py
 |   |   |___views.py
 |   |
 |   |___media/ #<------- new
 |   |     |__imgexp.png
 |   |
 |   |__manage.py
 |__venv/
```
Bash
9- Adicionando templates e pastas estáticas para criar o frontend

Neste ponto estamos prontos para iniciar nossa parte de frontend. Crie uma nova pasta chamada templates em seu diretório raiz. Vá para /blog-project/blog_project/ e adicione o seguinte comando:
```
$ mkdir templates
```
Bash
Assim a pasta de templates será criada, agora você precisa informar ao Django onde a pasta de templates está localizada.

Vá para settings.py e adicione o nome ‘templates’ no código do array TEMPLATES:

blog_project/settings.py
```
TEMPLATES = [
    {
        "DIRS": ["templates"],
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "APP_DIRS": True,
        "OPTIONS": {
            "context_processors": [
                "django.template.context_processors.debug",
                "django.template.context_processors.request",
                "django.contrib.auth.context_processors.auth",
                "django.contrib.messages.context_processors.messages"
            ],
        },
    },
]
```
Python
Você também precisará criar uma pasta estática para adicionar arquivos estáticos, como css, javascript e imagens estáticas. Você precisará seguir quase a mesma abordagem que fez para criar a pasta de modelos. Além disso, a pasta estática será colocada no mesmo local que a dos modelos. Portanto, em seu terminal adicione o seguinte comando:
```
$ mkdir static
```
Bash
Assim, sua pasta estática (static) será criada no diretório raiz do projeto. O mesmo que os modelos. Então, agora, assim como na pasta de templates você precisará dizer ao Django que você tem uma pasta estática:

Vá para settings.py e na parte inferior do arquivo adicione o seguinte código:

blog_project/settings.py:
```
STATICFILES_DIRS = (os.path.join(BASE_DIR, "static"),)
```
Python
Agora que você criou a pasta estática e a configurou seguindo o código acima você está pronto para ir para a próxima etapa, que é adicionar o frontend deste projeto.

NOTA: Ótimo, você está pronto para iniciar a parte frontend deste tutorial. Se tudo estiver funcionando corretamente, perfeito. Agora é a etapa em que você precisa criar os arquivos HTML e CSS onde o código será adicionado. Então, desta parte até o final vou pedir toda a atenção de você. Porque, se você perder um pequeno passo ou detalhe, poderá enfrentar alguns erros.

10- Adicionando arquivos HTML e CSS nos templates e pastas estáticas

Nesta parte você exibirá o frontend deste projeto. A partir da próxima parte começaremos a buscar dados do modelo Article que você criou na parte 8 deste tutorial e exibiremos no frontend.

10.1 – Adicionando o HTML com tags de template integradas ao Django

Os modelos e pastas estáticas que você adicionou agora serão usados para ter o arquivo base.html. O arquivo no qual será usado para armazenar todas as outras páginas que serão criadas.
- Dentro da pasta de templates crie um novo arquivo chamado base.html.
- Adicione o seguinte código dentro do base.html:
modelos/base.html:
```
{% load static %}
<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
  <meta name="description" content="">
  <meta name="author" content="">
  <title>Blog Project</title>
  
  <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-BmbxuPwQa2lc/FVzBcNJ7UAyJxM6wuqIj61tLrc4wSX0szH/Ev+nYRRuWlolflfl" crossorigin="anonymous">
  
  <link href="{% static 'css/style.css' %}" rel="stylesheet">
</head>

<body>
  
  <nav class="navbar fixed-top navbar-expand-lg navbar-default fixed-top shadow shadow-inset">
    <div class="container">
      <a class="navbar-brand" href="">Blog Project</a>
      <button class="navbar-toggler navbar-toggler-right" type="button" data-toggle="collapse" data-target="#navbarResponsive" aria-controls="navbarResponsive" aria-expanded="false" aria-label="Toggle navigation">
        <span class="navbar-toggler-icon"></span>
      </button>
    </div>
  </nav>
  <header>
    <div id="carouselExampleIndicators" class="carousel slide" data-ride="carousel">
      <div class="carousel-inner" role="listbox">
        
        <div class="carousel-item active" style="background-image: url('https://cdn.pixabay.com/photo/2017/09/16/16/09/sea-2755908_1280.jpg')">
          <div class="carousel-caption d-none d-md-block">
            <h3>Title</h3>
            <p>This is a description for your blog.</p>
          </div>
        </div>
  </header>
  
  <div class="container">
    {% block content %}

  {% endblock content %}
    </div>
  
  
  <footer class="py-5 shadow-xs shadow-inset">
    <div class="container">
      <p class="m-0 text-center ">Copyright © Your Website 2021</p>
    </div>
    
  </footer>
  
  
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta2/dist/js/bootstrap.bundle.min.js" integrity="sha384-b5kHyXgcpbZJO/tY9Ul7kGkf1S0CWuKcCD38l8YkeH8z8QjE0GmW1gYU5S9FOnJ0" crossorigin="anonymous"></script>
</body>
</html>
```
HTML
- Agora que você adicionou o código em base.html salve-o e vamos nos preparar para exibir esta página no frontend.
- Para adicionar o código css, crie uma nova pasta chamada css dentro da pasta static e dentro da pasta css crie um arquivo css chamado style.css. O caminho para este arquivo deve ser assim:
static/css/style.css

Agora que você adicionou style.css, adicione o seguinte estilo neste arquivo:
```
body {
    padding-top: 56px;
  }
  
.carousel-item {
    height: 65vh;
    min-height: 300px;
    background: no-repeat center center scroll;
    -webkit-background-size: cover;
    -moz-background-size: cover;
    -o-background-size: cover;
    background-size: cover;
  }
  
.portfolio-item {
    margin-bottom: 30px;
  }
```
CSS
After the creation the templates and css folders as well as the style.css file, your working directory should look like this:
```
blog-project/ 
 |  
 |   
 |___blog_project/
 |   | 
 |   |__blog_project/
 |   |    |__ __init__.py
 |   |    |__settings.py
 |   |    |__urls.py
 |   |    |__wsgy.py
 |   |
 |   |
 |   |___blog/
 |   |   |
 |   |   |__migrations/
 |   |   |___ __init__.py
 |   |   |___admin.py
 |   |   |___apps.py
 |   |   |___models.py
 |   |   |___views.py
 |   |
 |   |___media/
 |   |     |__imgexp.png
 |   |
 |   |___static/ #<------ NEW
 |   |     |__css/
 |   |         |__style.css
 |   |
 |   |___templates/  #<------ NEW
 |   |     |__base.html
 |   |
 |   |__manage.py
 |
 |__venv/
```
Bash
```
Note: make sure you have added the files within the right folders.
```
10.2 Explaining template tags

Antes de prosseguirmos, você deve ter visto algumas tags incomuns no arquivo base.html. Eles são usados para finalidades diferentes. Por exemplo, a tag de modelo {% load static %}.

Trata-se simplesmente de carregar os arquivos que são colocados em uma pasta estática (static). No código HTML acima, em você pode localizar um href=”{% static ‘css/style.css’ %} dentro de um link. Sem a tag de modelo {% load static %} na parte superior, seus arquivos estaticos não serão carregados.

Outras tags de modelo colocadas no meio do arquivo base.html são {% block content %} {% endblock content %}. Essas duas tags de template, como o nome diz, servem para estender outros templates dentro deste bloco html. Abordaremos mais sobre eles antecipadamente neste tutorial.

Se você é novo no Django, você deve estar se perguntando: o que essas tags de template fazem? A resposta é: eles são usados para trazer diferentes funcionalidades aos templates html. Como loops, condicionais, funcionalidades personalizadas de carregamento, inclusão de outras partes de HTML, como barras de navegação ou rodapés e etc.
```
Você pode ver mais sobre tags de modelo Django aqui.
```
11. Showing the template on frontend.

Agora que você já adicionou o template base.html nos templates e criou a pasta css e o arquivo style.css, é hora de mostrar o resultado no frontend.

No seu views.py você precisa alterar a função de índice para o seguinte código:

blog/views.py:
```
from django.shortcuts import render

# Create your views here.
def index(request):
    return render(request, 'base.html')
```
Python
O atalho render() solicitará o template base.html e retornará a resposta ao navegador com base na URL. Portanto, se você se lembra da parte 7, adicionamos a função de índice ao caminho raiz. Em outras palavras, você só precisará salvar o views.py e recarregar a página na url http://127.0.0.1:8000/ para ver o resultado do template no frontend.

Então, se você fez tudo certo, o resultado deve ser assim:

12. Mostrando postagens do blog no frontend

Fantástico, que bom que ficou até aqui. Esta é uma das partes mais difíceis do tutorial. Portanto, para as próximas partes, recomendo que você preste atenção redobrada aos pequenos detalhes para não enfrentar nenhum erro.

12–1. Crie uma nova pasta de modelos no aplicativo de blog

Vá para o aplicativo blog e crie uma nova pasta chamada templates e adicione um modelo chamado posts.html. Por enquanto estará vazio.

12–2. Atualize a função de index() para reconhecer o modelo de postagens e adicionar os artigos lá

Na sua função index() você pode ver que ela está renderizando o modelo base.html. Mude para posts.html. Depois disso, você precisa importar o modelo Article para o seu views.py e atribuí-lo como articles. Além disso, você precisa criar um dicionário com o nome articles para que o modelo de postagens reconheça as postagens que são adicionadas a este modelo.

blog/views.py:
```
from django.shortcuts import render
# import Article model 
from .models import Article #<------ NOVO

# Create your views here.

def index(request): 
# adicionar artigos
articles = Article.objects.all() #<------ NOVO
return render(request, 'posts.html', {'articles':articles}) #<------ CODIGO NOVO
```
Python
12–3. Exibindo as postagens no frontend

Agora é a hora de você encontrar os primeiros posts aparecendo no frontend do seu projeto. Então, se você já adicionou um artigo no formulário Artigos da página de administração, vá até lá e adicione alguns com imagens. Caso contrário, eles não serão exibidos quando esta etapa for implementada.

Sendo assim, adicione este código ao modelo posts.html que você criou na etapa 12–1:

blog/templates/posts.html:
```
{% extends 'base.html' %}
{% load static %}
{% block content %}

<br><br>
<h2>Portfolio Heading</h2>

<div class="row">
  {% for article in articles %}
   <div class="col-lg-4 col-sm-6 portfolio-item">
     <div class="card h-100">
       <a href="#"><img class="card-img-top" src="{{article.thumb.url}}" alt=""></a>
       <div class="card-body">
         <h4 class="card-title">
           <a href="#">{{article.title}}</a>
         </h4>
         <p class="card-text">{{article.body|slice:50}}</p>
       </div>
     </div>
   </div>
  <br><br>
  {% endfor %}
</div>
{% endblock content %}
```
HTML
Você percebeu que não há nenhuma função executando o modelo base.html, mas ele está sendo executado mesmo assim? Na verdade, ele está sendo renderizado porque o modelo posts.html o está estendendo. Portanto, ele pode ser usado para carregar todos os outros modelos, se desejar.

Você também percebeu que neste momento o código HTML está dentro das tags {% block content %} {% endblock content %}, e não como no base.html? Agora você pode entender como esses modelos funcionam. Um é usado para estender enquanto o modelo base será usado para exibir os outros modelos.

12–4. Explicando o loop “for” na template

O loop for exibirá todas as postagens do artigo adicionadas a ele no template usando a tag django loop. Você se lembrou da variável articles e do dicionário que você adicionou na função index? A variável articles será adicionada ao dicionário em views.py e o dicionário será carregado no modelo posts.html como artigos. Portanto, se você já possui um bom conhecimento de HTML poderá entender que todos os campos do template de artigos foram exibidos nos lugares ou elementos certos.

O article.body no elemento <p>, article.title no elemento <a>(sem href por enquanto) e o article.thum.url dentro do <img src=””>. No entanto, você pode perceber que a imagem não apareceu embora esteja implementada.
```
NOTA: O |slice:50 dentro do article.body não deve exibir todo o conteúdo do blog em um cartão. Apenas para mostrar parte do corpo nele. Esteja ciente também de que o href será adicionado posteriormente para vincular à funcionalidade de detalhes da postagem e ao URL.
```
12–5. Corrigindo a imagem que não aparece na template posts.html

Para corrigir esse problema, você precisará adicionar o seguinte código ao seu urls.py.

blog_projects/url.py:
```
from django.contrib import admin 
from django.urls import path 
from blog.views import index 

# import for display image
from django.conf import settings #<------ NOVO
from django.conf.urls.static import static #<------ NOVO

urlpatterns = [ 
    path('admin/', admin.site.urls),
    path('', index, name='index'),
]

if settings.DEBUG: #<------ NOVO
    urlpatterns += static(settings.STATIC_URL, 
    document_root=settings.STATIC_URL) 
    urlpatterns += static(settings.MEDIA_URL, 
    document_root=settings.MEDIA_ROOT)
```
Python
Você precisará importar configurações e estática de conf.url e iterar os urlpatterns com STATIC_URL, MEDIA_URL e MEDIA_ROOT das configurações. Se você tiver alguma dúvida você pode conferir a documentação do Django aqui para saber mais sobre essas configurações.

Após isso, atualize a página do seu navegador onde o aplicativo é exibido e verifique se as postagens aparecem. Se sim, você verá a tela assim:

13. Criando a página de detalhes do post

Esta é a última parte do nosso tutorial. Nesta seção você aprenderá como exibir a página de detalhes de cada postagem do blog individualmente clicando em um dos cartões que representam cada postagem.

13–1. crie a função post_detail

Em blog/views.py você precisará criar uma função chamada post_detail() e criar uma variável chamada detalhes atribuída a um método chamado get_object_or_404(ModelName, id=id).

A funcionalidade deste método funciona de forma que por exemplo quando você clica em um cartão ele irá até o ModelName que está atribuído e buscará o id do item e retornando o objeto. Se você quiser entender mais como funciona o método get_object_or_404 você pode dar uma olhada na documentação aqui.

Então, a função post_detail() ficará assim:

blog/views.py
```
from django.shortcuts import render, get_object_or_404 #<------ NOVO IMPORT
# import Article model
from .models import Article

# Create your views here.
def index(request):
    # add article.
    articles = Article.objects.all()
    return render(request, 'posts.html', {'articles':articles})

def post_detail(request, id): #<------ NOVO
    # mostrar a pagina de detalhe.
    details = get_object_or_404(Article, id=id)
    return render(request, 'details.html', {'details':details})
```
Python
```
NOTA: Para a função post_detail, você também precisará adicionar id como parâmetro para que a função retorne o resultado que é criar uma página de detalhes para cada postagem do blog. Além disso, você precisará adicionar um novo modelo html chamadodetails.html que será criado posteriormente e exibirá a variável de detalhes em um dicionário para ser reconhecida no modelo. Se ficou um pouco complicado para você, dê uma boa olhada nesta função e siga cada passo para você entender. :)
```
13–2. adicione o URL post-details e importe a função post_detail()

Nesta parte você precisará criar um novo caminho de URL. Em seguida, acesse blog_project/urls.py e adicione o seguinte código destacado:

blog_project/urls.py:
```
from django.contrib import admin
from django.urls import path
from blog.views import index, post_detail #<------ NOVO IMPORT

from django.conf import settings
from django.conf.urls.static import static


urlpatterns = [
    path('admin/', admin.site.urls),
    path('', index, name='index'),
    path('post-detail/<int:id>/', post_detail, name='postDetail') #<------ NOVO
]

if settings.DEBUG:
    urlpatterns += static(settings.STATIC_URL, 
    document_root=settings.STATIC_URL) 
    urlpatterns += static(settings.MEDIA_URL, 
    document_root=settings.MEDIA_ROOT)
```
Python
Nesta parte você precisará importar a função post_detail() que você criou em blog/views.py pois ela precisará de uma funcionalidade para ser usada na nova url que você irá criar. Agora, crie este novo caminho de URL chamado post-detail e adicione ao novo padrão de URL, pois int é o formato do id (inteiro).

13–3. Adicionando o href para acionar a função post_detail() e explicação

Antes de ir para a explicação de como url e post_detail() funcionam juntos, vá para posts.html e adicione o seguinte código em cada href:
```
href="{% url 'postDetail' id=article.id %}"
```
HTML
Este código permitirá que o Django acione a função post_detail quando você clicar em um dos cartões do modelo posts.html. Enviando você para a páginadetails.html.

Aqui você pode ver o que acontece quando você clica em um cartão postal:
- O detalhe da postagem visto acima vai para a url e verifica qual é o padrão da url e também qual função o trata;
- Então, depois de ver que post_detail é a função que trata a url, ela obtém o id do objeto no banco de dados e o retorna no template.
- Você recebe a resposta no navegador com a postagem exata em que clicou.
13–4. crie o modelodetails.html

Vá para o modelo details.html vazio e adicione o código a seguir. Se você ainda não o criou, acesse blog/templates e adicione o seguinte código dentro dele.

blog/modelos/
```
{% extends 'base.html' %}
{% load static %}
{% block content %}

<div class="row">
    <div class="col-lg-8 mx-auto">
       <h1 class="mt-4 mb-3">{{details.title}}</h1>
         <ol class="breadcrumb">
           <li class="breadcrumb-item active">Post Detail</li>
         </ol>
    </div>
</div>
 <div class="row">
   
   <div class="col-lg-8 mx-auto">
     
     <img class="img-fluid rounded" src="{{details.thumb.url}}" alt="">
     <hr>
     <p>Posted on {{details.date}}</p>
     <hr>
     <p class="lead">{{details.body}}</p>
     </div>
  </div>
  {% endblock content %}
```
HTML
A ideia do código acima é semelhante à do modelo posts.html. No entanto, neste modelo você não tem o loop for. Em vez disso, na função post_detail() você obterá título, thumb, corpo e data.

Portanto, se você adicionou o código corretamente, ao clicar em um dos cartões do modelo posts.html no navegador você obterá esta página:

Muito bem, você terminou este tutorial usando Django. Você pode usar este código para implementar mais recursos como autenticação de usuário, adicionar categorias diferentes ou até mesmo criar um cms. Use sua imaginação e o que você aprendeu neste tutorial para fazer outras aplicações com Django. Obrigado por ficar até aqui e se você tiver algum comentário deixe um comentário abaixo e eu responderei sua pergunta.
```
Caso você queira aprender um pouco mais sobre os beneficios deste framework da uma olhada neste artigo.
```
February 28, 2024