Arquivo da categoria ‘Python’

Flask é um pequeno framework web escrito em Python e baseado na biblioteca WSGI Werkzeug e na biblioteca Jinja2. Flask está disponível sob os termos da Licença BSD.

Flask tem a flexibilidade da linguagem de programação Python e provê um modelo simples para desenvolvimento web. Uma vez importando no Python, Flask pode ser usado para economizar tempo construindo aplicações web. Um exemplo de aplicação desenvolvida com Flask é a página da comunidade de desenvolvedores do framework.

É chamado de microframework porque mantem um núcleo simples mas estendível. Não há uma camada de abstração do banco de dados, validação de formulários, ou qualquer outro componente onde bibliotecas de terceiros existem para prover a funcionalidade. Assim, Flask suporta extensões capazes de adicionar tais funcionalidades na aplicação final. Há uma vasta coleção de bibliotecas para resolver essas questões em Python, isso simplifica o framework e torna sua curva de aprendizado mais suave.

Flaskhttp://flask.pocoo.org/

Instalando e configurando o Flask

Primeiramente você precisa ter uma instalação do Python em sua maquina, e no caso do sistema operacional Windows, que esta instalação inclua o caminho do ambiente Python na variável de ambiente Path:

1 – Por questões de preferências, utilizamos uma instalação do Python 2.7.x.

Variável de ambiente - Windows

Variável de ambiente – Windows

2 – Neste primeiro exemplo, vamos instalar, configurar e criar um servidor Flask e exibir uma pagina web utilizando o próprio exemplo do framework Flask. Para isto abra a linha de comando para criar um ambiente virtual:

Ambiente - Virtual

Ambiente – Virtual


pip install virtualenv

cd\

mkdir DesenvolvimentoAberto\FlaskPrj

cd DesenvolvimentoAberto\FlaskPrj

virtualenv flask

3 – Apos criar o ambiente virtual e o diretório para o nosso projeto, vamos instalar o Flask:

Instalando o Flask

Instalando o Flask


C:\DesenvolvimentoAberto\FlaskPrj\flask\Scripts\pip install flask

4 – Com o Flask instalado, você pode abrir sua IDE ou editor Python preferido e utilizar o exemplo Hello World do site do Flask. Salve o arquivo como o nome reservado de __init__.py em uma pasta chamada App que você irá criar:

__init.py__

__init.py__

5 – No diretório de Scripts, ative o Flask e chame sua aplicação Python:

Activate Flask

Activate Flask

C:\DesenvolvimentoAberto\FlaskPrj\flask\Scripts\activate

cd C:\DesenvolvimentoAberto\FlaskPrj\App
C:\DesenvolvimentoAberto\FlaskPrj\App Python __init__.py

6 –  Com o servidor rodando abra o navegador e digite a URL padrão: http://127.0.0.1:5000/

Website - Flask - Navegador

Website – Flask – Navegador

E Pronto! Você já possui uma servidor web Flask e uma aplicação Python rodando.

Exemplo:

Neste exemplo instalamos, configuramos e criamos uma aplicação web inicial Python com o Flask.

Python

from flask import Flask
app = Flask(__name__)
@app.route("/")
def hello():
    return "Hello World!"

if __name__ == "__main__":
    app.run()

Anúncios

DJango – ModelChoiceField – MySQL – Python

Publicado: 24 de fevereiro de 2015 em Python

Na maioria das vezes é útil utilizar componentes de listas conhecidos como Combobox ou Dropdown para mostrar relacionamentos de dados entre tabelas e de uma forma amigável exibir a descrição dos itens de dados e manipular seu identificador único. Para isto o DJango nos disponibiliza componentes e classes no qual nos permite manipular dados através de objetos e persisti-los em um banco de dados relacional usando o DJango ORM. Um relacionamento de dados mais simples é criado através de duas tabelas, sendo uma tabela pai que contem os dados mestres e uma filho que contem um ou mais identificadores relacionados ao pai. Um modo de fácil de identificar e tradicional de utilizar relacionamentos em um banco de dados é através de chaves estrangeiras, uma chave estrangeira é um campo, que aponta para a chave primária de outra tabela ou da mesma tabela. Ou seja, passa a existir uma relação entre duas tabelas ou de uma única tabela. A finalidade da chave estrangeira é garantir a integridade dos dados referenciais, pois apenas serão permitidos valores que supostamente vão aparecer na base de dados e estão ligados ao registro mestre.

O DJango possui o elemento ModelChoiceField que nos possibilita retornar dados diretamente do modelo, permitindo a seleção de um único objeto do modelo, adequado para a representação de uma chave estrangeira, possibilita ainda um numero de possíveis diferentes configurações.

ModelChoiceField: https://docs.djangoproject.com/en/dev/ref/forms/fields/#modelchoicefield

Exibindo Relacionamentos

1 – Após criar um novo projeto e uma aplicação Django e o configure adequadamente para acessar o banco de dados MySQL, utilize o modelo disponibilizado no código abaixo e sincronize o banco de dados:

Django - SyncDB

Django – SyncDB

2 – O Modelo criou duas tabelas e seus respectivos objetos no banco de dados MySQL , atente-se para a chave estrangeira que cria o relacionamento entre as tabelas usando a chave primaria da tabela pai:

MySQL - Relacionamento - Chave Estrangeira

MySQL – Relacionamento – Chave Estrangeira

3 – Utilize os códigos abaixo e rode sua aplicação:

DJango - Aplicação

DJango – Aplicação

4 – Assim que os dados forem enviados o DJango ORM gravará o conteúdo dos objetos no banco de dados relacional, você pode verificar na pagina que mostramos a descrição do campo cargo toda vez que utilizamos os dados da tabela de Cargos, porem na tabela Funcionário apenas seu identificador é gravado formando o relacionamento entre as duas tabelas:

MySQL - WorkBench

MySQL – WorkBench

Exemplo:

Neste exemplo criamos duas tabelas no banco de dados MySQL e as relacionamos através da chave primaria e uma chave estrangeira. Usamos um elemento DJango para tornar este relacionamento amigável, exibindo assim a descrição do relacionamento mas manipulando seu identificador e os persistindo através do DJango ORM.

Python

Model

from django.db import models

# Cria modelo Funcionario
class Funcionario (models.Model):
    nome = models.CharField(max_length=30)
    sobrenome = models.CharField(max_length=50)
    id_cargo = models.ForeignKey('Cargo')
    data = models.DateField()
    salario = models.DecimalField(max_digits=19, decimal_places=10)
    genero = models.CharField(max_length=30)
    ativo = models.BooleanField()
    observacao = models.CharField(max_length=255)

    # Define unicode para o Django Admin
    def __unicode__(self):
        return u'{0}'.format(self.nome)

# Cria modelo Cargo
class Cargo (models.Model):
    nome = models.CharField(max_length=50)

    def __unicode__(self):
        return u'{0}'.format(self.nome)

View

from django.shortcuts import render, render_to_response, RequestContext
from django.http import HttpResponse

# Importa form
from meusite.forms import MeuForm

# Exibe View
def home(request):

    # Cria form
    form = MeuForm(request.POST or None)   

    # Valida e salva
    if form.is_valid():
        salvar = form.save(commit=False)
        salvar.save()
        return HttpResponse("Dados inseridos com sucesso!")

    # Chama Template
    return render_to_response("devaberto.html",
                              locals(),
                              context_instance = RequestContext(request))

Forms

from  django import forms
from django.forms import extras
from django.core.validators import RegexValidator

# Importa modulo Regex
import re 

# cria objeto Regex
caracteres = RegexValidator(
    # regex= re.compile(r"[a-zA-Z]+"),
    regex=r"[a-zA-Z]+",
    message="Permitido somente caracteres Alpha numericos",
    code="invalid")

# Importa modelo
from models import Funcionario
from models import Cargo

# Cria classe do form para o modelo
class MeuForm(forms.ModelForm):

    # Cria Conteudo
    GENEROS = (("Masculino", "Masculino"), ("Feminino", "Feminino"))

    # Define Widgets
    nome = forms.CharField(required=True, validators=[caracteres])
    sobrenome = forms.CharField(required=True, validators=[caracteres])
    id_cargo = forms.ModelChoiceField (queryset=Cargo.objects.all().order_by('id'), widget=forms.Select)
    data = forms.DateField(required=True, widget=forms.extras.SelectDateWidget)
    salario = forms.DecimalField()
    genero = forms.ChoiceField (required=True, widget=forms.RadioSelect, choices=GENEROS)
    ativo = forms.BooleanField()
    observacao = forms.CharField(widget=forms.Textarea)    

    # Associa formulario ao modelo
    class Meta:
        model = Funcionario

    # Django Validations  - customizado campo sobrenome
    def clean_sobrenome(self):
        snome = self.cleaned_data['sobrenome']
        if len(snome) <= 3:
            raise forms.ValidationError("Sobrenome precisa conter mais de 3 caracteres.")
        return snome

Template

<!DOCTYPE html>
<html lang="en">
	<head>
		<meta charset="utf-8">
		<title>Desenvolvimento Aberto</title>
		<style>
			body {

				font-family: "Times New Roman", Times, serif;
				font-size: 12px;
			}
		</style>
	</head>
	<body>

		<h1>Desenvolvimento Aberto - Django - Elementos - Widgets </h1>

		<form method="post" action="">
			<fieldset>
				<legend>
					Cadastro:
				</legend>
				{% csrf_token %}
				<table>
					<td> {{ form.as_table }} </td>
				</table>
				<hr />
				<input type="submit" />
			</fieldset>
		</form>

	</body>
</html>

Django – Widgets – Python – Linux

Publicado: 4 de fevereiro de 2015 em Python

No framework Django um widget é a representação de um elemento de entrada HTML. O Widget lida com a prestação do HTML, e a extração de dados a partir de um dicionário que corresponde ao widget. Os Widgets não devem ser confundidos com os campos do formulário. Os campos do formulário lidam com a lógica de validação de entrada e são usados diretamente em modelos. Já os Widgets lidam com processamento de elementos de entrada de um formulário HTML na página web e na extração dos dados brutos apresentados. No entanto, os widgets não precisam ser atribuídos para formar campos, isto quer dizer que os campos de um formulário geram os elementos HTML básicos e um Widget pode ser atribuído ao campo para formar um componente visual mais avançado.

Widgets: https://docs.djangoproject.com/en/1.7/ref/forms/widgets/

Utilizando elementos e Widgets

Crie um projeto e uma aplicação Django, configure o banco de dados e a rota para sua visão adequadamente. Utilize os arquivos abaixo para os respectivos arquivos para o Model, View, Template e o Form:

Django - Widgets

Django – Widgets

Exemplo:

Neste exemplo criamos uma aplicação Django que utiliza um formulário de cadastro que utiliza elementos e Widgets que estão ligados em um modelo e são exibidos através de um Template.

Python

Model.py

from django.db import models

# Cria modelo
class Funcionario (models.Model):
    nome = models.CharField(max_length=30)
    sobrenome = models.CharField(max_length=50)
    cargo = models.CharField(max_length=50)
    data = models.DateField()
    salario = models.DecimalField(max_digits=19, decimal_places=10)
    genero = models.CharField(max_length=30)
    ativo = models.BooleanField()
    observacao = models.CharField(max_length=255)

    # Define unicode para o Django Admin
    def __unicode__(self):
        return self.nome

View.py

from django.shortcuts import render, render_to_response, RequestContext
from django.http import HttpResponse

# Importa form
from meusite.forms import MeuForm

# Exibe View
def home(request):

    # Cria form
    form = MeuForm(request.POST or None)   

    # Valida e salva
    if form.is_valid():
        salvar = form.save(commit=False)
        salvar.save()
        return HttpResponse("Dados inseridos com sucesso!")

    # Chama Template
    return render_to_response("devaberto.html",
                              locals(),
                              context_instance = RequestContext(request))

Template – devaberto.html

<!DOCTYPE html>
<html lang="en">
	<head>
		<meta charset="utf-8">
		<title>Desenvolvimento Aberto</title>
		<style>
			body {

				font-family: "Times New Roman", Times, serif;
				font-size: 12px;
			}
		</style>
	</head>
	<body>

		<h1>Desenvolvimento Aberto - Django - Elementos - Widgets </h1>

		<form method="post" action="">
			<fieldset>
				<legend>
					Cadastro:
				</legend>
				{% csrf_token %}
				<table>
					<td> {{ form.as_table }} </td>
				</table>
				<hr />
				<input type="submit" />
			</fieldset>
		</form>

	</body>
</html>

Form.py

from  django import forms
from django.forms import extras
from django.core.validators import RegexValidator

# Importa modulo Regex
import re 

# cria objeto Regex
caracteres = RegexValidator(
    # regex= re.compile(r"[a-zA-Z]+"),
    regex=r"[a-zA-Z]+",
    message="Permitido somente caracteres Alpha numericos",
    code="invalid")

# Importa modelo
from models import Funcionario

# Cria classe do form para o modelo
class MeuForm(forms.ModelForm):

    # Cria Conteudo
    GENEROS = (("Masculino", "Masculino"), ("Feminino", "Feminino"))

    CARGOS = (("Vocalista", "Vocalista"),
               ("Guitarrista", "Guitarrista"),
               ("Baixista", "Baixista"),
               ("Baterista", "Baterista"))

    # Define Widgets
    nome = forms.CharField(required=True, validators=[caracteres])
    sobrenome = forms.CharField(required=True, validators=[caracteres])
    cargo = forms.ChoiceField (required=True, widget=forms.Select, choices=CARGOS)
    data = forms.DateField(required=True, widget=forms.extras.SelectDateWidget)
    salario = forms.DecimalField(required=True)
    genero = forms.ChoiceField (required=True, widget=forms.RadioSelect, choices=GENEROS)
    ativo = forms.BooleanField()
    observacao = forms.CharField(widget=forms.Textarea)    

    # Associa formulario ao modelo
    class Meta:
        model = Funcionario

    # Django Validations  - customizado campo sobrenome
    def clean_sobrenome(self):
        snome = self.cleaned_data['sobrenome']
        if len(snome) <= 3:
            raise forms.ValidationError("Sobrenome precisa conter mais de 3 caracteres.")
        return snome

Em ciência da computação teórica e teoria da linguagem formal, uma expressão regular abreviada de Regex ou Regexp e, por vezes chamado de uma expressão racional é uma sequência de caracteres que forma um padrão de pesquisa, principalmente para uso na correspondência de padrões com Strings, ou sequência correspondente, ou seja, como operações de localizar e substituir. O conceito surgiu na década de 1950, quando o matemático americano Stephen Kleene formalizava a descrição de uma linguagem regular, e entrou em uso comum com os utilitários Unix de processamento de texto.

Cada caractere em uma expressão regular ou é entendido como um MetaCharacter com seu significado especial, ou um caractere regular com o seu significado literal. Em conjunto, eles podem ser usados para identificar material textual de um determinado padrão, ou processar um número de instâncias do mesmo que podem variar de uma igualdade exata para uma semelhança muito geral do padrão.

O Regex pode ser usado para analisar rapidamente grandes quantidades de texto para encontrar padrões de caracteres específicos; para extrair, editar, substituir ou excluir substrings de texto, também é comum serem utilizadas para validar campos.

Regular Expression

Existe muito material sobre expressões regulares, inclusive o Modulo re do Python contempla classes para combinar sequências de caracteres contra padrões especificados por expressões regulares.

Regex: https://docs.python.org/2/library/re.html

Por outro lado existem alguns sites que proporcionam ótimos materiais sobre Regex e permitem que você crie e teste sua própria expressão regular antes de a utilizar.

RegExr: http://regexr.com/

PyRegex: http://www.pyregex.com/

Expressão regular que contempla caracteres maiúsculos e minúsculos: Pattern [a-zA-Z]+

Regex - [a-zA-Z]+

Regex – [a-zA-Z]+

Expressão regular que contempla números inteiros e flutuantes: Pattern (?:\d*\.)?\d+

Regex - (?:\d*\.)?\d+

Regex – (?:\d*\.)?\d+

Usando Expressões Regulares

1 – Crie um projeto e uma aplicação Django e utilize os códigos abaixo para cada arquivo de sua aplicação, configure corretamente o arquivo de configuração para o Template, MySQL e as URLs:

Django - Regex

Django – Regex

Exemplo:

Neste exemplo utilizamos expressões regulares para validar o conteúdo dos campos de uma aplicação Django. Na aplicação se um campo de texto conter caracteres que não correspondem a expressão serão automaticamente invalidados.

Python

Model.py

from django.db import models

# Cria modelo
class Funcionario (models.Model):
    nome = models.CharField(max_length=30)
    sobrenome = models.CharField(max_length=50)
    cargo = models.CharField(max_length=50)
    salario = models.DecimalField(max_digits=19, decimal_places=10)

    # Define unicode para o Django Admin
    def __unicode__(self):
        return self.nome

View.py

from django.shortcuts import render, render_to_response, RequestContext
from django.http import HttpResponse

# Importa form
from meusite.forms import MeuForm

# Exibe View
def home(request):

    # Cria form
    form = MeuForm(request.POST or None)   

    # Valida e salva
    if form.is_valid():
        salvar = form.save(commit=False)
        salvar.save()
        return HttpResponse("Dados inseridos com sucesso!")

    # Chama Template
    return render_to_response("devaberto.html",
                              locals(),
                              context_instance = RequestContext(request))

Template – DevAberto.html

<!DOCTYPE html>
<html lang="en">
	<head>
		<meta charset="utf-8">
	</head>
	<body>
		<div>
			<header>
				<h1>Desenvolvimento Aberto</h1>
				<h2>Django - Validations </h2>
			</header>
			<div>
				<p>
					Meu Formulário
				</p>
				<form method="post" action="">
					{% csrf_token %}
					{{ form.as_p }}
					<input type="submit" />
				</form>
			</div>
		</div>
	</body>
</html>

Forms.py

from  django import forms
from django.core.validators import RegexValidator

#Importa modulo Regex
import re 

# cria objeto Regex
caracteres = RegexValidator(
    regex= re.compile(r"[a-zA-Z]+"),
    message="Permitido somente caracteres Alpha numericos",
    code="invalid")

# Importa modelo
from models import Funcionario

# Cria classe do form para o modelo
class MeuForm(forms.ModelForm):
    nome = forms.CharField(required= True, validators=[caracteres])
    sobrenome = forms.CharField(required= True, validators= [caracteres])
    cargo = forms.CharField(required= True, validators= [caracteres])
    salario = forms.DecimalField()

    # Associa formulario ao modelo
    class Meta:
        model = Funcionario

    # Django Validations  - customizado campo sobrenome
    def clean_sobrenome(self):
        snome = self.cleaned_data['sobrenome']
        if len(snome) <= 3:
            raise forms.ValidationError("Sobrenome precisa conter mais de 3 caracteres.")
        return snome

O Django possibilita trabalhar com Javascript de um modo automático e fácil, um destes modos é utilizando diretórios estáticos. Websites geralmente precisam servir arquivos adicionais, tais como imagens, JavaScript, ou CSS. Em Django, nos referimos a esses arquivos como arquivos estáticos e você pode configura-los facilmente utilizando algumas variáveis disponíveis no arquivo de configuração em um projeto Django. Um outro modo de utilizar Javascript e CSS em Django é utilizando os Form Assets que permitem utilizar uma combinação exata de CSS e JavaScript necessários para uma determinada página, dependendo dos widgets que estão em uso nessa página.

Static: https://docs.djangoproject.com/en/1.7/howto/static-files/

Form Assets: https://docs.djangoproject.com/en/1.7/topics/forms/media/

Usando uma Biblioteca Externa

1 – Crie um projeto e uma aplicação Django e configure o banco de dados MySQL, o diretório de templates e arquivos estáticos adequadamente para isto veja o código abaixo para o arquivo do projeto settings.py. Crie seu modelo, visão, template e form também de acordo os arquivos abaixo. Crie o arquivo meujsteste.js dentro das pastas estáticas que você também precisa criar chamadas assets/javascript:

Static - Javascript

Static – Javascript

2 – Verifique a estrutura do seu projeto para o template e o javascript, use a figura abaixo para referencia:

Django - diretórios

Django – diretórios

3 – Rode sua aplicação, no navegador clique com o botão direito e escolha exibir código fonte, verifique que os atributos do form e a variável estática do template formaram o HTML necessário para que os eventos javascript funcionem corretamente com o formulário Django:

Django - App - Código - Navegador

Django – App – Código – Navegador

4 – Teste a sua aplicação entrando e saindo do campo de texto para o nome e o evento javascript será disparado:

Django - Form - Javascript

Django – Form – Javascript

Exemplo:

Neste exemplo utilizamos Javascript através das configurações estáticas para imprimir na página os eventos de entrada e saída do mouse em um Widget CharField do Django utilizando atributos adicionais para criar o código HTML.

Python

settings.py

"""
Django settings for MeuDjango project.

For more information on this file, see
https://docs.djangoproject.com/en/1.6/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.6/ref/settings/
"""

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
import os
BASE_DIR = os.path.dirname(os.path.dirname(__file__))

# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.6/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '*0qj3@ul9n3k)%xbgxfqwwxm!+2f$1&)i*k1ft85(b-7kz)9q^'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

TEMPLATE_DEBUG = True

ALLOWED_HOSTS = []

# Application definition

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'meusite',
)

MIDDLEWARE_CLASSES = (
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',

)

ROOT_URLCONF = 'MeuDjango.urls'

WSGI_APPLICATION = 'MeuDjango.wsgi.application'

# Database
# https://docs.djangoproject.com/en/1.6/ref/settings/#databases

DATABASES = {
    'default': {
        'NAME': 'DAsandbox',
        'ENGINE': 'mysql.connector.django',
        'USER': 'root',
        'PASSWORD': 'minhasenha',
        'OPTIONS': {
          'autocommit': True,
        },
    }
}

# Internationalization
# https://docs.djangoproject.com/en/1.6/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.6/howto/static-files/

STATIC_URL = '/static/'

# Django - diretorios estaticos
STATICFILES_DIRS = (os.path.join(BASE_DIR, "static"),)

# Django - Templates
TEMPLATE_DIRS = (os.path.join(BASE_DIR, "static", "template"),)

model.py

from django.db import models

# Cria modelo
class Funcionario (models.Model):
    nome = models.CharField(max_length=30)
    sobrenome = models.CharField(max_length=50)
    cargo = models.CharField(max_length=50)
    salario = models.DecimalField(max_digits=19, decimal_places=10)

    # Define unicode para o Django Admin
    def __unicode__(self):
        return self.nome

view.py

from django.shortcuts import render, render_to_response, RequestContext
from django.http import HttpResponse

# Importa form
from meusite.forms import MeuForm

# Exibe View
def home(request):

    # Cria form
    form = MeuForm(request.POST or None)   

    # Valida e salva
    if form.is_valid():
        salvar = form.save(commit=False)
        salvar.save()
        return HttpResponse("Dados inseridos com sucesso!")

    # Chama Template
    return render_to_response("devaberto.html",
                              locals(),
                              context_instance = RequestContext(request))

template – devaberto.html

{% load static %}
<!DOCTYPE html>
<html lang="en">
	<head>
		<meta charset="utf-8">
		<script type="text/javascript" src='{% static "assets/javascript/meujsteste.js" %}'></script>
	</head>
	<body>
		<div>
			<header>
				<h1>Desenvolvimento Aberto</h1>
				<h2>Django - Validations </h2>
			</header>
			<div>
				<p>
					Meu Formulário
				</p>
				<form method="post" action="">
					{% csrf_token %}
					{{ form.as_p }}
					<input type="submit" />
				</form>
			</div>
		</div>
		<!-- Div - logs do evento javascript -->
		<div id="meulog">  </div>

	</body>
</html>

forms.py

from  django import forms

# Importa modelo
from models import Funcionario

# Cria classe do form para o modelo
class MeuForm(forms.ModelForm):
    nome = forms.CharField(widget=forms.TextInput(attrs={'onmouseover':'meuMouseOver()', 'onmouseout':'meuMouseOut()'}))
    sobrenome = forms.CharField()
    cargo = forms.CharField()
    salario = forms.DecimalField()

    # Associa formulario ao modelo
    class Meta:
        model = Funcionario

    # Django Validations  - customizar
    def clean_sobrenome(self):
        snome = self.cleaned_data['sobrenome']
        if len(snome) <= 3:
            raise forms.ValidationError("Sobrenome precisa conter mais de 3 caracteres.")
        return snome

Javascript – meujsteste.js

// Desenvolvimento Aberto
// Javascript teste

function meuMouseOver() {
    var div = document.getElementById('meulog');

    div.innerHTML = div.innerHTML + 'Você entrou no campo nome ';
}

function meuMouseOut() {
    var div = document.getElementById('meulog');

    div.innerHTML = div.innerHTML + 'Você saiu do campo nome ';
}

Django – Validations – MySQL – Python

Publicado: 16 de janeiro de 2015 em Python

O Django possui algumas funcionalidades que visam facilitar a validação de campos e economizar tempo do desenvolvedor na criação da interface com o usuário. Por padrão o Django já executa alguma validações de campos requeridos para os formulários que utilizam a classe Form ou os formulários associados ao modelo com a classe ModelForm. Entretanto você pode modificar a validação padrão, as desabilitando ou criando validações customizadas para os campo de seu formulário.

A validação do formulário acontece quando os dados são limpos (Cleaned). Se você quer personalizar este processo, há vários lugares que você pode mudar, cada um servindo a um propósito diferente. A maioria da validações podem ser feitas usando os validadores que são ajudantes simples que podem ser reutilizados facilmente. Validadores são funções simples (ou Callables) que levam um único argumento e chamam o ValidationError para a entrada inválida.

Django Validation: https://docs.djangoproject.com/en/1.7/ref/forms/validation/

Validando Campos Obrigatórios

Neste walkthrough utilizamos um projeto e uma aplicação Django básica, utilizando um modelo, uma visão e um template para exibir o formulário, caso queira saber mais sobre como chegar a está configuração utilize os posts anteriores sobre o Django.

1 – Após configurar seu projeto e sua aplicação, utilize os códigos abaixo para seus respectivos arquivos e rode sua aplicação. Você pode preencher os campos do formulários e salvar o registro no banco de dados:

Django - Formulário

Django – Formulário

2 – Uma vez que a entrada não satisfaça as validações do Django que por padrão requer todos os campos do modelo já que os mesmo não permitem campos nulos, uma mensagem de erro avisará para que você preencha corretamente o campo. No formulário abaixo também criamos uma validação customizada que previne que o usuário não insira qualquer coisa no campo, verificando o tamanho do campo:

Django - Validações

Django – Validações

Exemplo:

Neste exemplo utilizamos as validações padrões do Django para campos requeridos e também criamos uma validação customizada para o campo sobrenome.

Model – models.py

from django.db import models

# Cria modelo
class Funcionario (models.Model):
    nome = models.CharField(max_length=30)
    sobrenome = models.CharField(max_length=50)
    cargo = models.CharField(max_length=50)
    salario = models.DecimalField(max_digits=19, decimal_places=10)

    # Define unicode para o Django Admin
    def __unicode__(self):
        return self.nome

View – view.py

from django.shortcuts import render, render_to_response, RequestContext
from django.http import HttpResponse

# Importa form
from meusite.forms import MeuForm

# Exibe View
def home(request):

    # Cria form
    form = MeuForm(request.POST or None)   

    # Valida e salva
    if form.is_valid():
        salvar = form.save(commit=False)
        salvar.save()
        return HttpResponse("Dados inseridos com sucesso!")

    # Chama Template
    return render_to_response("devaberto.html",
                              locals(),
                              context_instance = RequestContext(request))

Template – devaberto.html

<!DOCTYPE html>
<html lang="en">
	<head>
		<meta charset="utf-8">
	</head>
	<body>
		<div>
			<header>
				<h1>Desenvolvimento Aberto</h1>
				<h2>Django - Validations </h2>
			</header>
			<div>
				<p>
					Meu Formulário
				</p>
				<form method="post" action="">
					{% csrf_token %}
					{{ form.as_p }}
					<input type="submit" />
				</form>
			</div>
		</div>
	</body>
</html>

Form- forms.py

from  django import forms

# Importa modelo
from models import Funcionario

# Cria classe do form para o modelo
class MeuForm(forms.ModelForm):
    nome = forms.CharField()
    sobrenome = forms.CharField()
    cargo = forms.CharField()
    salario = forms.DecimalField()

    # Associa formulario ao modelo
    class Meta:
        model = Funcionario

    # Django Validations  - customizado
    def clean_sobrenome(self):
        snome = self.cleaned_data['sobrenome']
        if len(snome) <= 3:
            raise forms.ValidationError("Sobrenome precisa conter mais de 3 caracteres.")
        return snome

Django – Forms – MySQL – Linux – Python

Publicado: 11 de janeiro de 2015 em Python

Um formulário HTML é uma seção de um documento que tenha elementos especiais chamados controles (caixas de seleção, botões de rádio, menus, etc.) ou seja estas tags são responsáveis por criar as entradas de dados em paginas da web. O Django oferece uma gama de ferramentas e bibliotecas para ajudar a construir Forms para aceitar a entrada de dados dos visitantes do site, e em seguida, processar e responder à esta entrada. Os Forms do Django criam automaticamente os formulário HTML à partir de campos únicos a sua escolha ou de um modelo de dados, esta funcionalidade pode poupar muito tempo já que isenta o desenvolvedor de escrever manualmente widgets em uma página.

Django Forms API: https://docs.djangoproject.com/en/1.7/ref/forms/api/

Criando um Form de um Modelo

Para utilizar este walkthrough você deve criar um projeto e uma aplicação Django, configurar o banco de dados MySQL e configurar a aplicação para que seja funcional utilizando um modelo, uma visão e um Template. Você pode consultar como fazer estes procedimentos nos posts anteriores sobre o Django.

1 – Após configurar sua aplicação adequadamente para que rode e exiba uma pagina HTML quando executada, crie um novo arquivo chamado forms.py:

Django - forms.py

Django – forms.py

2 – Utilize os códigos abaixo para criar seus respectivos arquivos, você pode usar a imagem como referencia para analisar a estrutura do seu projeto e de sua aplicação:

Django - Estrutura

Django – Estrutura

3 – Rode sua aplicação e preencha os dados no formulário e clique em enviar:

Django - Forms

Django – Forms

4 – Abra o site Admin para verificar a tabela caso tenha configurado seu arquivo admin.py para o modelo, caso contrario utilize uma ferramenta SQL como o MySQL Workbench para visualizar os dados:

Django - Admin - Visualiza Dados

Django – Admin – Visualiza Dados

Exemplo:

Neste exemplo criamos um formulário de um modelo de dados usando as APIs de Forms do Django para obter uma entrada de dados do usuário.

Python

Model.py

from django.db import models

# Cria modelo
class DevAberto (models.Model):
    usuario = models.CharField(max_length=30)
    linguagem = models.CharField(max_length=50)
    email = models.EmailField()

    # Define unicode para o Django Admin
    def __unicode__(self):
        return self.usuario

View.py

from django.shortcuts import render, render_to_response, RequestContext
from django.http import HttpResponse

 # Importa form

from meusite.forms import MeuForm

# Exibe View
def home(request):

    # Cria form
    form = MeuForm(request.POST or None)

    # Valida e salva
    if form.is_valid():
        salvar = form.save(commit=False)
        salvar.save()
        return HttpResponse("Dados inseridos com sucesso!")        

    # Chama Template
    return render_to_response("devaberto.html",
                              locals(),
                              context_instance = RequestContext(request))

Template devaberto.html

<!DOCTYPE html>
<html lang="en">
	<head>
		<meta charset="utf-8">

	</head>

	<body>
		<div>
			<header>
				<h1>Desenvolvimento Aberto</h1>
			</header>
			<nav>
				<p>
					<a href="/">Home</a>
				</p>

			</nav>

			<div>
				<p>
					Meu Formulário
				</p>
				<form method="post" action="">
					{% csrf_token %}
					{{ form.as_p }}
					<input type="submit" />
				</form>
			</div>

			<footer>
				<p>
					Copyright  by Desenvolvimento aberto
				</p>
			</footer>
		</div>
	</body>
</html>

Forms.py

from  django import forms

# Importa modelo
from meusite.models import DevAberto

# Cria classe do form para o modelo
class MeuForm(forms.ModelForm):
    class Meta:
        model = DevAberto

Django – Template – Linux – Python

Publicado: 10 de janeiro de 2015 em Python

Aqui está a principal diferença entre o Django e outros frameworks para web que utilizam o Pattern MVC, o Template Django é uma cadeia de texto que pretende separar a apresentação de um documento de seus dados. Um Template possui sua própria linguagem e contém variáveis, que são substituídas com valores quando o Template é avaliado e também contem tags, que controlam a lógica do Template.

Muitos outras linguagens permitem que você escreva código embutido no HTML, está técnica é chamada em algumas linguagens de In-line code, que especifica o código do servidor que está diretamente incorporado em uma página da Web, entretanto o sistema de Template do Django é destinado a expressar a apresentação, não a lógica do programa.

Template: https://docs.djangoproject.com/en/1.7/intro/tutorial03/

Criando Um Simples Template Django

Um Template é um arquivo texto que pode ser tipo HTML ou qualquer outro tipo de arquivo de texto (txt, xml, csv) e que pode conter a linguagem de Template do Django.

Podemos dizer que uma View do Django pode atuar como um controlador que especifica o Template a ser utilizado, ou a View também pode atuar como uma View se o desenvolvedor utilizar código dinâmico para exibir uma pagina HTML dispensando o uso do Template. Apesar de possível e em alguns casos resolver a situação, este método não é indicado, por vários motivos e o mais obvio deles é partir do principio que escrever código Python e projetar o design HTML são duas disciplinas diferentes e em um ambiente profissional que preze as boas praticas estes trabalhos são feitos por equipes diferentes.

1 – Crie um projeto e uma aplicação Django e crie uma pasta estática onde colocaremos os templates. Na raiz do projeto adicione uma pasta chamada static e dentro dela uma pasta chamada template:

Django - static/template

Django – static/template

2 – Na pasta template crie um arquivo HTML chamado devaberto.html:

Django - HTML

Django – HTML

4 – Abra o seu arquivo settings.py e adicione a linha abaixo no final do arquivo. No arquivo url.py desmarque o comentário da primeira url do exemplo e adicione o nome da sua aplicação onde se localiza a sua View, use a figura abaixo para referencia:

Django - Settings e Url

Django – Settings e Url

5 – Modifique sua View de acordo com o código abaixo e inicie o servidor Django, você pode utilizar esta imagem para conferir a estrutura de pastas do seu projeto:

Django - View

Django – View

6 – Após utilizar o código abaixo para cada respectivo arquivo e salvar, digite a url do servidor:

Django - Home

Django – Home

Exemplo:

Neste exemplo criamos um projeto e uma aplicação Django e definimos uma pasta estática para guardar os templates HTML e utilizamos a View para controlar o acesso ao Template.

Python

Settings.py (adicionar ao final)

# Django - Templates
TEMPLATE_DIRS = (os.path.join(BASE_DIR, "static", "template"),)

View.py

from django.shortcuts import render, render_to_response, RequestContext

# Exibe View
def home(request):
    return render_to_response("devaberto.html",
                              locals(),
                              context_instance = RequestContext(request))

devaberto.html

<!DOCTYPE html>
<html lang="en">
	<head>
		<meta charset="utf-8">

	</head>

	<body>
		<div>
			<header>
				<h1>Desenvolvimento Aberto</h1>
			</header>
			<nav>
				<p>
					<a href="/">Home</a>
				</p>

			</nav>

			<div>
				<p>
					Olá, Este é um template Django.
				</p>
				Você pode adicionar tags do Django Template Language
				para manipular a página HTML utilizando o Python.
			</div>

			<footer>
				<p>
					Copyright  by Desenvolvimento aberto
				</p>
			</footer>
		</div>
	</body>
</html>

Django – Admin – MySQL – Python

Publicado: 10 de janeiro de 2015 em Python

Uma das partes mais poderosas do Django é a interface de administração automática. Ele lê os meta dados no seu modelo para fornecer uma interface pronta para produção que os administradores ou usuários chave podem usar imediatamente para começar a adicionar conteúdo ao site. Isto significa que o site Admin proporciona automaticamente uma interface gráfica para operações CRUD  (criação, leitura, alteração e exclusão de dados) assim que um modelo é criado e registrado através de um objeto do administrador.  No entanto o site Django Admin possui mais alguns recursos interessantes.

Django Admin: https://docs.djangoproject.com/en/1.7/ref/contrib/admin/

Usando o Site Django Admin

O site Django Admin é uma aplicação Django que por padrão já vem instalada no arquivo settings.py e sua rota já configurada no arquivo url.py de uma aplicação Django.

1 – Crie um projeto Django chamado MeuDjango e uma aplicação chamada meusite. Modifique os arquivos settings e url para configurar sua aplicação e o banco de dados MySQL. Utilize o código abaixo para criar um modelo para a aplicação e use o Custom Command para criar o SQL do modelo:

Django - Manage.py - Sqlall

Django – Manage.py – Sqlall

2 – Sincronize o banco de dados:

Django - Manage.py - SyncDb

Django – Manage.py – SyncDb

3 – Com o modelo criado e sincronizado ao banco de dados, vamos iniciar o servidor Django e utilizar o site Django Admin, no entanto precisamos configurar um usuário e senha para o site, caso não tenha configurado ainda utilize o Custom Command: python manage.py createsuperuser:

Django - Manage.py createsuperuser

Django – Manage.py createsuperuser

4 – Configure o usuário e o senha como preferir:

Django - Usuário e Senha

Django – Usuário e Senha

5 – Rode seu projeto para iniciar o servidor e chame a aplicação Django Admin e efetue um login:

DJango - Admin - Login

DJango – Admin – Login

6 – O site do administrador será aberto, no entanto precisamos registrar o modelo para que o Django crie uma interface gráfica para manipular seus dados:

Django - Admin

Django – Admin

7 – Em sua aplicação abra o arquivo admin.py e crie um objeto administrador e registre seu modelo, para uma visão geral dos arquivos necessários para configurar o Django Admin e como deve ficar o projeto e a aplicação, baseie-se na figura abaixo:

Django - Admin.py

Django – Admin.py

8 – Após registrar o modelo volte ao site do administrador e você já pode ver o sua aplicação e o modelo registrado:

Admin - Aplicação e Modelos

Admin – Aplicação e Modelos

9 – Você pode efetuar as operações CRUD através do site de administração:

Django - Admin - Inserir

Django – Admin – Inserir

10 – Você também pode manipular seus dados os alterando e deletando como desejar:

Django - CRUD

Django – Admin – CRUD

Exemplo:

Neste exemplo utilizamos a aplicação Django Admin para registrar nosso modelo e efetuar operações através da interface visual do site administrador do Django.

Model.py

from django.db import models

# Cria modelo
class DevAberto (models.Model):
    usuario = models.CharField(max_length=30)
    linguagem = models.CharField(max_length=50)
    email = models.EmailField()
    
    # Define unicode para o Django Admin
    def __unicode__(self):
        return self.usuario
    

Admin.py

from django.contrib import admin

# Importa e registra modelo
from meusite.models import DevAberto

# Cria classe Admin
class DevAbertoAdmin (admin.ModelAdmin):
    class Meta:
        model = DevAberto

# Registra modelo        
admin.site.register(DevAberto, DevAbertoAdmin)        

 

A mais poderosa IDE de código aberto para desenvolvimento web ficou ainda melhor. Reconstruída a partir do zero. Agora é muito mais rápida, personalizável e inclui novos recursos para ajudar você a ser mais produtivo. Está é a Aptana Studio 3 uma IDE baseada no Eclipse muito utilizada por desenvolvedores Ruby on Rails e outras linguagens da web. A Aptana Studio 3 também aderiu ao universo Python através do PyDev que já é incorporado a IDE por padrão. A Aptana não precisa de instalação, assim com o Eclipse basta descompacta-la em um pasta de sua escolha e a utilizar através de seu executável.

Aptana: http://www.aptana.com/

Criando um Projeto Django – Aptana Studio 3

1 – Abra a IDE e clique no menu File->New->Project, expanda e procure PyDev e escolha PyDevDjangoProject e clique em próximo:

PyDev - Django Project

PyDev – Django Project

2 – Escolha um nome para seu projeto e clique em Please configure an interpreter before proceeding:

Configurar Interpretador Python

Configurar Interpretador Python

3 – Quando questionado escolha um modo para configurar o seu interpretador, nos escolhemos Quick Auto Config:

Quick Auto Config

Quick Auto Config

4 – Em Reference page clique em próximo, pois não o utilizaremos:

Reference Page

Reference Page

5 – Configure os parâmetros para seu banco de dados, utilizamos o MySQL:

MySQL - Configuração

MySQL – Configuração

6 – Com seu projeto criado, precisamos criar uma aplicação. Com o botão direito em seu projeto, escolha Django->Create Application:

Projeto Django

Projeto Django

7 – Nomeie sua aplicação de meusite:

Django - Aplicação

Django – Aplicação

8 – Após criar sua aplicação modifique os arquivos do projeto settings.py e url.py para definir os seus parâmetros necessários para o banco de dados, aplicação e rota da visão . Modifique os arquivos da aplicação: model.py e view.py de acordo com o código abaixo. Após criar seu modelo, clique no seu projeto com o botão direito e escolha Django->Custom Command, digite o comando sqlall meusite para criar o script SQL para a tabela do modelo.

Django - Command

Django – Custom Command – sqlall

9 – Com o script SQL pronto, clique com o botão direito em seu projeto e escolha Django->Sync DB para criar a tabela do modelo no banco de dados MySQL:

Django - Sync DB

Django – Sync DB

10 – Vamos inserir um registro no banco de dados, para isto usaremos o shell do Django, abra novamente o Custom Command e escolha o comando Shell:

Custom Command - Shell

Custom Command – Shell

11 – Com o shell aberto vamos utilizar os comandos da API para banco de dados do Django, utilize os comandos abaixo para inserir um registro no banco de dados:

from meusite.models import Saudacao 
s1 = Saudacao(saudacao = "Hello World - Aptana- Django")
s1.save()
Django - ORM - Shell

Django – ORM – Shell

12 – Para validar os modelos e rodar o servidor Django clique com o botão direito em seu projeto e escolha RunAs->PyDev:Django:

Django - Server

Django – Server

13 – Com o servidor rodando abra seu navegador e digite a url do servidor local sobre a porta 8000 seguido do nome de sua aplicação:

Hello World - Django - PyDev - Aptana

Hello World – Django – PyDev – Aptana

Exemplo:

Neste exemplo utilizamos um projeto PyDev Django e criamos uma aplicação, manuseando os arquivos e comandos do Django através da IDE Aptana Studio 3.

Python

Model

from django.db import models

class Saudacao (models.Model):
    saudacao = models.CharField(max_length=50)
    

View

from django.shortcuts import render
from django.http import HttpResponse

# Importa modelo
from meusite.models import Saudacao

# Retorna dados atraves do objeto do modelo
dados = Saudacao.objects.values_list(flat=True)
 
# Recupera campos de uma row
saudacao = str(dados[0][1])
 
# Cria simples HTML
html = """
 <h1>Desenvolvimento Aberto</h1>
<h2>Django - Models e Views</h2>
<br>
<h3>MySQL - Dados:</h3>
"""
 
# Exibe View
def hello(request):
    return HttpResponse(html + saudacao)