Sumário

1. Sobre o Autor
2. Introdução
Para quem é esse livro?
Por que devo aprender Flask?
Fundamentos de execução
Como baixar o material desse livro
Convenções tipográficas
3. O que é o Flask
4. Configurações e Instalações
Instalando o Python
Configurando o Python e as variáveis de ambiente
Criando um ambiente Flask
Instalando o Flask e seus recursos necessário
5. Criando seu primeiro WebApp
6. Estrutura de arquivos e pastas
7. Como funciona um projeto Flask de uma WebApp?
8. Como funciona uma rota?
9. O que é URL amigável?
10. Como funciona um template?
11. Recursos do Template
Usando uma variável no HTML
Usando IF no HTML
Usando FOR no HTML
12. Criando uma página de erro de rotas
13. Recuperando informações através do GET e POST
14. Criando e gerenciando sessões
O que é Secretkey?
Criando uma Sessão
Recuperando uma Sessão
Excluindo uma Sessão
Restrição de acesso usando Sessão
15. O que é um Dataset?
Criando uma conexão SQLite
Criando uma Tabela
Inserindo dados
Listando dados
Atualizando dados
Excluindo dados
 16. O que é um Blueprint
17. Projeto WebApp – Pizzaria
Criando a página principal
Criando área de acesso para Clientes
Criando área de acesso para Gerentes
Criando área para cadastro de Pizzas
Criando área de Pedidos Clientes/Gerentes
18. Próximos passos
19. Agradecimento
1. Sobre o Autor
Meu nome é Wallace Fragoso sou Desenvolvedor Web e Mobile, com mais de 10 anos de
experiência na área de informática, formado em Análise de Sistemas pela Estácio de Sá em
Natal/RN, pós-graduado em Engenharia de Software pela UFRN, professor e fundador do site
DevAcademy que é um projeto destinado a compartilhar conhecimento e formar novos
profissionais.
Me encontre:
Facebook: [Link]
Instagram: [Link]
E-mail: devacademybr@[Link]

2. Introdução
O Flask é um microframework para a criação de sites ou sistemas web, é considerado um
microframework porque mantêm um núcleo simples. Não há uma camada de abstração do banco
de dados, validação de formulários, ou qualquer outro componente, porém possui bastantes
bibliotecas de terceiros que provem uma gama de funcionalidades.
Nesse livro vamos entender os conceitos e estruturas desse framework incrível, vamos ter um
aprendizado focada nas principais funcionalidades disponíveis na sua documentação, abordando
desde sua instalação, sintaxe e seus principais recursos, dando a você a capacidade de construir
um site ou sistema em poucos minutos!

2.1 Pra quem é esse livro?

Esse livro é destinado a todos os desenvolvedores Python que querem expandir seus
conhecimentos e levá-lo a outro nível, permitindo assim utilizar todos os recursos do Python em
aplicações Web.

2.2 Por que devo aprender Flask?

O Flask é um Framework minimalista que te ajudar a conhecer os principais padrões de
frameworks mais complexo com a vantagem de ser bem simplificado, além disso é a porta de
entrada para frameworks mais robustos como Django.

2.3 Fundamento de execução

As primeiras etapas desse livro tem como objetivo principal apresentar a criação e estrutura do
projeto e apresentar a sintaxe dos principais recursos desse framework, em seguida teremos os
conceitos acompanhado de códigos de fácil aplicação e, por fim, criaremos um projeto completo
usando todo o conhecimento adquirido para criar um WebApp.

2.4 Como baixar o material desse curso

Todo material desse curso poderá ser encontrado nesse LINK
2.5 Convenções tipográficas
Com a finalidade de destacar diferentes tipos de informações neste livro estou adotando uma
convenção que será apresentada a seguir:
Marcação e scripts
Os scripts serão trazidos com estilos de fontes diferentes acompanhadas de sua respectiva página.
Em alguns casos teremos destaques em negrito, direcionando a informação principal abordado.
E por fim uma lista com as informações de cada linha comentada.
1. # coding: utf-8
2. from flask import Flask
3.
4. app = Flask(__name__)
5.
6. @[Link]("/")
7. def ola_mundo():
8. return "Olá Mundo! Esse é meu primeiro WebApp!", 200
9.
10. [Link]()
Linha 4: Iniciando o framework Flask.

3. O que é Flask?
Flask tem a flexibilidade da linguagem de programação Python e provê um modelo simples para
desenvolvimento web. Uma vez importando no Python, Flask pode ser usado para economizar
tempo construindo aplicações web.
É chamado de microframework porque mantêm um núcleo simples mas estendível. Não há uma
camada de abstração do banco de dados, validação de formulários, ou qualquer outro
componente onde bibliotecas de terceiros existem para prover a funcionalidade. Assim, Flask
suporta extensões capazes de adicionar tais funcionalidades na aplicação final. Há uma vasta
coleção de bibliotecas para resolver essas questões em Python, isso simplifica o framework e
torna sua curva de aprendizado mais suave.

4. Configurações e Instalações
Existe uma série de recursos que você precisa ficar atento para que funcione corretamente em seu
computador. Neste livro vamos utilizar os comandos e configurações padrão para o Windows,
porém você consegue facilmente encontrar essa informação para o Linux / Mac.

4.2 Configurando o Python e as variáveis de ambiente

Caso você não tenha o Python instalado na sua máquina:
Baixe o executável de instalação do Python nesse LINK;
Faça a instalação seguindo os passos necessários;
Em seguida instale o PIP caso não esteja instalado, nesse LINK;
 Caso não consiga instalar nesse link, pesquise como instalar PIP no Python 2.7

Por que vamos utilizar o Python 2.7?

Os principais plugins que é utilizado hoje em dia estão na versão 2.7, porém caso você entenda
que a versão 3.x é melhor para sua realidade você pode executar os mesmos comandos que tudo
deve funcionar normalmente.

4.3. Criando um ambiente Flask

Antes de prosseguir vamos instalar o virtualenv que é usado para isolar o ambiente do Flask,
para isso entre no CMD do Windows / Terminal do Linux/MacOS e faça a instalação usando o
seguinte comando:
[Link] -m pip install virtualenv
Aguarde a instalação e vamos configurar o ambiente de fato, seguindo os seguintes passos:
Primeiro crie uma pasta no local onde deseja criar o projeto;
Entre na pasta que você acabou de criar;
Crie 2 arquivos nessa pasta: __init__.py e [Link]
Execute o seguinte comando: C:\Python27\Scripts\[Link]
nome_do_projeto_env
Após terminar de criar o ambiente você deve ir na pasta e ativar o ambiente da
seguinte forma: nome_do_projeto_env\Scripts\activate
Caso o comando tenha sido realizado com sucesso você deve ver o terminal da
seguinte forma: (nome_do_projeto_env) seuuser@suamaquina/path/to/pasta$
Por fim, instale o Flask: pip install Flask

Agora vamos seguir esses passos para criar nosso primeiro projeto:
md Projeto01
cd Projeto01
. > __init__.py
. > [Link]
C:\Python27\Scripts\[Link] pj1_env
pj1_env\Scripts\activate
Seu terminal deve ficar assim:
(pj1_env) C:\Users\seu\caminho\aqui\projeto01>
E instale o Flask
pip install Flask

5. Criando seu primeiro WebApp

Já temos nosso ambiente configurado e vamos executar o nosso primeiro WebApp da seguinte
forma:
Abrar o arquivo que criamos com seu editor de código preferido;
Escreva o seguinte código:
1. # coding: utf-8
2. from flask import Flask
3.
4. app = Flask(__name__)
5.
6. @[Link]("/")
7. def ola_mundo():
8. return "Olá Mundo! Esse é meu primeiro WebApp!", 200
9.
10. [Link]()

Entendendo a nossa primeira aplicação web:

Linha 1 – Definimos a codificação do texto em utf-8 (Padrão para acentuação Brasileira)
Linha 2 – É a importação do framework Flask
Linha 4 – É a criação do nosso aplicativo Web, e passamos como parâmetro o nome do projeto
em questão, que nesse caso estamos utilizando uma variável de ambiente para carregar o nome
do arquivo. Se preferir use app = Flask(“projeto01”).
Linha 5 – É um decorator para definirmos a rota dessa função, nesse caso é a nossa index.
Linha 7 – Criamos uma função simples em Python para atribuir a nossa rota, ou seja, ao iniciar o
projeto web essa função será chamada.
Linha 8 – É o resultado que será apresentado na nossa página principal da nossa aplicação web.
Linha 10 – Agora que a nossa aplicação está pronta, podemos “rodá-la” usando o comando
[Link]()
Para executar nossa primeira página, vamos no terminal e executamos o arquivo [Link]:
(pj1_env) C:\Users\seu\caminho\aqui\projeto01> python [Link]
E deve apresentar a seguinte mensagem:
* Serving Flask app "app" (lazy loading)
* Environment: production
WARNING: Do not use the development server in a production environment.
Use a production WSGI server instead.
* Debug mode: off
* Running on [Link] (Press CTRL+C to quit)
Copie o endereço que foi impresso no terminal e cole-o no seu navegador, e você deve ver sua
primeira aplicação em pleno funcionamento!
E se quiser parar a aplicação para fazer qualquer alteração, você vai até o terminal que está com
essa mensagem e pressione CTRL (Comand) + C, como está apresentado no terminal.

6. Estrutura de arquivos e pastas

A estrutura básica de todo projeto deve seguir da seguinte forma:
/Pasta_do_Projeto
/[Link]
 /templates/*
/static/*
/media_files/*
Pasta_do_Projeto – É a pasta raiz do projeto
[Link] – É o arquivo padrão e de execução do projeto
templates – É uma pasta destinada a organizar todos os arquivos com extensão html
static – É a pasta destinada a inserção de arquivos javascript (.js) e folhas de estilos (.css)
media_files – É a pasta destinada a organização de arquivos de mídias.

7. Como funciona um projeto Flask de uma WebApp?

Como já sabemos o framework Flask é bem simples e com poucos recursos e ele se utiliza de
alguns plugins para gerenciar seus recursos, são eles:
WerkZeug – Um dos recursos mais importantes, é uma biblioteca destinada a criar
uma interface entre o Python e o Web Server. Ela possui a implementação básica de
padrões para interceptar requests e lidar com response, controle de cache, cookies,
HTTP, roteamento de urls.
Jinja2 – É um template engine utilizado para renderizar os recursos do HTML e
interpretar marcações entre coxetes e executá-los como se fosse em Python. Ele vem
com a implementação da maioria dos recursos necessários na construção de
templates html e facilita a customização de template filters, macros e muito mais.
WSGI – É uma implementação de Web Server que usa como base o Apache.

8. Como funciona uma rota?

As rotas são uma parte crucial de toda aplicação web, e neste caso não é diferente, elas são
usadas para associar o que digitamos no URL da página com uma função do nosso framework.
Para isso utilizamos o decorator @[Link](), e passamos como parâmetro o verificador da
URL:
@[Link](“/”)
def inicio()
Isso quer dizer que ao acessar a raiz do projeto o framework deve chamar a function inicio(), ao
acessar a URL [Link]
@[Link](“/casa/”)
def casa()
Neste outro exemplo, ao acessar a URL [Link] o framework vai entender
que você quer acessar a function casa().
Uma das maiores vantagens do Flask é a utilização de URLs de fácil leitura, permitindo assim
que os usuários lembre-se sempre da rota correta, além disso podemos associar facilmente o
nome da URL com nossas functions.
9. O que é URL amigável?
URLs amigáveis são aquelas de fácil compreensão tanto para usuários e quanto para os
buscadores, você bate olho e entende do que trata a página, e é muito mais convidativa a ser
clicada e memorizada e gerando assim mais segurança.
Todas as páginas que criamos utilizado esse framework utiliza-se o endereço padrão de acesso
que é gerado ao iniciar o projeto no terminal, a partir desse endereço padrão todas as nossas
páginas ganham uma extensão que pode ser /casa, /carro, /cadastro, etc.
Algumas recomendações ao criar URL amigáveis:

Não usar acentos, símbolos e caracteres diferentes como ç;

As palavras devem ser separadas por hífen (-);
Use letras minúsculas;
Sempre que possível inclua palavra-chave;
Deve ser mais curta possível.

10. Como funciona um template?

Os Templates são modelos em HTMLs que criamos e podemos utilizá-los em nosso projeto,
porém gerar HTML no Python não é nada divertido, na verdade, é bastante trabalhoso, porque
você precisa fazer o HTML não ter problemas de caracteres epeciais que podem gerar erros ao
serem lidos pelo Python. Por causa disso, o Flask configura o mecanismo do modelo Jinja2 para
você automaticamente.
Para renderizar um modelo, você pode usar o método render_template(). Tudo o que você
precisa fazer é fornecer o nome do modelo e as variáveis que deseja passar para o mecanismo de
modelo como argumentos de palavra-chave.
Sempre que utilizar o render_template certifique-se de criar uma pasta chamada templates na
raiz do projeto, e adicionar seu arquivo HTML dentro desta pasta.
No nosso exemplo, precisamos criar o arquivo templates/modelo_template.html:
1. <html>
2. <body>
3. <p>
4. Iniciando o modelo de template através do método <b>render_template</b>
5. </p>
6. </body>
7. </html>
Agora abra o arquivo ([Link]) do nosso projeto e faça a seguinte adição:
…
2. from flask import Flask, render_template
…
10. @[Link]("/modelo/")
11. def modelo():
12. return render_template("modelo_template.html"), 200
…
Linha 2: Vamos fazer a importação do método render_template.
Linha 10: Vamos adicionar a rota para a adição de uma nova página /modelo.
Linha 11: Criamos a function modelo() para ser direcionado pela URL.
Linha 12: Em vez de utilizarmos apenas um texto, vamos apontar como parâmetro do
render_template a nossa página em HTML.
OBS.: Para que o código funcione corretamente vamos precisar reiniciar o nosso servidor pelo
terminal, utilizando o comando CTRL + C e depois executando o nosso arquivo novamente.
Baixe esse projeto nesse LINK.

11. Recursos do Template

Uma das vantagens de utilizar o Flask é a possibilidade de usarmos todos os recursos e métodos
do Python, esses recursos podem ser usados de várias maneiras e vamos detalhar nesse capítulo.

11.1. Usando uma variável no HTML

As variáveis são os principais recursos do Python, e podemos utilizá-los em nosso HTML,
passando valores das nossas functions ou diretamente na página:
Vamos ver o arquivo templates/modelo_variavel.html:
1. <html>
2. <body>
3. <p>
4. Iniciando o modelo de template passando algumas <b>variáveis</b><br>
5. Meu nome: <b>{{ nome }}</b>
6. </p>
7. </body>
8. </html>
Linha 5: Vamos recuperar a variável nome, que deve vir do nosso método render_template, que
se encontra no arquivo principal do projeto.

No nosso arquivo principal [Link]:

…
14. @[Link]("/variavel/")
15. def variavel():
16. meu_nome = "Wallace Fragoso"
17. return render_template("modelo_variavel.html", nome=meu_nome), 200
…
Vamos criar uma rota para testarmos esse recurso.
Linha 16: Criamos uma variável que só pode ser vista dentro do nosso método, e atribuímos a ele
um valor, nesse caso utilizamos uma string com o meu nome.
Linha 17: No método render_template, podemos adicionar além da origem da página, uma ou
mais variável para ser carregada nesta página. Cada variável deve ser separada por vírgula.
Acesse essa página através da URL [Link] e será possível ver o
resultado.
É importante saber que existem alguns tipos de delimitadores.
Os delimitadores Jinja padrão são configurados da seguinte maneira:
{% %} Utilizada nas declarações.
{{ }} Utilizada para imprimir a saída do modelo.
{# #} Utilizada nos comentários, não são incluídos na saída do modelo.

No arquivo modelo_variavel.html faça os seguintes testes, adicione os seguintes trechos:

Soma: {{ (3+4) }} <br>
Subtração: {{ (3-4) }} <br>
Divisão: {{ (12/4) }} <br>
Multiplicação: {{ (3*4) }} <br>
Ao adicionar esses trechos diretamente na página você vai perceber que foram realizadas as
operações diretamente na página, sem a necessidade de criar variáveis.
Para ver a lista completa de tudo que é possível fazer nas páginas de templates, acesse o LINK
com a documentação do jinja2.

11.2. Usando IF no HTML

Agora que vimos como criar variáveis e acessá-las no nosso template, vamos a outro recurso de
fundamental importância, o condicional IF e ELSE:
No nosso aquivo principal [Link]:
…
19. @[Link]("/condicional/")
20. def condicional():
21. return render_template("modelo_condicional.html"), 200
…
Agora vamos ver o arquivo templates/modelo_condicional.html:
1. <html>
2. <body>
3. <p>
4. Iniciando o modelo de template utilizando <b>condicional IF e ELSE</b><br>
5. 3 é maior do que 5? <br>
6. {% if (3 > 5): %}
7. Sim <br>
8. {% else %}
9. Não <br>
10. {% endif %}
11. </p>
12. </body>
13. </html>
Linha 6: Iniciamos a verificação da condição IF.
Linha 7: Se o resultado for positivo, ou seja, se 3 for maior do que 5.
Linha 8: A condicional else.
Linha 9: Se o resultado for negativo, ou seja, se 3 NÃO for maior do que 5.
Linha 10: E por fim, o fechamento da verificação da condição IF.
Acesse essa página através da URL [Link] e será possível ver o
resultado.

11.3. Usando FOR no HTML

Agora que vimos como criar variáveis e o IF ELSE no condicional, vamos a outro recurso do
template, a repetição FOR:
No nosso aquivo principal [Link]:
…
23. @[Link]("/repeticao/")
24. def repeticao():
25. return render_template("modelo_repeticao.html"), 200
…
Agora vamos ver o arquivo templates/modelo_repeticao.html:
1. <html>
2. <body>
3. <p>
4. Iniciando o modelo de template utilizando a repetição <b>FOR</b><br>
5. {% for i in range(1,5): %}
6. {{ i }} <br>
7. {% endfor %}
8. </p>
9. </body>
10. </html>
Linha 5: Iniciamos a repetição FOR, e usando a função RANGE do Python para criar uma
sequência.
Linha 6: Vamos imprimir o valor sequencial que criamos no RANGE.
Linha 7: Finalizamos a repetição FOR.
Acesse essa página através da URL [Link] e será possível ver o
resultado.

12. Criando uma página de erro de rotas

Em muitos casos precisamos tratar rotas que não foram mapeadas, para uma pessoa que esteja
acessando seu site é uma experiência muito ruim se deparar com uma página de erro, porém
podemos suavizar essa experiência em nosso projeto.
No nosso aquivo principal [Link]:
…
27. @[Link](404)
28. def nao_encontrado(error):
29. return render_template('nao_encontrado.html'), 404
…
Linha 27: Vamos utilizar o decorate @[Link](404) para tratar e direcionar toda página
que o usuário digitou na URL e não foi encontrada em nosso projeto, e enviá-lo para uma página
informando que o que foi digitado não existe.
Agora vamos ver o arquivo templates/nao_encontrado.html:
1. <html>
2. <body>
3. <h1>Hum...</h1>
4. <p>Os nossos duendes não encontrou a página solicitada.</p>
5. </body>
6. </html>
Agora para testarmos o resultado vamos acessar a página digitando qualquer URL que não exista
em nosso projeto, como, por exemplo, [Link] e veremos o resultado.

13. Recuperando informações através do GET e POST

As requisições são envios de informações entre páginas, esses envios podem ser visíveis (GET)
ou invisíveis (POST) para a página solicitante.
Normalmente essas requisições são utilizadas por form ou formulários, e neles podemos definir o
método de envio (method) e os dados que serão enviados, esses dados são identificados através
das entradas de dados, que podem ser inputs com os atributos name e value preenchidos.
Para facilitar o entendimento deste capítulo, vamos criar um novo projeto para reforçar o
aprendizado no que diz respeito a criação de projetos.
Lembre-se de sair do projeto atual para podermos criar esse novo projeto.
Vamos criar esse projeto da seguinte forma:
md ProjetoGetPost
cd ProjetoGetPost
. > __init__.py
. > [Link]
C:\Python27\Scripts\[Link] pjgp_env
pjgp_env\Scripts\activate
E instale o Flask
pip install Flask
Agora vamos ajustar esse nosso projeto, abra o arquivo [Link]:
1. # coding: utf-8
2. from flask import Flask, render_template, request
3.
4. app = Flask(__name__)
5.
6. @[Link]("/")
7. def index():
8. return render_template("[Link]"), 200
9.
10. @[Link]("/form_get/")
11. def form_get():
12. return render_template("formulario_get.html"), 200
13.
14. @[Link]("/form_post/")
15. def form_post():
16. return render_template("formulario_post.html"), 200
17.
18. @[Link]("/resultado/", methods=['GET','POST'])
19. def resultado():
20. if [Link] == "GET":
21. return "Get", 200
22. elif [Link] == "POST":
23. return "Post", 200
24. else:
25. return "Não definido", 200
26.
27. [Link]()

Vamos entender alguns pontos desse novo projeto:

Linha 2: Além de importar os recursos necessários do Flask, vamos importar o request, que é o
método responsável das detecções das requisições.
Linha 18: Vamos utilizar o decorate @[Link] para definir a rota de recuperação das
requisições e vamos detectar o tipo de requisição, se é Get ou Post.
Agora vamos explorar os arquivos HTML.

Abrindo o arquivo templates/[Link]:

1. <html>
2. <body>
3. <h1>Início Projeto Get e Post</h1>
4. <ul>
5. <li> <a href="{{ url_for('form_get') }}">Exemplo Get</a> </li>
6. <li> <a href="{{ url_for('form_post') }}">Exemplo Post</a> </li>
7. </ul>
8. </body>
9. </html>
Linha 5 e 6: Um truque bem legal para gerar a URL do nosso projeto é utilizar o recurso url_for,
que monta completamente a URL baseando-se na rota do nosso projeto.
Abrindo o arquivo templates/formulario_get.html:
1. <html>
2. <body>
3. <h1>Formulário GET</h1>
4. <form method="get" action="{{ url_for('resultado') }}">
5. Nome: <input name="nome"/> <br/>
6. Idade: <input name="idade"/> <br/>
7. <button>Enviar</button>
8. </form>
9. </body>
10. </html>
Linha 4: Utilizando o elemento em HTML form, vamos definir o método para GET e a action ou
a ação do formulário para onde os dados serão enviados.
Linha 5: O elemento em HTML input vai ser utilizado para montar o dado do nome.
Linha 6: O elemento em HTML input vai ser utilizado para montar o dado da idade.
Abrindo o arquivo templates/formulario_post.html:
1. <html>
2. <body>
3. <h1>Formulário POST</h1>
4. <form method="post" action="{{ url_for('resultado') }}">
5. Nome: <input name="nome"/> <br/>
6. Idade: <input name="idade"/> <br/>
7. <button>Enviar</button>
8. </form>
9. </body>
10. </html>
Linha 4: Utilizando o elemento em HTML form, vamos definir o método para POST e a action
ou a ação do formulário para onde os dados serão enviados.
Linha 5: O elemento em HTML input vai ser utilizado para montar o dado do nome.
Linha 6: O elemento em HTML input vai ser utilizado para montar o dado da idade.

Agora vamos ver a diferença entre elas:

Como o projeto ativo, acesso a seguinte URL [Link]
Você vai ver o formulário com os dados do Nome e Idade, preencha elas e clique no botão
ENVIAR.
Vou preenchê-los com os seguintes dados:
Nome: Livro Python Flesk
Idade: 1
Ao clicar no botão enviar ele vai apresentar as seguintes informações:
Ele vai apontar para a URL que preenchemos no ACTION do FORM;
A URL deve ficar assim: [Link]
nome=Livro+Python+Flesk&idade=1
E terá uma mensagem na tela: GET

Agora vamos entender o que aconteceu:

Ao enviar os dados, eles foram capturados pela página resultado que ajustamos no arquivo
[Link], no método resultado() adicionamos um verificador para identificar que tipo de METHOD
foi enviado para essa página. Nesse caso, ele identificou que o METHOD enviado foi o GET, e
por isso ele mostrou exatamente o que queríamos. Por fim, a URL mostra exatamente o que
enviamos pelo nosso formulário, identificando o nome e a idade atribuindo os valores que
definirmos na página form_get.
Agora vamos fazer o mesmo com o POST na URL [Link]
Vou preenchê-los com os mesmos dados:
Nome: Livro Python Flesk
Idade: 1
E vamos ver as diferenças ao clicar no botão enviar:
Ele vai apontar para a URL que preenchemos no ACTION do FORM;
A URL deve ficar assim: [Link]

E terá uma mensagem na tela: POST

Para que possamos ver o resultado igual que vimos no GET vamos fazer a seguinte alteração no
arquivo [Link]:
Na linha 23 altere essa linha para
22. elif [Link] == "POST":
23. nome = [Link]["nome"]
24. idade = [Link]["idade"]
25. return "Nome: {} - Idade: {}<br>Post".format(nome, idade), 200
26. else:
Agora sim, você será capaz de ver o resultado do que enviamos do formulário.
Outra opção que podemos utilizar em nossos projetos que foge desses dois métodos é a
passagem de parâmetros via URL. Esse recurso é muito utilizado em API e bastante usado em
vários projetos Flask, um exemplo de URL é [Link] agora vamos
entender e saber como podemos construir e recuperar essas informações:
No mesmo arquivo vamos criar nossa função para recuperar essa informação:
…
29. @[Link]("/api/")
30. @[Link]("/api/<versao>/")
31. @[Link]("/api/<versao>/<metodo>/")
32. @[Link]("/api/<versao>/<metodo>/<pagina>/")
33. def api(versao = None, metodo = None, pagina = None):
34. return "Versao: {}<br> Metodo: {}<br> Página: {}".format(versao, metodo, pagina),
200
…
Linha 29, 30, 31 e 32: Vamos ajustar as rotas para receber todos os valores que possamos pela
URL e identificar qual informação estamos recebendo.
Linha 33: Vamos criar a função que corresponde a rota da API e atribuir os parâmetros de cada
valor que esperamos ter.
Linha 34: Agora vamos ver o resultado na tela, usando a function format do Python para
organizar melhor os dados.
Agora veja o resultado acessando a URL [Link]
É possível também estabelecer esses parâmetros com os seguintes tipos:
string (padrão) Aceita qualquer tipo de texto sem barras (/)
int Aceita inteiros positivos (1, 2l, 100, etc ...);
float Aceita pontos flutuantes positivos (13.1, 11.2, etc ...);
path Assim como string, porém aceita barras (/local/da/pasta);
uuid Aceita strings do tipo UUID (89c27436-d64d);

14. Criando e gerenciando sessões

Sessões são uma forma simples de armazenar dados para usuários individuais usando um ID de
sessão único. Elas podem ser usadas para persistir informações entre requisições de páginas e são
enviados ao navegador através de cookies de sessão e o ID, que pode ser usado para recuperar
dados da sessão existente. Caso uma ID ou cookie de sessão não exista, isso significa que
podemos criar uma nova sessão e gerar um novo ID de sessão.
O principal uso das sessões é compartilhar dados entre páginas de um mesmo projeto, assim você
não precisa ficar solicitando sempre ao banco de dados. Um dos usos mais clássicos da sessão é a
restrição de acesso às algumas páginas, validadas pelo tipo do usuário, vamos ver um exemplo
assim neste capítulo.

14.1. O que é Secretkey?

Uma parte importante das sessões são o seu segredo, e por isso precisamos cuidar muito bem
desses dados que ficam expostos em nossas páginas, e para evitar que qualquer um acesse essa
informação o Flask exige que você crie uma chave que será usada por ele para encriptar os dados
que são armazenados. Essa chave é usada como uma assinatura eletrônica por ele para manipular
facilmente os dados.
Essa chave pode ser criada como você preferir, por exemplo, você pode querer escrever seu
nome, seu aniversário, nome do seu cachorro ou uma sequência de números/letras que formam
uma frase, ou simplesmente criar uma chave usando um gerador em MD5.
Antes de prosseguir vamos criar um novo projeto para explorarmos esses recursos:
md ProjetoSession
cd ProjetoSession
. > __init__.py
. > [Link]
C:\Python27\Scripts\[Link] pjss_env
pjss_env\Scripts\activate
E instale o Flask
pip install Flask
Agora vamos ajustar esse nosso projeto, abra o arquivo [Link]:
1. # coding: utf-8
2. from flask import Flask, session
3.
4. app = Flask(__name__)
5. app.secret_key = 'MINHA_CHAVE_SECRETA' # nessário para a criação da sessão
6.
7. @[Link]('/')
8. def index():
9. return "Olá Sessão", 200
10.
11. [Link]()
Linha 2: Vamos importar o nosso framework Flask e a session para podermos utilizá-la.
Linha 5: Vamos criar a assinatura do projeto, no meu caso eu apenas escrevi um texto, porém é
recomendado que crie algo único para cada projeto.
Para que possamos entender melhor o gerenciamento da sessão, vamos fazer algumas alterações
no nosso arquivo principal para realizar as verificações necessárias.
Então precisamos que o arquivo [Link] esteja da seguinte forma:
1. # coding: utf-8
2. from flask import Flask, request, redirect, session, url_for
3.
4. app = Flask(__name__)
5. app.secret_key = 'MINHA_CHAVE_SECRETA' # nessário para a criação da sessão
6.
7. @[Link]('/')
8. def index():
9. html = '''<h1>Bem vindo ao Projeto Sessão</h1><p>Essa é a tela principal, logo abaixo
veremos se você está <i>Logado</i></p>'''
10.
11. if 'usuario' in session:
12. return html + '<p>Parabéns! Você está logado com o usuário {}. <a href="
{}">Sair</a></p>'.format(session['usuario'],url_for('logout'))
13. return html + '<p>Você não está logado, por favor acesse a área de <a href="'+
url_for('login') +'">Login</a>.</p>'
14.
15. @[Link]('/login', methods=['GET', 'POST'])
16. def login():
17. if [Link] == 'POST':
18. session['usuario'] = [Link]['usuario']
19. return redirect(url_for('index'))
20. return '''
21. <form method="post">
22. Usuário: <input type=text name=usuario> <br>
23. <input type=submit value=Entrar>
24. </form>
25. '''
26.
27. @[Link]('/logout')
28. def logout():
29. [Link]('usuario', None)
30. return redirect(url_for('index'))
31.
32. [Link]()

14.2. Criando uma Sessão

Ao configurar o projeto com a assinatura eletrônica e importar a session podermos começar a
manipular a sessão:
…
15. @[Link]('/login', methods=['GET', 'POST'])
16. def login():
17. if [Link] == 'POST':
18. session['usuario'] = [Link]['usuario']
19. return redirect(url_for('index'))
20. return '''
21. <form method="post">
22. Usuário: <input type=text name=usuario> <br>
23. <input type=submit value=Entrar>
24. </form>
25. '''
…
Nesse trecho de código estamos gerenciando a tela de login, caso o acesso a essa página seja
feita através de uma requisição POST, entendemos que precisamos cadastrar o nosso usuários,
caso contrário entendemos que não existe usuário logado e por isso precisamos mostrar um
formulário para que ele possa logar.
Linha 18: Nessa linha criamos a nossa sessão, neste caso estamos criando uma sessão chamada
usuario e nele vamos cadastrar o nome do usuário que foi enviada pelo formulário.
A variável de sessão pode armazenar qualquer tipo de dado, seja texto simples à tuplas

14.3. Recuperando uma Sessão

Para recuperar uma sessão, utilizamos o mesmo parametro do que usamos para cadastra-lo, no
nosso caso vamos recuperar a informação do usuario que foi armazenada no ato do login:
…
7. @[Link]('/')
8. def index():
9. html = '''<h1>Bem vindo ao Projeto Sessão</h1><p>Essa é a tela principal, logo abaixo
veremos se você está <i>Logado</i></p>'''
10.
11. if 'usuario' in session:
12. return html + '<p>Parabéns! Você está logado com o usuário {}. <a href="
{}">Sair</a></p>'.format(session['usuario'],url_for('logout'))
13. return html + '<p>Você não está logado, por favor acesse a área de <a href="'+
url_for('login') +'">Login</a>.</p>'
…
Linha 11: Vamos fazer uma verificação, e ver se na sessão existe o parâmetro que criamos, se ele
existir então prossiga.
Linha 12: Caso nossa sessão exista e tenha alguma informação, então vamos exibi-la, e neste
caso vamos dar a opção do usuário encerrar a sessão.

14.4. Excluindo uma Sessão

Para excluir a sessão, basta removê-la usando o comando pop():
…
27. @[Link]('/logout')
28. def logout():
29. [Link]('usuario', None)
30. return redirect(url_for('index'))
…
Linha 29: Vamos remover a sessão atual do usuário e em seguida redirecionamos para a tela
principal.

14.5. Restrição de acesso usando Sessão

Agora vamos criar uma área com restrição:
…
31.
32. @[Link]('/restrito')
33. def restrito():
34. if 'usuario' in session:
35. return 'Olá {}, <br> Você está autorizado a acessar está
área.'.format(session['usuario'])
36. return redirect(url_for('index'))
37.
…
Hora de testar, primeiro execute o projeto:
python [Link]
Acesse na URL [Link]
Você vai ver que não existe sessão, vamos clicar no link em Login.
Coloque o seu nome.
Assim que você clicar em entrar você será levado para a tela principal com o seu nome ativo.
Agora clique no link sair.
Agora tente acessar a URL que criamos a restrição [Link]
Você será redirecionado para a página principal, pois você não está logado.
Agora faça o login novamente e tente acessar a área do restrito.
Agora sim você será capaz de ver essa tela, pois você está autorizado a acessar essa área.
15. O que é um Dataset?
Um dos melhores recursos de todo site ou sistema, é ter a possibilidade de armazenar
informações, e usá-las para potencializar nossos objetivos. E Para poder armazenar informações,
precisamos guardá-las em algum lugar, e o mais comum é usarmos Bancos de Dados.
Bancos de dados ou bases de dados são um conjunto de arquivos relacionados entre si com
registros. Eles são coleções de dados que se relacionam para atribuir algum sentido e/ou
eficiência durante ao seu serviço.
Os bancos de dados atualmente são divididos em relacional (Mysql, Sql Server, SQLite, etc …) e
banco de dados não relacional (MongoDB, DynamoDB, ArangoDB, Oracle NoSQL, etc …).
Vamos abordar apenas o uso de banco de dados relacional, e principalmente o SQLite, porém
você pode utilizar o banco de sua preferência. Além disso vamos utilizar uma biblioteca para
abstrair ao máximo o uso do banco de dados, vamos utilizar o Dataset.
Não vou entrar em detalhes a respeito das operações de banco de dados, espero que você tenha
algum conhecimento a respeito, caso não tenha procure algum material de apoio para os
principais recursos de um banco de dados. Porém você não terá dificuldades de acompanhar esse
projeto, pois utilizamos uma linguagem simplificada que facilitará seu aprendizado.
Basicamente todo banco de dados relacional tem os seguintes aspectos:
Nome do banco: É o nome dado ao banco, todo banco de dados tem várias tabelas;
Tabelas: Uma tabela é composta por linhas e colunas, assim como no Excel;
Colunas: As colunas representa uma chave fixa, ou seja, ela é predefinida no início
da tabela ou é adicionada posteriormente quando há necessidade;
Linhas: São os dados em si, quando construímos um banco o que queremos extrair
deles é exatamente as linhas.

Como de costume vamos criar um novo projeto para reforçar nosso aprendizado:
md ProjetoBanco
cd ProjetoBanco
. > __init__.py
. > [Link]
C:\Python27\Scripts\[Link] pjdb_env
pjdb_env\Scripts\activate
E instale o Flask e o Dataset
pip install Flask
pip install dataset

15.1. Criando uma conexão SQLite

Para se conectar a um banco de dados, você precisa identificá-lo por sua URL, que basicamente é
uma string no formato "dialect://user:password@host/dbname". Aqui estão alguns exemplos para
diferentes tipos de banco de dados:
# conexão usando o banco SQLite
db = [Link]('sqlite:///[Link]')
# conexão usando o banco MySQL passando o usuário e senha
db = [Link]('mysql://user:password@localhost/mydatabase')
No nosso caso vamos utilizar a conexão do sqlite e para isso precisamos ajustar nosso projeto.
Abra o arquivo [Link] e escreva:
1. # coding: utf-8
2. from flask import Flask
3. import dataset
4.
5. app = Flask(__name__)
6. db = [Link]('sqlite:///[Link]')
7.
8. @[Link]('/')
9. def index():
10. return "Olá SQLite!", 200
11.
12. [Link]()
Linha 3: Vamos importar o dataset, para podermos manipular as informações do banco de
maneira simplifica.
Linha 6: Criamos uma variável chamada db, ou data base, usando uma conexão SQLite. Note
que nomeamos o banco de dados de [Link] e esse arquivo pode ser acessado na raiz
do seu projeto.

15.2. Criando uma Tabela

Para armazenar dados, você precisa ter como referência uma tabela. Usando o dataset você não
precisa se preocupar se a tabela já existe ou não, pois ele fará esse trabalho para nós, vamos
alterar o nosso arquivo [Link] e fazer os ajustes necessários:
…
8. @[Link]('/')
9. def index():
10. pessoa = db['pessoa']
11. return "Olá SQLite!", 200
…
Linha 10: Vamos criar uma variável que representará nossa tabela e iniciamos ela usando nossa
conexão com o banco de dados db['pessoa'] passando como parâmetro o nome da tabela que
queremos manipular.

15.3. Inserindo dados

Com nossa tabela construída precisamos criar inserir dados nela, para isso vamos utilizar a
função insert. Além disso como estamos utilizando o dataset você não vai precisar criar os
dados das colunas, pois ele fará isso automaticamente:
…
8. @[Link]('/')
9. def index():
10. pessoa = db['pessoa']
11. [Link](dict(nome="Wallace", idade=30))
12. return "Olá SQLite!", 200
…
Linha 11: Utilizando nossa variável da tabela, vamos usar a função insert e passar como
parâmetro um dicionário com a chave (representando nossa coluna) e o valor (representando o
dado para a linha)
Ao executar esse projeto vamos notar que nada vai mudar, não será apresentada nenhuma
informação, porém os dados foram inseridos.
Para podermos manipular melhor as informações, vamos adicionar outras informações:
[Link](dict(nome="Vanessa", idade=45))
[Link](dict(nome="Paula", idade=21))
[Link](dict(nome="Arthur", idade=18))
[Link](dict(nome="Miguel", idade=31))

15.4. Listando dados

Para listar os dados e apresentá-los a nossa página precisamos entender 3 formas que o dataset
oferece ao fazer a listagem:
Listar tudo
Para listar todas as informações da tabela, vamos utilizar a função all.
…
24. @[Link]('/listar_tudo/')
25. def listartudo():
26. lista = db['pessoa'].all()
27. html = u"Listando tudo!<br>"
28.
29. for linha in lista:
30. html = html + str(linha['id']) + u" - Nome: " + linha['nome'] + u" - Idade: " +
str(linha['idade']) + u"<br>"
31. return html, 200
…
Linha 26: Vamos criar uma variável chamado lista para armazenar o retorno de todos os dados
do nosso banco, e em seguida vamos usar a função all para listar os dados da tabela pessoa.
Linha 29: Vamos percorrer a lista utilizando o laço de repetição for, e armazenar cada linha que
retornar na variável linha.
Linha 30: Em seguida vamos adicionar cada informação que foi retornada na linha ao nosso
html, lembre-se de sempre colocar como parâmetro apenas as informações da coluna, no nosso
caso utilizei as colunas id (criado automaticamente), nome e idade.
Execute o projeto e veja os resultados obtidos, acessando a URL
[Link]
Listar uma linha
Para listar apenas uma linha da nossa tabela, vamos utilizar a função find_one.
…
33. @[Link]('/listar_um/')
34. def listarum():
35. linha = db['pessoa'].find_one(nome="Wallace")
36. html = u"Listando um!<br>"
37. html = html + str(linha['id']) + u" - Nome: " + linha['nome'] + u" - Idade: " +
str(linha['idade']) + u"<br>"
38. return html, 200
…
Linha 35: Vamos recuperar apenas uma linha da nossa tabela, usando a função find_one,
passando como parâmetro o nome da coluna e a informação que procuramos.
Linha 37: Com a informação da linha recuperada, podemos agora acessar as informações dela e
passar para nosso html.
Execute o projeto e veja os resultados obtidos, acessando a URL
[Link]
Listar com filtros
E por fim, podemos fazer uma busca em nossa tabela utilizando filtros específicos, para isso
vamos usar a função find.
Podemos ordenar nossa tabela:
db['pessoa'].find(order_by='nome')
Podemos também listar apenas algumas linhas:
db['pessoa'].find(_limit=2)
Ou até carregar a partir de algum registro específico:
db['pessoa'].find(_offset=2)
Caso seja necessário podemos utilizar a função query para fazer qualquer tipo de consulta no
banco, utilizando qualquer operação do banco selecionado:
[Link]('SELECT * FROM pessoa')
Vejamos como fica:
…
40. @[Link]('/listar_com_filtros/')
41. def listarcomfiltros():
42. lista = db['pessoa'].find(_limit=2, order_by='nome', _offset=2)
43. html = u"Listando com filtros!<br>"
44.
45. for linha in lista:
46. html = html + str(linha['id']) + u" - Nome: " + linha['nome'] + u" - Idade: " +
str(linha['idade']) + u"<br>"
47. return html, 200
…
Linha 42: Filtrando a tabela pessoa, limitando por 2 linhas, a partir da segunda linha e ordenado
pela coluna nome.

15.5. Atualizando dados

Para atualizar os dados da tabela, vamos utilizar a função update, passando como primeiro
parâmetro um dicionário com os dados que queremos alterar e o segundo parâmetro um filtro,
como por exemplo o id do registro que queremos alterar.
…
50. @[Link]('/atualizar/')
51. def atualizar():
52. db['pessoa'].update(dict(id=1,idade=40), ['id'])
53. return u"Alterando a idade da pessoa <b>Wallace</b> para 40.", 200
…
Linha 52: Usando a tabela pessoa e a função update para alterar o dicionário que passamos,
sendo que o que realmente vai ser alterado é a idade do registro 1.

15.6. Excluindo dados

Para excluir qualquer registro da tabela vamos utilizar a função delete:
…
55. @[Link]('/excluir/')
56. def excluir():
57. db['pessoa'].delete(id=5)
58. return u"Excluindo o registro com id<b>5</b>.", 200
…
Linha 57: Excluindo o registro com o id 5.
Com essa última operação concluímos esse capítulo e com tudo que aprendemos até aqui, já
podemos criar um sistema!
16. O que é um Blueprint
Blueprints são projetos Flask separados em arquivos e que podem ter funcionalidades
complementares e únicas. Cada Blueprint pode ser usados em camadas e isso te ajuda a organizar
melhor o seu projeto.
Para exemplificar vamos criar um novo projeto:
md ProjetoBlueprint
cd ProjetoBlueprint
. > __init__.py
. > [Link]
C:\Python27\Scripts\[Link] pjbp_env
pjbp_env\Scripts\activate
E instale o Flask:
pip install Flask
Para entender como funcionará o nosso projetos, vamos imaginar que neste projeto tenhamos 2
funcionalidades que podem ser usadas em qualquer projeto, como por exemplo transformar
nossos dados em uma API e outro exemplo e a conversão de Arquivos.
Para não poluir nosso arquivo principal vamos criar 2 Blueprints e um outro para carregar as
informações da tela inicial.
Nosso projeto deve ficar assim:
ProjetoBlueprint/
__init__.py
[Link]
pjbp_env/
blueprints/
__init__.py
[Link]
[Link]
[Link]
Portanto vamos ajustar nosso arquivo [Link]:
1. # coding: utf-8
2. from flask import Flask
3. from [Link] import bp_index
4. from [Link] import bp_api
5. from [Link] import bp_converter
6.
7. app = Flask(__name__)
8. app.register_blueprint(bp_index)
9. app.register_blueprint(bp_api)
10. app.register_blueprint(bp_converter)
11.
12. [Link]()
Linha 3, 4 e 5: Faz a importação dos arquivos que usaremos nesse aplicativo, e carrega a variável
do Blueprint de cada arquivo.
Linha 8, 9 e 10: Registra cada Blueprint importado ao nosso aplicativo principal.
Vamos dar uma olhada em cada arquivo:
blueprints/[Link]:
1. # coding: utf-8
2. from flask import Blueprint
3.
4. bp_index = Blueprint('index', __name__)
5.
6. @bp_index.route('/')
7. def index():
8. return u"Olá Projeto Blueprint!", 200
blueprints/[Link]:
1. # coding: utf-8
2. from flask import Blueprint
3.
4. bp_api = Blueprint('api', __name__)
5.
6. @bp_api.route('/api/')
7. def api():
8. return u"Olá Você está na página da API!", 200
blueprints/[Link]:
1. # coding: utf-8
2. from flask import Blueprint
3.
4. bp_converter = Blueprint('converter', __name__)
5.
6. @bp_converter.route('/converter/')
7. def converter():
8. return u"Olá Você está na página da CONVERTER!", 200
Vamos ver o que eles tem em comum:
Linha 4: Cria o Blueprint e ajusta o nome para facilitar a identificação.
Linha 6: Adiciona a rota de acordo com o nome dado ao Blueprint.
Note que basicamente todos são iguais, porém cada um registra a rota de forma separada, e pode
ser acessado de acordo com elas, vamos executar nosso projeto.
No seu terminal com o pjbp_env ativo, execute o comando: python [Link]
Agora vamos acessar todas as rotas cadastradas no projeto e ver o resultado:
[Link] ← Acessa o Blueprint [Link]
[Link] ← Acessa o Blueprint [Link]
[Link] ← Acessa o Blueprint [Link]

Com esse recurso podemos gerenciar melhores nossos projetos e separar os arquivos de acordo
com nossa necessidade, sem ter que nos preocupar de ficar gerenciando em uma infinidade de
ações em um único arquivo.
Com isso finalizamos todos os conceitos básico desse framework, agora vamos pôr em prática
tudo o que aprendemos em um projeto!
17. Projeto WebApp – Pizzaria
Vamos criar um site com sistema para uma Pizzaria qualquer, como todos nós já deve ter tido
algum contato com algum site, ou até mesmo a falta de um, de alguma pizzaria de bairro.
Para isso vamos explorar algumas das principais características desses refinados
estabelecimentos, começando do acesso à lista de Pizza até a entrega do pedido ao cliente.
Vamos estabelecer os seguintes REQUISITOS:
O site deve apresentar TODAS as Pizzas disponíveis;
Essas Pizzas são cadastradas pelo pelo Gerente;
O Cliente só PODE realizar os pedidos, caso estejam cadastrados e logados no
sistema;
O Cliente DEVE realizar seu cadastro de maneira simplificada, informando seu
Nome, E-mail, Senha;
O Gerente deve informar os status (Recebido, Enviar para o cliente, etc) do pedido
do Cliente;
O Gerente não pode ter acesso aos dados dos Clientes;

Essa é a ideia principal do nosso projeto e agora podemos começar a separar as atividades de
cada ATOR, atribuindo suas responsabilidades e restrições. Porém não vou entrar a fundo na
construção de modelos UML ou mapeamento de banco de dados, pois não é o objetivo deste
livro.
Vamos criar nosso projeto final:
md ProjetoPizzaria
cd ProjetoPizzaria
. > __init__.py
. > [Link]
C:\Python27\Scripts\[Link] pjfinal_env
pjfinal_env\Scripts\activate
E instale o Flask:
pip install Flask
pip install dataset
Agora vamos organizar nossa estrutura de pastas:

ProjetoPizzaria_v1/
__init__.py
[Link]
pjfinal_env/
controller/
__init__.py
[Link]
templates/
site/
[Link]
 static/
css/
[Link]
js/
img/
[Link]
util/
A medida que formos construindo o projeto, vamos preenchendo as informações com os
arquivos e/ou com novas estruturas.
A pasta static é destinada aos arquivos que desejamos carregar dentro das nossas páginas em
html, e carregá-los utilizando a função url_for.
Nesse nosso projeto vamos utilizar essa pasta para os arquivos de css, javascript e as imagens
que pretendemos carregar.
Podemos acompanhar essa configuração na pasta ProjetoPizzaria_v1.
A pasta pjfinal_env foi removida devido o seu tamanho, se sempre que for testar o projeto,
lembre-se de adicioná-la à raiz do projeto para que tudo funcione corretamente.

17.1. Criando a página principal

Na página principal vamos criar uma tela simples com as informações que qualquer um pode
consultar, com os preços e as pizzas. Para você não se perder, vamos fazer a criação aos poucos,
tela a tela e com suas características inicial e em seguida com seus ajustes.
Ao executarmos o ProjetoPizzaria_v1, podemos destacar alguns pontos importantes:
No arquivo [Link]:
1. # coding: utf-8
2. from flask import Flask
3. from [Link] import bp_site
4.
5. app = Flask(__name__)
6. app.register_blueprint(bp_site)
7.
8. [Link]()
Linha 3: Vamos separar cada propriedade em vários Blueprints, para termos controle absoluto e
melhorar a organização do nosso projeto.
Linha 6: Não se esqueça de registrar o Blueprint sempre que importar.
No arquivo templates/site/[Link]:
1. <html>
2. <head>
3. <title>Pizzaria - Projeto Final</title>
4. <link rel="stylesheet" href="{{ url_for('static', filename='css/[Link]') }}">
5. </head>
6. <body>
…
Linha 4: Estamos carregando a folha de estilo do css através da pasta static.
Como o objetivo é aprender sobre o framework Flask, não vamos dedicar tempo discutindo o que
foi feito no css, ou até mesmo na forma que o site da Pizzaria foi feito. Fique à vontade para
fazer seus ajustes, porém nesse momento sugiro que dê mais atenção em como o projeto está
sendo feito, do que no design em si.
Uma das primeiras coisas que precisamos fazer antes de criar a área dos clientes, é ter o acesso
aos usuários, e para isso precisamos criar a tela de login.

17.2. Criando área de acesso para Clientes

Vamos criar um Blueprint bp_usuario, e ter a possibilidade de fazer login, sair do sistema e
alterar seus dados, e por isso precisamo criar também o gerenciamento da sessão, vamos lá.
Para você ter uma ideia das alterações que foram feitas, eu criei outro projeto chamado
ProjetoPizzaria_v2 e nele você pode ver as alterações necessárias para a construção do
gerenciamento de usuários.
ProjetoPizzaria_v2/
__init__.py
[Link]
pjfinal_env/
controller/
__init__.py
[Link]
[Link]
templates/
site/
usuario/
[Link]
[Link]
erro_cadastro.html
sucesso_cadastro.html
static/
util/
[Link]
No arquivo [Link]:
1. # coding: utf-8
2. from flask import Flask, session
3. from [Link] import bp_site
4. from [Link] import bp_usuario
5.
6. app = Flask(__name__)
7. app.secret_key = b'_5#y2L"F4Q8z\n\xec]/'
8.
9. app.register_blueprint(bp_site)
10. app.register_blueprint(bp_usuario)
11.
12. [Link]()
Linha 4: Estou importando o Blueprint de usuario.
Linha 7: Estou adicionando uma chave para o gerenciamento das sessões.
Linha 10: Estou registrando o Blueprint de usuario para o nosso aplicativo principal.
No arquivo util/[Link]:
1. # coding: utf-8
2. import dataset
3.
4. class Banco:
5. def saveUsuario(self, nome, usuario, senha):
6. with [Link]('sqlite:///[Link]') as db:
7. if ( [Link](usuario, senha) ):
8. return False
9. else:
10 return db['usuario'].insert(dict(nome=nome, usuario=usuario, senha=senha))
11.
12. def getUsuario(self, usuario, senha):
13. with [Link]('sqlite:///[Link]') as db:
14. usuario = db['usuario'].find_one(usuario=usuario, senha=senha)
15.
16. if usuario:
17. return usuario
18. else:
19. return False
Esse arquivo é destinado ao gerenciamento de todas as funções que serão relacionadas ao banco
de dados, e por isso vamos começar criando alguns métodos.
Linha 2: Faz a importação do nosso conector que usaremos para gerenciar as requisições ao
banco SQLite.
Linha 5: Esse método serve para adicionar novos usuários ao nosso sistema;
Linha 12: Esse método serve para verificar se os usuários já estão cadastrado no sistema;
No arquivo controller/[Link]:
1. # coding: utf-8
2. from flask import Blueprint, render_template, session, request, redirect, url_for
3. from [Link] import Banco
4.
5. bp_usuario = Blueprint('usuario', __name__)
6. banco = Banco()
…
Linha 2: Vamos fazer a importação de todos os recursos do framework que vamos precisar usar.
Linha 3: Vamos importar o gerenciador de conexão.
Linha 5: Criaremos o Blueprint chamado usuario.
Linha 6: Vamos iniciar nossa classe e criar uma variável para usar nesse Blueprint.
Vamos configurar a rota para acessar a área de Login através da URL
[Link]
…
8. @bp_usuario.route('/usuario/login/')
9. def login():
10. return render_template("usuario/[Link]"), 200
…
Essa área vai carregar as informações do formulário de login, para o usuário acessar o sistema ou
criar uma conta.
Como inicialmente você não deve ter nenhum usuário registrado, podemos criá-lo através dessa
função:
…
24. @bp_usuario.route('/usuario/registro/')
25. def registro():
26. return render_template("usuario/[Link]"), 200
…
Agora ao acessar o link do registro, podemos ver o formulário para cadastrar nosso primeiro
usuário, que será gerenciado através da função:
…
28. @bp_usuario.route('/usuario/cadastro/', methods=['GET','POST'])
29. def cadastro():
30. if [Link] == "GET":
31. return render_template("usuario/erro_cadastro.html"), 200
32. elif [Link] == "POST":
33. if ( [Link]([Link]['nome'], [Link]['usuario'],
[Link]['senha']) ):
34. session['usuario'] = {"nome": [Link]['nome'], "usuario":
[Link]['usuario']}
35. return render_template("usuario/sucesso_cadastro.html"), 200
36. else:
37. return render_template("usuario/erro_cadastro.html"), 200
…
Linha 31: Se por acaso alguém tentar realizar o cadastro que não seja pelo formulário, ele vai
apresentar uma tela de Erro.
Linha 33 e 34: Se ele usar o formulário corretamente, vamos tentar salvar o usuário, e se der tudo
certo ele deve cadastrar no banco de dados e armazenar na sessão o nome do usuário e seu login.
Linha 37: Caso ele informe um usuário invalido, ou tenha algum erro na execução do cadastro,
ele será levado para uma tela de erro de cadastro e poderá tentar novamente.
Agora que já sabemos como cadastrar um usuário, vamos ver se esse usuário existe e direcionar
para a tela principal, carregando as informações dele na sessão.
Ao acessar a URL [Link] você poderá digitar seu usuário e senha
que você criou, se ele existir, então vamos logar no sistema, se não vamos apresentar uma
mensagem de erro informando que o usuário não existe ou é invalido!
…
12. @bp_usuario.route('/usuario/autenticar/', methods=['GET','POST'])
13. def autenticar():
14. if [Link] == "GET":
15. return render_template("usuario/[Link]", erro=u"Não foi possível realizar
o login!"), 200
16. elif [Link] == "POST":
17. usuario = [Link]([Link]['usuario'], [Link]['senha'])
18. if ( usuario ):
19. session['usuario'] = {"nome": usuario['nome'], "usuario": usuario['usuario']}
20. return redirect(url_for('[Link]'))
21. else:
22. return render_template("usuario/[Link]", erro=u"Usuário ou Senha inválidos!"),
200
…
Linha 15: Se ele tentar logar sem usar o formulário, ele vai apresentar a mensagem de erro “Não
foi possível realizar o login!”.
Linha 17, 18, 19 e 20: Se ele fizer o login através do formulário, ele vai verificar se o usuário
existe acessando o banco de dados ([Link]), se ele identificar que o usuário
corresponde ao usuário que está no banco de dados, então ele vai deixar o usuário ir para a tela
principal, se não ele vai redirecionar para a tela de login com a mensagem “Usuário ou senha
inválidos!”.
Agora que já podemos criar um usuário, e fizemos o login do usuário, precisamos sair do nosso
usuário.
…
39. @bp_usuario.route('/usuario/sair/')
40. def sair():
41. [Link]('usuario', None)
42. return redirect(url_for('[Link]'))
…
Neste caso não precisamos verificar a existência de nenhum formulário, ele pode sair do sistema
da forma que preferir, seja clicando no botão de sair na tela principal ou apenas digitando a URL
[Link] em seu navegador, que assim que acessar, ele será
redirecionado para a tela principal sem utilizar o seu usuário.
E com isso finalizamos a segunda parte do projeto, que é destinada ao gerenciamento de
usuários.
Agora que podemos gerenciar os usuários, precisamos identificar o tipo, para os clientes vamos
criar no banco de dados a informação tipo, e para o público em geral vamos identificá-lo como
usuário.
Separei esses ajustes no ProjetoPizzaria_v3.
No arquivo templates/usuario/[Link]:
…
84. <form action="{{ url_for('[Link]') }}" method="post">
85. <div class="container">
86. <input type="hidden" name="tipo" value="usuario"/>
87. <label for="nome"><b>Nome</b></label>
88. <input type="text" placeholder="Digite seu Nome" name="nome" required>
89.
90. <label for="usuario"><b>Usuário</b></label>
91. <input type="text" placeholder="Digite seu Usuário" name="usuario" required>
92.
93. <label for="senha"><b>Senha</b></label>
94. <input type="password" placeholder="Digite sua Senha" name="senha" required>
95.
96. <button type="submit">Cadastrar</button>
97. <br>
98. <button type="button" class="cancelbtn" onclick="[Link] = '{{ url_for('[Link]')
}}';">Cancelar</button>
99. </div>
100.
101. </form>
…
Linha 86: Adicionamos o campo no formulário para identificar o tipo, que nesse caso será
usuário.
Precisamos modificar também ao realizar o cadastro do usuário, então vamos alterar o arquivo
controlle/[Link]:
…
28. @bp_usuario.route('/usuario/cadastro/', methods=['GET','POST'])
29. def cadastro():
30. if [Link] == "GET":
31. return render_template("usuario/erro_cadastro.html"), 200
32. elif [Link] == "POST":
33. if ( [Link]([Link]['nome'], [Link]['usuario'],
[Link]['senha'], [Link]['tipo']) ):
34. session['usuario'] = {"nome": [Link]['nome'], "usuario":
[Link]['usuario'], "tipo": [Link]['tipo']}
35. return render_template("usuario/sucesso_cadastro.html"), 200
36. else:
37. return render_template("usuario/erro_cadastro.html"), 200
…
Linha 33: Agora devemos passar o tipo que recebemos do formulário para o nosso método do
banco de dados [Link]().
Linha 34: Em seguida, se ele for cadastrado, então adicione também na sessão do sistema.
E também vamos alterar ao acessar o sistema:
…
12. @bp_usuario.route('/usuario/autenticar/', methods=['GET','POST'])
13. def autenticar():
14. if [Link] == "GET":
15. return render_template("usuario/[Link]", erro=u"Não foi possível realizar o
login!"), 200
16. elif [Link] == "POST":
17. usuario = [Link]([Link]['usuario'], [Link]['senha'])
18. if ( usuario ):
19. session['usuario'] = {"nome": usuario['nome'], "usuario": usuario['usuario'], "tipo":
usuario['tipo']}
20. return redirect(url_for('[Link]'))
21. else:
22. return render_template("usuario/[Link]", erro=u"Usuário ou Senha inválidos!"),
200
…
Linha 19: Recuperar o tipo do usuário e em seguida adicionar na sessão.
Por fim vamos alterar o método [Link]() para receber o parâmetro tipo e inserir no
banco de dados, alterando o arquivo util/[Link]:

…
5. def saveUsuario(self, nome, usuario, senha, tipo):
6. with [Link]('sqlite:///[Link]') as db:
7. if ( [Link](usuario, senha) ):
8. return False
9. else:
10. return db['usuario'].insert(dict(nome=nome, usuario=usuario, senha=senha,
tipo=tipo))
…
Linha 5 e 10: Vamos acrescentar o tipo como parâmetro e inseri-lo no banco.

17.3. Criando área de acesso para Gerentes

Da mesma forma que criamos com o usuário, vamos criar uma Blueprint para gerentes, dar
acesso ao sistema e ter uma área para cadastrá-los.
No ProjetoPizzaria_v3 vamos adicionar os seguintes arquivos:
ProjetoPizzaria_v3/
__init__.py
[Link]
pjfinal_env/
controller/
__init__.py
[Link]
[Link]
[Link]
templates/
site/
usuario/
gerente/
[Link]
static/
util/

Inicialmente vamos ter uma área de cadastro de gerentes, porém ele não deve ser listado em
nenhuma área visível, pois no futuro apenas o Admin poderá criá-lo.
No arquivo controller/[Link]:
1. # coding: utf-8
2. from flask import Blueprint, render_template, session, request, redirect, url_for
3. from [Link] import Banco
4.
5. bp_gerencia = Blueprint('gerencia', __name__, url_prefix='/gerencia')
6. banco = Banco()
7.
8. @bp_gerencia.route('/registro/')
9. def gerencia_registro():
10. return render_template("gerencia/[Link]"), 200
Linha 5: Podem perceber que dessa vez, optei por adicionar no construtor do nosso Blueprint
uma URL pré-fixada, permitindo assim que o framework entenda que das as rotas desse
Blueprint será realizada através do termo gerencia.
E por fim, no arquivo de templates/gerencia/[Link], apenas substitui na linha 86 o tipo
de usuario para gerente.

17.4. Criando área para cadastro de Pizzas

Na área de cadastro de Pizzas, só devemos permitir que o usuário do tipo gerente possa acessá-
lo, e por isso vamos criar um novo Blueprint para esse tipo de atividade.
No ProjetoPizzaria_v4 vamos adicionar os seguintes arquivos:
ProjetoPizzaria_v4/
__init__.py
[Link]
pjfinal_env/
controller/
__init__.py
[Link]
[Link]
[Link]
[Link]
templates/
site/
usuario/
gerente/
pizzas/
[Link]
[Link]
static/
util/
Primeiro vamo ver as alterações no arquivo util/[Link]:
21. def listPizzas (self):
22. with [Link]('sqlite:///[Link]') as db:
23. pizzas = db['pizzas'].all()
24. return pizzas
25.
26. def getPizza (self, id):
27. with [Link]('sqlite:///[Link]') as db:
28. pizza = db['pizzas'].find_one(id=id)
29.
30. if pizza:
31. return pizza
32. else:
33. return False
34.
35. def savePizza(self, nome, descricao):
36. with [Link]('sqlite:///[Link]') as db:
37. return db['pizzas'].insert(dict(nome=nome, descricao=descricao,
status='ativo'))
38.
39. def updatePizza(self, id, nome, descricao, status):
40. with [Link]('sqlite:///[Link]') as db:
41. return db['pizzas'].update(dict(id=id, nome=nome, descricao=descricao,
status=status), ['id'])
42.
43. def deletePizza(self, id):
44. with [Link]('sqlite:///[Link]') as db:
45. return db['pizzas'].delete( id=id )
Linha 21: Vamos criar um método para listar todas as pizzas.
Linha 26: Neste método vamos recuperar apenas um registro da tabela pizzas., passando como
parâmetro o id da pizza.
Linha 35: Aqui vamos passar os dados para salvar no banco as informações das pizzas, como o
seu nome e sua descrição.
Linha 39: Neste método podemos fazer alterações nas informações da pizza, sem alterar o
registro de pedidos.
Linha 43: E por fim, vamos remover do banco as pizzas que não queremos mais em nosso
catálogo.
Com isso, já podemos fazer todo o gerenciamento da tabela pizzas, e podemos passar para a
etapa de ajustes no Blueprint.
Agora é hora de ver o arquivo controlle/[Link]:
…
8. @bp_pizzas.route('/lista/')
9. def lista():
10. lista = [Link]()
11. return render_template("pizzas/[Link]", lista=lista), 200
…
Neste primeiro método, vamos listar todas as pizzas cadastradas em nossa lista do HTML, e caso
não tenha nenhuma cadastrada, ele deve informar que não existe nenhuma pizza e que pode ser
adicionada.
Vejamos o arquivo templates/pizzas/[Link]:
29. <div class="card">
30. {% if not lista %}
31. Nenhuma Pizza foi cadastrada, por favor cadastre uma agora mesmo! <br>
32. <a href="{{ url_for('[Link]') }}"> CADASTRA </a>
33. {% else %}
34. <table width="100%">
35. <thead>
36. <tr>
37. <th>Nome</th>
38. <th>Descrição</th>
39. <th>Ação</th>
40. </tr>
41. </thead>
42. <tbody>
43. {% for item in lista %}
44. <tr>
45. <td>{{ item['nome'] }}</td>
46. <td>{{ item['descricao'] }}</td>
47. <td>
48. <a href="{{ url_for('[Link]') }}{{item['id']}}">Alterar</a>
49. &nbsp;
50. <a onclick="return confirm('Deseja realmente excluir a Pizza selecionada?')"
href="{{ url_for('[Link]') }}{{item['id']}}">Excluir</a>
51. </td>
52. </tr>
53. {% endfor %}
54. </tbody>
55. </table>
56. {% endif %}
57. </div>
Nos trechos destacados podemos ver a verificação da lista, caso não exista ele apresenta a
mensagem, e se existe e faz a interação dos dados e apresenta em forma de tabela.
Vamos voltar ao arquivo controlle/[Link]:
…
13. @bp_pizzas.route('/cadastro/')
14. @bp_pizzas.route('/cadastro/<int:id>')
15. def cadastro( id = None ):
16. dados = {'id':'','nome':'','descricao':''}
17. if id :
18. dados = [Link]( id )
19.
20. return render_template("pizzas/[Link]", pizza = dados), 200
…
Aqui vamos realizar o cadastro, note que vamos ajustar a rota para recuperar o id através da
URL, com isso podemos recuperar os dados para fazer alterações.
Salvando os dados
…
22. @bp_pizzas.route('/salvar/', methods=['POST'])
23. def salvar():
24. if [Link] == "POST":
25. if [Link]['id'] and [Link]['id'] != '' :
26. [Link]([Link]['id'], [Link]['nome'], [Link]['descricao'],
'ativo')
27. else:
28. [Link]([Link]['nome'], [Link]['descricao'])
29. return redirect(url_for('[Link]'))
…
Aqui vamos fazer a persistência dos dados, verificando se existe id, no caso de existir podemos
atualizar os dados, caso o contrário vamos criar um novo registro.
Excluindo os registros
…
31. @bp_pizzas.route('/excluir/')
32. @bp_pizzas.route('/excluir/<int:id>')
33. def excluir( id = None ):
34. if id:
35. [Link](id)
36. return redirect(url_for('[Link]'))
…
Para finalizar a estrutura de gerenciamento, temos a possibilidade de excluir aqueles registros
que não queremos mais apresentar em nosso cardápio. Só que diferente de cadastrar uma nova
pizza ou alterá-la utilizando uma tela de cadastro, vamos utilizar o javascript para fazer esse
pedido, e por isso vamos ajustar a rota para aceitar apenas no formato de excluir/id.

17.5. Criando área de Pedidos Clientes/Gerentes

Agora vamos finalizar o nosso projeto com o gerenciamento de pedidos, que tem como objetivo
receber os pedidos dos clientes, fazer a aprovação do pedido e, por fim, fazer a entrega.
No ProjetoPizzaria_final vamos adicionar os seguintes arquivos:
ProjetoPizzaria_final/
__init__.py
[Link]
pjfinal_env/
controller/
__init__.py
[Link]
[Link]
[Link]
[Link]
[Link]
templates/
site/
usuario/
gerente/
pizzas/
pedidos/
[Link]
[Link]
lista_clientes.html
static/
util/
Como de costume vamos criar um Blueprint destinado aos pedidos:
Agora é hora de ver o arquivo controlle/[Link]:
…
1. # coding: utf-8
2. from flask import Blueprint, render_template, session, request, redirect, url_for
3. from [Link] import Banco
4.
5. bp_pedidos = Blueprint('pedidos', __name__, url_prefix='/pedidos')
6. banco = Banco()
…
Linha 1 e 2: Vamos fazer as importações de tudo que vamos precisar.
Linha 5: Vamos iniciar o Blueprint, e colocar o nome de pedidos usando como prefixo da URL o
/pedidos como padrão para todos os acessos da URL.
Vamos precisar também, criar uma rota para a lista de pedidos, para Clientes ele deve apresentar
todos os pedidos e o status do pedido dele:
…
8. @bp_pedidos.route('/lista/')
9. def lista():
10. if session['usuario']['tipo'] == 'gerente':
11. lista = [Link]()
12. return render_template("pedidos/[Link]", lista=lista, banco=banco), 200
13. else:
14. lista = [Link](session['usuario']['id'])
15. return render_template("pedidos/lista_clientes.html", lista=lista, banco=banco), 200
…
Linha 10: Se o usuário for do tipo gerente, deve apresentar a lista de pedidos de todos os clientes.
Linha 14: A lista deve ser carregada de acordo com o id do cliente, que nesse caso traz todas os
pedidos que esse cliente realizou.
Para pedidos que os gerentes precisam lidar, vamos ver o arquivo templates/pedidos/[Link]:
26. <div class="row">
27. <div class="card">
28. {% if lista == False %}
29. Nenhum pedido encontrado! <br>
30. <a href="{{ url_for('[Link]') }}">Fazer pedido</a>
31. {% else %}
32. <h3 align="center">Meus pedidos</h3>
33. <table width="100%">
34. <thead>
35. <tr>
36. <th>Clientes</th>
37. <th>Pedidos</th>
38. <th>Valor pedido</th>
39. <th>Status pedido</th>
40. <th>Ação</th>
41. </tr>
42. </thead>
43. <tbody>
44. {% for item in lista %}
45. <tr>
46. <td>{{ [Link](item['usuario'])['nome'] }}</td>
47. <td>{{ [Link](item['codigo_pizza'])['nome'] }} - {{
[Link](item['codigo_pizza'])['descricao'] }}</td>
48. <td>R$ {{ item['tamanho_valor'].replace('.',',') }}</td>
49. <td>{{ item['status'] }}</td>
50. <td>
51. {% if item['status'] == 'Pendente' %}
52. <a onclick="return confirm('Deseja realmente enviar o pedido para a Cozinha?')"
href="{{ url_for('[Link]') }}{{item['id']}}/1">
53. Enviar para cozinha
54. </a>
55. {% elif item['status'] == 'Pronto para envio' %}
56. <a onclick="return confirm('Deseja realmente o pedido para o Cliente?')" href="{{
url_for('[Link]') }}{{item['id']}}/2">
57. Enviar para o cliente
58. </a>
59. {% elif item['status'] == 'Entregue' %}
60. <a onclick="return confirm('Deseja realmente concluir o pedido?')" href="{{
url_for('[Link]') }}{{item['id']}}/3">
61. Concluir pedido
62. </a>
63. {% else %}
64. Entregue
65. {% endif %}
66.
67. </td>
68. </tr>
69. {% endfor %}
70. </tbody>
71. </table>
72. {% endif %}
73. </div>
74. </div>
Linha 28: Verifica se não existem pedidos cadastrados.
Linha 31: Se existir então mostre os dados.
Linha 44: Pega todos os dados da lista e cria um item para cada linha dentro do for.
Linhas 46 e 47: Vamos pegar as informações do item, e passar como parâmetro para uma função
do banco para recuperar as informações do cliente e da pizza.
Linhas 51, 55, 59 e 63: Verifica qual tipo de status o pedido está, e apresenta uma ação de acordo
com cada status.
Quando o gerente recebe o pedido, ele pode decidir fazer uma ação de acordo com a lista abaixo:
Status: Pendente → Gerente pode enviar para a Cozinha;
 Status: Pronto para Envio → Gerente pode enviar para o Cliente;
Status: Entregue → Gerente pode finalizar o processo.

Cada ação desse informa ao cliente o status do seu pedido.

O Cliente pode criar um pedido acessando essa ação:
…
17. @bp_pedidos.route('/cadastro/')
18. @bp_pedidos.route('/cadastro/<int:id>')
19. def cadastro( id = None ):
20. dados = {'id':'','nome':'','descricao':''}
21. pizzas = [Link]()
22. if id :
23. dados = [Link]( id )
24.
25. return render_template("pedidos/[Link]", pedido=dados, pizzas=pizzas), 200
…
Linha 21: Lista as pizzas disponíveis para o pedido do cliente.
Linha 23: Se o cliente fizer algum pedido e decidir mudá-lo temos que listar as informações do
pedido.
Você pode ver a tela de pedidos no arquivo templates/pedidos/[Link].
Ao selecionar o pedido o cliente pode realizar o cadastro:
…
27. @bp_pedidos.route('/salvar/', methods=['POST'])
def salvar():
28. if [Link] == "POST":
29. if [Link]['id'] and [Link]['id'] != '' :
30. [Link]([Link]['id'], [Link]['pizza'], [Link]['preco'],
[Link]['usuario'])
31. else:
32. [Link]([Link]['pizza'], [Link]['preco'],
[Link]['usuario'])
33. return redirect(url_for('[Link]'))
…
Se o cliente desejar cancelar o pedido podemos fazê-lo através dessa função:
…
35. @bp_pedidos.route('/excluir/')
36. @bp_pedidos.route('/excluir/<int:id>')
37. def excluir( id = None ):
38. if id:
39. [Link](id)
40. return redirect(url_for('[Link]'))
…
E por fim podemos mudar o status de cada pedido pelo gerente:
…
42. @bp_pedidos.route('/status/')
43. @bp_pedidos.route('/status/<int:id>')
44. @bp_pedidos.route('/status/<int:id>/<int:status>')
45. def status( id = None, status = None):
46. if status == 1:
47. [Link](id, status)
48. elif status == 2:
49. [Link](id, status)
50. elif status == 3:
51. [Link](id, status)
52. return redirect(url_for('[Link]'))
…
Agora vamos ver esses novos métodos criados no arquivo util/[Link]:
Método destinado a recuperação dos dados do usuário pelo id dele:
…
21. def getUsuarioID(self, id):
22. with [Link]('sqlite:///[Link]') as db:
23. usuario = db['usuario'].find_one(id=id)
24.
25. if usuario:
26. return usuario
27. else:
28. return False
…
Método destinado a recuperação da lista de pizzas:
…
30. def listPizzas (self):
31. with [Link]('sqlite:///[Link]') as db:
32. pizzas = db['pizzas'].all()
33. if db['pizzas'].count() > 0 :
34. return pizzas
35. else:
36. return False
…
Método destinado a recuperação dos dados de uma pizza:
…
38. def getPizza (self, id):
39. with [Link]('sqlite:///[Link]') as db:
40. pizza = db['pizzas'].find_one(id=id)
41.
42. if pizza:
43. return pizza
44. else:
45. return False
…
Método usado para gravar os dados de uma pizza:
…
47. def savePizza(self, nome, descricao):
48. with [Link]('sqlite:///[Link]') as db:
49. return db['pizzas'].insert(dict(nome=nome, descricao=descricao,
status='ativo'))
…
Método usado para atualizar a pizza:
…
51. def updatePizza(self, id, nome, descricao, status):
52. with [Link]('sqlite:///[Link]') as db:
53. return db['pizzas'].update(dict(id=id, nome=nome, descricao=descricao,
status=status), ['id'])
…
Método usado para excluir a pizza do banco de dados:
…
55. def deletePizza(self, id):
56. with [Link]('sqlite:///[Link]') as db:
57. return db['pizzas'].delete( id=id )
…
Método destinado a listar todos os pedidos:
…
59. def listPedidos (self):
60. with [Link]('sqlite:///[Link]') as db:
61. pedidos = db['pedidos'].all()
62.
63. if db['pedidos'].count() > 0 :
64. return pedidos
65. else:
66. return False
…
Método destinado a listar apenas os pedidos de um cliente:
…
68. def listPedidosClientes (self, id):
69. with [Link]('sqlite:///[Link]') as db:
70. pedidos = db['pedidos'].find(usuario=id)
71.
72. if db['pedidos'].count(usuario=id) > 0 :
73. return pedidos
74. else:
75. return False
…
Método destinado a recuperação de um pedido:
…
77. def getPedido (self, id):
78. with [Link]('sqlite:///[Link]') as db:
79. pedidos = db['pedidos'].find_one(id=id)
80.
81. if pedidos:
82. return pedidos
83. else:
84. return False
…
Método usado para gravar o pedido no banco:
…
86. def savePedido(self, pizza, preco, usuario):
87. with [Link]('sqlite:///[Link]') as db:
88. return db['pedidos'].insert(dict(usuario=usuario, codigo_pizza=pizza,
tamanho_valor=preco, status='Pendente'))
…
Método usado para atualizar o pedido:
…
90. def updatePedido(self, id, pizza, preco, usuario):
91. with [Link]('sqlite:///[Link]') as db:
92. return db['pedidos'].update(dict(id=id, usuario=usuario, codigo_pizza=pizza,
tamanho_valor=preco), ['id'])
…
Método usado para remover o pedido do banco:
…
94. def deletePedido(self, id):
95. with [Link]('sqlite:///[Link]') as db:
96. return db['pedidos'].delete( id=id )
…
Método usado para alterar o status do pedido:
…
98. def statusPedido(self, id, status):
99. with [Link]('sqlite:///[Link]') as db:
100. if status == 1:
101. return db['pedidos'].update(dict(id=id, status='Pronto para envio'), ['id'])
102. elif status == 2:
103. return db['pedidos'].update(dict(id=id, status='Entregue'), ['id'])
104. elif status == 3:
105. return db['pedidos'].update(dict(id=id, status='Concluido'), ['id'])
…
Método usado para recuperar a descrição do pedido:
107. def getValorPedidoDescricao(self, valor):
108. if valor == '11.90':
109. return u'Broto - R$ 11,90 - 4 Fatias'
110. elif valor == '21.90':
111. return u'Pequena - R$ 21,90 - 6 Fatias'
112. elif valor == '31.90':
113. return u'Média - R$ 31,90 - 8 Fatias'
114. elif valor == '41.90':
115. return u'Grande - R$ 41,90 - 10 Fatias'
116. elif valor == '51.90':
117. return u'Extra Grande - R$ 51,90 - 12 Fatias'
…
Agora que vimos por completo passo a passo como construir nosso sistema para uma pizzaria,
recomendo você a testá-lo em seu computador, se possível não apenas teste, mais também tente
fazer todo o código baseado neste livro, se possível aprenda e crie um projeto com suas ideias,
pois assim você vai aprender muito mais rápido!
18. Próximos passos
Nesse ponto você já deve ter domínio de toda a estrutura e conceitos passado nesse livro, e para
expandir seu conhecimento sugiro que pratique o máximo possível os exemplos e comece a criar
pequenos projetos pessoais, permitindo assim você compartilhar esse conhecimento e dúvidas
com outras pessoas. E pensando nas suas dúvidas, criei um Grupo fechado para podermos
compartilhar código, experiências e quem sabe até empregos.
Faça sua inscrição no Grupo Fechado do Facebook:
[Acessar]

19. Agradecimento
Obrigado por se interessar no conteúdo desse livro, espero que ele tenha atendido sua expectativa
sobre como funciona uma estrutura desse framework e seus principais recursos, e que tenha
aprendido ou ampliando seus conhecimentos nessa área.
Espero ter facilitado sua caminhada e aproveito para deixar essa última dica, não pare de
aprender, pois o maior recurso do mundo é o conhecimento e com ele podemos transformar
todos ao nosso redor.

Um pedido especial
Se você gostou desse livro, eu gostaria de te pedir apenas mais um minuto do seu tempo para ir
na página desse livro no Site da Amazon e clicar no botão “Escreva uma Avaliação” e deixar
uma avaliação, pois isso vai me ajudar a identificar os meus acertos e minhas falhas.
Peço também que me acompanhe no Facebook.
E me envie um e-mail (devacademybr@[Link]) caso tenha alguma crítica ou sugestão.
E por fim indique esse livro para um amigo, se você gostou, ele provavelmente deve gostar!