Instalando o Smarty Template Engine

Instalando o Smarty Template Engine

Para instalar a última versão do Smarty, precisamos ter instalados o servidor apache e php5, que são os pré-requisitos, dessa instalação.

O primeiro passo é ter o smarty em nosso ambiente de trabalho, para isso basta fazer o download dele no site: http://smarty.php.net ou diretamente: http://www.smarty.net/do_download.php?download_file=Smarty-2.6.25.tar.gz

depois de ter feito o download do smarty, é necessário descompactar os arquivos, geralmente em um diretório, onde poderá ser acessado por várias aplicações, por exemplo:

windows: C:/smarty
linux: /var/www/smarty

pronto, o smarty está instalado!

Bom, agora que já temos o smarty instalado, vamos ao segundo passo.

A dica é: alterar o arquivo "php.ini", e colocar o smarty na propriedade "include_path", vamos ver um exemplo:

windows: include_path = ".;C:/smarty/libs"
linux: include_path = ".;/var/www/smarty/libs"

pronto, agora que está instalado e configurado, nada pode dar errado.

só precisamos ver ele funcionando pela primeira vez "só pra acreditar que só precisamos fazer isso para o smarty funcionar".

agora vamos criar uma aplicação no seguinte diretório:
"DOCUMENT_ROOT/app"

Dentro desse diretório vamos criar os seguintes diretórios:
"DOCUMENT_ROOT/app/smarty/templates" // onde colocaremos nossos arquivos .tpl (templates)
"DOCUMENT_ROOT/app/smarty/configs" // onde colocaremos nossas configurações
"DOCUMENT_ROOT/app/smarty/templates_c" // onde o smarty colocará os templates compilados
"DOCUMENT_ROOT/app/smarty/cache" // onde o smarty guardará o cache dos templates

Atenção: se estiver usando um SO linux, altere as permissões dos diretórios, da seguinte maneira:

chown apache:apache "DOCUMENT_ROOT/app/smarty/templates_c"
chown apache:apache "DOCUMENT_ROOT/app/smarty/cache"

chmod 775 "DOCUMENT_ROOT/app/smarty/templates_c"
chmod 775 "DOCUMENT_ROOT/app/smarty/cache"

Agora que temos toda nossa estrutura de diretórios montada, vamos criar dois arquivos:

"DOCUMENT_ROOT/app/index.php"

nesse caso podemos criar assim:
"DOCUMENT_ROOT/app/smarty/templates/index.tpl"
ou (como eu prefiro) assim:
"DOCUMENT_ROOT/app/smarty/templates/index/index.tpl"

Abra o arquivo "DOCUMENT_ROOT/app/index.php"
e coloque o seguinte código, alterando apenas "DOCUMENT_ROOT":
// smarty
require('Smarty.class.php');

$smarty = new Smarty;

$smarty->template_dir = 'DOCUMENT_ROOT/app/smarty/templates';
$smarty->config_dir = 'DOCUMENT_ROOT/app/smarty/config';
$smarty->cache_dir = 'DOCUMENT_ROOT/app/smarty/smarty_cache';
$smarty->compile_dir = 'DOCUMENT_ROOT/app/smarty/smarty_templates_c';

$smarty->assign('mensagem','Olá mundo!');

$smarty->display('index/index.tpl');
?>

salve o arquivo.

Abra o arquivo "DOCUMENT_ROOT/app/smarty/templates/index/index.tpl"
e coloque o seguinte código:
{$mensagem}

salve o arquivo.

agora abra o Firefox, e na barra de endereços e digite:
"http://localhost/app/index.php"

Surpresas? rafael[dot]armenio[at]gmail[dot]com

Espero que esteja legal e bem explicativo,
um abraço a todos que leram.

Rafael Armenio

Referências:
http://www.smarty.net/quick_start.php
http://news.php.net/php.smarty.dev/2703

Zend Framewor, php CLI

Bom, vou falar sobre um assunto, o qual pode agradar muitas pessoas, pelo que encontrei em minhas consultas em nosso amigão google,
quando precisamos migrar algumas tarefas do sistema da empresa em que trabalho.
Essas tarefas são executadas periódicamente por uma requisiçao http disparada pelo cron do linux utilizando o software "lynx".

A missão foi: Fazer a migração das tarefas para que elas fossem executadas pelo php em modo 'PHP CLI'.

Parece bem simples, não?

Sim, parece sim, mas me deparei com um sério "problema": Nosso sistema foi desenvolvido com base em Zend Framework,
um poderoso framework escrito em php, mas como sabemos, ele foi feito pra trabalhar com requisições http e possui toda sua estrutura preparada para isso.
Me deparando com essa situação, busquei algumas soluções no google, fóruns e outros, porém, não encontrei nada que pudesse resolver esse problema,
o jeito foi partir pra cima do Zend Framework e criar uma solução que resolvesse meu problema.

Depois de algumas horas, programando, fazendo testes, pesquisando e passando um pouco de raiva,
cheguei a uma solução que atendeu todas minhas necessidas,
vou mostrá-la abaixo e espero que ajude muitos que assim como eu,
precisem rodar aplicações desenvolvidas com Zend Framework em PHP CLI.



aqui temos uma estrutura simplificada de um projeto que está utilizando o Zend Framework,
note que temos um arquivo chamado cli.php, que nesse caso substitui o uso de index.php(nosso bootstrap)

.-- document root
|-- meuprojeto
| |-- controllers
| |-- library
| | |-- Meuprojeto
| | | |
| | | `-- Controller
| | | | |
| | | | `-- Request
| | | | | |
| | | | | `-- Cli.php
| | `-- Zend
| |-- models
| `cli.php

No arquivo "cli.php", que deve ficar em "/meuprojeto/cli.php", é onde criamos nosso bootstrap,
note que deve ser um bootstrap bem parecido com o bootstrap utilizado no sistema, porém em modo cli
não podemos fazer uso de views.




No arquivo "Cli.php", que deve ficar em "/meuprojeto/library/Meuprojeto/Controller/Request/Cli.php" temos o código
responsável por simular toda a requisição http em modo CLI, o tratamento é feito em uma string que passamos como parâmetro para arquivo cli.php e recuperamos com "argv" dentro do código.

Após ter os arquivos corretamente colocados em seu diretórios, fica simples executar um script em modo cli, veja como:

php -f cli.php 'autenticacao/login/usuario/rafae/senha/armenio'

o parâmetro passado deve ser idêntico ao que passamos em uma url para a aplicação em modo http.

abaixo temos os arquivos:

arquivo /meuprojeto/cli.php
<?php
ini_set('display_errors',true);

error_reporting(E_ALL|E_STRICT);

define('DOCUMENT_ROOT', '/var/www/html/');
define('PROJECT', 'meuprojeto');

set_include_path(get_include_path() .
DOCUMENT_ROOT . PROJECT . '/library' .
DOCUMENT_ROOT . PROJECT . '/models' .
DOCUMENT_ROOT . PROJECT . '/controllers');

date_default_timezone_set('America/Sao_Paulo');

include_once('Zend/Loader.php');

Zend_Loader::registerAutoload();

// aqui está o segredo, basta adicionar essas linhas em seu bootstrap original
if( ! isset($_SERVER['argv'][1]) ){
$_SERVER['argv'][1] = 'index/index';
}

$requestCli = new Meuprojeto_Controller_Request_Cli($_SERVER['argv'][1]);
$requestCli->run();
?>

arquivo /meuprojeto/library/Meuprojeto/Controller/Request/Cli.php
<?php
/**
*
* @author Rafael Armenio <rafael.armenio@gmail.com>
*
*/
class Meuprojeto_Controller_Request_Cli{
/**
* query string
*
* @var string $_queryString
*/
private $_queryString = 'index/index';

/**
* nome do controlador
*
* @var string $_controllerName
*/
private $_controllerName = 'index';

/**
* nome da ação
*
* @var string $_actionName
*/
private $_actionName = 'index';

/**
* contrutor da classe
*
* @param $queryString
* @return void
*/
public function __construct($queryString = '')
{
$this->setQueryString($queryString);
}

/**
* faz a execução
*
* @param $queryString
* @return void
*/
public function run($queryString = '')
{
$this->setQueryString($queryString);

$request = $this->getRequest();

$controller = $this->getControllerName();
$action = $this->getActionName();

$httpRequest = new Zend_Controller_Request_Http();
$httpResponse = new Zend_Controller_Response_Http();

if( ! empty($request) ){
$httpRequest->setParams($request);
}

$requestController = new $controller($httpRequest, $httpResponse);
print_r($requestController);
$requestController->$action();
}

/**
* _getFormatedName
*
* @param $name
* @return string
*/
private function _getFormatedName($name){
if( ! empty($name) ){
$arr = explode('-', $name);

for( $i=1; $i<count($arr); $i++ ){
$word = '-' . $arr[$i];
$name = str_replace($word, ucfirst($arr[$i]), $name);
}

$name = (string) $name;
}

return $name;
}

/**
* setQueryString
*
* @param $queryString
* @return void
*/
private function setQueryString($queryString)
{
if( ! empty($queryString) ){
$this->_queryString = (string) $queryString;
}
}

/**
* getQueryString
*
* @return string
*/
public function getQueryString()
{
return $this->_queryString;
}

/**
* setControllerName
*
* @param $controllerName
* @return void
*/
private function setControllerName($controllerName)
{
if( ! empty($controllerName) ){
$this->_controllerName = (string) ucfirst($this->_getFormatedName($controllerName) . 'Controller');
}
}

/**
* getControllerName
*
* @return string
*/
public function getControllerName()
{
return $this->_controllerName;
}

/**
* setActionName
*
* @param $actionName
* @return string
*/
private function setActionName($actionName)
{
if( ! empty($actionName) ){
$this->_actionName = (string) ($this->_getFormatedName($actionName) . 'Action');
}
}

/**
* getActionName
*
* @return string
*/
public function getActionName()
{
return $this->_actionName;
}

/**
* faz a manipulação da query string e retorna um array de parâmetro passados
* pelo usuário
*
* @return array
*/
private function getRequest()
{
$queryString = $this->getQueryString();

$arrParam = explode('/', $queryString);

$this->setControllerName($arrParam[0]);
$this->setActionName($arrParam[1]);

$params = array();
for($i=2;$i<count($arrParam);$i+=2){
if( (! isset($arrParam[$i])) || (empty($arrParam[$i])) ){
$arrParam[$i] = 'index';
}
if( (! isset($arrParam[$i+1])) || (empty($arrParam[$i+1])) ){
$arrParam[$i+1] = 'index';
}
$params[$arrParam[$i]] = $arrParam[$i+1];
}

return $params;
}
}
?>

espero que todos gostem e ainda ter simplificado e ajudado aqueles que precisavam de uma solução.

Rafael Armenio.

Zend Framework, trabalhando com os modelos

pessoal, descobri uma nova "manha" no Zend Framework para trabalhar com os modelos.

olha só, a idéia é trabalhar num estilo "ActiveRecord" do nosso modelo, que já vêm implementado no nosso Zend Framework, por padrão.

nesse primeiro exemplo, faço a citação de como incluir um novo usuário em minha tabela user, em meu banco de dados.

vamos ao código:

//criamos uma nova instância do nosso modelo "User", para manipular a tabela user do banco de dados
$user = new User();
//aqui é onde solicitamos do modelo um novo objeto, aqui chamado de $myUser, com os seu atributos vazios
$myUser = $user ->fetchNew();
//aqui é onde vamos trabalhar com os dados do usuário, preenchemos seus atributos da seguinte forma:
$myUser->name = 'meu nome';
$myUser->n = n;
//enfim fazemos a persistência dos dados, usando a seguinte linha de código:
$myUser->save();

Bom, agora só faltam duas coisas: alterar e excluir esses dados, vamos direto ao assunto:
a alteração, pode ser feita da seguinte maneira:

//criamos uma nova instância do nosso modelo "User", para manipular a tabela user do banco de dados
$user = new Entity();
//aqui é onde solicitamos do modelo um novo objeto, aqui chamado de $myUser, com os seu atributos preenchidos de acordo com os dados da
//tabela que está em nosso banco de dados
$myUser= $user ->fetchRow('id=1', 'id');
//alteramos apenas os atributos que nos interessar, nesse caso, vamos alterar apenas o nome do usuário, é bem simples, veja:
$myUser->name = 'meu novo nome';
//enfim fazemos a persistência dos dados, usando a seguinte linha de código:
$myUser->save();

Enfim, chegamos a parte mais fácil, a exclusão, vejamos como funciona:

//criamos uma nova instância do nosso modelo "User", para manipular a tabela user do banco de dados
$user = new Entity();
//aqui é onde solicitamos do modelo um novo objeto, aqui chamado de
$myUser, com os seu atributos preenchidos de acordo com os dados da
//tabela que está em nosso banco de dados
$myUser= $user ->fetchRow('id=1', 'id');
//enfim fazemos a exclusão dos dados, usando a seguinte linha de código:
$myUser->delete();



Simples, não?
essa é mais uma das facilidades que o Zend Framework nos oferece entre tantas outras,
espero ter ajudado,
Rafael Armenio.