Construindo visualizações no Flask

Dentro do modelo ou paradigma de desenvolvimento que propõe FrascoUm dos pontos mais importantes é a gestão das visualizações, pois permitem definir a forma como o utilizador irá interagir com a nossa página ou aplicação.

A maneira mais simples de trabalhar com uma view é definir a operação diretamente na definição de seu caminho, porém isso nem sempre é útil ou adequado, principalmente se construirmos grandes aplicações.

RequisitosPrecisamos de uma instalação funcional de Frasco e por razões de compatibilidade, precisamos de uma versão superior à 0.7 já que um dos componentes com os quais trabalharemos não foi incluído no framework até depois dessa versão. Também precisamos iniciar um aplicativo ou ter algum aplicativo Frasco para que possamos incluir os exemplos na seção de visualizações e, assim, sermos capazes de executá-los pelo navegador.

Visualizações baseadas em funções

É uma das formas mais simples de construir interação com o usuário, só temos que escrever uma função e decorá-la com a rota, isso faz quando o roteador Frasco recebe o pedido, verifica se existe uma função à espera da referida rota e, se a receber, executa-a.

Geralmente, este tipo de visualização requer pelo menos o método OBTER do HTTPNo entanto, como uma boa prática e por razões de segurança, se quisermos adicionar valores à nossa estrutura de persistência de dados, também podemos usar o método PUBLICAR.

Criando uma visualização com GET

Vamos criar uma visão usando o método OBTERPara fazer isso, basta definir seu nome em uma função e atribuir uma rota a ela, então dentro da função colocaremos nosso conteúdo, vamos ver o código a seguir para nos ilustrar.

 @ app.route ('/ view-get') def view (): value = request.args.get ('content', 'sample') return 'Esta é uma visualização usando GET e recebe um valor:% s'% valor

No código, então, vemos como usamos o decorador Para indicar a rota que estamos esperando, definimos a função correspondente e dentro dela fazemos uma chamada com solicitar aos argumentos recebidos por OBTER, neste caso procuramos por um argumento denominado content e atribuímos a uma variável denominada value, se este argumento não existir, "sample" será colocado como o valor padrão, e finalmente retornamos um texto e passamos o conteúdo do valor .

Se executarmos nosso exemplo no navegador, obteremos o seguinte:

Criação de uma visualização com POST

O que acontece se o que queremos é receber dados sigilosos e não queremos passá-los por parâmetros na URL, pois nesses casos devemos usar o método POST, já que envia os dados escondidos da visão do usuário, é claro aí são outras medidas de segurança que devemos usar, mas no momento não precisamos delas para este caso.

Para construir uma visão que receba dados por POST, você só precisa indicar o método esperado no decorador que recebe a rota que queremos, para isso usamos o parâmetro adicional métodos.

Então, dentro de nossa função, podemos usar solicitar para obter os valores, porém, ao contrário do exemplo anterior, em vez de exigir os argumentos, devemos indicar que estamos recebendo os valores de um formulário. Vejamos o código para o que acabamos de explicar.

 @ app.route ('/ post-view', methods = ['POST',]) def post_view (): value = request.form.get ('content', 'sample') return 'Esta é uma visualização usando POST e recebe um valor:% s '% value

Podemos notar que é quase o mesmo código acima, exceto pelas diferenças já mencionadas, mas vamos ver o que acontece se executarmos nosso código diretamente em nosso navegador:

PROLONGAR

Como especificamos apenas que podemos receber o método PUBLICAR, ao acessar via OBTER nosso aplicativo rejeita a entrada e, portanto, nos envia um código 405 Método não permitido, portanto, sem valores provenientes de uma solicitação POST, essa visualização não mostrará nenhuma informação.

Combinando GET e POST na visualização

Como lidar com diferentes visualizações para cada método nem sempre é o que desejamos, podemos usar os dois métodos na mesma visualização, isso é muito útil especialmente quando queremos processar formulários, por exemplo, com o método OBTER mostramos o formulário e com PUBLICAR processamos o envio do mesmo.

Para usar este modo, só precisamos adicionar OBTER na lista que passamos para métodos ao definir o decorador com o caminho, vamos ver o código abaixo:

 @ app.route ('/ view', methods = ['GET', 'POST',]) def view (): if request.method == "GET": return '' 'Mostrar visualizações' '' else: value = request.form.get ('content', 'sample') return 'Esta é uma visualização usando GET e POST que recebe um valor:% s'% value

Ao chamar a rota do navegador com método OBTER nós temos o seguinte:

Então, escrevendo algo no campo de texto e pressionando Enter estamos enviando o formulário para o mesmo caminho, mas com o método PUBLICAR, o que nos dá um resultado como o seguinte:

Aqui, escrevemos uma verdadeira visão baseada em função, que nos permite usar e tirar proveito de ambos os métodos de HTTP para fazer nossas operações.

Visualizações baseadas em classe

Como a criação de funções, mesmo que sirvam aos nossos propósitos, às vezes é muito complicada e se presta a ter mais código do que o necessário, Frasco implementou as chamadas visualizações baseadas em classe, um conceito que ele pegou emprestado Django, e isso nos permite escrever classes com as quais geraremos visualizações, essas classes podem ser genéricas com as quais podemos fazer herança se desejarmos.

Para usar este tipo de componente, devemos primeiro importar de flask.views, onde a aula Visão É uma classe genérica que nos permitirá adicionar as funcionalidades básicas para poder despachar rotas e definir métodos.

Criando nossa visão baseada em classe

Neste exemplo, vamos criar a mesma visão que criamos no exemplo anterior, mas a partir de uma abordagem baseada em classe, desta forma podemos estabelecer as diferenças entre os dois formulários, lembre-se que embora não apareça no código de exemplo, nós fizemos o importar da classe View.

Vejamos o código do nosso exemplo:

 class ViewClass (View): methods = ['GET', 'POST',] def dispatch_request (self): if request.method == "GET": return '' 'Show Views' '' if request.method == " POST ": value = request.form.get ('content', 'sample') return 'Esta é uma visão usando GET e POST que recebe um valor:% s'% valorapp.add_url_rule ('/ view-class', view_func = VistaClase.as_view ('view-class'))

Esta é a forma mais básica deste estilo de visão, no entanto, vemos que não dependemos mais do decorador, o que fazemos é chamar o método dispatch_request e nós passamos por ele auto para que receba seu mesmo objeto com isso podemos determinar as requisições que recebemos, então indicamos que receberemos os dois métodos e finalmente definimos nossos comportamentos, o resultado por navegador será o mesmo que o anterior, teremos um campo e quando o enviarmos receberemos a resposta especificada.

Mas e se quisermos escrever um código muito mais limpo? Para isso podemos usar a classe MethodView do Frasco que nos permite criar métodos dentro da classe para definir os métodos HTTP de uma forma mais simples.

Vejamos o seguinte exemplo em que reescrevemos o código anterior para usar este modo:

 class ViewClass (MethodView): def get (self): return '' 'Mostrar visualizações' '' def post (self): value = request.form.get ('content', 'sample') return 'Esta é uma visualização usando GET e POST que recebem um valor:% s '% valorapp.add_url_rule (' / view-class ', view_func = ViewClass.as_view (' view-class '))

Como podemos ver, dispensamos a definição dos métodos que receberemos, além disso, não utilizamos mais o método Despacho, simplesmente definimos o que faremos no método PUBLICAR, e o que faremos no GET, dando assim muito mais limpeza à nossa vista.

Ainda há um debate se é melhor visualizações baseadas em funções ondas baseado em classe, mas realmente não existe uma melhor que a outra, existem simplesmente duas formas de trabalhar, a recomendação é que se a view for muito simples poderemos fazer com funções e se já tiver uma lógica mais completa faremos com classes .

Com isso terminamos este tutorial, no qual construímos uma base importante, sabendo como funcionam as visualizações e como podemos trabalhar com seus diferentes métodos HTTP, uma vez que esta é a base que podemos usar para criar aplicativos mais avançados.