Exemplo utilizando GqlQuery like in gae.

query = self.request.str_POST['query']
queryEnd = query+"\xEF\xBF\xBD".decode('utf-8')
res = db.GqlQuery('SELECT * FROM User WHERE name>=:1 AND name<=:2 ORDER BY nom DESC', query, queryEnd)

Agora outro exemplo utilizando o a sintaxe de consultas do web2py

# observe a utilização do decode('utf-8') na linha abaixo para permitir filtro com caracteres acentuados
queryStart = request.vars.search.decode('utf-8')
queryEnd = queryStart+"\xEF\xBF\xBD".decode('utf-8')
query =((db.auth_user.email>=queryStart)&(db.auth_user.email<=queryEnd))
res = db(query).select()

Como isto deve ser utilizado em várias partes do código, você pode criar uma
pequena função que retorna o sql montado.

def like_query(term, field):
    """
    Recebe o termo pesquisado 'term (string)' e o campo a pesquisar 'field (object)'
    e retorna o SQL que será utilizado com o objeto db()
    """
    queryStart = term.decode('utf-8')
    queryEnd = queryStart+"\xEF\xBF\xBD".decode('utf-8')
    query =((field>=queryStart) & (field<=queryEnd))
    return query
 
query = like_query(request.vars.filter, db.auth_user.full_name)

O mais importante disto tudo, “Você pode pesquisar no gae sem precisar digitar todo o texto da pesquisa”

Galera, confesso que não foi fácil encontrar material para este post, e sei que
muita gente vai precisar disto, então peço que postem algo que seja uma solução
melhor ou até mesmo alternativa para utilização o like no gae.

Felizmente eu sempre compartilho as soluções dos meus problemas pois certamente isso pode ajudar a muitos.

Para este exemplo, vamos supor que você queira fazer um cadastro com dois ou mais passos (form wizard), com 4 campos (irei aproveitar a tabela padrão “auth_user”), são eles: “username, email, first_name, last_name” sendo que no primeiro passo teremos os campos username e email e no segundo passo os campos first_name e last_name.

Controllers:

def step1():
    form=SQLFORM(db.auth_user,fields=['username','email'])
    if form.accepts(request.vars, dbio=False):
        session.step1=request.vars
        redirect('step2')
    return dict(form=form)
 
def step2():
    form=SQLFORM(db.auth_user,fields=['username','email','first_name','last_name'])    
    if request.post_vars:
        request.vars.update(session.step1)    
    if form.accepts(request.vars):
        session.flash=T("Dados gravados")
        return redirect('index')
    return dict(form=form)

Views:

Step1

{{extend 'layout.html'}}
 
<fieldset>
<legend>Passo 1</legend>
 
    {{=form.custom.begin}}
 
    <div>
        <label>Username</label>
        {{=form.custom.widget.username}}
    </div>
 
    <div>
        <label>Email</label>
        {{=form.custom.widget.email}}
    </div>
 
    <div>
    {{=form.custom.submit}}
    </div>
    {{=form.custom.end}}
 
</fieldset>

Step2

{{extend 'layout.html'}}
 
<fieldset>
<legend>Passo 2</legend>
 
    {{=form.custom.begin}}
 
    <div>
        <label>First name</label>
        {{=form.custom.widget.first_name}}
    </div>
 
    <div>
        <label>Last name</label>
        {{=form.custom.widget.last_name}}
    </div>
 
    <div>
    {{=form.custom.submit}}
    </div>
    {{=form.custom.end}}
 
</fieldset>

Realmente é bem simples, a mágica aqui é a seguinte:

- No step1, definimos apenas os fields=['username','email'] para o SQLFORM e dbio=False para o form.accepts, desta forma iremos exibir apenas os dois campos descritos em fields e quando o formulário for submetido, os dados não serão salvos pois o dbio está definido como False.

- Criei também uma variável de sessão session.step1 e atribui o request.vars para ela, é desta forma que os dados serão passados para o segundo método (step2) através do método redirect(‘step2′).

- Outro detalhe importante que no step2, definimos todos os fields=['username','email','first_name','last_name'], sendo que os dois primeiros, já estarão preenchidos pois o usuário fez isso no passo um. O mais importante aqui é não exibir estes campos na view.

- Como os dados submetidos pelo step1 estão na sessão, lembra?, iremos atualizar o request.vars com estes dados, mas somente quando o usuário submeter no step2, fizemos isso através do comando

if request.post_vars:
        request.vars.update(session.step1)

- E para finalizar, o comando form.accepts do step2 se encarrega de fazer toda a validação e também gravar os dados no banco, veja que não definimos o dbio e o padrão dele é True (gravar no db).

Espero que seja útil, até a próxima.

function valid_mail($email){
    $pattern = '/^[A-Z0-9._%-+]+@[A-Z0-9][A-Z0-9.-]{0,61}[A-Z0-9]\.[A-Z]{2,6}$/i';
    return preg_match($pattern, $email)
}

Uso:

if valid_mail("ldmotta@motanet.com.br"){
    bla... bla... bla...
}

CBT Nuggets (http://www.cbtnuggets.com) lançou um vídeo de treinamento direcionado para aqueles que pretendem aprender a linguagem de programação Python.

Esta série de vídeos inclui desktop / desenvolvimento de aplicações web, a utilização de Python para automação e excelentes habilidades para os interessados na busca de uma carreira em programação. Além disso, a cobertura está incluído nos tipos de dados diferentes, manipulação de arquivos, estruturas de dados e programação modular e orientada a objetos.

Este CBT Nuggets Python é ministrado por especialistas programador Tim Warner e inclui 11 horas de instrução em 20 segmentos de vídeo. Os vídeos são curtos, 20-40 minutos.

Dan Charbonneau, CEO e fundador da CBT Nuggets, comentou: “Os programadores precisam ser extremamente flexíveis na aplicação de diferentes línguagens. Tendo uma outra ferramenta em seu cinto nunca é demais, e nossos treinamentos Python é um ótimo lugar para começar a expandir sua base de conhecimento. Você será capaz de programar em Python em todas as plataformas e tem uma vantagem sobre Java, Perl, C # e Ruby. ”

Vídeos de amostra da Formação Python estão disponíveis para consulta no site da CBT Nuggets, fornecendo exemplos da alta qualidade de ensino e estilo CBT Nuggets de treinamento.

CBT Nuggets também fornece treinamento completo para os exames de certificação da Microsoft ®, CompTIA ® e Cisco ®, além de vários outros fornecedores de certificação profissional. O treinamento é desenhado para oferecer precisão técnica em conjunto com analogias do mundo real para promover a compreensão para iniciantes e experts.

CBT Nuggets é o líder em treinamento de certificação baseado em vídeo de TI. Baseado em Eugene, Oregon, a empresa foi fundada em 1999 e está empenhada em oferecer qualidade de vídeos de formação para a indústria de tecnologia da informação. Para obter mais informações, visite http://www.cbtnuggets.com?promo=PR

Para a versão original em visita PRWeb: http://www.prweb.com/releases/prweb2011/01/prweb4985804.htm

Fonte: PRWEB

Olá a todos.
Um grande problema enfrentado por muitos no framework Web2py, refere-se a construção de formulários personalizados de Login e Cadastro.

Hoje o Python é a minha primeira linguagem de programação, e adoro programar utilizando o web2py, é ótimo ter a possibilidade de utilização dos formulários padrão de login e register deste framework, mas quando se trata de implementação de layout, muitos programadores não sabem por onde começar.

Vou dar um exemplo de construção de um formulário de cadastro personalizado e “engravatado”, como diria um amigo da visie.

Primeiro o Controller

Considerando que os campos “email,first_name,last_name e password” estejam na tabela auth_user, faça:

def register():
    form = auth.register()
    form.element(_name='email')['_class'] = "campo_email"
    form.element(_name='first_name')['_class'] = "campo_nome"
    form.element(_name='last_name')['_class'] = "campo_sobrenome"
    form.element(_name='password')['_class'] = "campo_senha"
    form.element(_name='password_two')['_class'] = "campo_confirmacao"
    return dict(form=form)

Acima estamos definindo classes para os campos personalizados

Agora a View

{{extend 'layout.html'}}
{{=form.custom.begin}}
 
<fieldset>
<legend></legend>
 
<div>
            <label>Seu nome:</label>
            {{=form.custom.widget.first_name}}</div>
 
 
<div>
            <label>Sobrenome:</label>
            {{=form.custom.widget.last_name}}</div>
 
 
<div>
            <label>Email:</label>
            {{=form.custom.widget.email}}</div>
 
 
<div>
            <label>Senha:</label>
            {{=form.custom.widget.password}}</div>
 
 
<div>
            <label>Confirme a senha:</label>
            {{=form.element(_name='password_two')}}</div>
 
<div class="checkbox">
            {{=form.element().append(INPUT(_type='checkbox', _name='termos'))}}
            {{=form.element(_name='termos')['requires']=IS_NOT_EMPTY(error_message=T('Aceite os termos do contrato'))
            <label>Li e aceito os <a href="#">termos de uso</a></label>
</div>
 
</fieldset>
 
<fieldset class="submit"><legend></legend>
            <button>Cadastrar</button>
</fieldset>
 
{{=form.custom.end}}

Aqui é simples, criei a estrutura do html normalmente, e onde quero que apareça os objetos de formulário (input,textarea,select etc) digito:

{{=form.custom.widget.nome_do_campo}}

Caso queira adicionar um novo objeto digito o html normalmente, como foi feito com o botão submit.

<button>Cadastrar</button>

Outra coisa muito importante, é a possibilidade de inclusão de campos extra no formulário. Na linha abaixo, estou incluindo um objeto de formulário que não faz parte do auth.register().

{{=form.element().append(INPUT(_type='checkbox', _name='termos'))}}

Podemos também incluir validação para o campo extra.

{{=form.element(_name='termos')['requires']=IS_NOT_EMPTY(error_message=T('Aceite os termos do contrato'))

Até aqui tudo bem, acesse a url da sua aplicação ex: http://0.0.0.0:8000/teste/default/register e o formulário de cadastro será renderizado perfeitamente.

Desta forma toda a validação padrão do formulário estará funcionando corretamente, mesmo a que verifica se as senhas conferem (inclusive muita gente teve problemas com isso).
Caso queira modificar as mensagens de erro, acesse o arquivo “/applications/sua_aplicacao/models/db.py” e defina as regras de validação da seguinte forma

auth.messages.mismatched_password = "Senha não confere"
db.auth_user.password.requires = CRYPT(key=auth.settings.hmac_key)
db.auth_user.password.requires = IS_NOT_EMPTY(error_message=T('Digite a sua senha'))
db.auth_user.first_name.requires = IS_NOT_EMPTY(error_message=T('Digite o seu nome'))
db.auth_user.last_name.requires = IS_NOT_EMPTY(error_message=T('Digite o seu sobrenome'))
db.auth_user.email.requires = (IS_EMAIL(error_message=T('E-mail inválido')), IS_NOT_IN_DB(db, db.auth_user.email,error_message=T('E-mail já cadastrado') ))

Done!

Ao preencher o formulário e submeter, os dados serão gravados no banco com sucesso.

Entretanto se você precisa de mais interação no formulário, aconselho utilizar a forma comun, que seria criar o formulário no controller utilizando o método FORM() e os helpres para html (TABLE, TR, TD, DIV etc.), retornar o formulário para a view e imprimir a variável que contém o formulário, e ao submeter, capture os dados utilizando o if form.accepts(request.vars, session): salva os dados…

Espero ter ajudado, espero que possam retribuir com comentários.

[]

Se você trabalha, estuda ou apenas gosta de desenvolvimento web, o Campus Online não pode faltar no seu Delicious ou na sua lista de favoritos.

O site está totalmente modificado para dar ao usuário a melhor experiência online. Com vídeos tutoriais sobre diversos assuntos, entre eles Python, Tableless e Ajax e uma infinidade de textos e artigos técnicos, desenvolvimento iPhone e muito mais.

O Campus Online realmente é uma fonte de informações sobre padrões web e programação. Os assuntos são compostos por textos e vídeos, explicados de forma simples e didática.

Acesse o Campus Online e divirta-se.

O Git, diferente do subversion, por exemplo, não é um repositório de dados centralizado. Assim, cada pessoa que trabalha no mesmo projeto terá uma cópia completa do repositório, portanto, as operções comuns de um repositório de dados são feitas localmente. Isso dá a liberdade total para o usuário trabalhar com o repositório como quiser, criando branches, fazendo merges, etc… Ao final do processo, ele pode enviar um branch mais bem trabalhado e testado ao repositório remoto.

Referência: http://akitaonrails.com/2008/10/2/entendendo-git-e-instalando-gitorious-git-via-web

Usando o Git na linha de comando

Criando um novo repositório

• Para as suas atualizações no repositório ficarem identificadas, configure o .gitconf na sua home:

       [user]
               name = seu nome
               email = seu email

• Crie o repositório

       $ mkdir projeto
       $ cd projeto
       $ git init      # inicia o repositório
       $ git add .     # inclui todos os arquivos no repositório
       $ git commit    # submete as suas mudanças e abre um arquivo texto para você comentá-las
       $ git log       # mostra o histórico de mudanças no repositório

Branching e merging

• Criando um novo branch:

       $ git branch novo-branch

• Para vizualizar os branches:

       $ git branch

O (*) mostra o branch em que você está trabalhando atualmente. Para escolher o branch que você criou:

       $ git checkout novo-branch

Agora, voce pode editar o que quiser. Para adicionar suas mudanças ao master:

       $ git checkout master   # volte ao branch principal
       $ git merge novo-branch

Se houver conflitos, vai ter que resolvê-los. A primeira vez, instale a sua ferramenta “diff”, meld por exemplo, e fale para git usá-la para resolver os conflitos:

       $ sudo apt-get install meld
       $ git config --global merge.tool meld

Agora, pode fazer

       $git mergetool
       $git commit

Tornando um repositório público

• Suponha que o seu repositório esteja em ~/projeto e você quer torna-lo público:

       $ git clone --bare ~/projeto projeto.git
       $ touch ~/projeto/projeto.git/git-daemon-export-ok

Pronto, agora você tem um diretório chamado projeto.git que pode disponibilizado para outras pessoas.

Editando um repositório remotamente

• Copie o repositório

       $ git clone ssh://host/caminho/projeto.git   # cria uma cópia local do repositório.

• Trabalhe como quiser e, se precisar, atualize o seu repositório local:

       $ git pull ssh://host/caminho/projeto.git

• Para atualizar o repositório remoto:

       $ git push ssh://host/caminho/projeto.git master   # master é o nome do branch que deseja atualizar

Um manual mais detalhado: http://www.akitaonrails.com/2008/4/3/micro-tutorial-de-git

Manual completo: http://www.kernel.org/pub/software/scm/git/docs/user-manual.html

Como verificar tipos de objetos em python


>>> type('texto') is str
True
>>> type('123') is str
True
>>> type(123) is str
False
>>> type([1,2,3]) is list
True
>>> type(42) is int
True