HUFERSIL.WEBDEVELOPER

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!

Deixar uma resposta

O seu endereço de email não será publicado. Campos obrigatórios marcados com *

*

Pode usar estas etiquetas HTML e atributos: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong> <pre lang="" line="" escaped="" highlight="">