HUFERSIL.WEBDEVELOPER - Soluções em desenvolvimento Web - Tecnologia - TI

Exemplo de lançamento de frequencia escolar

Como já vi vários posts em alguns fóruns perguntando sobre este assunto, resolvi fazer um exemplo para elucidar/ajudar aos que ainda estão começando.

Neste exemplo, ao invés de criar um banco de dias letivos, como vi várias pessoas comentando, criei um banco de feriados, afinal, o número de feriados/dias não letivos é menor do que o de dias letivos, consequentemente, as consultas ficam mais rápidas.

Só lançamos os alunos que estiveram presentes, consequentemente, quem não tem o registro de presença é porque faltou. Assim, também, as consultas ficam mais rápidas.

É um exemplo bem simples, mas bem útil.

Você pode baixá-lo na seção de exemplos.

@braços e fiquem com Deus!

Criando um catálogo de produtos com Lumine e CodeIgniter - Parte 5

Olá pessoal!

Hoje, vamos deixar nossa página um pouco mais apresentável e também fazer o cadastro de categorias.

Neste sistema, as categorias podem ter vários níveis. Então, nosso sistema deverá contemplar o cadastro de categorias filhas, netas, bisnetas...

Deixando a interface mais bonita

Antes de continuar a desenvolver as funcionalidades, vamos deixar o visual mais bacana.

Abra o arquivo application/views/admin/template.php e adicione depois da tag body o código abaixo:



	
	
		Página Inicial
		
Categorias
		
Produtos
		
Usuários
		
Sair

Este será o cabeçalho de nossa aplicação. Ele também já tem um menu básico sobre as coisas que vamos desenvolver.

Agora criando um footer simples. Adicione antes da tag de fechamento "body":


	HUFERSIL.WEBDEVELOPER -

Após adicionar estes códigos, precisamos estiliza-los. Para isso, abra o arquivo assets/css/admin.css e adicione os estilos abaixo:

.header {
	width: 85%;
	margin-left: auto;
	margin-right: auto;
	margin-bottom: 20px;
	padding: 80px 10px 10px 10px;
	background-image: URL(../imagens/logo.gif);
	background-position: left top;
	background-repeat: no-repeat;
	border-bottom: 2px solid #FFCC00;
}

.header ul {
	padding: 0px;
	margin: 0px;
}

.header ul li {
	list-style: none;
	display: inline;
	margin-right: 20px;
}
.header ul li a {
	text-decoration: none;
	color: #000000;
}
.header ul li a:hover {
	font-weight: bold;
	color: #0000CC;
}

.footer {
	width: 85%;
	margin-left: auto;
	margin-right: auto;
	margin-top: 20px;
	padding: 10px;
	text-align: center;
	font-size: 9px;
	color: #CCCCCC;
}

Pronto agora, temos um visual mais bacana para podermos acessar os itens que criamos.

Criando a controller de gerenciamento de categorias

Agora, precisamos cadastrar as categorias, antes de podermos cadastrar produtos. Para esta parte de categorias, como vamos poder trabalhar com estrutura hierarquica, precisaremos de algumas funções extras para podermos exibir os dados de forma hierarquica/aninhada.

Este tipo de função, na estrutura do CodeIgniter, fica dentro de arquivos chamados helpers (http://codeigniter.com/user_guide/general/helpers.html). Vamos criar um arquivo de helper, no caminho application/helpers/util_helper.php, com a seguinte função:

/**
 * Recebe uma lista de elementos e os coloca de forma aninhada.
 * 
 * @param array $lista       Lista de elementos a ser aninhada
 * @param string $chave      Indice que contem o valor padrao (codcategoria, por exemplo)
 * @param string $chavePai   Indice que contem o valor do codigo pai (codpai, por exemplo)
 * @param string $propFilhos Novo indice a ser gerado que armazenara os elementos aninhados
 * @return array Lista com os elementos aninhados 
 * @author Hugo Ferreira da Silva
 */
function fncAninharElementos(array $lista, $chave, $chavePai, $propFilhos = '_filhos'){
	
	// 1 - colocando os itens indexados pelo codigo principal
	$tmp = array();
	foreach($lista as $item){
		$tmp[$item[$chave]] = $item;
	}
	
	
	// 2 - colocando um item dentro do outro,
	// conforme pais e filhos
	foreach($tmp as &$item){
		if(!empty($item[$chavePai])){
			$tmp[$item[$chavePai]][$propFilhos][] = &$item;
		}
	}
	
	// 3 - deixando somente os itens que nao tem pai
	$nova = array();
	foreach($tmp as $node){
		if(empty($node[$chavePai])){
			$nova[] = $node;
		}
	}
	
	// pronto, retornando os elementos
	return $nova;
}

Depois de criar o arquivo, temos que carregar ele. Poderiamos utilizar o autoload, mas neste exemplo, vamos fazer um pouco diferente. Abra o arquivo application/core/MY_Controller.php e adicione ao construtor as seguintes linhas:

// carregando a helper customizada
$this->load->helper('util');

Pronto. Agora podermos utilizar as funções que estão dentro de arquivo. Agora, vamos criar nossa controller de gerenciamento de caregorias.

Crie um arquivo na estrutura application/controllers/admin/categorias.php com o seguinte conteúdo:

getCategoriasAninhadas();
		
		// colocamos a lista de resultados
		$this->assign('lista', $listaAninhada);
		// exibimos o resultado
		$this->display('categorias/index');
	}
	
	/**
	 * Exibe a tela de inserção/atualização de categorias
	 * 
	 * @param int $id Codigo da categoria que esta sendo editada ou null para cadastrar uma nova
	 * @author Hugo Ferreira da Silva
	 */
	public function editar($id = null){
		// se tem codigo de usuario e o metodo é GET
		if(!empty($id) && $_SERVER['REQUEST_METHOD'] == 'GET'){
			// resgatamos o registro do banco
			$obj = new Categoria();
			$obj->get($id);
			// colocamos os dados na variavel $_POST
			$_POST = $obj->toArray();
		}
		// colocamos a lista de categorias para exibirmos na combo
		$this->assign('categorias', $this->getCategoriasAninhadas());
		
		// exibimos a tela de inserção/edição de categorias
		$this->display('categorias/editar');
	}
	
	/**
	 * Insere uma nova categoria ou altera os dados de uma existente
	 * 
	 * @param int $id Código da categoria ou null para uma nova
	 * @author Hugo Ferreira da Silva
	 */
	public function salvar($id = null){
		// cria um objeto para persistencia
		$dao = new Categoria();
		
		// se está editando (informou o código da categoria)
		if(!empty($id)){
			// pegamos o registro do banco de dados
			$dao->get($id);
		}
		
		// se não tiver código pai, colocamos como NULL
		if(empty($_POST['codpai'])){
			$_POST['codpai'] = null;
		}
		
		// colocamos no objeto os valores que estão no formulario
		// como os nomes dos campos tem os mesmos nomes dos campos,
		// este método facilita o preenchimento do objeto
		$dao->populateFrom($_POST);
		
		// fazemos a validação dos dados
		$erros = $dao->validate();
		
		// se não houveram erros
		if(empty($erros)){
			// fazemos a persistencia
			$dao->save();
			
			// redirecionamos para a tela de listagem de categorias
			redirect('admin/categorias/index');
			
		// mas se não passou na validação
		} else {
			// informamos quais foram os erros
			$this->assign('erros', $erros);
			
			// exibimos a tela de inserção/edição
			$this->editar($id);
		}
	}
	
	/**
	 * Remove uma categoria cadastrada
	 * 
	 * @param int $id Código da categoria a ser removida
	 * @author Hugo Ferreira da Silva
	 */
	public function remover($id){
		// criamos um objeto de categoria
		$user = new Categoria();
		
		// se informou o codigo da categoria e encontrou no banco
		if(!empty($id) && $user->get($id) == 1){
			// removemos a categoria
			// as subcategorias serão removidas em cascata,
			// bem como os produtos
			$user->delete();
		}
		
		// redirecionamos para a tela de listagem de categorias
		redirect('admin/categorias/index');
	}
	
	/**
	 * Recupera as categorias de forma aninhada
	 * 
	 * @author Hugo Ferreira da Silva
	 */
	protected function getCategoriasAninhadas(){
		$lista = new Categoria();
		// fazemos a consulta
		$lista->alias('c')
			// ordenamos pelo nome
			->order('c.ordem asc')
			// efetuamos a consulta
			->find();
		
		// precisamos colocar um "item dentro do outro" para poder enviar
		// e montar o html corretamente
		$listaAninhada = fncAninharElementos($lista->allToArray()
			, 'codcategoria'
			, 'codpai'
			, 'categorias'
		);
		
		return $listaAninhada;
	}
}

Nesta parte de categorias, precisamos fazer uma verificação para saber se o usuário não está inserindo referências circulares (um objeto é pai/avô dele mesmo).

Para adicionarmos esta validação, abra o arquivo application/models/Categoria.php e adicione os seguintes métodos:

    public function validate(){
    	$this->addValidator(new Lumine_Validator_String('nome', 'Informe o nome da categoria'));
    	$this->addValidator(new Lumine_Validator_Custom('codpai', 'Referência ciclica detectada', array($this,'validarCodPai')));
    	return parent::validate();
    }

    /**
     * Efetua a validação contra referências circulares
     * 
     * @param Categoria $obj Referencia ao objeto que está sendo validado
     * @param string $field  Nome do campo que está sendo validado
     * @param mixed $value   Valor do campo que está sendo validado
     * @return boolean
     * @author Hugo Ferreira da Silva
     */
    public function validarCodPai(Categoria $obj, $field, $value){
    	// se estiver inserindo, tudo bem
    	if(empty($obj->codcategoria)){
    		return true;
    	}
    	
    	// se tiver vazio, virou uma categoria principal
    	if(empty($value)){
    		return true;
    	}
    	
    	// ele não pode ser pai dele mesmo
    	if($value == $obj->codcategoria){
    		return false;
    	}
    	
    	// e nao pode ser avo, bisavo ... dele mesmo
    	$stack = array($obj->codpai);
    	$tmp = new Categoria();
    	
    	while(!empty($stack)){
    		$tmp->reset();
    		$tmp->select('codcategoria,codpai')
    			->where('{codcategoria} IN (?)', $stack)
    			->find();
    		
    		$stack = array();
    		foreach($tmp->allToArray(false,true) as $item){
    			$stack[] = $item['codpai'];
    		}
    		
    		if(in_array($obj->codcategoria, $stack)){
    			return false;
    		}
    	}
    	
    	return true;
    }

E, para completarmos esta parte, vamos criar as views. Primeiro, a de listagem de categorias (application/views/admin/categorias/index.php):


	Categorias cadastradas
	
		'
						, $item['codcategoria']
						, $indent * 30
						, $item['nome']
						, site_url('admin/categorias/editar/'.$item['codcategoria'])
						, site_url('admin/categorias/remover/'.$item['codcategoria'])
					);
					
					if(!empty($item['categorias'])){
						createRow($item['categorias'], $indent+1);
					} 
				}
			}
			
			createRow($lista);
			?>
		
			
				
					Código
					Nome
					Ações
				
			
			
							%d
							%s
							
								Editar
								Remover
							
						
	
		Nenhum registro encontrado

Código	Nome	Ações
%d	%s	Editar Remover

E agora, a de inserção e edição (application/views/admin/categorias/editar.php):


	Cadastro de Categorias - uri->segment(4) == '' ? 'Adicionar' : 'Atualizar'; ?>
	', implode("
", $erros), '';
	}
	?>
	
		
			Categoria Pai: 
			
		
		
			Nome: 
			
		
		
			Ordem:

É isso. Efetue seu login e teste a aplicaçao!

Abraços e fiquem com Deus!

Exemplo de Chat

Fala galera,

Hoje resolvi colocar um exemplo diferente.
Fiz um exemplozinho de chat.

Ele já tem a estrutura de banco de dados. Basta:

criar a base,
importar o "dump",
ajustar as configurações no lumine-conf.php

Para baixar, vá até a parte de exemplos.

Você também pode conferir online.

@braços e fiquem com Deus!

Criando um catálogo de produtos com Lumine e CodeIgniter - Parte 4

Nesta quarta parte de como integrar Lumine com CodeIgniter, vamos estudar sobre como criar nossa controller de cadastro de usuários.

Nela criaremos as operações de

Listar os usuários cadastrados
Pesquisar os usuários cadastrados
Inclusão de usuários
Edição de usuários
Remoção de usuários

Criando a controller de gerenciamento de usuários

Crie um arquivo usuarios.php na seguinte estrutura:

application/controllers/admin/usuarios.php

Abra o arquivo recém criado coloque o conteúdo abaixo (as explicações estão nos comentários do arquivo):

alias('u');
		
		// se usuario informou o nome na pesquisa
		if($this->input->post('nome') != ''){
			// filtramos pelo nome
			$lista->where('u.nome like ?', $this->input->post('nome'));
		}
		
		// se usuario informou o email na pesquisa
		if($this->input->post('email') != ''){
			$lista->where('u.email like ?', $this->input->post('email'));
		}
		
		// contamos o numero de registros encontrados
		$total = $lista->count();
		// limitamos o numero de resultados
		$lista->limit(max(0, (int)$page - 1) * LIMITE_PAGINACAO_ADMIN, LIMITE_PAGINACAO_ADMIN)
			// ordenamos pelo nome
			->order('u.nome asc')
			// efetuamos a consulta
			->find();
		
		// colocamos nos dados para o template o numero de resultados...
		$this->assign('total', $total);
		// ... e a lista de resultados
		$this->assign('lista', $lista->allToArray());
		// exibimos o resultado
		$this->display('usuarios/index');
	}
	
	/**
	 * Exibe a tela de inserção/atualização de usuários
	 * 
	 * @param int $id Codigo do usuario que esta sendo editado ou null para cadastrar um novo
	 * @author Hugo Ferreira da Silva
	 */
	public function editar($id = null){
		// se tem codigo de usuario e o metodo é GET
		if(!empty($id) && $_SERVER['REQUEST_METHOD'] == 'GET'){
			// resgatamos o registro do banco
			$user = new Usuario();
			$user->get($id);
			// colocamos os dados na variavel $_POST
			$_POST = $user->toArray();
			// tiramos a senha (está em MD5)
			unset($_POST['senha']);
		}
		// exibimos a tela de inserção/edição de usuarios
		$this->display('usuarios/editar');
	}
	
	/**
	 * Insere um novo usuário ou salva as alterações feitas em um usuário existente
	 * 
	 * @param int $id Código do Usuário ou null para um novo usuário
	 * @author Hugo Ferreira da Silva
	 */
	public function salvar($id = null){
		// cria um objeto para persistencia
		$dao = new Usuario();
		
		// se está editando (informou o código do usuário)
		if(!empty($id)){
			// pegamos o registro do banco de dados
			$dao->get($id);
			
			// se não informou a senha, então deixamos a mesma
			if(empty($_POST['senha'])){
				unset($_POST['senha']);
			}
		}
		
		// se tem senha enviada do formulario
		if(!empty($_POST['senha'])){
			// colocamos em MD5
			$_POST['senha'] = md5($_POST['senha']);
		}
		
		// colocamos no objeto os valores que estão no formulario
		// como os nomes dos campos tem os mesmos nomes dos campos,
		// este método facilita o preenchimento do objeto
		$dao->populateFrom($_POST);
		
		// fazemos a validação dos dados
		$erros = $dao->validate();
		
		// se não houveram erros
		if(empty($erros)){
			// fazemos a persistencia
			$dao->save();
			
			// redirecionamos para a tela de listagem de usuários
			redirect('admin/usuarios/index');
			
		// mas se não passou na validação
		} else {
			// informamos quais foram os erros
			$this->assign('erros', $erros);
			
			// exibimos a tela de inserção/edição
			$this->editar($id);
		}
	}
	
	/**
	 * Remove um usuário cadastrado
	 * 
	 * @param int $id Código do usuário a ser removido
	 * @author Hugo Ferreira da Silva
	 */
	public function remover($id){
		// criamos um objeto de usuario
		$user = new Usuario();
		
		// se informou o codigo do usuario e encontrou no banco
		if(!empty($id) && $user->get($id) == 1){
			// removemos o usuario
			$user->delete();
		}
		
		// redirecionamos para a tela de listagem de usuários
		redirect('admin/usuarios/index');
	}
}
?>

Para podermos validar o cadastro de usuários, precisamos adicionar regras de validação de preenchimento de dados do formulário. Estas regras ficarão dentro do arquivo de model de usuário, que está em:

application/models/Usuario.php

Adicione o método abaixo:

    public function validate(){
    	
    	$this->addValidator(new Lumine_Validator_String('nome', 'Informe o nome do usuário', 3));
    	$this->addValidator(new Lumine_Validator_Email('email', 'Informe um e-mail válido'));
    	$this->addValidator(new Lumine_Validator_Unique('email', 'E-mail já utilizado por outro usuário'));
    	$this->addValidator(new Lumine_Validator_String('senha', 'Informe uma senha com ao menos 4 caracteres', 4));
    	
    	return parent::validate();
    }

Adicionando facilidades para desenvolver o admin.

Para facilitar, iremos realizar algumas alterações no arquivo application/core/AdminController.php. Vamos adicionar:

O carregamento da biblioteca pagination do CodeIgniter. Ela servirá para colocarmos o número de páginas em resultados encontrados para listagem de registros.
Criar uma função para armazenar os dados da ultima pesquisa realizada. Assim, podemos fazer uma pesquisa, editar o registro encontrado e, quando retornarmos à tela de listagem, os dados da última pesquisa continuam salvos.

Encontre a linha onde está:

	// verifica se a permissão do usuário de acessar a URL indicada
	$this->verificarPermissao();
	
	// -------- e adicione 
	
	// carrega a biblioteca de paginação
	$this->load->library('pagination');
	
	// fazemos um hook para formularios de pesquisa
	$this->hookFormularioPesquisa();

Adicione a seguinte função:

	/**
	 * Grava os dados da pesquisa realizada.
	 * 
	 * Ao realizar uma pesquisa, gravamos quais foram os dados 
	 * enviados pelo usuário na sessão, para quando ele voltar
	 * na tela de pesquisa os dados continuem lá.
	 * 
	 * Para funcionar corretamente, o nome do método que realiza
	 * a consulta deve ser sempre o método "index" da controller.
	 * 
	 * Ao acessar uma controller diferente, limpamos os dados anteriores
	 * 
	 * @author Hugo Ferreira da Silva
	 */
	protected function hookFormularioPesquisa(){
		// pega  o nome da controller anterior e atual
		$ctrlAnterior = empty($_SESSION['_ctrl']) ? null : $_SESSION['_ctrl'];
		$ctrlAtual    = $this->uri->segment(2);
		
		// se enviou uma solicitação via POST e foi pelo metodo index 
		if($_SERVER['REQUEST_METHOD'] == 'POST' && strpos($this->uri->uri_string(), '/index') !== false){
			$_SESSION['_busca'] = $_POST;
			$_SESSION['_ctrl'] = $ctrlAtual;
			return;
		}
		
		// se não for a mesma controller
		if($ctrlAnterior != $ctrlAtual){
			// limpamos os dados
			unset($_SESSION['_busca'], $_SESSION['_ctrl']);
			return;
		}
		
		// se tem dados de busca e for o metodo index
		if(!empty($_SESSION['_busca']) && $this->uri->segment(3) == 'index'){
			$_POST = $_SESSION['_busca'];
		}
	}

Agora que já temos a lógica de negócio, controller e auxiliadores criados, vamos construir nossas views.

Crie o arquivo application/views/admin/usuarios/index.php com o conteúdo abaixo:


	Cadastro de Usuários - Pesquisar
	
		
			Nome: 
			
		
		
			E-mail: 
			
		
		
			
			
		
	



	Usuários encontrados
	
		'
					, $item['codusuario']
					, $item['nome']
					, $item['email']
					, site_url('admin/usuarios/editar/'.$item['codusuario'])
					, site_url('admin/usuarios/remover/'.$item['codusuario'])
				);
			}
			
			// configurações da paginacao
			// @link http://codeigniter.com/user_guide/libraries/pagination.html
			$config['uri_segment'] = 4;
			$config['total_rows'] = $total;
			$config['per_page'] = LIMITE_PAGINACAO_ADMIN;
			$config['base_url'] = site_url('admin/usuarios/index');
			$config['use_page_numbers'] = TRUE;
			$this->pagination->initialize($config);
			
			// exibe a paginacao
			printf(''
				, $this->pagination->create_links()
			);
			?>
		
			
				
					Código
					Nome
					E-mail
					Ações
				
			
			
						%d
						%s
						%s
						
							Editar
							Remover
						
					

					 %s 
				
	
		Nenhum registro encontrado

Código	Nome	E-mail	Ações
%d	%s	%s	Editar Remover
%s

Crie o arquivo application/views/admin/usuarios/editar.php com o conteúdo abaixo:


	Cadastro de Usuários - uri->segment(4) == '' ? 'Adicionar' : 'Atualizar'; ?>
	', implode("
", $erros), '';
	}
	?>
	
		
			Nome: 
			
		
		
			E-mail: 
			
		
		
			Senha:

E, para deixarmos nossas views um pouco mais amigáveis, vamos adicionar no arquivo assets/css/admin.css o conteúdo abaixo:

/*************************************/
/* Estilos gerais para admin
/*************************************/
.admin-container {
	width: 85%;
	margin-left: auto;
	margin-right: auto;
	margin-bottom: 40px;
	padding: 10px;
}
.admin-container legend {
	font-weight: bold;
	font-size: 14px;
	color: #003300;
}
.admin-container input[type="submit"], .admin-container input[type="button"] {
	padding: 5px;
}
.admin-container .tabela-resultados {
	width: 100%;
	border: 1px solid black
}
.admin-container .tabela-resultados td, .admin-container .tabela-resultados th {
	padding: 3px;
}
.admin-container .tabela-resultados thead th {
	background-color: #EFEFEF;
	font-weight:bold;
	text-align: left; 
}
.admin-container .tabela-resultados tbody tr:hover {
	background-color: #EFEFEF;
}
.form-padrao p {
	clear: both;
	padding-bottom: 5px;
}
.form-padrao p label {
	display: block;
	float: left;
	width: 120px;
	padding-top: 2px;
	padding-right: 10px;
	text-align: right;
}
.btnEditar {
	background-image: url("http://www.iconfinder.com/ajax/download/png/?id=11450&s=16");
	background-position: center center;
	background-repeat: no-repeat;
	width: 15px;
	height: 15px;
	display: inline-block;
	overflow:hidden;
	text-indent: -10000px;
}
.btnRemover {
	background-image: url("http://www.iconfinder.com/ajax/download/png/?id=10032&s=16");
	background-position: center center;
	background-repeat: no-repeat;
	width: 15px;
	height: 15px;
	display: inline-block;
	overflow:hidden;
	text-indent: -10000px;
}
.erros {
	padding: 4px;
	background-color: #FFFF55;
	color: #FF0000;
	font-weight: bold;
	margin-bottom: 10px;
}

Pronto! Se tudo deu certo, efetue o login e depois acesse http://localhost/vitrine/admin/usuarios/index para ver a lista de usuários.

Até a próxima!

@braços e fiquem com Deus!

Criando um catálogo de produtos com Lumine e CodeIgniter - Parte 3

Hoje veremos:

Como organizar nossos diretórios
Criar uma tela de login para a parte administrativa

Como organizar nossos diretórios

Nesta aplicação, iremos criar uma área administrativa e uma área publica.

A parte administrativa, iremos chamar de admin. A pública, de site.

Tudo que está dentro da pasta "application" não poderá ser acessado externamente quando o sistema estiver em produção. Portanto, as imagens, arquivos CSS e JavaScript deverão estar fora da pasta "application". Então, criaremos uma pasta para podermos armazenar estes tipos de arquivo.

Tendo isto em mente, crie a seguinte estrutura de diretórios:

c:\www\vitrine\assets
c:\www\vitrine\assets\css
c:\www\vitrine\assets\imagens
c:\www\vitrine\assets\js
c:\www\vitrine\application\views\admin
c:\www\vitrine\application\views\site

Para cada controller criada, seja administativa ou pública, iremos também criar um diretório na área correspondente para podermos armazenar as visualizações de comportamento. Cada método dentro de uma controller é um comportamento, e ficará extremamente mais simples de manter o sistema se criarmos um arquivo view para cada método.

Seguindo esta linha de raciocínio, criaremos mais um diretório:

c:\www\vitrine\application\views\admin\login

Como podemos ver facilmente, este diretório armazenará os arquivos de visualização da controller "login" da parte administrativa.

Para facilitarmos o desenvolvimento, vamos criar um "template principal" para a parte administrativa. As visualizações de comportamento de cada método serão, na verdade, trechos menores que irão ser incorporados dentro do template principal. Em outras palavras, vamos fazer um "include" do trecho a ser visualizado dentro do template principal. Este template principal já terá as partes mais importantes, como topo, rodapé, menu principal de navegação, etc. As visualizações terão somente o "miolo", que serão incorporadas ao template.

Antes de criarmos o template, abaixo o arquivo CSS usado para o admin. Salve o arquivo em assets/css/admin.css

@CHARSET "UTF-8";
/*************************************/
/* Tela de Login
/*************************************/
* {
	margin: 0px;
	padding: 0px;
	font-family: Verdana, Geneva, Arial, Helvetica, sans-serif;
	font-size: 11px;
	font-weight: normal;
	font-style: normal;
}
.login-box {
	margin-top: 200px;
	width: 450px;
	margin-left: auto;
	margin-right: auto;
	border: 1px solid #999999;
	padding: 5px;
	border-radius: 5px;
}
.login-box p {
	clear: both;
	padding-bottom: 5px;
}
.login-box label {
	display: block;
	float: left;
	width: 120px;
	padding-top: 2px;
	padding-right: 10px;
	text-align: right;
}
.login-box #btnLogin {
	margin-left: 160px;
	padding: 4px;
}
.login-box h1 {
	border-radius: 5px;
	font-size: 14px;
	font-weight: bold;
	color: #555555;
	margin-bottom: 10px;
	background-color: #EFEFEF;
	padding: 4px 4px 4px 25px;
	background-image: url("http://www.iconfinder.com/ajax/download/png/?id=36090&s=16");
	background-position: 3px center;
	background-repeat: no-repeat;
}
.login-box .erro{
	padding: 4px;
	background-color: #FFFF55;
	color: #FF0000;
	font-weight: bold;
	margin-bottom: 10px;
}

Nosso arquivo de template por enquanto será bem simples, para poder facilitar nossos estudos. Vamos criar uma estrutura básica e fazer a verificação de existência do arquivo que será incluido. Salve este arquivo em application/views/admin/template.php:

	
	
	
		Sistema de Gerenciamento de Conteudo

Pronto! Agora nossas visualizações de comportamento (views) da área administrativa serão bem mais simples!

Vamos agora criar nossa visualização da tela de login. Salve o arquivo em application/views/admin/login/index.php


	
		Efetue seu login
		uri->segment(4)){
			case 'informe_seus_dados':
				echo 'Usuário ou senha em branco';
			break;
			case 'usuario_nao_encontrado':
				echo 'Nenhum usuário encontrado com as credenciais informadas';
			break;
		}
		?>
		
			E-mail
			
		
		
			Senha

Note que para este arquivo fizemos somente o formulário de login sem a necessidade de outras informações, como topo, rodapé, etc, pois estas informações já estão no arquivo template.php. Bem mais simples, não?.

Agora que já criamos nosso arquivo de visualização principal (template.php) e login (login/index.php), vamos criar nossa controller para podermos fazer o login no sistema.

Para isso, crie uma controller chamada login.php com o conteúdo abaixo:

display('login/index');
	}
	
	/**
	 * Efetua a validação do usuário no sistema e efetua o login do mesmo.
	 * 
	 * Caso as credenciais estejam corretas, gravamos as informações de login
	 * na sessão.
	 * 
	 * @author Hugo Ferreira da Silva
	 */
	public function do_login(){
		// nova instancia de usuario
		$user = new Usuario();
		
		// pegamos as informações do formulario.
		$user->email = $this->input->post('email');
		$user->senha = $this->input->post('senha');
		
		// se uma informação ficou em branco,
		// redirecionamos para a tela de login
		if(empty($user->email) || empty($user->senha)){
			redirect('admin/login/index/informe_seus_dados');
		}
		
		// colocamos a senha em md5
		$user->senha = md5($user->senha);
		
		// faz a consulta obtendo o numero de resultados
		$total = $user->find(true);
		
		// se não encontrou nada
		if( $total == 0 ){
			redirect('admin/login/index/usuario_nao_encontrado');
		}
		
		// se encontrou, colocamos os dados do usuario na sessão
		$_SESSION['usuario'] = $user->toArray();
		
		// redirecionamos o usuario para a tela de produtos.
		redirect('admin/produtos/index');
	}
	
	/**
	 * Efetua o logout do usuario
	 * 
	 * Limpa os dados da seção e envia o usuário para a tela de login
	 * 
	 * @author Hugo Ferreira da Silva
	 */
	public function do_logout(){
		$_SESSION = array();
		redirect('admin/login/index');
	}
}

Salve este arquivo como application/controllers/admin/login.php

Se tudo foi seguido corretamente, ao acessar a URL http://localhost/vitrine/admin/login/index você deverá ver a tela abaixo:

Para praticar, tente fazer a controller de produtos com um método index e uma visualização simples.

Na próxima matéria vamos fazer a controller de usuários.

@braços e fiquem com Deus!

Criando um catálogo de produtos com Lumine e CodeIgniter - Parte 2

Dando continuidade ao post anterior, vamos ver hoje como:

Configurar a base do CodeIgniter

Criar uma controller base

Criar uma controller base de administração

Para não estender muito o tutorial e ficar complicado, a tela de login vamos deixar para o próximo post, juntamente sobre como configurar as "Views" de nosso projeto.

Configurar a base do CodeIgniter

Para torar as URL's mais amigáveis, vamos tirar o "index.php".
É necessário que o ModRewrite do Apache esteja ativo.
Crie um arquivo chamado ".htaccess" na pasta raiz do projeto (c:\www\vitrine).
Coloque o conteúdo abaixo dentro deste arquivo:

RewriteEngine On

RewriteCond $1 !^(index\.php|images|css|robots\.txt)
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php/$2 [L]

Com isto, toda requisição feita para o servidor que não possua um arquivo ou pasta existente será redirecionada para o CodeIgniter tratar.

A segunda coisa que iremos fazer, será configurar a URL base do nosso projeto.
Abra o arquivo "application/config/config.php".

Altere a linha:

$config['index_page'] = 'index.php';

// para

$config['index_page'] = '';

Com isto, o segmento "index.php" não será mais apresentado quando formos construir URL's internas com a funções de criação de link do CodeIgniter.

Agora, precisamos colocar no arquivo "application/config/autoload.php" quais bibliotecas iremos carregar por padrão.

Ele nos permite indicar vários tipos de arquivos, mas por enquanto, vamos nos atentar somente à algumas bibliotecas que já vem com o CI.

Abra o arquivo mencionado e procure pela linha:

$autoload['libraries'] = array('');
// e troque para 
$autoload['libraries'] = array('uri');

A biblioteca URI nos dá acesso aos "segmentos" formados pelo endereço acessado pelo usuário.
Exemplo: quando acessamos a URL:
http://www.hufersil.com.br/post/nome_do_post

Você pode recuperá-la com o CodeIgniter desta forma:

echo $this->uri->segment(1); // exibirá "post";
echo $this->uri->segment(2); // exibirá "nome_do_post";

Entre outras funções úteis que veremos durantes os tutoriais. Você pode conferir a lista de métodos na documentação do CodeIgniter.

Depois, procure:

$autoload['helper'] = array('');
// e troque para 
$autoload['helper'] = array('url');

Este "helper" na verdade é um conjunto de funções de auxilio na criação de URL's.
Você também pode ver melhor quais são estes métodos na documentação do CodeIgniter (http://codeigniter.com/user_guide/helpers/url_helper.html)

A última coisa que precisamos configurar no momento é a "rota" padrão do CI.
Como vamos começar primeiro pelo admin, vamos configurar a rota padrão sendo a nossa tela de autenticação.
Para isto, abra o arquivo "application/config/routes.php".

Procure pela linha:

$route['default_controller'] = "welcome";

// e troque para

$route['default_controller'] = "admin/login/index";

Isto fará com que o CodeIgniter procure na pasta "admin" uma controller chamda "login" e acesse o método "index".

Pronto! A configuração básica do CI está montada!

Agora podemos avançar um pouco mais.

Criar uma controller base

A controller que vem com o CodeIgniter é bem básica.
Para melhorarmos o nosso trabalho, vamos criar a nossa própria controller base extendendo a controller base do CI.

Por padrão, quando queremos que o CodeIgniter carregue nossas implementações ao invés das implementações dele, criamos nossas classes com o prefixo "MY_".
Este prefixo também pode ser alterado no arquivo de configuração (application/config/config.php), mas por enquanto vamos deixar o padrão.

O que queremos é "criar nossa controller base", extendendo a classe CI_Controller (que é base padrão de todas as controllers do CI).
Então, para isso, crie um arquivo chamado "MY_Controller.php" dentro da pasta "application/core". Sua estrutura deverá ser:
C:\www\vitrine\application\core\MY_Controller.php

Agora, implemente a classe abaixo (nos comentários estão as responsabilidades de cada método implementado):

/**
 * Controller base para as implementações de nosso Catalogo de Produtos
 * 
 * @author Hugo Ferreira da Silva
 * @link http://www.hufersil.com.br
 *
 */
class MY_Controller extends CI_Controller {

	/**
	 * Indica se a sessão já foi iniciada
	 * @var boolean
	 */
	protected static $sessionStarted = false;

	/**
	 * Indica o arquivo de layout padrão
	 * @var string
	 */
	protected $layoutFile = 'template.php';
	
	/**
	 * Dados para serem enviados para o template
	 * @var array
	 */
	protected $data = array();
	
	/**
	 * Construtor
	 * 
	 * @author Hugo Ferreira da Silva
	 */
	public function __construct(){
		// chamamos o construtor pai
		parent::__construct();
		
		// carregamos a configuracao de Lumine
		// o CI já cria a instancia
		$this->load->library('Lumine_ApplicationContext');
		
		// se a sessão ainda não foi iniciada
		if(!self::$sessionStarted){
			// iniciamos e marcamos como iniciada
			session_start();
			self::$sessionStarted = true;
		}
	}
	
	/**
	 * Adiciona um valor para ser enviado para o template
	 * 
	 * @param string $key Nome da chave
	 * @param mixed $value Valor a ser enviado
	 * @author Hugo Ferreira da Silva
	 */
	public function assign($key, $value){
		$this->data[$key] = $value;
	}
	
	/**
	 * Renderiza uma view.
	 * 
	 * @link http://codeigniter.com/user_guide/general/views.html
	 * 
	 * @param string $tpl Nome do template "miolo".
	 * @param boolean $return Indica se vamos renderizar na tela (false) ou retornar o resultado como string (true) 
	 * @author Hugo Ferreira da Silva
	 * @return string Resultado da renderização
	 */
	public function display($tpl, $return = false){
		// so para garantir que a extensao sempre existirá
		$tpl = preg_replace('@\.php$@i', '', $tpl) . '.php';
		$tpl = (empty($this->uriSession) ? '' : trim($this->uriSession, '/') . '/') . $tpl;
		$this->assign('_template', $tpl);
		
		return $this->load->view($this->layoutFile, $this->data, $return);
	}
}

E esta será nossa controller base.
Estes pequenos métodos farão uma grande diferença enquanto estivermos trabalhando com nossas controllers finais.

Criar uma controller base de administração

A controller base nos fornece comportamentos comuns entre o que iremos usar no administrador e na parte pública.
Porém, precisamos de um comportamos um pouco mais especializado na tela área de administração.
Para isso, criaremos uma controller base de administração.

Adicione ao final do arquivo
C:\www\vitrine\application\core\MY_Controller.php

A linha:

require_once dirname(__FILE__) . '/AdminController.php';

Precisamos colocar neste arquivo porque o CI não tem como carregar este arquivo de forma automática, mas ele carrega automaticamente a MY_Controller.
Quando formos implementar a parte publica, veremos como fazer este carregamento de forma condicional.

Agora, crie um arquivo na estrutura:
C:\www\vitrine\application\core\AdminController.php

E coloque o conteúdo abaixo dentro deste arquivo criado:

/**
 * Controller base para seção de administração
 *
 * @author Hugo Ferreira da Silva
 * @link http://www.hufersil.com.br
 *
 */
class AdminController extends MY_Controller {
	
	/**
	 * Caminhos que os usuários poderão acessar sem a necessidade
	 * de estarem autenticados.
	 * 
	 * Cada caminho é uma entrada no array em forma de expressão regular.
	 * O mostrado abaixo dá acesso sem necessidade de autenticação 
	 * a qualquer método da controller "login"
	 * 
	 * @var array
	 */
	protected $allowedPaths = array(
		'^admin/login/.*?'
	);
	
	/**
	 * Contrutor
	 * 
	 * @author Hugo Ferreira da Silva
	 */
	public function __construct(){
		// chamamos o construtor "pai"
		parent::__construct();
		
		// indicamos o arquivo de layout da área de administração
		$this->layoutFile = 'admin/template.php';
		
		// verifica se a permissão do usuário de acessar a URL indicada
		$this->verificarPermissao();
		
		// ja colocamos os dados do usuario da sessão para
		// podermos renderizar nos templates
		$this->assign('_usuario', $this->getUsuarioSessao());
	}
	
	/**
	 * Recupera os dados do usuário logado
	 * 
	 * @author Hugo Ferreira da Silva
	 * @return array
	 */
	protected function getUsuarioSessao(){
		return empty($_SESSION['usuario']) ? null : $_SESSION['usuario'];
	}
	
	/**
	 * Verifica a permissão de acesso do usuário.
	 * 
	 * Por enquanto, somente verificamos se o usuário está logado;
	 * 
	 * @author Hugo Ferreira da Silva
	 */
	protected function verificarPermissao(){
		$user = $this->getUsuarioSessao();
		$uri = $this->uri->uri_string();
		
		// se não está logado e esta acessando uma URL não permitida.
		if(empty($user) && !preg_match('@' . implode('|', $this->allowedPaths) . '@', $uri)){
			// limpa a sessão
			$_SESSION = array();
			// envia para tela de login
			redirect('admin/login/index/sem_permissao');
		}
	}
}

Agora, nosso trabalho dentro da parte de administração será bem mais fácil ;)
No próximo post veremos como organizar nossas views e criaremos nossa tela de login.

@braços e fiquem com Deus!

Criando um catálogo de produtos com Lumine e CodeIgniter.

Como tive vários pedidos para mostrar melhor uma forma de integrar o Lumine com CodeIgniter, resolvi fazer um exemplo um pouco mais complexo, que estaremos montando ao longo de alguns tutoriais.

Neste primeiro artigo, iremos:

Baixar os pacotes necessários e configurando a pasta corretamente;

Criar o banco de dados;

Efetuar a engenharia reversa;

Testar se tudo está correto.

Baixar os pacotes necessários e configurando a pasta corretamente

A pasta raiz durante esta série de tutoriais será a "C:\www\vitrine", sendo "C:\www" o document-root do servidor web.
Sendo assim, a nossa URL padrão será: http://localhost/vitrine/

Para este exemplo, vamos utilizar o Lumine versão 1.6 e CodeIgniter 2.1.0.

Baixe primeiramente o CodeIgniter e descompacte dentro da pasta raiz. Sua estrutura de pastas e arquivos deverá ser:

C:\www\vitrine\application
C:\www\vitrine\system
C:\www\vitrine\user_guide
C:\www\vitrine\index.php
C:\www\vitrine\license.txt

Se quiser, você poderá apagar a pasta "user_guide". Não usaremos ela durante o desenvolvimento.
Feita esta estrutura, baixe o Lumine, versão 1.6

Descompacte os arquivos de Lumine dentro do diretório "C:\www\vitrine\application\libraries\lumine".

A estrutura final deverá ficar semelhante a

C:\www\vitrine\application\libraries\lumine\lib\
C:\www\vitrine\application\libraries\lumine\changelog.txt
C:\www\vitrine\application\libraries\lumine\Lumine.php

Pronto. Agora vamos criar o nosso banco de dados.

Criar o banco de dados.

Crie um banco de dados chamado "vitrine".

Importe a estrutura abaixo para criar as tabelas necessarias.

Este "dump" já vem com um usuário padrao (e-mail: hufersil@gmail.com, senha: "123456").

/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;
/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
/*!40103 SET TIME_ZONE='+00:00' */;
/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;

--
-- Table structure for table `categoria`
--

DROP TABLE IF EXISTS `categoria`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `categoria` (
  `codcategoria` int(11) NOT NULL AUTO_INCREMENT,
  `codpai` int(11) DEFAULT NULL,
  `nome` varchar(100) DEFAULT NULL,
  `permalink` varchar(100) DEFAULT NULL,
  `ordem` int(11) DEFAULT NULL,
  PRIMARY KEY (`codcategoria`),
  KEY `codpai` (`codpai`),
  CONSTRAINT `categoria_ibfk_1` FOREIGN KEY (`codpai`) REFERENCES `categoria` (`codcategoria`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `categoria`
--

LOCK TABLES `categoria` WRITE;
/*!40000 ALTER TABLE `categoria` DISABLE KEYS */;
/*!40000 ALTER TABLE `categoria` ENABLE KEYS */;
UNLOCK TABLES;

--
-- Table structure for table `foto`
--

DROP TABLE IF EXISTS `foto`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `foto` (
  `codfoto` int(11) NOT NULL AUTO_INCREMENT,
  `codproduto` int(11) NOT NULL,
  `thumb` varchar(100) NOT NULL,
  `grande` varchar(100) NOT NULL,
  `ordem` int(11) NOT NULL DEFAULT '1',
  PRIMARY KEY (`codfoto`),
  KEY `codproduto` (`codproduto`),
  CONSTRAINT `foto_ibfk_1` FOREIGN KEY (`codproduto`) REFERENCES `produto` (`codproduto`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `foto`
--

LOCK TABLES `foto` WRITE;
/*!40000 ALTER TABLE `foto` DISABLE KEYS */;
/*!40000 ALTER TABLE `foto` ENABLE KEYS */;
UNLOCK TABLES;

--
-- Table structure for table `produto`
--

DROP TABLE IF EXISTS `produto`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `produto` (
  `codproduto` int(11) NOT NULL AUTO_INCREMENT,
  `codcategoria` int(11) NOT NULL,
  `nome` varchar(200) DEFAULT NULL,
  `permalink` varchar(200) DEFAULT NULL,
  `descricao` text,
  `valor` float DEFAULT NULL,
  `observacoes_tecnicas` text,
  `data_cadastro` datetime DEFAULT NULL,
  PRIMARY KEY (`codproduto`),
  KEY `codcategoria` (`codcategoria`),
  CONSTRAINT `produto_ibfk_1` FOREIGN KEY (`codcategoria`) REFERENCES `categoria` (`codcategoria`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `produto`
--

LOCK TABLES `produto` WRITE;
/*!40000 ALTER TABLE `produto` DISABLE KEYS */;
/*!40000 ALTER TABLE `produto` ENABLE KEYS */;
UNLOCK TABLES;

--
-- Table structure for table `usuario`
--

DROP TABLE IF EXISTS `usuario`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `usuario` (
  `codusuario` int(11) NOT NULL AUTO_INCREMENT,
  `nome` varchar(150) NOT NULL,
  `email` varchar(150) NOT NULL,
  `senha` varchar(32) NOT NULL,
  PRIMARY KEY (`codusuario`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `usuario`
--

LOCK TABLES `usuario` WRITE;
/*!40000 ALTER TABLE `usuario` DISABLE KEYS */;
INSERT INTO `usuario` VALUES (1,'Hugo Silva','hufersil@gmail.com','e10adc3949ba59abbe56e057f20f883e');
/*!40000 ALTER TABLE `usuario` ENABLE KEYS */;
UNLOCK TABLES;
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

Efetuando a engenharia reversa

Com a estrutura do banco de dados criada, fica fácil gerar as classes de acesso.
Para isso, basta efetuar a engenharia reversa que Lumine (http://www.hufersil.com.br/lumine/engenharia_reversa) já oferece.
Acesse pelo browser: http://localhost/vitrine/application/libraries/lumine/lib/ui/reverse.php

Nota: caso apareça a mensagem "Forbidden", é porque existe um arquivo chamado ".htaccess" dentro do diretório "application".
Renomeie este arquivo para poder acessar os arquivos dentro da pasta "application" durante o processo de desenvolvimento.
Quando terminar e for colocar em produção, restaure este arquivo.

Deverá ser exibida a seguinte tela:

Preencha as abas como mostrado abaixo:

Na aba "Tabelas", clique em "Atualizar Tabelas".

Deverão ser exibidas as tabelas em seu banco de dados "vitrine", como na tela abaixo:

Selecione todas elas e clique no botão "Gerar Classes". Você será direcionado para a aba "Log de geração" onde poderá acompanhar o que Lumine está fazendo.

Caso corra tudo sem problemas, a mensagem final deverá ser "Engenharia reversa terminada!".

Nota: o servidor web deverá ter permissão de escrita nas pastas:
C:\www\vitrine\application
C:\www\vitrine\application\libraries
C:\www\vitrine\application\models

Os seguintes arquivos deverão ter sido criados:

C:\www\vitrine\application\lumine-conf.php

C:\www\vitrine\application\libraries\Lumine_ApplicationContext.php

C:\www\vitrine\application\models\Categoria.php

C:\www\vitrine\application\models\Foto.php

C:\www\vitrine\application\models\Produto.php

C:\www\vitrine\application\models\Usuario.php

Confira se estes arquivos foram criados corretamente.

Abra o arquivo "Lumine_ApplicationContext.php" e troque a linha

require_once 'lumine/Lumine.php';

por

require_once APPPATH . '/libraries/lumine/Lumine.php';

e a linha

include 'lumine-conf.php';

por

include APPPATH . '/lumine-conf.php';

Pronto! Agora podemos testar nossa aplicação.

Testar se tudo está correto

Abra a controller padrão que vem com a instalação do CodeIgniter.
Ela deverá estar em "application/controllers/welcome.php".

Apague o método "index" que ela possui e coloque este:

public function index(){
	// trocando o timezone para nao ficar aparecendo varios warnings
	// isto depende da configuracao do servidor, e nao do Lumine ou CodeIgniter
	date_default_timezone_set('America/Sao_Paulo');
	// importando a inicializacao de Lumine
	$this->load->library('Lumine_ApplicationContext');
	// ligando o log
	Lumine_Log::setLevel(3);
	// listando os usuarios
	$userList = new Usuario();
	$userList->find();
	
	while($userList->fetch()){
		echo 'Nome do usuario: ', $userList->nome, '
';
		echo 'E-mail: ', $userList->email, '
';
	}
}

Se aparecer um log e as informações:
Nome do usuario: Hugo Silva
E-mail: hufersil@gmail.com

Significa que está tudo certo!

Na próxima matéria vamos aprender a:

configurar a base do CodeIgniter
criar uma controller base
criar uma controller base de administração
criando a tela de login

@braços e fiquem com Deus!

Geração de imagem com JQuery/JQueryUI e PHP

Ajudando uma pessoa no fórum do iMasters, fiz um exemplo bem bacana de como gerar imagens com feedback visual de Drag-Drop.

Assim, a pessoa monta uma imagem composta por outas imagens. Bem simples porém bem divertido e fácil de fazer.

Vamos ver como fazê-lo!

Iremos criar apenas dois arquivos e duas pastas para esta tarefa. As pastas são:

imagens - coloque suas imagens originais aqui
geradas - pasta onde as imagens geradas serão salvas. Não esqueça de alterar o permissionamento para escrita.

Depois de criar as pastas, vamos criar os arquivos. Os arquivos devem estar no mesmo nível das pastas.

Arquivo de entrada e composição das imagens (index.php).

Imagens

Arraste as imagens da direita para a "área do papel" abaixo

Como podemos ver, este arquivo é composto apenas de HTML, CSS e JavaScript. Simples e direto.

Agora, vamos criar o arquivo que gera as imagens compostas (gerar.php):

Como podemos ver, são dois arquivos simples e pequenos, fáceis de serem alterados para suas necessidades!

Você pode conferir um exemplo online ou baixar os arquivos do tutorial na seção de exemplos.

@braços e fiquem com Deus!

Exemplo de questionário

Fala galera.

Ajudando uma pessoa no fórum do iMasters / PHP esses dias atrás, fiz um para ele um exemplo de como criar um questionário e gravar as opções selecionadas.

O usuário também pode definir quantas opções podem ser selecionadas dentro de cada pergunta.

Também fiz um exemplo de como extrair os resultados do questionário.

O exemplo pode ser baixado na seção de exemplos.

@braços e fiquem com Deus!

Exemplo de Jogo: Nave

Mais um exemplozinho de jogo em HTML + JS + CSS:

Link do Jogo

Link do JS

@braços e fiquem com Deus!