Quem sou eu

Minha foto

Formado em Computação, desenvolvedor web, interessado em tecnologia, metaleiro e um gamer inveterado.

Pesquisar

sábado, 24 de janeiro de 2009

Parte 5 - Integrando o cadastro aos usuários do Django


Neste tópico, mostrarei um dos muitos recursos do Django em detalhes: a Integração do cadastro do projeto ao usuários Django.

Vamos primeiro entender do que se trata. Cadastro é uma das muitas aplicações que geralmente temos em todos os projetos, e muita das vezes, os usuários que se cadastrarem tem acesso privilegiado à algumas seções. Para restringir o acesso não autorizado ao conteúdo controlado, era necessário controlar em todas as páginas se o usuário estava logado, se tinha permissão de fazer àquela requisição, etc.
No Django há uma forma fácil de fazer isso. Vamos ao código. Crie sua aplicação cadastro:

python manage.py startapp cadastro


E deixe o model da seguinte forma:






O relacionamento da classe cadastro recém criada e a de usuários do Django ocorre na linha 11, onde temos uma FK para a classe User, importada na linha 2.

Outra coisa interessante, é a linha 3, onde importamos a lista de estados brasileiros provida pelo próprio Django. Utilizo esta lista na linha 25 para prover uma escolha no campo estado da classe cadastro.

Abaixo da classe meta que vimos nos posts anteriores, temos um método muito importante. A def save é a responsável por fazer a persistencia dos dados no banco. O que estou fazendo nesta classe é simplemente sobrescrevendo ela, de forma a funcionar como preciso.

Quando um objeto é adicionado ao banco, o método save é chamado e instancia um objeto de uma classe, setando os valores passados para cada respectivo atributo.

Caso for sobrescrever a def save, é necessário prever as duas situações: quando um objeto for inserido ou quando for alterado. Em ambos os casos, o o save é chamado.

Para testar qual caso estaremos lidando basta fazer o teste da linha 36:

if not self.id:

Se não existir conteudo dendo do atributo id do objeto atual, o mesmo estará sendo inserido ao banco de dados, caso contrário, alterado.


Neste exemplo utilizaremos o email como usuário. Como o usuário do Django tem que ser único, farei alguns tratar isso. Na linha 37, é feito uma busca no banco de cadastro para verificar se o email já existe no sistema.

c = Cadastro.objects.filter(email=self.email).count()

Caso o email existir (linha 38), levantaremos uma exceção EmailExistente impedir o cadastro.

Veremos como utilizar as excessões mais a frente.

Nas linhas 41 à 47, é feito uma verificação para saber se o usuário já existe. Caso existir, o mesmo é atribuído ao objeto u, caso contrário, é criado um novo usuário com base no email e senha fornecidos e atribuido ao objeto u. Em ambos os casos, o objeto u é salvo e a FK para a classe User é setada com o mesmo.


Para alteração (linhas 48 à 52), basta setar os atributos da classe user com os novos dados forncecidos.


Após este tratamento, será chamado o método save original para fazer a persistência, passando os seguintes parâmetros: a classe Cadastro e nosso objeto em questão (self), da seguinte forma:

super(Cadastro, self).save()


As classes CadastroPF e CadastroPJ, são classes normais iguais as que já foram feitas, com apenas uma diferença: não herdam da models.Model, mas sim da classe Cadastro, onde temos os atributos comuns às duas. Crie o restante das classes conforme a figura abaixo:






Crie um admin.py da seguinte forma:




Note que apesar de criar uma administração pra classe Cadastro, esta não está registrada na administração. Desta forma, apenas será inserido um cadastro de pessoa física ou jurídica, e veremos a herança funcionado.



Instale sua aplicação no settings, sincronize o banco, inicie o servidor e faça os testes necessários.


svn: Revision 8
hasta!


domingo, 18 de janeiro de 2009

Parte 4 - Criando views

Para concluir essa primeira fase do tutorial, faremos agora exemplo com duas views para a aplicação CD.

Abra o arquivo views.py e o deixe da seguinte forma:

# -*- coding: utf-8 -*-
# Create your views here.

from django.shortcuts import render_to_response
from app.cd.models import Interprete, Album

def listaInterpretes(request):

interpretes = Interprete.objects.order_by('nome')
return render_to_response('cds/interpretes.html', {'interpretes':interpretes,})


def listaCds(request,slug=None):

cds = Album.objects.filter(interprete__slug = slug)
return render_to_response('cds/cds.html', {'cds':cds,})

A função render_to_response é a responsável de passar todos os objetos para o template especificado.

Para listar os intérpretes, utilizaremos def listaInterpretes. Todas as defs criadas no views.py para utilização no front precisam do parâmetro obrigátorio resquest. Através dele, será possível pegar conteúdos dos POSTs, GETs e SESSIONs.

A primeira linha da def listaInterpretes, é a responsavél por pegar todos os registros contidos no banco para esta classe e através do método order_by, os registros já virão ordenados pelo campo solicitado, neste caso, o nome.

Ao clicar no nome do intérprete, queremos mostrar quais cds estão relacionados a ele. Faremos isso utilizando a listaCds. Da mesma forma que fizemos com a primeira def, será necessário pegar todos os cds, porém agora temos uma restrição: mostraremos apenas os cds vinculados ao intérprete escolhido.

Vamos enteder como isso será feito:

cds = Album.objects

Neste ponto, temos todos os cds contidos no banco de dados. Para filtrar apenas os relacionados ao intérprete escolhido utilizaremos o método filter.

Nossa chave estrangeira interprete da classe Album é uma conexão direta aos objetos da classe Interprete, sendo possivel desta forma acessar quaisquer conteudos lá contidos.

Lembra do campo slug do model? Aqui ele será utilzado. Cada intérprete possui um slug, e como ele estará contido na url, por que não utilizá-lo para o filtro? É extamente isso que iremos fazer.

No comando filter, vamos filtrar pelo campo slug da classe Interprete da seguinte forma:

filter(interprete__slug = slug)

O parâmetro slug desta def será passado pela url. Com as defs prontas veremos agora como criar tais urls para deixá-las elegantes e funcionais.

O URLS.PY

Adicone ao urls.py da raiz do seu projeto a seguinte linha abaixo da url do admin:

(r'^cds/', include('app.cd.urls')),

Esta linha importará todas as urls contidas no urls.py da sua aplicação cd. É possivel colocá-las no arquivo urls.py da raiz, mas por questão de organização, criaremos um outro urls.py dentro da aplicação, referenciando as mesmas través do include acima, mapeadas pela url: /cds/.

Agora crie dentro da pasta cd, um arquivo chamado urls.py e deixe-o da seguinte forma:



from django.conf.urls.defaults import *

urlpatterns = patterns('app.cd.views',

(r'^$', 'listaInterpretes'),
(r'^interpretes/$', 'listaInterpretes'),
(r'^(?P<slug>[-\w]+)/$', listaCds),

)


Com as importações necessárias, definiremos os padrões de urls desta aplicação.
Neste exemplo estão sendo criadas três urls:

  • /cds/
    Irá funcionar de maneira similar ao index.html em uma pasta qualquer. Essa urls chamará a def listaInterpretes contidas no views.py da aplicação cd.

  • /cds/interpretes/
    Esta url terá a mesma funcionalidade da anterior.

  • /cds/
    Aqui, o slug do intérprete será passado através da expressão regular para texto : [-\w]+ , que chamará a def listaCds, passando o segundo parâmetro necessária para a listagem de cds: o slug do intérprete.

OS TEMPLATES

Criarei os dois templates dos exemplos acima de forma bem simples, apenas para servir de exemplo.

Dentro da pasta templates na raiz do projeto crie a pasta cds. Dentro dela crie os dois arquivos abaixo:

interpretes.html



Na linha 14 da imagem a acima, temos um for que irá passar por todos os registros vindos o objeto interepretes que foi passado na view. Para cada registro, será criado um link para redirecionar até SLUG/, onde o mesmo será o valor contido no atributo slug do objeto i corrente.
Conforme vimos anteriormente, o parâmetro slug, será passado através da expressão regular contida no urls.py que foi criado na aplicação.

Vejamos o outro template a ser criado:


cds.html


Neste template, apenas temos um for, que irá correr todos os registros do objeto cds filtrados pelo slug do intérprete, conforme vimos na view.


OBSERVAÇÕES:

  • Note que as variáveis apenas são ACESSADAS no template, não é possivel definí-las no mesmo.

  • Para os comandos, deve-se utilizar o bloco:
    {% comando %} com seu respectivo bloco de fechamento {% endcomando %}.

  • Para acessar o conteúdo dos objetos deve-se utilizar: {{ obj.atritbuto }}, conforme nos exemplos acima.

Agora basta iniciar o servidor e acessar http://localhost:8000/cds/, se estiver rodando local.

Repositório atulizado até este post: Revisao 7.

hasta!

sexta-feira, 16 de janeiro de 2009

Parte 3 - Criação da primeira APP

Dentro da pasta do projeto iremos criar a primeira aplicação deste projeto. Começarei por CD. Navegue até a pasta do projetop via prompt e execute o comando:

python manage.py startapp cd

Este comando irá criar uma pasta com 3 arquivos:

  • __init__.py
  • models.py
    Neste arquivo será colocado todos os modelos da aplicaçã
  • views.py
    Aqui ficam as views que utilizaremos no front. Voltaremos a falar delas mais a frente.

Por hora abra o models.py.

Acima da importação do pacote models, coloque a codificação a ser utilizada:

# -*- coding: utf-8 -*-
from django.db import models


Deixando tudo em UTF-8, problemas de acentuação tanto no banco quanto nos templates serão evitados.
Mantenha essa string sempre na primeira linha de todos os models.py e views.py.


CRIANDO O PRIMEIRO MODELO


Nesta aplicação, defini que os cds serão divididos por categoria, intérprete e conterão algumas informações espefíficas do album tais como: foto, ano e faixas. Vamos ao código:




A classe categoria:

class Categoria(models.Model):

nome = models.CharField(max_length=100)
slug = models.SlugField(max_length=100)

class Meta:

ordering = ['nome']

def __unicode__(self):

return self.nome



A classe categoria herda as propriedades da classe Model, por isso o import nas primeiras linhas.

Os atributos:

nome = models.CharField(max_length=100)
slug = models.SlugField(max_length=100)


Ambos serão renderizados como um INPUT TEXT no admin, porém o campo slug gera uma melhor indexação no banco, além de ser o grande responsável pelas urls elegantes que criaremos para as views.
Em ambos os casos o parâmetro max_length é obrigatório.

O campo slug será utlizado de forma a identificar um registro nos banco de forma única no banco, e será preenchido de uma forma interessante quando chegarmos na administração desse modelo.

A classe Meta, que está definida dentro de da classe recém criada possui muitos recursos interessantes. Para categoria, estou utilizando apenas a ordenação padrão quando os objetos da mesma forem listados:

ordering = ['nome']

Com o ordering posso colocar a ordenação por quaisquer atributos pertencentes a minha classe, e utilizar o sinal "-" (menos) para ordenação decrescente, como por exemplo:

ordering = ['-id']


O método __unicode__ é o responsável por retornar uma string contendo o conteudo de qualquer campo da instância do objeto em questão. Caso ele não esteja defindo, ocorre a seguinte diferença para um objeto c pertencente a esta classe:

c - retornaria: OBJECT
c.nome - retornaria o valor do atributo nome

Já com o __unicode__, ambos os casos retornariam diretamente o valor, o que poupa trabalho.





A classe Interprete:

class Interprete(models.Model):

nome = models.CharField(max_length=100)
slug = models.SlugField(max_length=100)

def __unicode__(self):

return self.nome



class Meta:

ordering = ['-id']
verbose_name = u'Intérprete'
verbose_name_plural = u'Intérpretes'



Aqui temos dois novos recursos da classe meta. É possivel setar qual será o nome no singular e no plural através do verbose_name, de forma a deixar correto (com acento) no admin.




A classe Album:

class Album(models.Model):


categoria = models.ForeignKey(Categoria)
interprete = models.ForeignKey(Interprete)
titulo = models.CharField(max_length=255,verbose_name=u'Título')
cover = models.ImageField(upload_to='albuns/%Y/', null=True, blank=True)
ano = models.IntegerField()
slug = models.SlugField(max_length=255)

def __unicode__(self):

return self.titulo


class Meta:

ordering = ['-id']
verbose_name = u'Album'
verbose_name_plural = u'Albuns'




Aqui temos algumas novidades em relação as anteriores:

- É possivel utilizar o verbose_name para atributos de forma a corrigir o nome mostrado no admin, conforme visto no título;

- Para nomes com acentos, se faz necessário colocar a letra "u" antes da string com o mesmo, para ficar correto com a codificação;

- um campo do tipo Imagem para fazer o upload da capa do álbum. O parâmetro upload_to é obrigatório e deve ser a string do caminho onde ficarão as imagens. Também é possivel organizar os uploads por datas. Neste exemplo, será gerada a pasta albuns dentro do media, e dentro dela, uma pasta com o ano que fez o upload defindo pelo caracter "%Y". Observação: o ano do álbum não está relacionado com o caminho do upload;

- Para o campo cover, temos dois parâmetros opcionais que permitem ao usuário criar um álbum sem a necessidade de preencher este campo. Colocando ambos campos em um atributo, o django exclui o mesmo da validação automática.

- Temos duas chaves estrangeiras para a classe album: categoria e interprete. Previmente definidos;


- E por fim, o campo do tipo inteiro ano, que também será renderizado como um INPUT TEXT no admin.




A classe Faixa:

class Faixa(models.Model):

album = models.ForeignKey(Album)
nro = models.IntegerField(verbose_name = u'Número')
nome = models.CharField(max_length=200)
tempo = models.CharField(max_length=10, help_text='Formato MM:SS',blank=True,null=True)

def __unicode__(self):

return self.nome




A novidade na classe faixa é uma dica dada ao usuário sobre o correto preenchimento para um campo na administração. Utilizando o atributo opcional help_text, a mensagem desejada aparece ao lado do campo escolhido.


CRIANDO O ADMIN PARA O MODELO

Crie dentro da pasta da sua aplicação um arquivo com o nome de admin.py. Dentro dele precisaremos de dois imports:

from django.contrib import admin
from app.cd.models import *

O primeiro para as funcionalidades do admin em si, e o segundo para as informações do modelo criado.

Logo abaixo, será criado as classes do administrativo:





O admin de Categoria:

class CategoriaAdmin(admin.ModelAdmin):

search_fields = ('nome',)
list_display = ('nome',)
prepopulated_fields = {'slug': ('nome',)}
save_on_top = True



search_fields - recebe uma tupla com os campos em que será realizada uma busca por quaisquer ocorrências do que for digitado.

list_display - recebe uma tupla com os campos que aparecerão na listagem

prepopulated_fields - aqui um recurso interssante do django para o campo slug. O preenchimento automático do campo slug com o texto do quer for inserido no campo nome, com excessão de algumas palavras reservadas, espaços e acentuação.

save_on_top - útil para formulários grandes. Esta opção replica a barra de controle para salvar/apagar registros acima do form.




O admin de Interprete:


class InterpreteAdmin(admin.ModelAdmin):

search_fields = ('nome',)
list_display = ('nome',)
prepopulated_fields = {'slug': ('nome',)}
save_on_top = True


Vamos utilizar um recurso muito interessante para as duas classes que faltam. Imagine se tivesse que inserir primeiro álbum com todas as informações, depois ir até o administrativo de faixas para inserir uma a uma tendo que escolher o álbum. Trabalhoso demais. O Django possui uma solução para isso.

É possível utilizar um recurso chamado INLINE, para adicionar uma ou várias faixas durante a inserção do álbum. Vejamos como:




O admin inline de Faixa:

class FaixasInline(admin.TabularInline):

model = Faixa
extra = 15


Esta classe herda de uma classe diferente das outras extamente por possuir esse recurso. Apenas precisamos definir a qual modelo ela se refere:

model = Faixa


E a quantidade de itens que serão exibidas além dos preenchidos:

extra = 15




O admin de Album:

class AlbumAdmin(admin.ModelAdmin):

inlines = [

FaixasInline,

]
raw_id_fields = ('categoria','interprete',)
search_fields = ('titulo',)
list_display = ('titulo','interprete','categoria','ano')
list_filter = ['categoria']
prepopulated_fields = {'slug': ('titulo',)}
save_on_top = True


Novidades desta classe:

- Nesta classe, é definido que será utilizado a classe FaixasInline criada anteriormente

- Como provavelmente teremos muitos artistas e categorias, procurá-los em um campo do tipo SELECT (tipo renderizado pelos campos ForeignKey) seria um tanto trabalhoso. Com a opção raw_id_fields, é aberto uma nova janela com a listagem definida pela referência a chave estrangeira, de forma a utilizar todas as buscas, filtros e ordenação providas pelo admin da mesma.

- list_filter - gera um filtro para facilitar a busca de um registro. O filtro só é exibido quando esta classe possuir registros pertencentes a mais de uma classe do filtro.




O admin de Faixa:

class FaixaAdmin(admin.ModelAdmin):

search_fields = ('nome',)
list_display = ('nome','album','nro','tempo')
save_on_top = True




Para concluir o admin.py, registre os admins criados ao final do arquivo:


admin.site.register(Categoria, CategoriaAdmin)
admin.site.register(Interprete, InterpreteAdmin)
admin.site.register(Album, AlbumAdmin)
admin.site.register(Faixa, FaixaAdmin)



TESTES


Adicone dentro do INSTALLED_APPS no settings.py a aplicação criada.


INSTALLED_APPS = (

'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.admin',
'app.cd',


)



Pare o servidor local de testes caso esteja rodando e execute um syncdb para gerar as tabelas.
Inicie novamente o servidor de testes com o runserver e abra o admin do seu projeto no link:

http://localhost:8000/admin/

Faça o login e veja o foi criado.

Dicas Úteis - Visão geral do SVN com o Tortoise

Quando comecei a trabalhar com Django, foi quando coloquei os conhecimentos sobre essa fantástica ferramenta chamada SVN à prova.

Simples de utilizar, e com a possibilidade de restaurar quaisquer versões de algo que já foi feito, facilmente caiu nas graças da equipe de desenvolvimento quando apresentada.

Para poupar o trabalho repetitivo de ficar copiando e colando daqui do blog, mesmo porquê, o editor html disponível para os post dificulta a vida quando se faz necessário uma indentação precisa. Vou disponibilizar o que for desenvolvendo em um repositório, e gerenciando as versões do projeto através do controle de versão oferecido pelo Google Code (http://code.google.com/hosting/).

Para subir as versões mais novas do projeto, utilizarei o comando SVN Commit, que enviará os arquivos recém alterados para o servidor.

Resumindo, não muda nada. Será necessário fazer o checkout do link abaixo da mesma forma que fizemos no post de instalação do Django:
http://colecoes.googlecode.com/svn/trunk/


Vamos ao trabalho. Dentro de sua pasta de projetos (C:\projetos\) , crie uma pasta chamada colecoes. Da mesma forma que fizemos com o Django, clique com o botão direito e escolha a opção SVN Checkout do Tortoise, colocando no link do repositorio o link do projeto citado anteriormente.

Depois do projeto sincronizado com o servidor, a cada nova atualização , será necessário clicar com o botão direito na pasta criada e escolher a opção SVN Update. Isso fará com que o Tortoise puxe todos os arquivos alterados que estiverem no servidor para a maquina local, mas NÃO substituirá arquivos alterados localmente que estiverem diferentes do servidor.

Caso altere algo, e desejar pegar a versão correta do servidor novamente, utilize a opção Tortoise SVN >> Revert, ao clicar com o botão direito em cima do arquivo e/ou pasta que desejar puxar novamente.

Outra opção é atualizar para uma revisão específica, através da opção Tortoise SVN >> Update to Revision. Basta passar o número da revisão com o qual quer trabalhar, que um download da mesma será feito.


Graças a esse controle de versões, o SVN possibilita trabalhos em equipe de forma sincronizada, gerenciando inclusive mais um desenvolvedor trabalhando no mesmo arquivo. Quando isso acontece ele possui duas opções:

  1. Merge (junção) das alterações em um único arquivo quando as linhas editadas pelos membros da equipe NÃO for a mesma.

  2. Gerenciador de conflitos para edição em mesma linha. Para este caso, é mantido uma cópia da versão original do servidor e uma cópia para cada commit responsável por esse conflito. Quando isso acontecer, o Tortoise cria uma entrada dentro do menu Tortoise SVN, para resolver os conflitos com uma decisão humana, onde o responsável pela mesma verá as três cópias possíveis e decidirá qual manter no servidor.
A partir desse ponto ficará mais facil acompanhar este desenvolvimento através do SVN, mas quem optar por não segui-lo, poderá perfeitamente continuar acompanhando o projeto a partir do próximo post. Fica a dica.

hasta!

quinta-feira, 15 de janeiro de 2009

Parte 2 - Breve tour pelo admin do Django

Continuando de onde parei no último post, uma funcionalidade muito útil que o Django já trouxe pronto: A administração de usuários.

Como é bem auto explicativo, apenas vou apresentar brevemente como ficou o admin criado. Depois de logar, verá a home da administração. É nela que estarão todas suas aplicações instaladas. Como acabamos de criar o admin, este contém apenas o módulo padrão Site, que já vem configurado no settings.py na setting INSTALLED_APPS, conforme vimos na parte 1.

O módulo Auth é o módulo que adiconamos à INSTALLED_APPS quando configuramos o settings.py do projeto. É ele o responsável por gerenciar todos os logins e permissões de usuários e grupos, o que se integrado com o usuário do front-end, facilita muito o desenvolvimento. Veremos como integrar o usuário do Django com um usuário do projeto mais a frente.



Também na home, é apresentado um box a direita que mantém o historórico das modificações realizadas recentemente na administração.


Home da administração


Pré-cadastro dos usuários


Para utilizar a administração o usuário orbigatoriamente precisa ser um Membro da equipe. Automáticamente quando cria-se um usuário este vem com a opção ativo pré-selecionada. Este recurso é bastate util caso não queira perder as informações do usuário em seu projeto, como por exemplo um E-Commerce que existam vários pedidos associados a este usuário, caso precise "removê-lo", pense na simples opção de desativá-lo, porque SIM, com o Django nada fica órfão no banco.



Permissões

Outra facilidade que o Django provê é a customização das permissões por usuários e grupos. Sobre as permissões existem três opções: ou cria-se um usuário com privilégio de superusuário (o que poupa o trabalho de setar todas as permissões individualmente), ou caso precise de apenas algumas pode setá-las com base na lista de permissões. Esta lista também vai apresentar todas as aplicações que você instalar no seu projeto, ou ainda criar um grupo e setar apenas as permissões do grupo. Os usuários que forem associados ao grupo em questão herdarão as permissões do mesmo.

Edição de permissões


Precisa de um grupo e agora já digitou todas as informações do seu usuário? Sem problemas. É possivel utilizar o símbolo de "+" ao lado da lista de grupos, sem a necessidade de voltar à home para criar o grupo pelo módulo de grupos. Ao criar um grupo por aqui, além de ele já ser adicionado ao banco, ao clicar em salvar, o Django automaticamente o seleciona para a concluir a crição do usuário. Veremos como fazer isso quando criarmos a primeira aplicação.

Adicionando grupos pela administração de usuários



Atalhos, buscas e filtros com uma linha de código.

Listagem dos usuários com alguns recursos interessantes


Insira um usuário, edite as permissões, logue com ele para ver as diferenças para sentir uma das várias facilidades que teremos para os projetos.

hasta!

terça-feira, 13 de janeiro de 2009

Parte 1 - O Projeto

Defini como projeto, algo genérico suficiente para podermos seguir de maneira fácil e possibilitar adpatções conforme for o desenrolar do mesmo.
Utilizarei no meu exemplo, um sitema para gerenciar cds, dvds e livros de um colecionador.

O INÍCIO

Crie uma pasta para armazenar seus projetos, de preferência um lugar fácil para acessar via prompt (Ex. C:\Projetos). Para criar seu projeto vá até sua pasta de projetos e digite o comando:

django-admin.py startproject app

Neste exemplo, adoto por padrão o nome app para meu projeto. Mais a frente entrarei em detalhes sobre isso.

Ao executar o comando, na sua pasta de projetos será criada uma pasta com o nome do projeto escolhido e dentro dela 4 arquivos:
  • __init__.py
    Este arquivo não será utilizado por hora, mas ele serve para informar ao django que é uma pasta com conteúdo Python.

  • manage.py
    Este arquivo será utilizado mais a frente quando for criar as aplicações para o projeto

  • settings.py
    Este arquivo é o responsável por gerenciar todas as configurações do seu projeto. Entraremos em mais detalhes abaixo.

  • urls.py
    Este arquivo conterá todas as urls de nossas aplicações mapeadas para suas respectivas views.

O SETTINGS.PY

Abra o settings.py da raiz do projeto. Por hora, irei alterar apenas o básico de forma a colocar o administrativo gerado pelo django com poucas alterações:

coloque o seguinte comando na primeira linha do seu arquivo:

from os import path as os_path

Nesta linha, estou importando o objeto path do pacote os, e colocando um alias para tal: os_path. Utilzaremos isso logo a seguir para configurar o media.


Os controles de debug servem para o django gerar uma tela erro ao desenvolvedor informando o motivo do erro. Mais a frente tratarei dos erros mais comuns de cometer durente o desenvolvimento. Por hora, deixe as duas linhas como estão:

DEBUG = True TEMPLATE_DEBUG = DEBUG


Vamos criar duas setting neste ponto para definir o caminho e a url do projeto. Coloque os comandos a seguir abaixo dos controles do DEBUG.

PROJECT_PATH = os_path.abspath(os_path.split(__file__)[0])
SITE_URL = 'http://localhost:8000/'



Certifique-se que a setting SITE_URL tenha uma barra no final conforme o código acima.

Logo em seguida está uma tupla com os administradores do seu projeto. Coloque seu nome e seu email. nos respectivos lugares e descomente a linha. Isso será util mais a frente quando for colocar para enviar os logs de erros para o email. Deixe seu código assim:

ADMINS = ( ('Seu nome aqui', 'seuemail@provedor.com.br'), )

VALE LEMBRAR:

A indentação para indicar que os elementos hierarquicamente dispostos têm o mesmo avanço relativamente à posição (x,0). Na maioria das linguagens a indentação tem um papel meramente estético, tornando a leitura do código fonte muito mais fácil (read-friendly), porém é obrigatória em outras. Python, por exemplo, utiliza esse recurso tornando desnecessário o uso de certos identificadores de blocos ("begin" e/ou "end").

Para este tutorial utilizarei UM TAB, para cada nível de indentação


O Banco de Dados

Crie uma database no seu banco de dados e configure cada variável com seu respectivo valor conforme o exemplo abaixo:


DATABASE_ENGINE = 'mysql'
DATABASE_NAME = 'app'

DATABASE_USER = 'usuario'

DATABASE_PASSWORD = 'senha'

DATABASE_HOST = '' # deixe vazio para localhost

DATABASE_PORT = '' #deixe vazio para porta padrao do banco escolhido. Neste caso 3306.



O usuário informado acima deve ter privilégios para criação/alteração de tabelas, indices etc., na database informada.

Acerte também o fuso horário que deseja utilizar:

TIME_ZONE = 'America/Sao_Paulo'

Outro recurso muito interessante é a internacionalização. O Django já provê uma serie de facilidades para deixar seu projeto multi-lingua. Mais a frente , mostro como funciona a traduçãio automática. Coloque o idioma padrão aqui:
LANGUAGE_CODE = 'pt-Br'

O próximo setting é o ID do site que está trabalhando. Com o django é possível utilizar a mesma administração pra projetos semelhantes porém independentes, gerenciando através desta setting. Deixe ela sem nenhuma alteração como descrito abaixo:

SITE_ID = 1

A próxima setting é referente a internacionalização. Deixe ela como True que iremos utilizá-la mais a frente.

USE_I18N = True


O MEDIA

O media é onde ficarão todos os arquivos referentes a conteúdo, como por exemplo
  • páginas de estilos (css)
  • javascripts
  • todos os arquivos vindos de upload pela administração, tais como fotos, videos, pdfs, etc.
A correta configuração do media se faz necessária para acessar os conteúdos descritos acima. Para definir um padrão de configuração, vamos utilizar a setting PROJECT_PATH, defina anteriormente. Deixe a configuração do media da seguinte forma:

  1. MEDIA_ROOT = os_path.join(PROJECT_PATH, 'media')
  2. MEDIA_URL = '%smedia/' % SITE_URL # trailing slash
  3. ADMIN_MEDIA_PREFIX = '%smedia/' % SITE_URL # trailing slash.

No item 1, usaremos o método join do objeto os_path previamente importado para concatenar o caminho do projeto com a string media. Já no item 2, será definido a url do media. O conteudo de %s será substituido pela setting SITE_URL (outra forma de concatenação de strings), também previamente definida. E por fim, no item 3, o caminho do media para o administrativo, igualmente definido no item 2.

Para o administrativo do django, não é necessário ter uma pasta media dentro do seu projeto. Farei isso mais a frente quando criar uma aplicação que precisará disso.

A setting SECRET_KEY, faz parte do algoritmo de criptografia que o django utiliza para gerar senhas por exemplo. Deixe esta setting sem nenhuma alteração.


A tupla MIDDLEWARE_CLASSES define quais middlewares serão utilizados pelo projeto, por default 3 deles já vem adicionados a lista e por hora são apenas os necessários. Deixe esta settings também sem nenhuma alteração.


ROOT_URLCONF define qual será o arquivo de urls utilizado pelo projeto. No caso usaremos o criado na raiz do projeto. Por default, essa setting já vem com esse valor, apenas confira para checar:

ROOT_URLCONF = 'app.urls'


A tupla TEMPLATE_DIRS é a responsável por mapear os possíveis caminhos para seus templates que serão utilizados nas views de suas aplicações e/ou alguma view personalizada no admin. Este tópico será discutido mais a frente.
Deixe a tupla da seguinte forma:

TEMPLATE_DIRS = ( os_path.join(PROJECT_PATH, 'templates') )


E por fim, a setting INSTALLED_APPS é a tupla que contém todas as aplicações instaladas do seu projeto. Vale destacar que se desenvolvido corretamente uma aplicação, é possivel torná-la plugável e utilizá-la em outros projetos de forma fácil e rápida.
Por hora apenas adicione a aplicação dos usuarios do admin:

INSTALLED_APPS = (


'django.contrib.auth',

'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',

'django.contrib.admin', #linha que adiciona o admin

)


Com o settings.py configurado, vá ao promtp, navegue até a pasta do seu projeto (C:\Projetos\app) e execute o seguinte comando para a criação do banco:

python manage.py syncdb

Isto irá criar todas as tabelas das aplicações instaladas, com relacionamentos, indices e de uma maneira otimizada.

Após a criação das tabelas, digite yes quando for questionado se deseja criar um super-usuário. Prencha os dados conforme forem solicitados.

Este usuário é o primeiro usuário com acesso ao administrativo. Trataremos da administração de usuários na Parte 2.


Para definirmos a url da administração, abra o urls.py e descomente as seguintes linhas linhas:

from django.contrib import
admin
admin.autodiscover()



e dentro de urlpatterns, descomente a url do admin:

(r'^admin/(.*)', admin.site.root),

No servidor de teste local do Django, é necessário informar que os conteudos da pasta media são conteudos estáticos.

No urls.py deixe o início do arquivo da seguinte forma:

from django.conf.urls.defaults import *
from django.conf import settings
from os import path as os_path


Ainda no urls.py coloque o seguinte código no final do arquivo:

if settings.DEBUG:


urlpatterns += patterns('',

(r'^media/(.*)$', 'django.views.static.serve', {'document_root': os_path.join(settings.PROJECT_PATH, 'media')}),)




Mais uma vez tome cuidado com a indentação.
Feito isso, vá até a pasta onde fez o checkout do Django (C:\Django\), e copie as seguintes pastas:

C:\Django\django\contrib\admin\media C:\Django\django\contrib\admin\templates

Agora vá até a raiz do seu projeto e cole-as.


Volte ao prompt e digite o seguinte comando para iniciar o servidor inbutido no django para testes:

python manage.py runserver

Com tudo corretamente configurado, você dever receber uma mensagem semelhante à:

Django version 1.1 pre-alpha, using settings 'app.settings'
Development server is running at http://127.0.0.1:8000/

Quit the server with CTRL-BREAK.



Pronto! Já temos o servidor do django rodando local para testes.
Vá ao navegador e digite o seguinte endereço:

http://localhost:8000/admin/

Com tudo rodando perfeitamente, você verá uma tela conforme a apresentada na Figura 1:


Figura 1. Interface de login da administração do Django


Caso queira ver tudo o que foi feito neste passo, acesse a administração com o super-usuário criado.

Na próxima parte, será explicado detalhes sobre a administração.

hasta! =D


domingo, 11 de janeiro de 2009

Instalando o Django

Aqui darei uma breve expliação de como proceder para fazer a instalação do Django no Windows.
Para mais detalhes, o DjangoBrasil possui um tutorial muito bem explicado: http://www.djangobrasil.org/documentacao/instalar/

Downloads:


2 - Python Imaging Library (PIL): http://www.pythonware.com/products/pil/

3 - Bibliotecas/Pacotes dos bancos de dados:

4 -Tortoise :
Cliente SVN que será utilizado no item 5.

5 - Django:
  • Última versao de desenvolvimento:

6 - Editor utilizado neste tutorial:
Notepad++ - http://notepad-plus.sourceforge.net/uk/download.php


7 - Banco de dados:


Se estiver no Windows com o Tortoise instalado, clique com o botao direito pasta desejada pra a instalação (C:\Django\) e clique na opção SVN Checkout,como mostra a figura a seguir:



Coloque o caminho do trunk do Django no campo URL do repositório, conforme a figura a seguir:

http://code.djangoproject.com/svn/django/trunk/


Clique em OK e espere o Tortoise fazer o download do fonte do Django, pode demorar alguns minutos dependendo de sua conexão.


Para demais sistemas execute o comando:
svn co http://code.djangoproject.com/svn/django/trunk/

OBSERVAÇÃO:
Para o download do item 3, certifique-se em puxar a versão compativél com o item 1



Instalação:

1 - Instale o Python que fez o download. No Vista se UAC estiver habilitado, ele provavelmente vai te fazer algumas perguntas.

2 - Instale o banco de sua preferência.

3 - No Windows Vista, desabilite o UAC antes de instalar a PIL e do pacote para os bancos de dados.

4 - Entre na pasta que fez o o checkout do Django via prompt/shell e execute o seguinte comando:
python setup.py install

5 - Adicone os caminhos das instalações do Python e do Django ao PATH do seu sistema
Ex:
C:\Python25;
C:\Django\django\bin;




Isto já deve deixar sua máquina pronta para começar brincar. =]



Um pouco de historia....

Django é um framework para desenvolvimento rápido para web, escrito em Python, que utiliza o padrão MVC (model-view-controller). Foi criado originalmente como sistema para gerenciar um site jornalístico na cidade de Lawrence, no Kansas. Tornou-se um projeto de código aberto e foi publicado sob a licença BSD em 2005. O nome Django foi inspirado no músico de jazz Django Reinhardt.

Desenvolvido e utilizado por mais de dois anos em uma operação ágil de notícias online, Django foi projetado para lidar com dois desafios: os prazos apertados de uma redação e os requisitos rígidos dos experientes desenvolvedores web que o criaram. Ele permite que você construa rapidamente aplicações web de alto desempenho e elegância.

Django utiliza o princípio DRY (Don't Repeat Yourself), onde faz com que o desenvolvedor aproveite ao máximo o código já feito, evitando a repetição.


Principais caracteristicas do Django:

  • Mapeamento Objeto-Relacional (ORM)

    Com o ORM do Django você define a modelagem de dados através de classes em Python. Com isso é possível gerar suas tabelas no banco de dados e manipulá-las sem necessidade de utilizar SQL (o que também é possivel).
  • Interface Administrativa

    No Django é possivel gerar automaticamente uma interface para administração para os modelos criados através do ORM.
  • Formulários

    É possível gerar formulários automaticamente através dos modelos de dados.
  • URL's Elegantes

    No Django não há limitações para criação de URL's elegantes e de maneira simples.
  • Sistema de Templates

    O Django tem uma linguagem de templates poderosa, extensível e amigável. Com ela você pode separar design, conteúdo e código em Python.
  • Sistema de Cache

    O Django possui um sistema de cache que se integra ao memcached ou em outros frameworks de cache.
  • Internacionalização

    Django tem total suporte para aplicações multi-idioma, deixando você especificar strings de tradução e fornecendo ganchos para funcionalidades específicas do idioma.
Fontes:
http://www.djangoproject.com/
http://www.djangobrasil.org/
http://pt.wikipedia.org/wiki/Django_(framework_web)