Leandro Martins

Iniciando com Django - Desenvolvendo com esse poderoso Framework - Parte III

by Leandro Martins on dez.27, 2008, under Django, Framework, Python

Criando uma área para consulta e visualização dos dados

Nessa última parte do tutorial vamos ver como criar uma área de consulta e visualização dos dados que foram cadastrados no admin desenvolvido nos tutoriais anteriores. O objetivo de criar essa área externa ao admin, é mostrar como o django trabalha com template e consultas no banco de dados.

Vou falar um pouco sobre sistema de template, antes de iniciar o desenvolvimento da estrutura de consulta.

O que é um template engine?

Um sistema de template é um software que é responsável por criar documentos de saída(ex: páginas html), a partir de uma junção de um modelo de layout, e dados fornecidos do banco de dados. Esse modelo de layout normalmente é feito usando o HTML/CSS para desenhar o visual do documento, que contêm instruções lógicas de como tratar os dados vindo do banco de dados. Vou citar algumas vantagens no uso de um sistema de template: reusabilidade dos modelos de layout, uma apresentação mais flexível dos dados, separação entre o de negocio de lógica e a apresentação, fácil manutenção, entre outras. Para saber mais sobre, acesse template engine.

Modelo de layout

Vamos usar como modelo de layout uma página simples, apenas para demonstrar o funcionamento. Abaixo segue seu código HTML.

index.html

  1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
  2. <html>
  3.         <head>
  4.                 <meta http-equiv=“Content-Type” content=“text/html; charset=UTF-8″ />
  5.                 <title>titulo</title>
  6.         </head>
  7.         <body>
  8.                
  9.                 <h2>titulo</h2>
  10.                 <hr>
  11.                
  12.                 <form action=“.” method=“post”>
  13.                         <label for=“titulo_livro”>Livro a ser pesquisado:</label><br />
  14.                         <input type=“text” id=“titulo_livro” name=“titulo_livro” size=“50″/>
  15.                         <input type=“submit” value=“Buscar!”>
  16.                 </form>
  17.                
  18.                 <p><strong>> mensagem </strong></p>
  19.                 <hr>
  20.        
  21.                 <table id=“consulta_tbl” >
  22.                         <thead>
  23.                         <tr>
  24.                             <th>Nome do livro | </th>
  25.                             <th>Cliente | </th>
  26.                             <th>Aluguel data | </th>
  27.                             <th>Entrega data | </th>
  28.                             <th>Status do aluguel</th>
  29.                         </tr>
  30.                         </thead>
  31.                         <tbody>
  32.                                 <tr>
  33.                                     <td>livro</td>
  34.                                     <td>cliente</td>
  35.                                         <td>aluguel_data</td>
  36.                                         <td>entrega_data</td>
  37.                                         <td>status</td>
  38.                                 </tr>
  39.                         </tbody>
  40.                 </table>
  41.                 <hr>
  42.         </body>
  43. </html>

Django template system

O django possui um sistema de template bem completo, com vários recursos, vou fazer uma pequena demonstração. Tendo o modelo de layout acima pronto, vamos fazer algumas configurações no django que são necessárias para o uso do template.

1) No arquivo settings.py de seu projeto existe um variável chamada TEMPLATE_DIRS, que tem a função de guardar o local onde estão os templates para o seu projeto, para serem carregados. Para carregar os templates automaticamente, basta indica o caminho completo que estão seus templates, no caso do tutorial:

  1. TEMPLATE_DIRS = (
  2.     ‘/home/leandro/lab/dj-app/tuto_app/tpl’,
  3. )

2) Nosso próximo arquivo é o urls.py, esse arquivo é responsável por todo mapeamento de url do nosso projeto, nele vamos adicionamos a expressão de mapeamento para nossa url http://localhost:8081/consulta/ funcionar e carregar a área de consulta quando for requisitada. Para isso adicionamos importar view Consulta e colocamos no array urlpatterns, a expressão (r’^consulta/’, Consulta), como segue abaixo.

  1. from django.conf.urls.defaults import *
  2. from tuto_app.consulta.views import Consulta
  3.  
  4. from django.contrib import admin
  5. admin.autodiscover()
  6.  
  7. urlpatterns = patterns(”,
  8.     (r‘^admin/(.*)’, admin.site.root),
  9.     (r‘^consulta/’, Consulta),
  10. )

Como podemos ver nosso projeto só têm duas urls: admin e cosulta. As urlspatterns são definidas com dois parâmetros, uma expressão regular que indica o caminho e outra o view que vai ser carregado quando solicitado. Clique expressões regulares para mais informações.

3) O nosso próximo passo será incluir no template, algumas template tags, para que ele receba os dados enviado pelo view Consulta. Sendo assim vamos deixar ele parecido com a estrutura abaixo.

index.html

  1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
  2. <html>
  3.         <head>
  4.                 <meta http-equiv=“Content-Type” content=“text/html; charset=UTF-8″ />
  5.                 <title>{{ titulo }}</title>
  6.         </head>
  7.         <body>
  8.                
  9.                 <h2>{{ titulo }}</h2>
  10.                 <hr>
  11.                
  12.                 <form action=“.” method=“post”>
  13.                         <label for=“titulo_livro”>Livro a ser pesquisado:</label><br />
  14.                         <input type=“text” id=“titulo_livro” name=“titulo_livro” size=“50″/>
  15.                         <input type=“submit” value=“Buscar!”>
  16.                 </form>
  17.                
  18.                 <p><strong>> {{ mensagem }}</strong></p>
  19.                 <hr>
  20.        
  21.                 <table id=“consulta_tbl” >
  22.                         <thead>
  23.                         <tr>
  24.                             <th>Nome do livro | </th>
  25.                             <th>Cliente | </th>
  26.                             <th>Aluguel data | </th>
  27.                             <th>Entrega data | </th>
  28.                             <th>Status do aluguel</th>
  29.                         </tr>
  30.                         </thead>
  31.                         {% ifnotequal n_registros ‘0′ %}
  32.                         <tbody>
  33.                                 {% for dados in lista_registros %}
  34.                                 <tr>
  35.                                     <td>{{ dados.livro }}</td>
  36.                                     <td>{{ dados.cliente }}</td>
  37.                                         <td>{{ dados.aluguel_data }}</td>
  38.                                         <td>{{ dados.entrega_data }}</td>
  39.                                         <td>{{ dados.status }}</td>
  40.                                 </tr>
  41.                                 {% endfor %}
  42.                         </tbody>
  43.                         {% endifnotequal %}
  44.                 </table>
  45.                 <hr>
  46.         </body>
  47. </html>

Como podemos ver, o template é composto por tags html, tags template e algumas condições lógicas e de repetições, elas têm a finalidade de mostrar o conteúdo encaminhado pela view.

View consulta

Configurado todo template, agora vamos adicionar mais aplicação ao nosso projeto, chamada Consulta. Para isso digitamos o conhecido comando:

  1. $ sudo python manage.py startapp consulta

Feito isso, vamos abrir o arquivo views.py de nossa aplicação consulta e adicionar o código abaixo. O código está todo comentado para melhor entendimento.

views.py

  1. #Importa a classe render_to_response, responsavel por renderizar o conteudo no template.
  2. from django.shortcuts import render_to_response
  3.  
  4. #Importa a classe ObjectDoesNotExist, responsavel pela excessoes de objetos.
  5. from django.core.exceptions import ObjectDoesNotExist
  6.  
  7. #Importa os models das aplicacoes.
  8. from tuto_app.livros_alugado.models import LivrosAlugado
  9. from tuto_app.livro.models import Livro
  10.  
  11. def Consulta(request):
  12.  
  13.     #Lista por padrao os ultimos 5 livros alugados e mostra uma mensagem.
  14.     lista_registros     = LivrosAlugado.objects.all().order_by(‘-id’,‘livro’)[:5]
  15.     mensagem            = ‘Mostrando os ultimos 5 livros alugados.’
  16.     n_registros         = lista_registros.count()
  17.    
  18.     #Verifica se o metodo post foi enviado.
  19.     if request.method == ‘POST’:
  20.        
  21.         try:
  22.            
  23.             #Procura na tabela livro, o nome do titulo digitado.
  24.             livro = Livro.objects.get(titulo__icontains=request.POST[‘titulo_livro’])
  25.            
  26.             #Pega o id do livro, e faz um filtro na tabela livros alugado.
  27.             lista_registros = LivrosAlugado.objects.filter(livro=livro.id)
  28.             mensagem        = ‘Foram encontrados os seguintes(s) livro(s).’
  29.             n_registros     = lista_registros.count()
  30.            
  31.         #Caso ocorra alguma excessao no procedimento e mostrada a mensagem.
  32.         except ObjectDoesNotExist:
  33.            
  34.             mensagem    = ‘Nenhum resultado encontrado!’
  35.             n_registros = ‘0′
  36.    
  37.     #Defini os dados que vao ser mostrado no template.
  38.     dados_template = {‘titulo’          : ‘Tutorial Django’,
  39.                       ‘mensagem’        : mensagem,
  40.                       ‘lista_registros’ : lista_registros,
  41.                       ‘n_registros’     : n_registros}
  42.    
  43.     #Defini qual template vai ser receber os dados e renderizar.
  44.     return render_to_response(‘index.html’, dados_template)

Basicamente quando você acessar a url http://localhost:8081/consulta/, a urlpatterns vai indicar que deve ser carregado o view Consulta e executar os procedimentos contido nele e depois carrega o template index.html. Esses procedimentos são de verificação do método POST e consulta do livro na base de dados.

Testando o projeto

Para testar nosso projeto, basta acessar a url http://localhost:8081/consulta/ e você vai ver algo parecido com imagem abaixo.

tutorial-django

tutorial-django

Nessa tela você pode fazer consultas pelo nome do livro, e o resultado vai ser um histórico de alugueis daquele livro pesquisado.

Bom, esse pequeno tutorial é só o básico que pode ser feito com o django, o qual se mostra ser um framework para deseja desenvolver aplicações rapidamente.

Próximos passos

Comunidade nacional, Django Brasil com bastante novidades;

Documentação básica traduzida;

Tambêm existe o livro, Django Book, on-line e em inglês;

Um projeto muito legal chamado Aprendendo django no planeta Terra, elaborado pelo Marinho Brandão;

Django cheat sheet é um resumo de todos comandos utilizados no django, bem útil;

Django Snippets é um espécie de repositório de códigos django, feito por vários desenvolvedores.

Referências

http://docs.djangoproject.com/en/dev/

http://www.djangobook.com/

http://www.aprendendodjango.com/

http://www.igorsobreira.com/envolva-se-no-mundo-django/

Até a próxima!

:, , ,
No comments for this entry yet...

Leave a Reply

Pesquisar

Sites

Arquivos