janeiro | 2015 | Desenvolvimento Código Aberto

Arquivo de janeiro, 2015

JSF – Faces Managed Bean – Java

Publicado: 13 de janeiro de 2015 em Java

Um Managed Bean é implementado por uma classe Java, que é chamada de classe Bean. A classe de nível superior Java é um Bean gerenciado se ele é definido como sendo um Bean gerenciado por qualquer outra especificação de tecnologia Java EE, como a especificação da tecnologia JavaServer Faces, ou se ele atende todas as seguintes condições:

Não ser uma classe interna não estática.
Ser uma classe concreta ou ser anotada @Decorator.
Não ser anotado com uma anotação de definição de componente EJB ou declarada como uma classe de Bean EJB no ejb-jar.xml.
Ter um construtor apropriado, a classe deve ter um construtor sem parâmetros ou a classe deve declarar um construtor anotado @Inject.

Uma típica aplicação JavaServer Faces inclui um ou mais Managed Beans, cada um dos quais podem estar associados com os componentes utilizados em uma página particular. Para saber o alcance do escopo de um Managed Bean utilize o link abaixo:

Escopo: JavaServer Faces Managed Bean

Usando um Faces Managed Bean

1 – Crie um novo projeto web dinâmico com a configuração JavaServer Faces utilizando a biblioteca Mojarra da Oracle. Utilize o código abaixo para criar o Managed Bean e a página principal da sua aplicação. Você pode perceber a cada nova tag que insere no código html, que você conta com as facilidades do JSF para criar sua interface com o usuário de um modo simples e intuitivo:

JSF – Index.xhtml

2 – Rode a aplicação no servidor de aplicação de sua preferencia. Preencha seu nome no campo de texto e clique no botão, assim que o botão é disparado o conteúdo do campo de texto é associado ao Setter do Managed Bean e resgatado através do Getter do método de ação ligado ao botão imprimindo o resultado da ação no console do Eclipse:

JSF – Managed Bean – Console

Exemplo:

Neste exemplo utilizamos de modo mais simples o Managed Bean de uma aplicação JSF para exibir os dados entrados pelo usuário através de uma pagina da web.

Java

Managed Bean – Participante

package org.desenvolvimento.aberto;

import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;

// Define decoradores
@ManagedBean(name = "Participante")
@RequestScoped
public class Participante {

	// Define atributos privados
	private long id;
	private String nome;

	// Metodos Getter e Setter
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	public String getNome() {
		return nome;
	}
	public void setNome(String nome) {
		this.nome = nome;
	}

   public String Acao() {
	   System.out.println("Clique do botão");
	   System.out.println("Nome: " + this.getNome());
	   return null;
   }
}

JSF – index.xhtml

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml"
	xmlns:ui="http://java.sun.com/jsf/facelets"
	xmlns:h="http://java.sun.com/jsf/html"
	xmlns:f="http://java.sun.com/jsf/core">

<f:loadBundle basename="resources.application" var="msg" />

<head>
<title><h:outputText value="#{msg.welcomeTitle}" /></title>
</head>

<h:body>
	<h2>JSF - Desenvolvimento Aberto - Managed Beans</h2>
	<h3>
		<h:outputText id="lnome" value="Digite o seu nome:" />
	</h3>
	<h:form>
		<h:messages style="color:red" />
		<h:panelGrid columns="3">
			<h:outputText id="lnome" value="Nome:" />
			<h:inputText id="tnome" value="#{Participante.nome}" required="true" />
			<h:commandButton id="botao" action="#{Participante.Acao}"
				value="Enviar Dados" />
		</h:panelGrid>
	</h:form>
</h:body>
</html>

JSF – JavaServer Faces – Hello World – Eclipse – Java

Publicado: 12 de janeiro de 2015 em Java

O JavaServer Faces é um framework MVC baseado em Java para a construção de interfaces de usuário baseadas em componentes para aplicações web. Possui um modelo de programação dirigido a eventos, abstraindo os detalhes da manipulação dos eventos e organização dos componentes, permitindo que o programador se concentre na lógica da aplicação. Foi formalizada como um padrão através do Java Community Process e faz parte da plataforma Java Enterprise Edition.

O JSF 2 utiliza Facelets como seu sistema de template padrão. Outras tecnologias da camada de visão, como XUL também podem ser empregadas. Em contraste, JSF 1.x utiliza JavaServer Pages (JSP) como seu sistema de template padrão. O JSF é atualmente considerado pela comunidade Java como a última palavra em termos de desenvolvimento de aplicações Web utilizando Java, resultado da experiência e maturidade adquiridas com o JSP/Servlet e Struts.

JSF: http://www.oracle.com/technetwork/java/javaee/javaserverfaces-139869.html

O Facelets é um sistema de template Web de código aberto sob a licença Apache e a tecnologia de processador de visões padrão para o JavaServer Faces (JSF). O Mojarra JavaServer Faces é a implementação open source da Oracle do padrão JSF.

Oracle Mojarra: https://javaserverfaces.java.net/

Criando uma Aplicação Hello World – JSF

1 – Para criar sua primeira aplicação JSF, abra o Eclipse e crie um projeto web dinâmico e na opção configuration, escolha JavaServer Faces 2.2, e clique em próximo duas vezes:

Dynamic Web Project – JSF

2 – Na janela Web Module clique em Generate web.xml deployment descriptor e clique em próximo:

JSF – Web.xml

3 – Nesta janela vamos escolher a biblioteca JSF, clique no botão de download para baixar a biblioteca:

JSF – Capabilities

4 – Escolha Oracle Mojarra, baixe o arquivo e finalize o projeto:

JSF – Oracle – Mojarra

5 – Um novo projeto com uma aplicação JSF em branco foi criado, você pode expandir as pastas do projeto e encontrar o index.xhtml que possui um exemplo padrão de como utilizar o framework:

Projeto – JSF – index.xhtml

6 – Uma rápida olhada no código da página e podemos ver que o JSF utiliza as tags especiais do seu framework, elas são ui (Facelets), h (Html) e f (Core). Expanda a pasta Java Resources e clique em Application Properties e você verá que esta é a fonte dos textos exibidos na página:

JSF – Application Properties

7 – Clique em Add e adicione uma nova propriedade contendo uma saudação:

JSF – Add – Propriedades

8 – No editor adicione uma nova tag para exibir sua propriedade, utilize o código abaixo para referencia:

JSF – Tags

9 – Salva e rode sua aplicação no servidor de aplicação de sua preferencia, neste exemplo utilizamos o Tomcat:

JSF – Tomcat

10 – Com servidor rodando você pode copiar a url do navegador do Eclipse e testar no seu navegador de preferencia:

JSF – Hello World – Firefox

Exemplo:

Neste exemplo criamos um projeto Java EE dinâmico para Web, configuramos a biblioteca JSF Oracle Mojarra e efetuamos uma básica modificação nas propriedades da aplicação para nos familiarizar com as tags do JSF.

Html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml"
    xmlns:ui="http://java.sun.com/jsf/facelets"
    xmlns:h="http://java.sun.com/jsf/html"
    xmlns:f="http://java.sun.com/jsf/core">

<f:loadBundle basename="resources.application" var="msg"/>

<head>
    <title><h:outputText value="#{msg.welcomeTitle}" /></title>
</head>

<body>
<h3><h:outputText value="#{msg.welcomeHeading}" /></h3>
<p><h:outputText value="#{msg.welcomeMessage}" /></p>
<br />
<h2><h:outputText value="#{msg.DevAberto}"  /></h2>
</body>
</html>

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

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

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

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

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

2 – Na pasta template crie um arquivo HTML chamado devaberto.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

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

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

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

2 – Sincronize o banco de dados:

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

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

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

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

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

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

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

Django – Admin – Inserir

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

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)

Django – Aptana Studio 3 – PyDev – MySQL – Linux – Python

Publicado: 9 de janeiro de 2015 em Python

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

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

Configurar Interpretador Python

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

Quick Auto Config

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

Reference Page

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

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

7 – Nomeie sua aplicação de meusite:

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 – 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

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

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

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

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

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)

Ruby on Rails – ORM – Active Record – Queries – MySQL

Publicado: 8 de janeiro de 2015 em Ruby on Rails

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

2 – Na pasta config da sua aplicação configure os parâmetros de acesso ao 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

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)

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

6 – Se a Camila desejar excluir seu registro:

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

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

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

Django – Plugar Aplicação

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

Django – MySQL

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

Django – Modelo

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

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 – 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

8 – Se a Camila desejar excluir seu registro:

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)

Ruby on Rails – Model View Controller – MySQL – Linux – Ruby

Publicado: 7 de janeiro de 2015 em Ruby on Rails

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

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

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

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

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

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

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

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

rails server

Rails – Server – Iniciar

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

Rails Server – Localhost

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

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

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

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

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%>

Instalando o MySQL Community Edition – MySQL WorkBench – MySQL Ruby API – Linux

Publicado: 7 de janeiro de 2015 em Ruby on Rails, Sql

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

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

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

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

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

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))

Desenvolvimento Código Aberto

Arquivos

Categorias

Mais Acessados

Recomendados

Translate

Downloads

Desenvolvimento Aberto

Uteis

Visualizações

Comentários

Arquivo de janeiro, 2015

JSF – Faces Managed Bean – Java

JSF – JavaServer Faces – Hello World – Eclipse – Java

Django – Forms – MySQL – Linux – Python

Django – Template – Linux – Python

Django – Admin – MySQL – Python

Django – Aptana Studio 3 – PyDev – MySQL – Linux – Python

Ruby on Rails – ORM – Active Record – Queries – MySQL

Django – ORM – Queries – MySQL – Python

Ruby on Rails – Model View Controller – MySQL – Linux – Ruby

Instalando o MySQL Community Edition – MySQL WorkBench – MySQL Ruby API – Linux

Autores

Digite uma palavra chave para uma busca