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)

Depois de criar os seus modelos de dados, o Rails lhe fornece automaticamente uma API de banco de dados com abstração que permite criar, recuperar, atualizar e excluir objetos. Você pode utilizar uma gama de instruções Ruby para manipular dados através de objetos fornecidos pelo ORM do Active Record que também lhe proporciona praticidade e segurança pois sua arquitetura foi construída sob as boas praticas de acesso a dados, onde o desenvolvedor não precisa saber de detalhes técnicos sobre os diferentes bancos de dados pois os objetos já incluem recursos para minimizar o acesso ao banco de dados, criação de IDs automáticos e muitas outras vantagens.

Active Record: http://guides.rubyonrails.org/active_record_basics.html

Usando o Active Record no Rails Shell

1 – Em um diretório de sua escolha crie um projeto Ruby on Rails:

RoR - Criar Projeto

RoR – Criar Projeto

2 – Na pasta config da sua aplicação configure os parâmetros de acesso ao MySQL:

RoR - Conexão MySQL

RoR – Conexão MySQL

3 – Entre na pasta do seu projeto, e no terminal crie o modelo e migre o modelo para o banco de dados:

rails g model meumodelo nome:string album:string musica:string
Criar Modelo

Criar Modelo

4 – Entre no Shell utilizando o comando rails para gravar registros no banco de dados através do Active Records, você pode perceber que os comandos SQL utilizados para as operações no banco de dados são mostradas pelo Active Record.

Vamos tomar como exemplo que a Camila goste da banda chamada Stone Temple Pilots, o modelo proporciona que o usuário escolha sua musica e seu álbum preferido:

Active Record - Criar (Inserir)

Active Record – Criar (Inserir)

5 – Também podemos recuperar os dados e altera-los caso a Camila tenha lembrado uma musica que goste mais e deseje alterar seu registro:

Active Record - Alterar Dados

Active Record – Alterar Dados

6 – Se a Camila desejar excluir seu registro:

Active Record - Deleta - Dados

Active Record – Deleta – Dados

7 – Caso queira confirmar o trabalho do Active Record, no meio dos processo acima você pode consultar o banco de dados para ver o resultado de suas operações:

MySQL - Workbench

MySQL – Workbench

Exemplo:

Neste exemplo criamos um projeto e uma aplicação Ruby on Rails e criamos um modelo de dados através de seu ORM e  utilizamos o Active Record para efetuar operações CRUD através do Rails Shell.

Database.yml

Ruby

# MySQL.  Versions 5.0+ are recommended.
#
# Install the MYSQL driver
#   gem install mysql2
#
# Ensure the MySQL gem is defined in your Gemfile
#   gem 'mysql2'
#
# And be sure to use new-style password hashing:
#   http://dev.mysql.com/doc/refman/5.0/en/old-client.html
#
default: &default
  adapter: mysql2
  encoding: utf8
  pool: 5
  username: root
  password: minhasenha
  socket: /var/run/mysqld/mysqld.sock

development:
  <<: *default
  database: DAsandbox

# Warning: The database defined as "test" will be erased and
# re-generated from your development database when you run "rake".
# Do not set this db to the same as development or production.
test:
  <<: *default
  database: meusite_test

# As with config/secrets.yml, you never want to store sensitive information,
# like your database password, in your source code. If your source code is
# ever seen by anyone, they now have access to your database.
#
# Instead, provide the password as a unix environment variable when you boot
# the app. Read http://guides.rubyonrails.org/configuring.html#configuring-a-database
# for a full rundown on how to provide these environment variables in a
# production deployment.
#
# On Heroku and other platform providers, you may have a full connection URL
# available as an environment variable. For example:
#
#   DATABASE_URL="mysql2://myuser:mypass@localhost/somedatabase"
#
# You can use this database configuration with:
#
#   production:
#     url: <%= ENV['DATABASE_URL'] %>
#
production:
  <<: *default
  database: meusite_production
  username: meusite
  password: <%= ENV['MEUSITE_DATABASE_PASSWORD'] %>

Django – ORM – Queries – MySQL – Python

Publicado: 8 de janeiro de 2015 em Python

Depois de criar os seus modelos de dados, o Django lhe fornece automaticamente uma API de banco de dados com abstração que permite criar, recuperar, atualizar e excluir objetos. Você pode utilizar uma gama de instruções Python para manipular dados através de objetos fornecidos pelo ORM Django que também lhe proporciona praticidade e segurança pois sua arquitetura foi construída sob as boas praticas de acesso a dados, onde o desenvolvedor não precisa saber de detalhes técnicos sobre os diferentes bancos de dados pois os objetos já incluem recursos para minimizar o acesso ao banco de dados, criação de IDs automáticos e muitas outras vantagens.

Django Queries: https://docs.djangoproject.com/en/1.7/topics/db/queries/

Usando o Django ORM

1 – Em um diretório de sua escolha crie um projeto e uma aplicação Django:

Django - Projeto e Aplicação

Django – Projeto e Aplicação

2 – No arquivo settings.py do seu projeto, plugue sua aplicação:

Django - Plugar Aplicação

Django – Plugar Aplicação

3 – Defina as configurações para o acesso ao banco de dados MySQL:

Django - MySQL

Django – MySQL

4 – Abra o arquivo de modelo de sua aplicação e escreva seu modelo:

Django - Modelo

Django – Modelo

5 – Valide, gere o SQL e sincronize o bando de dados:

Django - Sincronizar Modelo

Django – Sincronizar Modelo

6 – Agora vamos utilizar o Shell do Django para testar sua API para o banco de dados, vamos utilizar as operações básicas conhecidas com CRUD.

Vamos tomar como exemplo que a Camila goste da banda chamada Stone Temple Pilots, o modelo proporciona que o usuário escolha sua musica e seu álbum preferido:

Django - Crud - Criar e Ler

Django – CRUD – Criar e Ler – Dados

7 – Também podemos recuperar os dados e altera-los caso a Camila tenha lembrado uma musica que goste mais e deseje alterar seu registro:

Django - CRUD - Alterar - Dados

Django – CRUD – Alterar – Dados

8 – Se a Camila desejar excluir seu registro:

Django - CRUD - Deletar - Dados

Django – CRUD – Deletar – Dados

Exemplo:

Neste exemplo criamos um projeto e uma aplicação Django e criamos um modelo de dados através de seu ORM e o utilizamos para efetuar operações CRUD através do seu Shell.

Python

Modelo

from django.db import models

# Desenvolvimento Aberto - Model

class MeuModelo(models.Model):
    nome   = models.CharField(max_length=50)
    album  = models.CharField(max_length=50)
    musica = models.CharField(max_length=70)

Shell – Manipulando objetos ORM

# Importa modelo
from minhaapp.models import MeuModelo

# Inserir e Retornar dados
M1 = MeuModelo(nome="Camila", album="Core", musica="plush")
M1.save()

# Verifica dados do objeto
MeuModelo.objects.values_list(flat=True)

# Alterar
altera = MeuModelo.objects.get(id=1)
altera.musica ="Interstate Love Song"
altera.album="Purple"
altera.save()

MeuModelo.objects.values_list(flat=True)

# Deletar

apagar = MeuModelo.objects.get(id=1)
apagar.delete()

MeuModelo.objects.values_list(flat=True)

Rails é um framework de desenvolvimento de aplicações web escrito na linguagem Ruby. Ele é projetado para tornar a programação de aplicações web mais fácil, fazendo suposições sobre o que cada desenvolvedor precisa para começar. Ele permite que você escreva menos código enquanto faz mais do que muitas outras linguagens e frameworks.

O Rails utiliza o Object-Relational Mapping, comumente referido como seu ORM, é uma técnica que liga os objetos de uma aplicação para tabelas em um sistema de gerenciamento de banco de dados relacional. Rails utiliza o ORM através do Active Record que pode ser considerado o Model no Pattern MVC – o modelo – é a camada do sistema responsável por representar dados de negócios e sua lógica. O Active Record facilita a criação e utilização de objetos de negócios cujos dados requer armazenamento persistente em um banco de dados. É uma implementação do padrão Active Record, que em si é uma descrição de um objeto do sistema Relational Mapping.

Caso você ainda não tenha instalado o Ruby on Rails em seu computador clique aqui ou talvez queira ver uma introdução mais simples e menos detalhada, usando o Rails a partir de uma IDE, clique aqui.

Rails: http://guides.rubyonrails.org/

Basicamente vamos focar em duas pastas do projeto Rails elas são App e Config,  mais tarde entraremos em mais detalhes sobre a estrutura de diretórios do Rails:

  • App –  Contém os controladores, modelos, visões, ajuda, malas diretas e outros itens para a sua aplicação.
  • Config – Configura rotas de sua aplicação, banco de dados e muito mais.

Criando uma Aplicação Ruby on Rails com MySQL

1 – Após instalar o Ruby, o Rails e suas dependências, abra o terminal do Linux para criar um projeto Rails para MySQL:

rails new MinhaApp -d mysql
Rails - Cria Projeto - MinhaApp

Rails – Cria Projeto – MinhaApp

2 – Após criar o projeto entre na pasta MinhaApp. Dê um pouco de atenção a sua estrutura de arquivos, principalmente as pastas contollers, models e views. Estas pastas são responsáveis pela estrutura básica do Pattern MVC dentro de uma aplicação Rails:

Rails - App - MVC

Rails – App – MVC

3 – Vamos criar um controle chamado meucontrole, este será responsável pelo controlador de nossa aplicação, no terminal digite:

rails g controller meucontrole index
Rails - Cria Controle

Rails – Cria Controle

4 – Na pasta config abra o arquivo database.yml e configure os parâmetros de conexão com o banco de dados MySQL:

Rails - Conexão - MySQL

Rails – Conexão – MySQL

5 – Precisamos criar um modelo para nossa aplicação, no terminal digite:

rails g model meumodelo nome:string sobrenome:string cargo:string salario:float

rake db:migrate
Rails - Cria Modelo

Rails – Cria Modelo

6 – Depois de criar um objeto do modelo podemos utilizar o Active Record através do terminal para inserir uma linha de dados no banco, para isto vamos utilizar o console de comandos do Rails, digite:

rails c

Meumodelo.create(:nome=>'james', :sobrenome=>'Hetfield', :cargo=>'Vocalista/Guitarrista', :salario=>1234.56)
Rails - Console - Active Record

Rails – Console – Active Record

7 – Para visualizar os dados que acabamos de gravar e entender a estrutura dos modelos do Rails no banco de dados, abra o MySQL Workbench e execute uma pesquisa na tabela do seu modelo para ver os dados inseridos através do ORM:

MySQL - Workbench - Modelo

MySQL – Workbench – Modelo

8 – Com o controle e modelo prontos, vamos iniciar o servidor Rails, no terminal digite:

rails server
Rails - Server - Iniciar

Rails – Server – Iniciar

9 – Para testar o servidor, abra seu navegador, digite localhost e a porta de numero 3000:

Rails Server - Localhost

Rails Server – Localhost

10 – Na pasta App/Controllers, abra seu controle e crie uma variável de instancia para seu modelo:

Rails - Controle

Rails – Controle

11 – Na pasta App/Views modifique a View padrão index.html.erb para exibir a pagina html, utilize o código abaixo:

Rails - View

Rails – View

12 – Já temos o Modelo, a Visão e o Controlador, precisamos criar uma rota para que o controlador saiba qual será nossa pagina índice. Na pasta Config, abra o arquivo routes.rb e altere seu conteúdo inserindo uma linha de recursos para seu controle, use a figura abaixo como referencia:

Rails - Configura Rotas

Rails – Configura Rotas

13 – Para rodar sua aplicação abra o navegador e digite o nome do seu controle sobre a porta 3000  do servidor local:

Ruby on Rails - MinhaApp

Ruby on Rails – MinhaApp

Exemplo:

Neste exemplo criamos uma aplicação RoR, usando os conceitos básicos do padrão MVC do Rail, utilizando a pasta App do projeto para os arquivos de modelo, visão e controles e configurando os arquivos responsáveis pela conexão e rotas na pasta Config do projeto.

Ruby on Rails

Controlador – meucontrole_controller.rb

class MeucontroleController < ApplicationController
  def index
     @Modelo = Meumodelo.all
  end
end

Visão – index.html.erb

<h1>Desenvolvimento Aberto</h1>
<h2>Ruby on Rails - Model View Controller</h2>
<h3>Dados - Mysql</h3>
<% @Modelo.each do |dados| %>
<br>
<%=String(dados.id) +  " " + dados.nome +  " " + dados.sobrenome + " " + dados.cargo + " " + String(dados.salario)%>

<%end%>

O MySQL Community Edition é uma versão gratuita do banco de dados de código aberto mais popular do mundo, que é apoiado por uma comunidade ativa de desenvolvedores de código aberto e entusiastas. O MySQL hoje suporta Unicode, Full Text Indexes, replicação, Hot Backup, GIS, OLAP e muitos outros recursos de banco de dados.

O MySQL Workbench fornece aos DBAs e desenvolvedores um ambiente integrado de ferramentas para, design e modelagem do banco de dados, desenvolvimento SQL, administração do banco de dados e migração. O MySQL Workbench necessita de bibliotecas adicionais para que funcione corretamente, deste modo consulte o site oficial caso queira instalar em um sistema operacional diferente do Linux.

MySQL Community Edition: http://www.mysql.com/

O MySQL/Ruby é construído em cima da API C do MySQL, e oferece as mesmas funções para programas Ruby que a API C do MySQL fornece para programas em C.

MySQL/Ruby: http://dev.mysql.com/downloads/ruby.html

Instalando e Testando o MySQL e o MySQL/Ruby API

1-  Para instalar o banco de dados MySQL, a ferramenta de administração digite os comandos abaixo no terminal do Linux. Quando questionado escolha uma senha para o usuário root:

sudo apt-get install mysql-server

sudo apt-get install mysql-workbench

sudo apt-get install libmysqlclient-dev
MySQL Community Edition

MySQL Community Edition

2 – Após a instalação das três aplicações digite no terminal mysql-workbench para abrir a ferramenta de administração e desenvolvimento do MySQL:

MySQL Workbench

MySQL Workbench

3 – Clique no quadro Local Instance e digite a senha para o usuário root para se conectar, rode as instruções SQL abaixo para criar um banco de dados e uma tabela para testes:

Workbench - SQL

Workbench – SQL

4 – De volta ao terminal do Linux, instale as bibliotecas Ruby Dev e o conector Ruby utilizando o seguinte comando:

sudo apt-get install ruby-dev

sudo gem install mysql
Ruby - MySQL - C - API

Ruby – MySQL – C – API

5 – Abra a IDE ou o editor e de sua preferencia e utilize o código abaixo para testar o conector:

Apatna - Programa - MySQL

Apatna – Programa – MySQL

Exemplo:

Neste exemplo instalamos o banco de dados MySQL, sua ferramenta de desenvolvimento e administração e as bibliotecas necessária para que o Workbench funcione corretamente, ainda instalamos e testamos o MySQL Ruby API.

SQL

-- Cria banco de dados
Create database DAsandbox;
 
-- Cria privilegios para o usuário root
Grant all privileges on DAsandbox.*
to 'root'@'localhost' identified by 'password';
 
-- nivela privilegios
FLUSH PRIVILEGES;

-- Usa database
use DAsandbox;

-- Cria tabela
Create table Teste ( 
  id int, 
  nome varchar(50),
  sobrenome varchar(70),
  cargo varchar(30),
  salario decimal(9,2));

-- Insere dados na tabela
insert into Teste values (1, 'John','Lennon',
      'Guitarrista/Vocalista', 1234.56);

-- Testa tabela
select * from Teste;

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# conectar.rb

# Declara driver MySQL
require "mysql"

# Define conexão - Host - usuário - senha
conn = Mysql.new 'localhost', 'root', 'pass'

# Define banco de dados
db = conn.select_db('DAsandbox')

# Define um pesquisa
sql = conn.query('Select * from Teste')

# recupera campos
campos = sql.fetch_fields
row = ""

campos.each do |campo|  
     row = row + String(campo.name).ljust(15)  
end

# Recupeda dados
puts row
puts "-" * 100
puts  sql.fetch_row.join("".ljust(15))

Django – Model e View – MySQL – Python

Publicado: 6 de janeiro de 2015 em Python

Um modelo é a única e definitiva fonte de informações sobre seus dados. Ele contém os campos essenciais e os comportamentos dos dados que você está armazenando. Geralmente, cada modelo mapeia uma tabela do banco de dados. Como uma regra em geral, cada modelo é uma classe em Python e cada atributo do modelo representa um campo no banco de dados.

Em Django, a maioria das interações com um banco de dados são feitas por meio de seu ORM (Object-Relational Mapper), que é um recurso de ações do Django bem parecido com outros frameworks como o famoso Rails. Os quadros ORMs são cada vez mais populares entre os desenvolvedores, pois eles automatizam muitas interações comuns com um banco de dados e usam abordagens orientadas a objetos familiares em vez de instruções SQL. Contudo desenvolvedores podem optar por um não utilizar o ORM nativo do Django o substituindo por um Toolkit como o SQLAlchemy que é um kit de ferramentas Python SQL e Object Relational Mapper que dá aos desenvolvedores de aplicativos o poder e a flexibilidade do SQL.

Django Models: https://docs.djangoproject.com/en/1.7/topics/db/models/

Criando um Modelo e Exibindo seus Dados

Vamos começar criando um modelo básico para uma tabela do banco de dados igual a uma tabela no qual já utilizamos em outros exemplos e criamos usando scripts SQL. No entanto não podemos utilizar a tabela já pronta pois vamos cria-la através do ORM do Django sem utilizar instruções SQL.

Ao criar seus modelos o Django cria uma serie de outras tabelas no banco de dados que são necessárias para que um projeto funcione corretamente, não se preocupe com isto agora, o universo de frameworks ORMs são profundos e possuem seus próprios conceitos nos quais são capazes de facilitar a vida do desenvolvedor proporcionando uma sintaxe uniforme e regras sobre as boas praticas de utilização para se manipular dados, evitando assim que desenvolvedores utilizem o banco de dados de forma despadronizada, deste modo, garantindo de um jeito mais eficaz sua normalização e seu desempenho.

1 – Crie um projeto e uma aplicação Django, vamos utilizar o projeto e a aplicação criada anteriormente chamada HelloWorldApp, e vamos utilizar o conector Python para MySQL da Oracle, que você também encontra no post anterior. Para utilizar o conector, altere o arquivo settings.py do seu projeto e defina a conexão e seus parâmetros:

MySQL - settings.py

MySQL – settings.py

2 – Abra o arquivo models.py e crie seu modelo, utilizando o código abaixo:

Model

Model

3 – Abra o terminal do Linux, pois precisamos utilizar alguns comandos do administrador Django para efetuar as tarefas necessárias, elas são: A validação do modelo, a criação do script SQL para o modelo, e a execução do script SQL no banco de dados. Utilize os comandos abaixo:

python manage.py validate

python manage.py sqlall HelloWorldApp

python manage.py syncdb
Django - Validate - Sqlall, SyncDB

Django – Validate – Sqlall, SyncDB

4 – Através do ORM do Django, uma vez que você tem um modelo e sua respectiva tabela no banco de dados, você pode utilizar comandos para operações CRUD (ler, criar, alterar e deletar). Use o comando abaixo para criar um objeto do modelo e inserir dados no banco:

python manage.py shell

from HelloWorldApp.models import Funcionario

f1 = Funcionario(nome="James", sobrenome="Hetfield", cargo="Vocalista/Guitarrista", salario = "1234.56")
f1.save()
Python Shell

Python Shell

5 – Você pode abrir o MySQL Workbench para visualizar sua tabela e as tabelas que o ORM do Django criou assim que você definiu seu primeiro modelo:

MySQL Workbench

MySQL Workbench

6 – Modifique seu arquivo views.py de acordo com o código correspondente e rode o servidor Django e teste sua aplicação:

Django - Aplicação

Django – Aplicação

Exemplo:

Neste exemplo criamos uma aplicação simples que utiliza o banco de dados MySQL, criando um modelo de dados e o exibindo através de sua visão.

Python

settings.py

"""
Django settings for devaberto 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 = 's8eic)^+f@%gg0ffq9j3_kfsoo11k*a-&8x7jw@2p(ujy$=p4a'

# 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',
    'HelloWorldApp',    

)

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 = 'devaberto.urls'

WSGI_APPLICATION = 'devaberto.wsgi.application'

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

DATABASES = {
    'default': {
        'NAME': 'DAsandbox',
        'ENGINE': 'mysql.connector.django',
        'USER': 'root',
        'PASSWORD': 'pass',
        '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/'

models.py

from django.db import models

# Create your models here.

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)

views.py

# coding=utf-8
from django.shortcuts import render
from django.http import HttpResponse

# Importa dados
from HelloWorldApp.models import Funcionario

# Retorna dados atraves do objeto do modelo
dados = Funcionario.objects.values_list(flat=True)

# Recupera campos de uma row
cod = str(dados[0][0])
nome = str(dados[0][1])
sobrenome = str(dados[0][2])
cargo = str(dados[0][3])
salario =str(dados[0][4])

# Cria simples HTML
html = """
 <h1>Desenvolvimento Aberto</h1>
<h2>Django - Models e Views</h2>
<br>
<h3>MySQL - Dados:</h3>
"""

# Formataçao simples
row =  cod + " - " + nome + " " + sobrenome + \
       " - " + cargo + " - R$: " + salario

# Exibe View
def hello(request):
    return HttpResponse(html + row)

O MySQL Community Edition é uma versão gratuita do banco de dados de código aberto mais popular do mundo, que é apoiado por uma comunidade ativa de desenvolvedores de código aberto e entusiastas. O MySQL hoje suporta Unicode, Full Text Indexes, replicação, Hot Backup, GIS, OLAP e muitos outros recursos de banco de dados.

O MySQL Workbench fornece aos DBAs e desenvolvedores um ambiente integrado de ferramentas para, design e modelagem do banco de dados, desenvolvimento SQL, administração do banco de dados e migração. O MySQL Workbench necessita de bibliotecas adicionais para que funcione corretamente, deste modo consulte o site oficial caso queira instalar em um sistema operacional diferente do Linux.

MySQL Community Edition: http://www.mysql.com/

O MySQL Connector/Python habilita programas escritos em Python acessar o bancos de dados MySQL, usando uma API que é compatível com o Python Database API Specification v2.0 (PEP 249). O conector é escrito em Python puro e não tem quaisquer dependências, exceto a biblioteca padrão do Python.

MySQL Connector/Python: http://dev.mysql.com/downloads/connector/python

Instalando e Testando o MySQL e o Python Connector

1- Primeiro você precisa baixar o MySQL Connector/Python do site acima em uma pasta de sua escolha, é necessário um login no site da Oracle, crie um perfil gratuito caso ainda não tenha um. Para instalar o banco de dados MySQL, a ferramenta de administração digite os comandos abaixo no terminal do Linux. Quando questionado escolha uma senha para o usuário root:

sudo apt-get install mysql-server

sudo apt-get install mysql-workbench

sudo apt-get install libmysqlclient-dev
MySQL Community Edition

MySQL Community Edition

2 – Após a instalação das três aplicações digite no terminal mysql-workbench para abrir a ferramenta de administração e desenvolvimento do MySQL:

MySQL Workbench

MySQL Workbench

3 – Clique no quadro Local Instance e digite a senha para o usuário root para se conectar, rode as instruções SQL abaixo para criar um banco de dados e uma tabela para testes:

Workbench - SQL

Workbench – SQL

4 – De volta ao terminal do Linux, instale o conector Python baixado anteriormente utilizando o seguinte comando:

sudo dpkg -i mysql-connector-python_2.0.2-1ubuntu14.04_all.deb
Pacote Debian - Oracle Connector/Python

Pacote Debian – Oracle Connector/Python

5 – Abra a IDE ou o editor e de sua preferencia e utilize o código abaixo para testar o conector:

PyCharm Community - Python

PyCharm Community – Python

Exemplo:

Neste exemplo instalamos o banco de dados MySQL, sua ferramenta de desenvolvimento e administração e as bibliotecas necessária para que o Workbench funcione corretamente, ainda instalamos e testamos o MySQL Connector Python da Oracle.

SQL

-- Cria banco de dados
Create database DAsandbox;
 
-- Cria privilegios para o usuário root
Grant all privileges on DAsandbox.*
to 'root'@'localhost' identified by 'password';
 
-- nivela privilegios
FLUSH PRIVILEGES;

-- Usa database
use DAsandbox;

-- Cria tabela
Create table Teste ( 
  id int, 
  nome varchar(50),
  sobrenome varchar(70),
  cargo varchar(30),
  salario decimal(9,2));

-- Insere dados na tabela
insert into Teste values (1, 'John','Lennon',
      'Guitarrista/Vocalista', 1234.56);

-- Testa tabela
select * from Teste;

Python

__author__ = 'Desenvolvimento Aberto'

# Importa modulos
import mysql.connector

# Cria conexao
conn = mysql.connector.connect(user='root', password='*******',
                              host='127.0.0.1',
                              database='DAsandbox')
# Abre cursor
cursor = conn.cursor()

# Define pesquisa
query = ("SELECT * FROM Teste ")

# Executa pesquisa
cursor.execute(query)

# Imprime resultado
for (id, nome, sobrenome, cargo, salario) in cursor:
  print("{}, {}, {}, {}, {}".format(
    id, nome, sobrenome, cargo, salario))

# Fecha cursor e conexao
cursor.close()
conn.close()