01.introducao.ipynb

{
    "cells": [
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# <center>`Django`</center>"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## O que é?"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Django é uma framework web de alto nível escrita em Python que segue o padrão de design de model-template-view. Ele é utilizado para desenvolvimento de aplicações web, com o objetivo de simplificar o processo de desenvolvimento, fornecendo componentes prontos para serem utilizados, tais como gerenciamento de banco de dados, formulários, autenticação de usuários, entre outros.\n",
                "\n",
                "A estrutura do Django é baseada em três componentes principais :\n",
                "- `Model` : representa a camada de dados, responsável por gerenciar informações e realizar operações de negócios;\n",
                "- `View` : responsável por apresentar os dados ao usuário;\n",
                "- `Template` : é a camada de apresentação, responsável por definir a estrutura básica da página, como posições de elementos e estilos;"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Preparando o Local de Trabalho"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Ambiente Virtual"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Um ambiente virtual é um ambiente isolado em seu sistema operacional que permite que você instale pacotes e gerencie suas dependências de forma separada das outras aplicações em seu computador. Isso é útil porque diferentes aplicações podem exigir diferentes versões de bibliotecas e pacotes, e o uso de um ambiente virtual permite que você mantenha as versões corretas para cada aplicação.\n",
                "\n",
                "Você pode criar um ambiente virtual específico para sua aplicação e, em seguida, instalar pacotes e gerenciar suas dependências nesse ambiente. Quando você estiver pronto para trabalhar em sua aplicação, poderá ativar o ambiente virtual e ter certeza de que está usando as versões corretas dos pacotes."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Há duas ferramentas que possibilitam trabalhar com ambientes virtuais :\n",
                "- `virtualenv` : é uma ferramenta externa que pode ser instalada através do gerenciador de pacotes `pip`; é uma das ferramentas mais antigas e amplamente utilizadas para criar ambientes virtuais em Python;\n",
                "- `venv` : é uma ferramenta embutida na distribuição do Python a partir da versão 3.3; é uma alternativa ao `virtualenv` e fornece as mesmas funcionalidades básicas, mas sem a necessidade de instalar uma ferramenta externa;"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Ambos `virtualenv` e `venv` são ferramentas válidas para criar ambientes virtuais em Python, mas `venv` é uma opção nativa e mais simples que está incluída nas distribuições mais recentes do Python. Se você estiver usando uma versão recente do Python, é recomendável usar `venv`. Caso contrário, pode ser mais conveniente usar `virtualenv`."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### `venv`"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Como descrito anteriormente, não é necessário instalar qualquer pacote para usar a funcionalidade."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Para criar um ambiente virtual com `venv`, basta executar como abaixo :\n",
                "\n",
                "```cmd\n",
                "pasta_projeto> python -m venv .venv\n",
                "```\n",
                "\n",
                "Onde\n",
                "- `python` é o interpretador instalado na máquina;\n",
                "- `-m <modulo>` o módulo fornecido está localizado no caminho do módulo Python e é executado como um script;\n",
                "- `.venv` é o nome que se convencionou chamar esse tipo de pasta;\n",
                "\n",
                "Mais conteúdo e explicações podem ser encontrados aqui [Linha de Comando e Ambiente](https://docs.python.org/pt-br/3/using/cmdline.html)"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### `virtualenv`"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Como explicado acima, é o módulo que serviu de referência para o built-in venv. O funcionamento é praticamente igual, só tendo que instalar o pacote antes de utilizá-lo.\n",
                "\n",
                "```cmd\n",
                "pasta_projeto>pip install virtualenv\n",
                "```\n",
                "\n",
                "Para criação, basta usar :\n",
                "\n",
                "```cmd\n",
                "pasta_projeto> python -m virtualenv .venv\n",
                "```"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### Ativando o Ambiente Virtual"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Há duas formas de ativar o ambiente :\n",
                "- executando a partir da raiz do projeto `.venv\\Scripts\\activate`\n",
                "- navegando até a pasta Scripts e ativando :\n",
                "    - `cd .venv\\Scripts`\n",
                "    - `activate`"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Uma vez ativado, você pode instalar os pacotes necessários diretamente na pasta para o projeto.\n",
                "\n",
                "Exemplos :\n",
                "```cmd\n",
                "pasta_projeto>pip install pylint\n",
                "pasta_projeto>pip install autopep8\n",
                "pasta_projeto>pip install ipykernel\n",
                "```"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### VS Code"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Para o VS Code, tenha certeza de ter as extensões do Python e do Django (Baptiste Darthenay) estejam instaladas."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Iniciando o Projeto"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Para iniciarmos um novo projeto, primeiro criamos uma pasta com o nome do nosso projeto, que vai ser chamada de `aula`.\n",
                "\n",
                "Agora, vamos seguir o passo a passo abaixo :\n",
                "- crie a pasta do projeto;\n",
                "- crie um ambiente virtual para ele;\n",
                "- ative o ambiente virtual;\n",
                "- instale os pacotes;\n",
                "    ```cmd\n",
                "    aula>pip install pylint autopep8\n",
                "    ```\n",
                "- instale o Django;\n",
                "    ```cmd\n",
                "    aula>pip install django\n",
                "    ```\n",
                "- talvez seja necessário atualizar o pip, basta seguir as instruções fornecidas no terminal;\n",
                "- verifique a instalação do django\n",
                "    ```cmd\n",
                "    aula>django-admin --version\n",
                "    ```\n",
                "- podemos ver vários comandos do django usando\n",
                "    ```cmd\n",
                "    aula>django-admin --help\n",
                "    ```\n",
                "- agora vamos iniciar o nosso site\n",
                "    ```cmd\n",
                "    aula>django-admin startproject meu_site .\n",
                "    ```\n",
                "    - o `ponto` é muito importante, pois indica onde queremos criar a pasta, que no caso é na própria pasta `aula`;\n",
                "- finalmente, vamos inicializar o servidor\n",
                "    ```cmd\n",
                "    aula>python manage.py runserver\n",
                "    ```\n",
                "    - isso vai inicializar um servidor django local em nossa máquina, em modo de desenvolvimento;\n",
                "    - vão aparecer alguns erros (em vermelho), mas vamos ignorar por hora, mais tarde voltaremos nisso;\n",
                "- entre no link especificado no terminal;\n",
                "- et voilà, temos nossa primeira página;"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Conhecendo as pastas e arquivos"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Vamos passar pelos arquivos e pastas que temos até então."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "`db.sqlite3` - repare que surgiu um novo arquivo no seu projeto. Ele é um arquivo de banco de dados, que vai guardar tudo que salvarmos no django. Não vamos nos preocupar com ele agora."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "`manage.py` - arquivo muito importante durante o desenvolvimento. Ele faz a mesma coisa que o `django-admin` faz. Todos os comandos podem ser executados também pelo arquivo.\n",
                "\n",
                "A diferença dele para o `django-admin` é que ele configura uma variável de ambiente para dentro do seu projeto, carregando todas as configurações de `settings.py` para nosso site.\n",
                "```python\n",
                "os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'site_aula.settings')\n",
                "```\n",
                "\n",
                "Se tentar executar o servidor diretamente pelo `django-admin`, vai ocorrer um erro.\n",
                "```cmd\n",
                "aula>django-admin runserver\n",
                "```\n",
                "pois ele não encontrou a variável de ambiente do projeto, a `DJANGO_SETTINGS_MODULE`;\n",
                "\n",
                "Por enquanto, a única finalidade do `django-admin` é a execução do `startproject`. Todos os demais usaremos o `manage.py`."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### Pasta Criada"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "`__init__.py` - é o módulo responsável por indicar que aquela pasta é um pacote do python. Podemos usar para inicializar determinadas tarefas do pacote, mas não vamos usar por hora."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "`asgi.py` e `wsgi.py` - são arquivos de configuração usados quando publicamos nosso site, para realizar a conexão entre o servidor web e o django. Às vezes um será utilizado, às vezes outro. Vai depender do servidor que nosos site ficará hospedado;"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "`settings.py` - é o arquivo de configuração do nosso django. Todas as configurações que precisamos para o django funcionar corretamente, precisam estar dentro desse arquivo. Ele especifica para o django como o nosso site deve se comportar. Vamos utilizar muito esse arquivo."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "`urls.py` - é o arquivo muito importante. É a porta de entrada da nossa aplicação. É onde vamos cadastras nossos aplicativos do site;"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Criando um Debugger"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Para facilitar nosso trabalho com o django, vamos criar um debugger com o json abaixo. Dessa forma, não será preciso reiniciar e interromper o servidor sempre que realizarmos qualquer alteração."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "{\n",
                "    \"version\": \"0.2.0\",\n",
                "    \"configurations\": [\n",
                "        {\n",
                "            \"name\": \"Python Django\",\n",
                "            \"type\": \"python\",\n",
                "            \"request\": \"launch\",\n",
                "            \"program\": \"${workspaceFolder}/manage.py\",\n",
                "            \"args\": [\n",
                "                \"runserver\"\n",
                "            ],\n",
                "            \"django\": true,\n",
                "        }\n",
                "    ]\n",
                "}"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Usando as urls"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Lembrando, o `urls.py` é a porta de entrada da nossa aplicação. Quando acessamos qualquer site, estamos acessando a porta de entrada da aplicação. O arquivo nos permite configurar esse comportamento para nossa aplicação."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Para adicionarmos uma nova página, temos que alterar o arquivo com as especificações do `path`;\n",
                "\n",
                "```python\n",
                "urlpatterns = [\n",
                "    path('admin/', admin.site.urls),\n",
                "    path('<nova_página>/', <função dentro do app>)\n",
                "]\n",
                "```\n",
                "Por hora, vamos criar uma função no próprio arquivo `urls.py` para ver o funcionamento.\n",
                "Para isso, ela precisa ter os parâmetros `*args` e `**kwargs` e retornar um objeto do tipo `HttpResponse`, mas antes, vamos carregar a página e ver o que está acontecendo.\n",
                "\n",
                "Repare que uma série de erros foram levantados. O que mais se destaca é o `minha_view() takes 0 positional arguments but 1 was given`. O que isso quer dizer, indica que a minha função foi chamada e um argumento foi enviado para ela, mas como ela não tem parâmetros, aconteceu o erro. O argumento enviado é o `request`, que é uma requisição que realizamos pelas urls, que é recebido pelo servidor e retornado uma página web.\n",
                "\n",
                "Se adicionarmos um parâmetro requests, repare que agora o erro está diferente `The view site_aula.urls.minha_view didn't return an HttpResponse object. It returned None instead.`. Por padrão, toda função/método em python retorna None se não especificado, que é o que podemos ver ali. Faltou retornar um objeto `HttpResponse`. Para corrigir o erro, mas ainda sem muito se preocupar com o que e como retornar, vamos importar um `HttpResponse` e retornar ele de forma genérica. Como o `HttpResponse` espera um argumento, vamos passar uma string para ele e ver o que acontece.\n",
                "\n",
                "Repare que agora os erros desapareceram e agora nossa string está sendo exibida na página."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Criando Aplicativos"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Vamos criar mais algumas páginas diretamente no nosso `urls.py`."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "urlpatterns = [\n",
                "    path('admin/', admin.site.urls),\n",
                "    path('', minha_view),  # home\n",
                "    path('sobre/', minha_view),  # /sobre/\n",
                "    path('contato/', minha_view),  # /contato/\n",
                "]"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Como agora queremos criar mais páginas, temos que configurar mais funções para cada uma."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def home(request):\n",
                "    # pass\n",
                "    # tem que retornar um http response\n",
                "    return HttpResponse('Bom dia, Dave!')\n",
                "\n",
                "\n",
                "def sobre(request):\n",
                "    # pass\n",
                "    # tem que retornar um http response\n",
                "    return HttpResponse('Página de Sobre')\n",
                "\n",
                "\n",
                "def contato(request):\n",
                "    # pass\n",
                "    # tem que retornar um http response\n",
                "    return HttpResponse('Página de Contato')\n",
                "\n",
                "\n",
                "urlpatterns = [\n",
                "    # o cliente pede\n",
                "    path('admin/', admin.site.urls),\n",
                "    path('', home),  # home\n",
                "    path('sobre/', sobre),  # /sobre/\n",
                "    path('contato/', contato),  # /contato/\n",
                "]"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Repare como fica trabalhoso ficar criando funções para cada urls e, geralmente, essas funções serão grandes blocos de códigos.\n",
                "\n",
                "Por isso, o django nos permite criar aplicativos para isso tudo. Então, para cada página, teremos aplicativos individuais. Isso também nos permite realizar a portabilidade desses aplicativos para outros sites apenas copiando a referida pasta, sem ter que recriar tudo novamente. Assim, alteramos apenas o necessário."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Por hora, vamos criar uma página de receitas de macarrão.\n",
                "Em um novo terminal (para não interromper a execução do nosso site), vamos executar o comando abaixo :\n",
                "```cmd\n",
                "aula>python manage.py startapp receita\n",
                "```\n",
                "e vamos dar uma olhada no que foi criado."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Repare que temos uma nova pasta com o nome especificado, que foi `receita`. Dentro dela, há diversos módulos python. Temos o `__init__.py`, que faz com que a pasta seja reconhecida como um módulo do python. \n",
                "\n",
                "A pasta `migrations` serve para configurarmos nosso banco de dados, mas não vamos nos preocupar com isso agora.\n",
                "\n",
                "O que importa são os novos arquivos :\n",
                "- `admin.py` e `models.py` : são mapeadores de objeto-relacional (ORM), que é usado para o banco de dados da aplicação;\n",
                "- `apps.py` : nome do seu aplicativo criado, quando alteramos o `settings.py`, vamos usar o valor da variável `name` ou o caminho completo; veremos mais sobre isso adiante;\n",
                "- `tests.py` : é usado para testarmos nossa aplicação (não todo o site, mas apenas esse aplicativo);\n",
                "- `views.py` : arquivo que será usado para criarmos nossas páginas;"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Para usarmos o arquivo `views.py` no nosso `urls.py`, temos que realizar a importação do módulo. Quando se trabalha com django, todas as importações são feitas de forma absoluta da raiz do projeto. Então, para importar o `view.py`, temos que fazer :\n",
                "```python\n",
                "from receita.views import home, sobre, contato\n",
                "```\n",
                "Uma vez importado, movemos todas as funções para o referido arquivo e lá importamos o `HttpResponse`."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Mas também podemos mover o `urlpatterns` para nosso aplicativo, facilitando a importação geral pelo nosso site.\n",
                "Vamos copiar o código `urlpatterns` e os imports necessários para um novo arquivo `urls.py`, mas que estará dentro do nosso aplicativo (receita/urls.py).\n",
                "\n",
                "Depois de mover, vai ocorrer um erro porque o django não vai encontrar as urls mais. Para corrigir isso, temos que importar (conforme abaixo) no primeiro arquivo `urls.py` o `include`, que faz parte do `django.urls`.\n",
                "\n",
                "```python\n",
                "from django.urls import path, include\n",
                "```\n",
                "\n",
                "Uma vez importado, agora temos que usar ele no `path`, passando como argumento uma string que será o caminho do nosso novo arquivo de urls, como abaixo :\n",
                "\n",
                "```python\n",
                "urlpatterns = [\n",
                "    path('admin/', admin.site.urls),\n",
                "    path('', include('receita.urls')),\n",
                "]\n",
                "```\n",
                "\n",
                "Agora temos a nossa importação bem mais organizada."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Repare que todas as páginas são filhas da página principal, não qualquer outro caminho antes.\n",
                "\n",
                "`http://127.0.0.1:8000/`, `http://127.0.0.1:8000/sobre` e `http://127.0.0.1:8000/contato`.\n",
                "\n",
                "Isso acontece porque deixamos a o path como `path('', include('receita.urls')),`. Se quisermos que essas páginas sejam subpáginas de uma outra página, adicionamos um valor no path :\n",
                "```python\n",
                "urlpatterns = [\n",
                "    path('admin/', admin.site.urls),\n",
                "    path('receitas/', include('receita.urls')),\n",
                "]\n",
                "```"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Isso nos permite trabalhar isoladamante cada uma das funções da view nos arquivos."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Se observarmos o código fonte da página, não temos nada de HTML, apenas a string que estamos trabalhando. Nós podemos adicionar código HTML diretamente na string, mas isso deixaria o processo de criação e manutenção da página extremamante trabalhoso.\n",
                "\n",
                "Para isso, o Django já tem métodos próprios de realizar esse trabalho. Então usamos o `from django.shortcuts import render` (observe o que ele pede como parâmetro e retorna);<br>\n",
                "Então, usaremos o render para receber uma requisição HTTP e o caminho do nosso templete HTML."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "# receita/views.py\n",
                "from django.http import HttpResponse\n",
                "from django.shortcuts import render  \n",
                "\n",
                "def home(request):\n",
                "    return render(request, 'home.html')"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Agora, dentro da nossa pasta `receita`, criaremos uma pasta chamada `templates`, que já vai ser detectada pelo django como a pasta onde conterão os nossos modelos HTML.\n",
                "\n",
                "Lá dentro, vamos criar um arquivo `home.html` e vamos adicionar um código html dentro dele. O VSCode tem um atalho para inserir um modelo de código. Para isso, basta digitar `!` e verá que aparece um código que será gerado ao dermos Enter.\n",
                "\n",
                "Realizamos as alteraçõs que achamos necessáiras no nosso código html e salvamos."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Quando formos ver nossa página, provavelmente teremos o erro `TemplateDoesNotExist`.\n",
                "\n",
                "Isso acontece porque o django ainda não sabe que temos um aplicativo chamado `receita`, logo ele também não localiza a pasta `template`. Para resolver isso, temos que ir no arquivo de configurações, onde tem os `INSTALLED_APPS`;"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "# site_aula/settings.py\n",
                "INSTALLED_APPS = [\n",
                "    'django.contrib.admin',\n",
                "    'django.contrib.auth',\n",
                "    'django.contrib.contenttypes',\n",
                "    'django.contrib.sessions',\n",
                "    'django.contrib.messages',\n",
                "    'django.contrib.staticfiles',\n",
                "]"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Repare que ainda não registramos o nosso aplicativo. Então temos que adicionar o nome do nosso aplicativo na lista. Para termos certeza de estarmos usando o nome correto, podemos verificar a variável `name` no arquivo `receita/apps.py`; Com aquele valor da variável (a string), adicionamos ele no nosso `meu_site/settings.py`."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "# site_aula/settings.py\n",
                "INSTALLED_APPS = [\n",
                "    'django.contrib.admin',\n",
                "    'django.contrib.auth',\n",
                "    'django.contrib.contenttypes',\n",
                "    'django.contrib.sessions',\n",
                "    'django.contrib.messages',\n",
                "    'django.contrib.staticfiles',\n",
                "    # meus apps\n",
                "    'receitas',\n",
                "]"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Agora podemos ver que a nossa página está sendo carregada corretamente."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Agora, o django está buscando o arquivo `home.html` dentro da nossa pasta `receita\\templates`. Esse nome de `templates` é o padrão para o django. Podemos alterar isso no arquivo `meu_site/settings.py`, mas isso poderia deixar nosso site muito confuso, já que estaríamos saindo do padrão do django.\n",
                "\n",
                "Contudo, podemos adicionar uma nova pasta de templates personalizada em `meu_site/settings.py`. Indo até a constante `TEMPLATES`, na chave `DIRS` do dicionário, temos uma lista. Nós podemos criar uma pasta na raiz do nosso projeto e adicionar lá dentro os nossos templates."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "# meu_site/settings.py\n",
                "TEMPLATES = [\n",
                "    {\n",
                "        'BACKEND': 'django.template.backends.django.DjangoTemplates',\n",
                "        'DIRS': [\n",
                "            BASE_DIR / 'meus_templates',\n",
                "        ],\n",
                "        'APP_DIRS': True,\n",
                "        'OPTIONS': {\n",
                "            'context_processors': [\n",
                "                'django.template.context_processors.debug',\n",
                "                'django.template.context_processors.request',\n",
                "                'django.contrib.auth.context_processors.auth',\n",
                "                'django.contrib.messages.context_processors.messages',\n",
                "            ],\n",
                "        },\n",
                "    },\n",
                "]"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "A constante `BASE_DIR` é a variável que aponta para a raiz do nosso site."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Se ralizarmos a configuração acima, agora a nossa página `home.html` estará sendo carregada da pasta `meus_templates`.\n",
                "\n",
                "Por que isso acontece? O django carrega o arquivo `home.html` que ele encontrar primeiro. Como a pasta `meus_templates` está numa hierarquia acima, ele é carregado primeiro.\n",
                "\n",
                "Isso é chamado de `colisão de nomes`. Para evitar isso, usamos um `namespace` para nossos arquivos dentro do `templates`. Fazemos isso criando uma outra pasta dentro de `templates` do nome do nosso aplicativo, que será `receita`, e lá dentro iremos colocar o nosso arquivo `home.html`. Dessa forma, sempre que quisermos usar a home da receita, teremos que ser específicos quanto ao caminho."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "# receita/views.py\n",
                "def home(request):\n",
                "    # pass\n",
                "    # tem que retornar um http response\n",
                "    return render(request, 'receita/home.html')"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "E na pasta do `meus_templates`, criamos uma pasta chamada `global` (afinal, ela poderá ser usada globalmente pelo nosso site) e lá dentro colocamos a `home.html`. Assim precisaremos nos referir aquela home como `global/home.html`.\n",
                "\n",
                "Isso será muito importante quando começarmos a trabalhar com arquivos estáticos mais adiante."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Se olharmos mais sobre essa função de `render`, vamos ver que ela aceita como parâmetro um `context`. Isso pode ser usado para enviar variáveis de dicionário para nossa página HTML.\n",
                "\n",
                "Para exibir isso no nosso html, temos que usar duas chaves `{{ <variável> }}` e dentro chamamos a variável."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "# receira/views.py\n",
                "def home(request):\n",
                "    # pass\n",
                "    # tem que retornar um http response\n",
                "    return render(request, 'receita/home.html', context={\n",
                "        'nome': 'Augusto Hertzog'\n",
                "    })"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "vscode": {
                    "languageId": "html"
                }
            },
            "outputs": [],
            "source": [
                "# receita/templates/receira/home.html\n",
                "<body>\n",
                "    <h1>Página home {{ nome }}</h1>\n",
                "</body>"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Agora, finalmente, podemos enviar variáveis para nossa página HTML."
            ]
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "Python 3",
            "language": "python",
            "name": "python3"
        },
        "language_info": {
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "file_extension": ".py",
            "mimetype": "text/x-python",
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
            "version": "3.11.1 (tags/v3.11.1:a7a450f, Dec  6 2022, 19:58:39) [MSC v.1934 64 bit (AMD64)]"
        },
        "orig_nbformat": 4,
        "vscode": {
            "interpreter": {
                "hash": "5238573367df39f7286bb46f9ff5f08f63a01a80960060ce41e3c79b190280fa"
            }
        }
    },
    "nbformat": 4,
    "nbformat_minor": 2
}