Django
Carregando, aguarde alguns segundos.

2 - Livraria Exemplo

Para cada projeto Django é necessário um ambiente virtual, o qual é recomendável que seja dedicado ao projeto.

2.1 - Ambiente virtual

O ambiente virtual pode comportar mais de um um projeto mas é típico cada projeto ter seu próprio ambiente virtual dedicado.

No projeto são criados os aplicativos.

Apresentamos o projeto da livraria com exemplo de ambiente virtual Livraria dedicado ao projeto Livraria, com o aplicativo Livros.

Diretório para o ambiente virtual

Primeiro diponibile e posicione o diretório corrente onde o projeto será criado.

Abaixo simulamos o diretório c:\diretorio_livraria como raiz para pastas e arquivos do projeto Django da livraria, iniciando com ambiente_livraria 

md \diretorio_livraria
cd \diretorio_livraria

Ambiente virtual da livraria

Uma forma de gerenciar um ambiente virtual é com o aplicativo venv (sigla de virtual environment), incluído no Python.

O projeto projeto_livraria é criado junto com o ambiente virtual da livraria, utilizando-se o venv.

Com o venv é criado um ambiente virtual para o projeto ambiente_livraria.

O venv é um programa Python, executado com o Python.

Executando o venv com o Python digitando no prompt de comando: 

python -m venv ambiente_livraria

O ambiente virtual será criado na pasta "ambiente_livraria", com subpastas e arquivos, como a seguir: 

ambiente_livraria
    Include
    Lib
    Scripts
    pyvenv.cfg

Para carregar o ambiente digite no prompt de comando do Windows: 

ambiente_livraria\Scripts\activate.bat

Com linux/Mac: 

source ambiente_livraria/bin/activate

Ao ser ativado o ambiente virtual disponibiliza o prompt de comando:

Com Windows: 

(ambiente_livraria) C:\diretorio_livraria>

Com Linux/Mac: 

(ambiente_livraria) ... $

Você deve ativar o ambiente virtual e abrir o prompt de comando para trabalhar em seu projeto.

Instalação do Django no ambiente virtual

Finalmente, podemos instalar o Django no ambiente virtual.

Lembre-se de instalar o Django enquanto estiver no ambiente virtual.

O Django é instalado usando pip, com o comando: 

python -m pip install Django

É impresso algo semelhante a: 

Collecting Django
  Downloading Django-4.0.3-py3-none-any.whl (8.0 MB)
      |████████████████████████████████| 8.0 MB 2.2 MB/s
Collecting sqlparse>=0.2.2
  Using cached sqlparse-0.4.2-py3-none-any.whl (42 kB)
Collecting asgiref<4,>=3.4.1
  Downloading asgiref-3.5.0-py3-none-any.whl (22 kB)
Collecting tzdata; sys_platform == "win32"
  Downloading tzdata-2021.5-py2.py3-none-any.whl (339 kB)
      |████████████████████████████████| 339 kB 6.4 MB/s
Installing collected packages: sqlparse, asgiref, tzdata, Django
Successfully installed Django-4.0.3 asgiref-3.5.0 sqlparse-0.4.2 tzdata-2021.5
WARNING: You are using pip version 20.2.3; however, version 22.0.4 is available.
You should consider upgrading via the 'C:\diretorio_livraria\ambiente_livraria\Scripts\python.exe -m pip install --upgrade pip' command.

Agora o Django está instalado no ambiente virtual ambiente_livraria!

Verificação da versão do Django

A instalação do Django pode ser verificada: 

(ambiente_livraria) C:\diretorio_livraria>django-admin --version

Se estiver, será impresso o número da versão: 

4.0.3

2.2 - Criação do projeto Livraria

O ambiente virtual está pronto para criação do projeto Django no ambiente virtual do computador.

Depois de encontrar um nome adequado para seu projeto Django, como projeto_livraria, navegue até onde no sistema de arquivos você deseja armazenar o código (no ambiente virtual) e execute este comando no prompt de comando: 

django-admin startproject projeto_livraria

O Django cria a pasta projeto_livraria no computador, com este conteúdo: 

projeto_livraria
    manage.py
    projeto_livraria/
        __init__.py
        asgi.py
        settings.py
        urls.py
        wsgi.py

Estes são todos os arquivos e pastas com um significado específico, você aprenderá sobre alguns deles mais adiante neste tutorial, mas por enquanto, é mais importante saber que este é o local do seu projeto e que você pode começar a construir aplicativos em isto.

Execute o projeto Django

Agora que você tem um projeto Django, você pode executá-lo e ver como ele fica em um navegador.

Navegue até a pasta /projeto_livraria e execute no prompt de comando: 

python manage.py runserver

Que produzirá este resultado: 

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.
December 02, 2021 - 13:14:51
Django version 3.2.9, using settings 'projeto_livraria.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.

Abra uma nova janela do navegador e digite 127.0.0.1:8000 na barra de endereço.

O resultado: 

Qual é o próximo?

Temos um projeto Django!

O próximo passo é fazer um aplicativo em seu projeto.

Você não pode ter uma página web criada com Django sem um aplicativo.

2.3 - Aplicativo Livros

Um aplicativo é um programa da Web que tem um significado específico em seu projeto, como uma página inicial, um formulário de contato ou um cadastro de banco de dados.

Neste tutorial vamos criar um aplicativo que nos permite listar e cadastrar livros em um banco de dados.

Mas primeiro, vamos apenas criar um aplicativo Django simples que exibe "Alô mundo!".

Vamos nomear o aplicativo como livros.

Se o servidor ainda estiver em execução e você não conseguir escrever comandos, pressione [CTRL] [BREAK] para parar o servidor e você deverá voltar ao ambiente virtual.

Navegue para o diretório diretorio_livraria/projeto_livraria onde o aplicativo será armazenado e execute: 

py manage.py startapp livros

O Django cria uma pasta nomeada membersno meu projeto, com este conteúdo: 

projeto_livraria
    manage.py
    projeto_livraria/
    livros/
        migrations/
            __init__.py
        __init__.py
        admin.py
        apps.py
        models.py
        tests.py
        views.

Os arquivos e pastas na pasta livros têm funcionalidade específica.

O arquivo views.py coleta as informações necessárias para retornar uma resposta adequada ao navegador solicitante.

2.3.1 - Views

As views do Django são funções que recebem solicitações http e retornam respostas http como HTML.

Uma página web que usa Django está cheia de views com diferentes tarefas e missões.

As views geralmente são colocadas no arquivo views.py localizado na pasta do seu aplicativo.

Existe um arquivo views.py na pasta livros ainda sem funções-view, como abaixo:

livros/views.py: 

from django.shortcuts import render

As funções-view serão codificadas neste arquivo.

Edite este arquivo substituindo o conteúdo pelo código abaixo:

livros/views.py: 

from django.shortcuts import render
from django.http import HttpResponse
def index(request):
    return HttpResponse("Alô, mundo!")

Este é um exemplo simples de como enviar uma resposta de volta ao navegador.

A view é executada por meio de uma URL.

2.3.2 - URLs

Crie um arquivo nomeado urls.py na mesma pasta que o arquivo views.py e adicione o código abaixo:

livros/urls.py: 

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
]

O arquivo urls.py que você acabou de criar é específico para o aplicativo livros.

Temos que fazer algum roteamento no diretório raiz > também.

Existe um arquivo chamado urls.py na pasta projeto_livraria/projeto_livraria.

Abra esse arquivo e adicione o módulo include na declaração import.

Também adicione uma função path() na lista urlpatterns[], com argumentos que irão rotear os usuários que entrarem via 127.0.0.1:8000/livros.

Então seu arquivo ficará assim:

projeto_livraria/urls.py: 

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

urlpatterns = [
    path('livros/', include('livros.urls')),
    path('admin/', admin.site.urls),
]

Se o servidor não estiver em execução, navegue até a pasta /projeto_livraria e execute este comando no prompt de comando:

py manage.py runserver

Na janela do navegador digite 127.0.0.1:8000/livros na barra de endereço.

2.3.3 - Uso de templates

Templates são arquivos HTML contendo Tags Django das páginas retornadas pelas views.

Crie uma pasta templates dentro da pasta livros e crie um arquivo HTML chamado alomundo.html.

A estrutura do arquivo deve ser algo assim: 

projeto_livraria
    manage.py
    projeto_livraria/
    livros/
        templates/
            alomundo.html

Edite a template alomundo.html presente na pasta livros.

livros/templates/alomundo.html: 

<!DOCTYPE html>
<html>
  <body>
    <h1>Alô mundo!</h1>
    <p>Bem vindo ao projeto Django Alô mundo!</p>
  </body>
</html>

2.3.4 - View index com template

Abra o arquivo views.py e adapte a view index>:

livros/views.py: 

from django.http import HttpResponse
from django.template import loader
#
def index(request):
  template = loader.get_template('alomundo.html')
  return HttpResponse(template.render())

2.3.5 - Configuração do aplicativo livros

Para poder trabalhar com coisas mais complicadas do que "Alô mundo!", temos que dizer ao Django que um novo aplicativo foi criado.

Isso é feito no arquivo settings.py na pasta projeto-livraria.

Procure a lista INSTALLED_APPS[] e adicione o aplicativo livros assim:

projeto_livraria/settings.py: 

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'livros.apps.LivrosConfig'
]

A classe LivrosConfig é criada junto com o aplicativo e está declarada no arquivo apps.py no diretório livros.

livros/apps.py: 

from django.apps import AppConfig
class LivrosConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'livros'

Em seguida, execute este comando: 

py manage.py migrate

Que produzirá esta saída: 

Operations to perform:
    Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
    Applying contenttypes.0001_initial... OK
    Applying auth.0001_initial... OK
    Applying admin.0001_initial... OK
    Applying admin.0002_logentry_remove_auto_add... OK
    Applying admin.0003_logentry_add_action_flag_choices... OK
    Applying contenttypes.0002_remove_content_type_name... OK
    Applying auth.0002_alter_permission_name_max_length... OK
    Applying auth.0003_alter_user_email_max_length... OK
    Applying auth.0004_alter_user_username_opts... OK
    Applying auth.0005_alter_user_last_login_null... OK
    Applying auth.0006_require_contenttypes_0002... OK
    Applying auth.0007_alter_validators_add_error_messages... OK
    Applying auth.0008_alter_user_username_max_length... OK
    Applying auth.0009_alter_user_last_name_max_length... OK
    Applying auth.0010_alter_group_name_max_length... OK
    Applying auth.0011_update_proxy_permissions... OK
    Applying auth.0012_alter_user_first_name_max_length... OK
    Applying sessions.0001_initial... OK

Inicie o servidor navegando até a pasta /projeto_livraria e inicie o servidor com o comando: 

py manage.py runserver

Na janela do navegador, digite 127.0.0.1:8000/livros na barra de endereço.

O resultado deve ficar assim:

2.4 - Classe Model

A classe Model do Django e suas classes descendentes representam as tabelas do banco de dados.

Quando criamos o projeto Django é também criado um banco de dados SQLite vazio na pasta-raiz /projeto_livraria.

Utilizando o aplicativo SQLiteStudio fotogravamos o estado do banco de dados após ter sido criado junto com o projeto.

Usaremos esse banco de dados neste tutorial.

2.4.1 - Criar a tabela de livros

Para criar uma nova tabela, devemos usar uma nova classe descendente de Model.

Na pasta /livros, abra o arquivo models.py.

Está com apenas uma instrução de importação.

livros/models.py: 

from django.db import models

Para adicionar uma tabela Livros no banco de dados, crie uma classe Livros descrevendo os campos da tabela:

livros/models.py: 

from django.db import models

class Livros(models.Model):
    titulo_livro = models.CharField(max_length=255)
    autor_livro = models.CharField(max_length=255)

A classe Livros herda models.Model e declara dois campos na tabela configurados para ter até 255 caracteres.

  • O primeiro campo titulo_livro é um campo de texto para conter o título do livro.
  • O segundo campo autor_livro" também é um campo de texto para conter o autor do livro.

Em seguida, navegue até a pasta /projeto_livraria e execute o comando: 

python manage.py makemigrations livros

O que resultará nesta saída: 

Migrations for 'livros':
    livros\migrations\0001_initial.py
        - Create model Livros

O Django cria um arquivo com quaisquer novas alterações e armazena o arquivo na pasta /migrations.

Da próxima vez que você executar o comando "python manage.py migrate" Django irá criar e executar uma instrução SQL, baseada no conteúdo do novo arquivo na pasta migrations.

Execute o comando de migração: 

py manage.py migrate

O que resultará nesta saída: 

Operations to perform:
    Apply all migrations: admin, auth, contenttypes, livros, sessions
Running migrations:
    Applying livros.0001_initial... OK

A instrução SQL criada a partir do model é: 

CREATE TABLE "livros_livros" (
"id" INT NOT NULL PRIMARY KEY AUTOINCREMENT,
"titulo_livro" varchar(255) NOT NULL,
"autor_livro" varchar(255) NOT NULL);

Agora você tem uma tabela Livros em seu banco de dados!

Utilizando o aplicativo SQLiteStudio fotogravamos o estado do banco de dados após a migração.

2.4.2 - Adicionar Livros

A tabela Livros está vazia, devemos adicionar alguns livros a ela.

Nos próximos capítulos você aprenderá como fazer uma interface de usuário que cuidará das operações CRUD (Criar, Ler, Atualizar, Excluir), mas por enquanto, vamos escrever código Python diretamente no interpretador Python (shell Python) e adicionar alguns livros em nosso banco de dados, sem a interface do usuário.

Para abrir um shell Python, digite este comando: 

python manage.py shell

Agora que estamos no shell, o resultado deve ser algo assim: 

Python 3.9.2 (tags/v3.9.2:1a79785, Feb 19 2021, 13:44:55) [MSC v.1928 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>>

Na parte inferior, após os três >>> escreva o seguinte: 

>>> from livros.models import Livros

Aperte [enter] e escreva para ver a tabela Livros vazia: 

>>> Livros.objects.all()

Isso deve retornar um objeto QuerySet vazio: 

<QuerySet []>

Um QuerySet é uma coleção de dados de um banco de dados.

Adicione um registro à tabela, executando as duas linhas abaixo: 

>>> livro = Livros(titulo_livro='O Dia de Amanhã', autor_livro='Jorge Dias')
>>> livro.save()

Execute o comando para ver se a tabela Livros obteve um livro: 

>>> Livros.objects.all().values()

O resultado deve ficar: 

<QuerySet [{'id': 1, 'titulo_livro': 'O Dia de Amanhã', 'autor_livro': 'Jorge Dias'}]>

Com o aplicativo SQLiteStudio temos:

2.4.3 - Adicionar vários registros

Você pode adicionar vários registros fazendo uma lista de objetos Livros e executar save() em cada entrada: 

>>> livro1 = Livros(titulo_livro='O Sol Amarelo', autor_livro='Maria Amélia')
>>> livro2 = Livros(titulo_livro='A Viagem', autor_livro='Joana Martins')
>>> livro3 = Livros(titulo_livro='Carros em Fuga', autor_livro='José Silva')
>>> livro4 = Livros(titulo_livro='O Baralho do Mágico', autor_livro='Ana Torres')
>>> livros_list = [livro1, livro2, livro3, livro4]
>>> for x in livros_list:
>>>     x.save()

Agora existem 5 livros na tabela Livros: 

>>> Livros.objects.all().values()
<QuerySet [
      {'id': 1, 'titulo_livro': 'O Dia de Amanhã'  , 'autor_livro': 'Jorge Dias'},
      {'id': 2, 'titulo_livro': 'O Sol Amarelo', 'autor_livro': 'Maria Amélia'}, 
      {'id': 3, 'titulo_livro': 'A Viagem' , 'autor_livro': 'Joana Martins'},
      {'id': 4, 'titulo_livro': 'Carros em Fuga'  , 'autor_livro': 'José Silva'}, 
      {'id': 5, 'titulo_livro': 'O Baralho do Mágico' , 'autor_livro': 'Ana Torres'}
]>

2.4.4 - Ver no navegador

Queremos ver o resultado em uma página da Web, não em um ambiente de shell Python.

Para ver o resultado em uma página da Web, podemos criar uma view para essa tarefa específica.

na pasta livros, abra o arquivo views.py, que caso você tenha seguido os passos aqui, deve estar:

livros/views.py: 

from django.http import HttpResponse
from django.template import loader

def index(request):
  template = loader.get_template('olamundo.html')
  HttpResponse(template.render())

Altere o conteúdo do arquivo views.py para como a seguir:

livros/views.py: 

from django.http import HttpResponse
from django.template import loader
from .models import Livros

def index(request):
    meus_livros = Livros.objects.all().values()
    output = ""
    for x in meus_livros:
      output += x["titulo_livro"]
    return HttpResponse(output)

Como você pode ver na linha 3, o model Livros modelo é importado e a view index faz o seguinte:

  • Aponta um objeto na variável meus_livros com todos os valores do modelo Livros.
  • Faz um laço em todos os itens no meus_livros objeto para construir uma string com todos os valores titulo_livro.
  • Retorna a string como saída para o navegador.

Se você ainda estiver no shell do Python comande quit() para sair: 

>>> quit()

Navegue até a pasta /projeto_livraria e para iniciar o servidor, digite: 

py manage.py runserver

Na janela do navegador, digite 127.0.0.1:8000/livros/na barra de endereço.

O resultado:

2.4.5 - Template index.html com lista de livros

No capítulo anterior, conseguimos exibir o conteúdo de uma tabela de banco de dados em uma página web:

Para adicionar um pouco de HTML em torno dos valores, criaremos um template para o aplicativo.

Todos os templates devem estar localizados na pasta templates do seu aplicativo, se você ainda não criou uma pasta templates, faça isso agora.

Na pasta templates, crie um arquivo chamado index.html, com o seguinte conteúdo:

livros/templates/index.html: 

<h1>Livros</h1>
<table border="1">
    {% for x in meus_livros %}
    <tr>
        <td>{{ x.id }}</td>
        <td>{{ x.titulo_livro }}</td>
        <td>{{ x.autor_livro }}</td>
    </tr>
    {% endfor %}
</table>

Os simbolos {% %} e {{ }} são chamados de tags da template e permitem indo que você execute a lógica e coloque variáveis na renderização de suas templates.

2.4.6 - View index com template index.html

Altere a view index para incluir a template index.html:

livros/views.py: 
from django.http import HttpResponse
from django.template import loader
from .models import Livros

def index(request):
  meus_livros = Livros.objects.all().values()
  template = loader.get_template('index.html')
  context = {
    'meus_livros': meus_livros,
  }
  return HttpResponse(template.render(context, request))

A view do index faz o seguinte:

  • Cria um objeto meu_livro com todos os valores do model Livros.
  • Carrega um template index.html.
  • Cria um objeto contendo o objeto meu_livro.
  • Envia o objeto para o modelo.
  • Gera o HTML que é renderizado pelo modelo.
  • Na janela do navegador, digite 127.0.0.1:8000/livros/na barra de endereço.

O resultado:

2.4.7 - Adicionar livro

Até agora, criamos uma tabela Livros em nosso banco de dados e inserimos cinco livros escrevendo código no shell do Python.

Também fizemos um template que nos permite exibir o conteúdo da tabela em uma página web.

Agora queremos ser capazes de criar novos livros a partir de uma página da web.

2.5 - Adicionar livro

Comece adicionando um link "Adicionar livro" no template index.html:

livros/templates/index.html: 

<h1>Livros</h1>
<table border="1">
    {% for x in meus_livros %}
    <tr>
        <td>{{ x.id }}</td>
        <td>{{ x.titulo_livro }}</td>
        <td>{{ x.autor_livro }}</td>
    </tr>
    {% endfor %}
</table>
<p><a href="adicionar_livro/">Adicionar livro</a></p>

O resultado ficará assim:

2.5.1 - Template adicionar_livro.html

Adicione o template -livro.html na pasta templates.

livros/templates/adicionar-livro.html: 

<h1>Adicionar livro</h1>
<form action="adicionar_livro/" method="post">
    {% csrf_token %}
    Primeiro nome:<br>
    <input name="titulo_livro">
    <br><br>
    Último nome:<br>
    <input name="autor_livro">
    <br><br>
    <input type="submit" value="Submit">
</form>

O modelo contém um formulário HTML vazio com dois campos de entrada e um botão de envio.

Nota: O Django requer esta linha no formulário: 

{% csrf_token %}

para manipular Cross Site Request Forgeries em formulários onde o método é POST.

View: em seguida, adicione uma view no arquivo livros/views.py, nomeie a nova view adicionar:

livros/views.py: 

from django.http import HttpResponse
from django.template import loader
from .models import Livros
#
def adicionar_livro(request):
    template = loader.get_template('adicionar_livro.html')
    return HttpResponse(template.render({}, request))

2.5.2 - URL adicionar_livro

Adicione uma função path() no arquivo livros/urls.py, que aponte a url "127.0.0.1:8000/livros/adicionar/ " para o local correto:

livros/urls.py: 
from django.urls import path
from . import views
urlpatterns = [
    ...
    path('adicionar_livro/', views.adicionar_livro, name='adicionar_livro'),
]

No navegador, clique no link "Adicionar livro" e o resultado deve ficar assim:

Até agora fizemos a interface do usuário e apontamos a URL para a view salvar_inserir_livro, mas ainda não criamos a view.

2.5.3 - View salvar_inserir_livro

Certifique-se de adicionar a view salvar_inserir_livro no arquivo livros/views.py:

livros/views.py: 

from django.http import HttpResponse
from django.template import loader
from .models import Livros
...
def adicionar_livro(request):
    template = loader.get_template('adicionar_livro.html')
    return HttpResponse(template.render({},request))

Alterações feitas no arquivo views.py:

Linha 1: importação HttpResponseRedirect

Linha 3: importação reversa

A view salvar_adicao_livro faz o seguinte:

  • Obtém o titulo do livro e o autor do livro com a instrução request.POST.
  • Adiciona um novo registro na tabela de livros.
  • Redireciona o usuário de volta para a exibição do index.
  • Tente adicionar um novo registro e veja como funciona:
  • Se você pressionar o botão enviar, a tabela de livros deve ter sido atualizada:

2.5.4 - Salvar inserção livro

Você notou o atributo action no formulário HTML?

O atributo action especifica para onde enviar os dados do formulário.

Neste caso os dados do formulário serão enviados para adicionar_livro/.

Portanto, devemos adicionar uma função path() no arquivo livros/urls.py que aponte para a view correta:

livros/urls.py: 

from django.urls import path
from . import views
urlpatterns = [
    ...
  path('adicionar_livro/salvar_adicionar_livro/', views.salvar_adicionar_livro, name='salvar_adicionar_livro'),
]

Até agora fizemos a interface do usuário e apontamos a URL para a view chamada salvar_inserir_livro, mas ainda não criamos a view.

Certifique-se de adicionar a view salvar_adicao_livro no arquivo livros/views.py:

livros/views.py: 

from django.http import HttpResponseRedirect
from django.urls import reverse
from .models import Livros
...
def salvar_adicionar_livro(request):
    x = request.POST['titulo_livro']
    y = request.POST['autor_livro']
    livro = Livros(titulo_livro = x, autor_livro = y)
    livro.save()
    return HttpResponseRedirect(reverse('index'))

Alterações feitas no arquivo views.py:

Linha 1: importação HttpResponseRedirect

Linha 2: importação reversa

A view salvar_adicao_livro faz o seguinte:

  • Obtém o titulo e autor do livro com a instrução request.POST
  • Adiciona um novo registro na tabela de livros
  • Redireciona o usuário de volta para a exibição do index

Tente adicionar um novo registro e veja como funciona:

Se você pressionar o botão enviar, a tabela de livros deve ter sido atualizada:

2.6 - Excluir livro

Para excluir o registro de um livro, o template de livros.

Adicionamos um link "excluir" para cada registro em uma nova coluna da tabela.

O link "excluir" também conterá o ID de cada registro.

2.6.1 - Link excluir no template index.html

Adicione uma coluna "excluir_livro" na template index.html:

livros/templates/index.html: 

<h1>Livros</h1>
<table border="1">
{% for x in meus_livros %}
    <tr>
        <td>{{ x.id }}</td>
        <td>{{ x.titulo_livro }}</td>
        <td>{{ x.autor_livro }}</td>
        <td><a href="excluir_livro/{{ x.id }}">Excluir</a></td>
    </tr>
{% endfor %}
</table>
<p><a href="adicionar/">Adicionar livro</a></p>

O resultado ficará assim:

2.6.2 - URL para view excluir_livro

O link "excluir_livro" na tabela HTML aponta para 127.0.0.1:8000/livros/excluir_livro/ então adicionaremos uma função path() no arquivo livros/urls.py, que aponta a url para o local correto, com o ID como parâmetro:

livros/urls.py: 

from django.urls import path
from . import views
urlpatterns = [
  ...
  path('excluir_livro/<int:id>', views.excluir_livro, name='excluir_livro'),
]

2.6.3 - View excluir livro

Agora precisamos adicionar uma nova view chamada deleteno arquivo livros/views.py:

livros/views.py: 

from django.http import HttpResponse, HttpResponseRedirect
from django.template import loader
from django.urls import reverse
from .models import Livros
...
def excluir_livro(request, id):
    livro = Livros.objects.get(id=id)
    livro.delete()
    return HttpResponseRedirect(reverse('index'))

A view de exclusão faz o seguinte:

  • Obtém o id como um argumento.
  • Usa o id para localizar o registro correto na tabela Livros.
  • Exclui esse registro.
  • Redireciona o usuário de volta para a index exibição.

Clique no link "excluir_livro" para Jane Doe e veja o resultado:

2.7 - Alterar livro

Para alterar os livros cadastrados adicionamos um link no id de cada livro na tabela.

Para atualizar um registro, precisamos do ID do registro e precisamos de um modelo com uma interface que nos permita alterar os valores.

Primeiro precisamos fazer algumas alterações no template index.html.

livros/templates/index.html: 

<h1>Livros</h1>
<table border="1">
    {% for x in meus_livros %}
    <tr>
        <td><a href="alterar_livro/{{ x.id }}">{{ x.id }}</a></td>
        <td>{{ x.titulo_livro }}</td>
        <td>{{ x.autor_livro }}</td>
        <td><a href="excluir_livro/{{ x.id }}">Excluir</a>
    </tr>
    {% endfor %}
</table>
<p><a href="adicionar_livro/">Adicionar livro</a></p>

O link vai para uma view chamada alterar_livro com o id do livro atual.

O resultado ficará assim:

Em seguida, adicione a view alterar_livro no livros/views.py arquivo:

livros/views.py: 

from django.http import HttpResponse
from django.template import loader
from .models import Livros
#
...
def alterar_livro(request, id):
    meu_livro = Livros.objects.get(id=id)
    template = loader.get_template('alterar_livro.html')
    context = {
      'meu_livro': meu_livro,
    }
    return HttpResponse(template.render(context, request))

A view alterar_livro faz o seguinte:

  • Obtém o id como um argumento.
  • Usa o id para localizar o registro correto na tabela Livros.
  • carrega um modelo chamado alterar_livro.html.
  • Cria um objeto contendo o livro.
  • Envia o objeto para o modelo.
  • Gera o HTML que é renderizado pelo modelo.

2.7.1 - Template alterar_livro.html

Adicione o template alterar_livro.html na pasta templates:

livros/templates/alterar_livro.html: 

<h1>Update livro</h1>
<form action="salvar_alterar_livro/{{ meu_livro.id }}" method="post">
{% csrf_token %}
Primeiro nome:<br>
<input name="primeiro" value="{{ meu_livro.titulo_livro }}">
<br><br>
Último nome:<br>
<input name="ultimo" value="{{ meu_livro.autor_livro }}">
<br><br>
<input type="submit" value="Submit">
</form>

O modelo contém um formulário HTML com os valores do livro selecionado.

Nota: O Django requer esta linha no formulário: {% csrf_token %}

para manipular Cross Site Request Forgeries em formulários onde o método é POST.

2.7.2 - URL para alteração

Adicione uma função path() no arquivo livros/urls.py, que aponte a url 127.0.0.1:8000/livros/alterar_livro/ para o local correto, com o ID como parâmetro:

livros/urls.py: 

from django.urls import path
from . import views
urlpatterns = [
  ...
  path('alterar_livro/<int:id>', views.alterar_livro, name='alterar_livro'),
]

No navegador, clique no ID do livro que você deseja alterar e o resultado deve ser semelhante a este:

O atributo action no formulário HTML especifica para onde enviar os dados do formulário.

Para o salvamento das alterações de livro os dados do formulário serão enviados para o endereço salvar_alterar_livro/{{ meu_livro.id }}.

2.8 - Salvar alteração de livro

O atributo action no formulário HTML especifica para onde enviar os dados do formulário.

Para o salvamento das alterações de livro os dados do formulário serão enviados para o endereço salvar_alterar_livro/{{ meu_livro.id }}.

Então devemos criar uma função path() no arquivo livros/urls.py que aponte para a view correta:

livros/urls.py: 

from django.urls import path
from . import views
urlpatterns = [
  ...
  path('alterar_livro/salvar_alterar_livro/<int:id>', views.salvar_alterar_livro, name='salvar_alterar_livro')
]

Até agora fizemos a interface do usuário e apontamos a URL para a view chamada salvar_alterar_livro, mas ainda não criamos a view.

Certifique-se de adicionar a view salvar_alterar_livro no arquivo livros/views.py:

livros/views.py: 

from django.http import HttpResponseRedirect
from django.urls import reverse
from .models import Livros
...  
def salvar_alterar_livro(request, id):
    titulo = request.POST['titulo_livro']
    autor = request.POST['autor_livro']
    livro = Livros.objects.get(id=id)
    livro.titulo_livro = titulo
    livro.autor_livro = autor
    livro.save()
    return HttpResponseRedirect(reverse('index'))

A função salvar_alterar_livro atualizará o registro do livro com o id selecionado na tabela de livros.

Tente atualizar um registro e veja como funciona.

Se você pressionar o botão enviar, a tabela de livros deve ter sido atualizada.

2.9 - Aplicativo livro completo

O aplicativo livro completo tem:

  • Funções-views no arquivo /livros/views.py
  • A template com links para inclusão, exclusão e alteração de livros no arquivo-template index.html
  • O model Livros no arquivo "livros/models.py".

2.9.1 - Model

livros/models.py: 

from django.db import models

class Livros(models.Model):
    titulo_livro = models.CharField(max_length=255)
    autor_livro = models.CharField(max_length=255)

2.9.2 - Templates

livros/templates/index.html: 

<h1>Livros</h1>
<table border="1">
    {% for x in meus_livros %}
    <tr>
        <td><a href="alterar_livro/{{ x.id }}">{{ x.id }}</a></td>
        <td>{{ x.titulo_livro }}</td>
        <td>{{ x.autor_livro }}</td>
        <td><a href="excluir_livro/{{ x.id }}">Excluir</a>
    </tr>
{% endfor %}
</table>
<p><a href="adicionar_livro/">Adicionar livro</a></p>

2.9.3 - Views

livros/views.py: 

from django.http import HttpResponse, HttpResponseRedirect
from django.template import loader
from django.urls import reverse
from .models import Livros
#
def index(request):
    meus_livros = Livros.objects.all().values()
    template = loader.get_template('index.html')
    context = {
      'meus_livros': meus_livros,
    }
    return HttpResponse(template.render(context, request))
#
def adicionar_livro(request):
    template = loader.get_template('adicionar-livro.html')
    return HttpResponse(template.render({}, request))
#
def salvar_adicionar_livro(request):
    x = request.POST['primeiro']
    y = request.POST['ultimo']
    livro = Livros(titulo_livro=x, autor_livro=y)
    livro.save()
    return HttpResponseRedirect(reverse('index'))
#
def excluir_livro(request, id):
    livro = Livros.objects.get(id=id)
    livro.excluir_livro()
    return HttpResponseRedirect(reverse('index'))
#
def alterar_livro(request, id):
    meu_livro = Livros.objects.get(id=id)
    template = loader.get_template('alterar_livro.html')
    context = {
      'meu_livro': meu_livro,
    }
    return HttpResponse(template.render(context, request))
#
def salvar_alterar_livro(request, id):
    titulo = request.POST['titulo_livro']
    autor = request.POST['autor_livro']
    livro = Livros.objects.get(id=id)
    livro.titulo_livro = titulo
    livro.autor_livro = autor
    livro.save()
    return HttpResponseRedirect(reverse('index'))

2.9.4 - URLs

projeto_livraria/urls.py: 

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

urlpatterns = [
    path('livros/', include('livros.urls')),
    path('admin/', admin.site.urls),
]
livros/urls.py: 
from django.urls import path
from . import views
urlpatterns = [
  path('', views.index, name='index'),
  path('adicionar_livro/', views.adicionar_livro, name='adicionar_livro'),
  path('adicionar_livro/salvar_adicionar_livro/', views.salvar_adicionar_livro, name='salvar_adicionar_livro'),
  path('excluir_livro/<int:id>', views.excluir_livro, name='excluir_livro'),
  path('alterar_livro/<int:id>', views.alterar_livro, name='alterar_livro'),
  path('alterar_livro/salvar_alterar_livro/<int:id>', views.salvar_alterar_livro, name='salvar_alterar_livro')
]
Arduino
Coautor
Betobyte
Autor
Autores
||| Áreas ||| Estatística ||| Python ||| Projetos ||| Dicas & Truques ||| Quantum ||| Django || Python para Iniciantes || Python Básico || Matplotlib || Numpy || Seaborn || Pandas || Django || Estatística para Cientistas de Dados || Python com ML Básico || Python com ML Básico || Aulas | Introdução (models, views, templates) | Livraria Exemplo (ambiente virtual, projeto, aplicativo, banco de dados) | Templates (templates HTML e tags django) | QuerySets (consultas de dados com querysets) |