Django é o framework ideal para os que buscam agilidade e simplicidade. Um dos recursos que mais gosto é o Admin, uma poderosa interface para produzir conteúdo. Simples de usar, bastante customizável e com um visual agradável, bastante útil durante a fase de desenvolvimento e ideal para pequenos projetos com ausência de um designer na equipe. Outras caracteristicas interessantes são:

• API para autenticação de usuários com suporte à grupos e níveis de acesso, que permite a criação de permissões personalizadas para cada página, classe ou método;
• Sistema de cache que torna mais rápido o carregamento das páginas e o acesso ao banco de dados;
• Sistema de templates utilizando HTML, com suporte a herança e Template Tags – uma linguagem de templates para manipulação de conteúdo dinamicamente. É possível criar suas próprias com código Python e utiliza-las em qualquer parte do projeto;
• Trabalhar com formulários e extremamente simples e há diversos tipos de validações disponíveis como por exemplo e-mail, cpf e endereço IP;
• ORM compatível com os bancos de dados mais utilizados no mercado;
• Paginação é uma tarefa trivial;
• Incrível suporte à internacionalização;
• É multiplataforma;
• Documentação bem completa e de fácil entendimento;
• Comunidade altamente ativa.

Por utilizar Python, é compatível com uma grande variedade de bibliotecas para trabalhar com xml, json, webservices, restful, graficos, relatorios, imagens e etc. Sem dúvida uma ótima escolha para quem procura agilidade com produtividade.

Essa foi minha opinião expressada no debate Django vs. Ruby on Rails, matéria da revista TiDigital (edição 16 de junho/2010).

Compartilhe esse artigo

Cada vez mais há um distanciamento de computadores isolados para uma tecnologia mais ampla, conectando dispositivos móveis em redes distribuídas. Tal arquitetura computacional traz grandes vantagens como a Continuidade de Serviços, que garante o funcionamento de serviços básicos, e o Armazenamento Distribuído, que torna dados e informações acessíveis em caso de desastres. Isso se deve ao avanço da Computação nas Nuvens, uma evolução da Computação Móvel, cujo conceito é compartilhar dados e serviços através da interligação de sistemas, sempre disponíveis, não mais locais, mas nas nuvens . Os dispositivos, como um computador ou um celular, apenas solicitam os serviços e apresentam os resultados. Mas não pára por aí. Um professor chamado Mark Weiser, cientista chefe do centro de pesquisas da Xerox, por meio de um artigo chamado “O Computador do Século 21”, introduziu um novo conceito chamado Computação Ubíqua, cuja idéia principal é focar a atenção do usuário na tarefa e não na ferramenta.
Considerada uma evolução da computação em nuvem, a Computação Ubíqua, também conhecida como Ubicomp, é uma visão de que humanos estejam cercados por computadores interligados rodando sistemas inteligentes capazes de captar variações no ambiente e entender, de acordo com gestos e expressões dos usuários, qual tarefa deve executar, de forma que as pessoas sequer percebam que estão dando comandos a um computador. Resumindo, é a união entre a Computação nas Nuvens e a Computação Pervasiva (sistemas distribuídos e imperceptíveis ao usuário).
O grande desafio para tornar a Ubicomp uma realidade, de forma mais natural possível, é o desenvolvimento de Interfaces Naturais como reconhecimento de voz e escrita, ambientes inteligentes, realidade aumentada e etc. Os computadores estão se integrando cada dia mais na vida das pessoas e a tendência é que consigam interpretar, e não traduzir, os comandos dos usuários.
Aos mais interessados, há um artigo mais completo escrito pelo Fabiano Domingues no Guia do Hardware.net que pode ser acessado pela URL http://www.guiadohardware.net/artigos/computacao-ubiqua/.

Compartilhe esse artigo

Recentemente estive analisando alguns projetos de softwares open source com o objetivo de colaborar no desenvolvimento. A grande maioria não possui rotinas de testes, comentários em código ou qualquer tipo de documentação útil aos novos desenvolvedores. Assim resolvi falar um pouco sobre qualidade de software do ponto de vista da construção.

Um software tem característica de qualidades internas e externas. As características externas são aquelas que os usuários tem conhecimento e se preocupam, por exemplo, se o software é fácil de usar. As características internas são mais preocupações dos programadores, por exemplo, se o software é fácil de modificar. Os usuários querem saber se o software é fácil de usar e não fácil de modificar. Querem saber se o software funciona corretamente e não se o código é legível.

São características de qualidade externas:

• Adaptabilidade
  Capacidade de alterar o ambiente de maneira simples sem necessidade de modificação no software.
• Confiabilidade
  Capacidade do software funcionar corretamente com o mínimo de falhas.
• Eficiência
  Capacidade de funcionar corretamente e fornecer o desempenho adequado com o uso mínimo de recursos disponíveis.
• Integridade
  Garante integridade dos dados acessados e restrição de acessos ao software.
• Precisão
  Grau de precisão das informações geradas pelo software.
• Robustez
  Capacidade do software continuar funcionando na presença de dados inválidos ou condições inesperadas.
• Usabilidade
  Facilidade dos usuários aprenderem a utilizar o software.

São características de qualidade internas:

• Capacidade de Teste
  Capacidade com que se pode fazer testes de unidades e de integração para verificar se o software satisfaz os requisitos.
• Flexibilidade
  Facilidade de modificar o software para usos diferentes daquele para o qual foi projetado.
• Inteligibilidade
  Facilidade de compreender a coerência de um software em um nível superior do que a legibilidade proporciona.
• Legibilidade
  Facilidade de entender o código-fonte do software.
• Manutenibilidade
  Facilidade para modificar um software ou corrigir problemas.
• Portabilidade
  Capacidade de modificar o software para uso em ambientes diferentes daquele para o qual foi projetado.
• Reusabilidade
  Facilidade de reutilizar partes do software em outros projetos.

Algumas dessas características têm diferentes variações de significados. As diferenças entre elas não são completamente claras e algumas vezes as características internas afetam as externas. Um software que não é flexível não pode ser aprimorado de acordo com as solicitações dos usuários, o que, por sua vez, afeta a característica externa de usabilidade.
A questão é que algumas características da qualidade de software são acentuadas para ajudar aos usuários enquanto outras tornam a vida do programador mais fácil. O que falta em muitos projetos de código aberto é uma atenção especial às características de qualidade internas.
Espero que esse cenário mude em breve.

Compartilhe esse artigo

Após meses ausente, cá estou novamente fazendo planos para tentar manter o blog atualizado com mais frequencia.
Em fevereiro passado fui surpreendido com o rumo que minha vida profissional seguiu e a velocidade com que tudo aconteceu. Foi uma mudança positiva mas que consome muito do meu tempo. Devido à isso me afestei um pouco das listas de discussões e eventos da comunidade open source. Espero que de agora em diante consiga escrever com mais frequência.
Torçam por mim! \o/

Compartilhe esse artigo

“O Flex for Kids é uma maratona de palestras on-line que será realizado no dia 06/02/2010 e contará com grandes nomes da comunidade Adobe Flex brasileira.
Serão 10 palestras on-line ao vivo durante o dia inteiro, usando um ambiente de eventos multimídia onde os palestrantes ministrarão seus temas através de recursos de áudio, vídeo, slides e chat.
Qualquer pessoa, empresa ou faculdade poderá participar do Flex for Kids, para isto basta fazer uma doação de um valor simbólico de R$ 30,00 para ter acesso as 10 palestras on-line e suas gravações que serão disponibilizadas 15 dias após o evento.
Todo dinheiro arrecadado será doado ao Cotolengo de Mato Grosso do Sul. Para conhecer a Cotolengo clique aqui.”

Obviamente eu já me inscrevi! E você?

Compartilhe esse artigo

Pisa é um conversor de HTML/XHTML/CSS para PDF, escrito em Python e baseado nas bibliotecas Reportlab, PyPDF, TechGame Networks CSS e HTML5lib. Seu foco principal não é gerar páginas perfeitas para impressão, mas utilizar HTML e CSS para gerar PDFs dentro de aplicações.
A instalação pode ser feita através do código no site do projeto ou pelo comando easy_install pisa.

Crie um arquivo chamado report.py dentro do diretório do projeto contendo o código abaixo:

# -*- coding: utf-8 -*-
from django import http
from django.template.loader import get_template
from django.template import Context
import ho.pisa as pisa
import cStringIO as StringIO
import cgi, os
 
 
def fetch_resources(uri, rel):
    path = '/path/para/diretorio/contendo/imagens/a/serem/exibidas'
    return path
 
def write_to_pdf(template_src, context_dict, filename):
    template = get_template(template_src)
    context = Context(context_dict)
    html  = template.render(context)
    result = StringIO.StringIO()
    pdf = pisa.pisaDocument(StringIO.StringIO(html.encode("UTF-8")), result, link_callback=fetch_resources)
    if not pdf.err:
        response = http.HttpResponse(mimetype='application/pdf')
        response['Content-Disposition'] = 'attachment; filename=%s.pdf' % filename
        response.write(result.getvalue())
        return response
    return http.HttpResponse('Problema ao gerar PDF: %s' % cgi.escape(html))

E agora, dentro de uma view, é preciso importar o arquivo report.py e chamar a função write_to_pdf para fazer a conversão:

# views.py
from report import write_to_pdf
 
def listar_clientes_cadastrados(request):
    clientes = Cliente.objects.all()
    return write_to_pdf('relatorio.html', {'clientes': clientes}, 'nome_do_arquivo_pdf')

A função write_to_pdf recebe como parâmetro o nome do arquivo HTML que será convertido, as variáveis que serão tratadas dentro desse arquivo e o nome que o arquivo PDF sem a extensão. Retorna o download do arquivo PDF.

Conforme citado no início do post, a conversão não é perfeita. Por exemplo, às vezes uma tabela apresenta mínimas deformações, não fica igual como na versão HTML. Apesar disso Pisa é uma ótima solução que muitas vezes ajuda bastante e, como puderam ver, é muito fácil de usar.

Compartilhe esse artigo

KinterbasDB é uma biblioteca open source para Python que possibilita acessar banco de dados Firebird e algumas versões do Interbase.
O download pode ser feito na página do projeto.

Após o download, descompacte o pacote kinterbasdb-3.2.src.tar.gz.
Abra um terminal, entre no diretório onde o kinterbasdb foi descompactado e execute o comando python setup.py build. O script de instalação, setup.py, automaticamente vai detectar as informações necessárias pelo compilador C.
Se não ocorreu nenhum erro, execute o comando python setup.py install para instalar no diretório padrão de módulos do Python (varia de acordo com a distro).

root@localhost: ~# wget http://downloads.sourceforge.net/project/kinterbasdb/kinterbasdb/kinterbasdb-3.2/kinterbasdb-3.2.src.tar.gz?use_mirror=ufpr
root@localhost: ~# tar zxvf kinterbasdb-3.2.src.tar.gz
root@localhost: ~# python setup.py build
Succeeded:
  /usr/bin/python setup.py build
root@localhost: ~# python setup.py install

Para testar se foi instalado corretamente:

root@localhost: ~# python -c "import kinterbasdb as k; print k.__version__"
(3, 2, 0, 'final', 0)
root@localhost: ~#

É possível que apareça uma mensagem de erro em distros baseadas no Ubuntu:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
kinterbasdb.OperationalError: (-901, 'begin transaction: \n  invalid parameter in transaction parameter block')

Para corrigir esse problema é preciso usar uma outra versão do arquivo __init__.py.
Faça o download em https://firebird.svn.sourceforge.net/svnroot/firebird/qa/trunk/kinterbasdb/__init__.py e substitua o arquivo existente no diretório kinterbasdb.

root@localhost: ~# wget https://firebird.svn.sourceforge.net/svnroot/firebird/qa/trunk/kinterbasdb/__init__.py
root@localhost: ~# mv __init__.py /usr/lib/python2.5/site-packages/kinterbasdb/

Exemplo para Firebird-2.1 em servidor Windows:

import kinterbasdb
conn = kinterbasdb.connect(
    host='192.168.0.2',
    database='C:\\Dados\\meubanco.fdb',
    user='sysdba',
    password='masterkey'
)
cur = conn.cursor()
cur.execute('SELECT id, nome, telefone FROM tabela')
for (id, nome, telefone) in cur:
    print 'ID: %s, Nome: %s, Fone: %s' % (id, nome, telefone)

Compartilhe esse artigo

Um formulário dinâmico é aquele que o usuário pode definir quais campos vão existir. O programador não precisa criar código para cada formulário.
Imagine um sistema que necessite de diversos tipos de formulários. Tarefa no mínimo entediante para o responsável pela manutenção. E se o usuário puder criar e modificar um formulário por uma interface gráfica fácil de usar? Seria muito bom para o programador!
O segredo desse dinamismo é o uso de metaclasses, que são classes cujas instâncias também são classes.
O truque é criar em tempo de execução uma metaclasse da classe forms.Form. Atributos dos campos como label, tipo, max length etc, podem ficar armazenados no banco de dados. Os valores dos campos podem ficar em outra tabela com uma referência de chave estrangeira. Usando o ORM do Django é muito simples, e de quebra já ganha uma interface gráfica para administrar tudo (admin).
Sendo assim, o usuário poderia montar os campos do formulário definindo um label, tipo de campo, se é obrigatório ou não, valor padrão… e essas informações ficarão no armazenadas no BD. Fica fácil criar um código para pegar essas informações, criar uma nova classe Form em tempo de execução, instância-la e renderizar no template.

Exemplo:

# views.py
 
from django.views.generic.simple import direct_to_template
from django.forms import forms, fields
 
def montar_formulario_dinamico(request):
    campos_dinamicos = {
        'nome': fields.CharField(max_length=100, required=True, label='Nome', initial='Gustavo'),
        'idade': fields.IntegerField(label='Idade', min_value=0),
        'email': fields.EmailField(max_length=200, required=False, label='E-mail')
    }
 
    FormDinamico = type('', (forms.Form,), campos_dinamicos)
    form = FormDinamico()
 
    return direct_to_template(request, 'formulario.html', extra_context={'formulario': form})

Fica a dica!

Compartilhe esse artigo

Instalação

Há diversas maneiras de se instalar um sistema feito em django. Vou mostrar como fazer o deploy usando Apache2 com o módulo mod_wsgi.
O ambiente completo usa Apache2, sqlite3, python-2.6 e Django-1.1.

root@localhost# apt-get install apache2 libapache2-mod-wsgi sqlite3 python-pysqlite2 python-django

O diretório web padrão do Apache no Ubuntu é o /var/www. Vamos manter assim. Faça o download do Bandcontrol pelo site github.com (no site, clique no botão Download Source), descompacte no /var/www, renomeie o diretório para bandcontrol e altere o dono/grupo de acordo com o usuário do apache.

root@localhost: /var/www# tar zxvf gustavohenrique-bandcontrol-XXXXXX.tar.gz
root@localhost: /var/www# mv gustavohenrique-bandcontrol-XXXXXX bandcontrol
root@localhost: /var/www# chown www-data.www-data -Rf bandcontrol

Os shell scripts usam o Iptables para firewall e TC para controle de banda. É necessário permissão de super usuário para executar esses comandos. Vamos configurar o sudo para que o usuário do Apache possa executar tais comandos como root.

root@localhost: /var/www# chmod +w /etc/sudoers
root@localhost: /var/www# vim /etc/sudoers

Adicione essas linhas no arquivo /etc/sudoers:

# No Ubuntu o iptables e o tc estao dentro do /sbin
Cmd_Alias BANDCONTROL = /sbin/iptables, /sbin/tc
www-data  ALL = (ALL) NOPASSWD: BANDCONTROL

Configuracao do Apache

Configure um virtualhost no apache criando o arquivo /etc/apache2/sites-enabled/bandcontrol contendo:

WSGIRestrictStdout Off
NameVirtualHost bandcontrol
<VirtualHost bandcontrol>
        ServerAdmin webmaster@localhost
        LimitInternalRecursion 1000
        ServerName bandcontrol
 
        <Directory /var/www/bandcontrol>
                Options ExecCGI FollowSymLinks MultiViews
                AllowOverride FileInfo
                MultiviewsMatch Handlers
                Order deny,allow
                Allow from all
        </Directory>
 
        ErrorLog /var/log/apache2/bandcontrol_error.log
        CustomLog /var/log/apache2/bandcontrol_access.log combined
 
        WSGIScriptAlias /     "/var/www/bandcontrol/config.wsgi"
 
        Alias /admin_media/ "/usr/lib/pymodules/python2.6/django/contrib/admin/media/"
        Alias /media/           "/var/www/bandcontrol/media/"
</VirtualHost>

Edite o /etc/hosts e adicione:

127.0.0.2     bandcontrol

Configuracao do Bandcontrol

Altere o arquivo /var/www/bandcontrol/config.wsgi ajustando o diretório de instalação do Django. O padrão do Ubuntu é /usr/lib/pymodules/python2.6/django. Nesse arquivo também é configurado o diretório do bandcontrol:

import os, sys
PROJECT_ROOT_PATH = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, PROJECT_ROOT_PATH)
sys.path.append('/usr/lib/pymodules/python2.6/django/')
sys.path.append('/var/www')
os.environ['DJANGO_SETTINGS_MODULE']='settings'
import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()
 
import bandcontrol.monitor
bandcontrol.monitor.start(interval=1.0)

No arquivo /var/www/bandcontrol/settings.py é possível fazer mais alterações.
Para definir as interfaces de rede e classe IP utilizada na rede, edite os arquivos /var/www/bandcontrol/scripts/CONFIG e /var/www/bandcontrol/scripts/firewall.

Por padrão é utilizado o banco de dados sqlite3. Você pode escolher usar o MySQL ou PostgreSQL editando o arquivo /var/www/bandcontrol/settings.py.
Para criar o BD, entre no diretório do bandcontrol e execute o comando manage.py syncdb. Digite yes para confirmar a criação do super usuário. Forneça um login, e-mail e senha:

root@localhost: /var/www/bandcontrol# python manage.py syncdb
Creating table auth_permission
Creating table auth_group
Creating table auth_user
Creating table auth_message
Creating table django_content_type
Creating table django_session
Creating table django_site
Creating table django_admin_log
Creating table rede_plano
Creating table rede_pontorede
 
You just installed Django's auth system, which means you don't have any superusers defined.
Would you like to create one now? (yes/no): yes
Username (Leave blank to use 'root'): gustavo
E-mail address: eu@gustavohenrique.net
Password:
Password (again):
Superuser created successfully.
Installing index for auth.Permission model
Installing index for auth.Message model
Installing index for admin.LogEntry model
Installing index for rede.PontoRede model

Reinicie o Apache para que as alterações tenham efeito.

Utilização

Abra o browser e acesse http://bandcontrol/.
Reparem que no campo de endereço da URL e os nomes de usuário utilizados não condizem com o que foi exemplificado nesse artigo. Bom... estou com preguiça para alterar as imagens, então vamos desconsiderar esse "bug".

Entre com o login e senha criados no passo anterior.

Tela inicial do sistema.

Clique em Planos e vamos criar alguns.

Volte à tela inicial, clique em Pontos de Rede. No menu superior há opção para executar o firewall, parar o controle de banda e exibir os IPs conectados ao servidor. Sempre que fizer alguma alteração no sistema deve executar o firewall para ativar as mudanças.

Em exibir IPs conectados, para adicionar um IP no sistema forneça uma descrição única, escolha o plano e clique em [+].

O bandcontrol permite criar outros usuários com acesso ao sistema. Trabalha com permissões e grupos. Cortesia do Django \o/

Conclusão

Bandcontrol foi uma daquelas coisas "pra ontem". Foi feito em uma tarde de terça-feira. Tal velocidade se deve ao framework Django.
Esse artigo foi escrito um pouco de cada vez, por isso há grandes chances de algo sair errado. Há muito material disponível na web sobre deploy de projetos em Django. Em caso de dúvidas estarei disposto a ajudar.

Compartilhe esse artigo

* Coding Dojo Rio *
dojo-rio@googlegroups.com

http://groups.google.com/group/dojo-rio

http://code.google.com/p/dojo-rio

http://dojorio.wordpress.com

Compartilhe esse artigo