Bar do Zend

Esta é minha casa mesmo ? :: Tirando o 'public' da url no Zend Framework 2

2013-08-25T18:53:00.000-07:00

Quem já já experimentou o Zend ( tanto o 1 quanto o 2 ) sabe que toda a festa rola na pasta 'public' da raiz de seu projeto, já que o 'index.php' fica lá.

Isso é uma situação muito chata, porque primeiramente, é feio aquele 'public' na url, e segundo porque é mais seguro manter o 'index.php' dentro da pasta 'public'.

eu já tinha ensinado aqui no Bar do Zend como se procede para tirar o 'public' no caso do ZF1, então agora é a vez de fazer o mesmo no ZF2.

Para isso, tenha certeza que seu seu servidor web esteja configurado com o module 'rewrite'. Uma googlada por ai você pode achar a configuração certa para seu caso.

Certificando que o servidor está ok, criamos um arquivo '.htaccess' na raiz do projeto:

RewriteEngine On
RewriteBase /meuprojetozf2
RewriteCond %{REQUEST_FILENAME} -s [OR]
RewriteCond %{REQUEST_FILENAME} -l [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^.*$ - [NC,L]
RewriteRule ^.*$ index.php [NC,L]

O endereço da raiz do projeto é aquele logo após seu domínio ( ex: http:///meusite.com/meuprojetozf2 ), ou após 'localhost' ( ex: http://localhost/meuprojetozf2 ) se estiver num servidor local. Caso o projeto esteja já na raiz do dominio, uma barra '/' já é suficiente.

Agora, criemos na raiz do projeto uma arquivo 'index.php' :

<?php
define('RUNNING_FROM_ROOT', true);
include 'public/index.php';

E pronto, pode acessar seu projeto e a sua url vai estar livre do 'public'.
Agora, um porém. Todos os arquivos que estão contidos na pasta 'public' ( como os css, imagens e javascript ) deverão ser ter seus endereços acrecidos de 'public', pois para fins práticos, o aplicativo está rodando a partir da raiz, e não da pasta 'public'.

Então é isso, até a próxima.

Novas biritas : Introdução ao Zend Framework 2 - Parte 3 - 1 - Rotas, links e menus

2013-08-18T15:35:00.000-07:00

Chegamos agora ao ponto onde você criou centenas de 'controllers' e outras dezenas de 'actions', e então faz-se necessário colocar tudo isso em menus ou links por ai.
Para conseguir organizar essa fauna de conteudos, o zf2 disponibiliza as 'routes' ( rotas em inglês, para quem não sabe ).
As 'routes' servem para fazer um mapeamento ou busca nas urls o caminho do conteudo desejado.

Para fazer uma rota, você precisa editar o arquivo do seu módulo 'module/Meumodulo/config/module.config.php' .

Dentro desse arquivo, você encontrara o array

return array(
    ...
    'router' =>array(
          'routes' => array(
                     ...
          ),
    ),
    ...
);

A variável 'router' é a variável que define o roteamento das páginas. Um modo de ficar mais simples de organizar esse array ( que pode ficar enorme conforme vai acrescentando coisas ), é separar o array do router assim:

// Você declara e preenche a variável '$router' antes do 'return'
$router = array(
          'routes' => array(
                     ...
          ),
);

// E aqui o array de configuração do módulo
return array(
    ...
    'router' => $router,
    ...
);

Bom, sabendo da localização, vamos ver como usar isso. Primeiro temos de criar uma rota, que consiste na seguinte forma

$minharota= array(          
    'type' => 'Zend\Mvc\Router\Http\Literal',
    'options' => array(
        'route' => '/endereco/de/minha/rota',
        'defaults' => array(
            'controller' => 'Meumodulo\Controller\Meucontroller',
            'action'     => 'minhaaction',
        ),
    ),
);

Explicando:

type : define o tipo da rota. Aqui é o tipo 'Literal', que nada mais é que dizer explicitamente qual o módulo, controller e action do conteúdo.

route : esse é um alias, um endereço qualquer que você mesmo escolhe que deve ser digitado na url para acessar o conteúdo. Se você quiser que o conteúdo do action 'index' do controller 'index' do modulo 'application' apareça na url '/texto' ou '/esta/e/uma/url/estupidamente/grande' , basta colocar na variável route e digitar na url esses endereços bizarros que vai aparecer o conteúdo de '/application/index/index/'

defaults : aqui é definido o endereço REAL do conteúdo que deve ser acessado. Nas rotas literais, esse é o único endereço da rota, nas rotas do tipo 'segment' esse é um valor a ser chamado por padrão, isso será explicado daqui a pouco.

controller e action : bom, está claro o que são esses valores. Com ênfase na parte do controller, onde você precisa definir o módulo da qual o controller pertence.

Bom, assim que você cria sua rota, você adiciona aos 'routes'

$router = array(
    'routes' => array(
        'minharota1' => $minharota1,
        'minharota2' => $minharota2,
        ...
    ),
);

O nome 'minharota1' e a variável '$minharota1' e seguinte, não precisam ter o mesmo nome. Isso é uma padrão que eu adotei para facilitar a organização da configuração e melhor explicar nesse tutorial como funciona a coisa.

Na verdade você pode evitar essas variáveis e jogar como arrays puros diretamente na varável 'router' da configuração.

Uma coisa imprescindível é definir uma rota literal para sua página inicial do aplicativo. Sim, bom do zendo que não precisa ser necessariamente o 'application\index\index' o endereço inicial, você pode definir uma route para a página inicial. No geral ela vem assim

$home = array(
    'type' => 'Zend\Mvc\Router\Http\Literal',
    'options' => array(
        'route' => '/',
        'defaults' => array(
            'controller' => 'Application\Controller\Index',
            'action'     => 'index',
        ),
    ),
),

e o que define a página inicial não é o nome 'home', mas sim a variável 'route' ser definida como '/' - o diretório raiz onde teremos

$router = array(
    'routes' => array(
        'home' => $home,
        'minharota1' => $minharota1,
        'minharota2' => $minharota2,
        ...
    ),
);

Agora, uma vez criadas as rotas e colocadas no config certo, você pode digitar os endereços definidos nas variáveis 'routes' para testar.

O tipo de rota literal é a mais simples, e boa para sites simples. Para sites um nível a mais de complexidade, os endereços são mais dinâmicos e envolve variáveis. Para isso existe a rota do tipo 'Segment'.

O tipo 'Segment' segue a seguinte estrutura

$minharotasegment= array(          
    'type' => 'Zend\Mvc\Router\Http\Segment',
    'options' => array(
        'route' => '/algum/endereco[/:var]',
        'constraints' => array(
            'var' => '[a-zA-Z0-9_-]*', // Define o regexp de busca desejado
        ),
        'defaults' => array(
            'controller'    => 'Meumodule\Controller\Meucontroller',
            'action'        => 'meuaction',
            'var' => '123abc',
        ),
    ),
);

Aqui como podemos ver, temos uma mudança na variável 'route'. o termo '[:var]' define uma variável a ser digitada na url e tratada pelo zend no action 'meuaction' do controller 'Meucontroller' definido na variavel 'defaults'. Ainda em 'defaults', definimos um valor padrão para 'var' caso esse não tenha sido fornecido na url. Caso não precise de um valor padrão, basta apagar do 'defaults'.

Agora, para pegar o valor de 'var' da url, basta usar no controller definido no 'defaults' o helper

$var = $this->params('var');

Podemos definir varias variáveis no route

'route' => '/algum/endereco[/:var1[/:var2[/:var3]]]',

e basta declará-las em 'constraints' juntamente com o pattern desejado e no 'defaults' os valores padrões.

Ainda podemos fazer um mix de rota com variáveis

'route' => '/trecho1[/:var1[/trecho2[/:var2[/trecho3[/:var3]]]]]',

e qualquer outra combinação que lhe venha a cabeça.

Para entender o essa route, só ver que tudo que estiver entre colchetes '[ ]' é considerado opcional, e tudo que vier depois do dois pontos ':' é o nome da variável. Portanto, não escreva nada atrás do nome da variável que não seja o colchete de fechamento ']'.

Também podemos ( e na maioria das vezes vamos ) usar variáveis pré-definidas no zend. Duas delas são o ':controller' e o ':action'. Numa rota seriam usados assim:

$minharotasegment=array(
    'type'    => 'Zend\Mvc\Router\Http\Segment',
    'options' => array(
        'route'    => '/endereco/segment/[:controller[/:action]]',
        'constraints' => array(
            'controller' => '[a-zA-Z][a-zA-Z0-9_-]*',
            'action'     => '[a-zA-Z][a-zA-Z0-9_-]*',
       	),
	'defaults' => array(
            'controller' => 'Meucontroller',
            'action'     => 'meuaction', 
        ),
    ),
);

onde vemos que podemos definir variáveis que chamem por um controller ou por um action na rota definida. Na verdade é isso que é feito por padrão no SkelettonApplication do Zend, ele define a rota da raiz '/[:controller[/:action]]' onde a sequência digitada é o controller e o action, como sempre foi no zend, apenas que agora as rotas dão liberdade para você definir o caminho como você precisar com mais poder. Não que não desse para fazer isso no ZF1, mas que enquanto no ZF1 isso era apenas uma regalia, agora no ZF2 é rotineiro.

Entremos na última parte sobre rotas nesse tutorial, as subrrotas. As subrotas são parecidas com as rotas segment, mas na verdade você pode considerá-las como um 'subconjunto' de uma rota pai que é segment ou literal. Uma subrota é definida assim:

$minhasubrrota=array(
    'type'    => 'Zend\Mvc\Router\Http\Literal',
    'options' => array(
        'route'    => '/endereco/da/subrrota',
        'constraints' => array(
            'controller' => 'Meumodulodasubrrota\Controller\Meucontrollerdasubrrota',
            'action'     => 'meuactiondasubrota',
       	),
    ),
);

enfim, você na verdade cria uma rota como qualquer outra, com a diferença que ela vai ser colocada aqui:

$minharota=array(
    'type' => 'Zend\Mvc\Router\Http\Literal',
    'options' => array(
        'route'    => '/application',
        'defaults' => array(
            '__NAMESPACE__' => 'Application\Controller',
            'controller'    => 'Index',
            'action'        => 'index',
        ),
    ),
    'may_terminate' => true,
    'child_routes' => array(
        'minhasubrota' => $minhasubrrota,
    ),
);

Como funciona isso ? Você simplesmente vai digitar na url '/endereco/da/rota' que vai aparecer o conteudo do controller e action no default, mas se voce digitar '/endereco/da/rota/endereco/da/surrota' vai aparecer o conteudo definido no controller e action do default da subrrota. A vantagem disso é que você pode colocar muitas subrrotas sob uma mesma rota:

$minharota=array(
    'type' => 'Zend\Mvc\Router\Http\Literal',
    'options' => array(
        'route'    => '/application',
        'defaults' => array(
            '__NAMESPACE__' => 'Application\Controller',
            'controller'    => 'Index',
            'action'        => 'index',
        ),
    ),
    'may_terminate' => true,
    'child_routes' => array(
        'minhasubrota1' => $minhasubrrota1,
        'minhasubrota2' => $minhasubrrota2,
        'minhasubrota3' => $minhasubrrota3,
        ...
    ),
);

de forma que cada rota vira um conjunto de subrrotas. Nos exemplos aqui em cima fizemos com rotas tipo 'Literal', mas tanto a rota quanto as subrrotas podem ser de qualquer tipo. E adiantando aqui, subrrotas são uma mão na roda na hora de criar submenus, se é que não foram feitas pensando nisso.

Bom, então, uma vez definidas as rotas , podemos localizar o conteudo de nosso aplicativo. Como a criação de rotas possuem várias possibilidades, crie uns 2 ou 3 controllers e uns 2 ou 3 actions em cada um deles e brinque criando suas rotas. No próximo parte dessa parte faremos uso de links, zf2 navigation e breadcrumbs.

Até lá.

Novas biritas : Introdução ao Zend Framework 2 - Parte 2 - Criando seus controllers

2013-03-25T13:35:00.001-07:00

Na parte 1 dessa série de tutoriais, mostrei como criar as actions e as views no controller padrão do módulo padrão do ZF2. Nesta segunda parte, vou ensinar como criar seus controllers.

A bem da verdade, é muito fácil.

Na pasta 'module/Application/src/Application/Controller', crie seu controller com o nome que desejar. Aqui usaremos 'Meucontroller' e criaremos o arquivo 'MeucontrollerController.php'.
Copie todo conteudo do arquivo 'IndexController.php' da mesma pasta. Apenas apague os actions que tem lá - que você pode ter feito a partir do tutorial anterior - deixando apenas o 'indexAction()'.

Apague o conteudo do 'indexAction()' que agora você terá o mínimo que precisa para ter um controller funcional.
Agora crie a pasta das views desse controller 'module/Application/view/application/user' e dentro dessa pasta crie o arquivo 'index.phtml', que é a 'view' do 'indexAction()' do controller 'Meucontroller'.

E para finalizar, vamos rotear o controller para que ele funcione no módulo 'Application'

Para isso, abre o arquivo de configuração do módulo 'module/Application/config/module.config.php'

Dentro desse arquivo, encntre a sessão:

    'controllers' => array(
        'invokables' => array(
            'Application\Controller\Index' => 'Application\Controller\IndexController',
        ),
    ),

e apenas acrescente a linha

    'controllers' => array(
        'invokables' => array(
            'Application\Controller\Index' => 'Application\Controller\IndexController',
            'Application\Controller\Meucontroller' => 'Application\Controller\MeucontrollerController'
        ),
    ),

Acrescente algum conteudo na views 'index.phtml' de 'Meucontroller' e entre na url:
```
http://localhost/meuprojeto/application/meucontroller/index
```

Se você viu seu conteudo do 'index.phtml' no navegador, então você fez tudo corretamente, e poderá fazer o mesmo processo para criar mais controllers, e junto com tutorial anterior, criar mais actions para cada um deles.

No próximo tutorial vamos tratar de rotas, links e navigation.

Até lá.

Novas biritas : Introdução ao Zend Framework 2 - Parte 1 - Instalação e zf2tool

2013-03-25T11:52:00.001-07:00

Eis que agora temos a nova versão do Zend Framework - o ZF2.

Eu confesso que olhando o bicho, minha impressão é que ele é um pouco mais complicado de configurar que o ZF1, então tentei usar outro framework escolhido por motivos profissionais ( não vou falar qual é o concorrente, humft ! ).

Esse se mostrou tão mais complica do quanto o ZF2, então resolvi voltar ao velho framework.

As vantagens de se usar o ZF2 são as mesmas de sempre: padronização, modularização etc. Então, escolhido usar o ZF2, vamos trabalhar.

Para começar, devemos ter a mão o zf2tool. Para quem não sabe, o zf2tool é uma ferramenta de linha de comando que nos permite criar nosso projeto e seus componentes automaticamente usando a shell ao invés de criarmos cada coisinha a mão.

Baixe o zf2tool do endereço http://packages.zendframework.com/zftool.phar.

Salve esse arquivo 'zftool.phar' na sua pasta de executaveis do sistema, ou coloque numa pasta que esteja em seu PATH.

Agora, vamos trablhar com ele.

Crie seu projeto ( aqui chamamos de 'meuprojeto' mesmo ):
```
$ zf create project meuprojeto
```
e assim será criado uma pasta de nome "meuprojeto " com o "esqueleto" do zf2.
Se você percebeu, ao terminar o comando acima, foi mandado que você entre na pasta e execute o comando:
```
$ composer.phar install
```
Pois bem, faça isso.

Caso você não tenha o composer instalado, baixe-o daqui http://getcomposer.org/.
Se tudo deu certo, entre na url de seu projeto no navegador
```
http://localhost/meuprojeto
```
e se você ver a página de boas vindas do ZF2, então está tudo ok até agora.
Aogra, para dar o gostinho de quero mais, vamos criar a coisa mais básica no zf2 : uma 'action'.

Para isso, temos de ter em mente 3 arquivos:
- module/Application/src/Application/Controller/IndexController.php
- module/Application/view/application/index/index.phtml
- module/Application/view/application/layout/layout.phtml
Onde vemos aqui que o primeiro é o controller padrão da aplicação, na segunda linha temos a 'view' para o 'indexAction' e a terceira linha é o arquivo de layout do site.

Você pode brincar a vontade com esses arquivos para ver como é a coisa.
No controller 'IndexController.php', crie uma action com o nome que quiser ( aqui usaremos 'minhaaction' ):
```
function minhaactionAction(){
    print "Alô mamãe !";
}
```
Agora, crie uma 'view' para 'minhaaction' na pasta 'module/Application/view/application/index' de nome 'minhaaction.phtml', e escreva algo dentro.
Agora, no seu navegador, digite a url
```
http://localhost/meuprojeto/application/index/minhaaction
```
e se aparecer escrito "Alô, mamãe !", você acabou de criar sua action.

E pronto, agora você está apto a criar um site beeeem simples com o zf2, já que o processo de criação de mais 'actions' e mais 'views' segue o mesmo esquema.

Na parte 2 eu vou ensinar como criar seus controllers. Até lá.

Tô vendo tudo em dobro : Como utilizar dois ou mais banco de dados ao mesmo tempo com Zend

2012-11-06T07:30:00.001-08:00

Muita gente tenta criar uma aplicação e se depara com o fato de ter de utilizar mais que um banco de dados ao mesmo tempo.

Uma situação típica : existe um aplicativo ( que não foi você quem fez ) que têm um banco de dados próprio e você não pode alterar os dados dele, somente ler.

Mas ao mesmo tempo você precisa usar esses dados para seu ERP feito em Zend, e não pode alterar o banco de dados do outro aplicativo, pois você precisa de um gerenciamento de usuários do seu ERP por exemplo.

Neste caso, você precisará criar um banco de dados próprio para seu ERP, e trabalhar junto com o banco de dados do outro aplicativo.

Então, vem a pergunta natural : como faço isso no Zend ? A resposta é surpreendentemente simples.

Para este post, considere dois banco de dados : 'db1' e 'db2'. O banco de dados 'db1' é do tipo 'dbtype1' ( onde 'dbtype1' pode ser o mysql, postgres, mssql, etc ) e o 'db2' seria do tipo 'dbtype2'.

No arquivo 'application/configs/application.ini' de seu projeto, configure esses banco de dados assim:

;; application/configs/application.ini

;; Configura o adaptador para 'db1' e o define como o adaptador padrão da aplicação.
resources.resourcealias.dbalias1.adapter  = pdo_dbtype1
resources.resourcealias.dbalias1.host     = host1
resources.resourcealias.dbalias1.username = userdb1
resources.resourcealias.dbalias1.password = passdb1
resources.resourcealias.dbalias1.dbname   = db1
resources.resourcealias.dbalias1.default  = true

;; Configura o adaptador para 'db2'.
resources.resourcealias.dbalias2.adapter  = pdo_dbtype2
resources.resourcealias.dbalias2.host     = host2
resources.resourcealias.dbalias2.username = userdb2
resources.resourcealias.dbalias2.password = passdb2
resources.resourcealias.dbalias2.dbname   = db2
resources.resourcealias.dbalias2.default  = false

Aqui devemos notar que 'resourcealias' é um apelido para esse recurso, 'dbalias1' e 'dbalias2' são apelidos para as conexões, 'pdo_dbtype1' e 'pdo_dbtype1' são os tipo de banco de dados, como 'pdo_mysql' para MySQL, 'pdo_pgsql' para PostgreSQL, etc. O resto é auto-explicativo, espero ...

Pois bem, definido a configuração dos bancos de dados, agora abramos o 'Bootstrap.php' e fazemos um 'inicializador':

public function _initDbRegistry(){

    $this->bootstrap('resourcealias');
    $obj = $this->getPluginResource('resourcealias');
    Zend_Registry::set('adapteralias1', $obj->getDb('dbalias1'));
    Zend_Registry::set('adapteralias2', $obj->getDb('dbalias2'));

}

E agora simplesmente, crie seu model e adicione:

class Meumodel1_Model extends Zend_Db_Table_Abstract {

    protected $_name    = 'uma_tabela_qualquer_do_db1';
    protected $_adapter = 'adapteralias1';

}

class Meumodel2 extends Zend_Db_Table_Abstract {

    protected $_name    = 'uma_tabela_qualquer_do_db2';
    protected $_adapter = 'adapteralias2';

}

E está pronto tudo o que você precisa para utilizar dois bancos de dados totalmente diferentes juntos. Definida a classe, você poderá criar os métodos e objetos de seus modelos como sempre utilizou com Zend, inclusive usando relacionamento de tabelas ( fiz um post sobre isso aqui ) sem problemas.

Eeeee até a próxima.

Referências

Amazium : Using Different Databases with Zend Framework
Zend Manual : Zend Adapter
Zend Manual : Available Resource Plugins

Bota uma branquinha ai :: Habilitando caracteres brancos no campo do formulário

2012-02-19T17:32:00.000-08:00

sso é um probleminha que existe quando queremos habilitar um campo que pode ter um espaço em branco no formulário, como por exemplo, na hora de inscrever um usuário e é pro bendito colocar o nome inteiro dele. Nessa hora, o espaço entre os nomes têm um espaço em branco.

Pra ir bem rápido: você têm no seu form da aplicação Zend um validator

...

'validator' => array('Alpha')

...

Pois bem, para habilitar caracteres brancos no form, basta acrescentar

...

'validator' => array('Alpha', array('allowWhiteSpace' => true))

...

E pronto. Simples assim só mamão com açucar.

Até a próxima.

Referências:

- Standart Filter Class : http://framework.zend.com/manual/en/zend.filter.set.html

Essa é minha casa ? :: Sistema simples de login com Zend

2012-02-12T05:51:00.000-08:00

Esse deve ser o que deixa boa parte dos programadores de Zend com água na boca.
Um sistema de login, é uma das maiores nescessidade quando se colocar seu apĺicativo online e não quer ver fulano mechendo na sua área administrativa que tanto tempo levou pra fazer. Ou quando cria um sistema em que seus usuários fazem coisas escondidas que só eles podem saber ... hehehe
De qualquer forma, um sistema de login é o que vão ter agora.
Primeiro, temo de criar a tabela de usuarios no banco de dados:

CREATE TABLE IF NOT EXISTS 'usuarios' (
'id' int(11) NOT NULL AUTO_INCREMENT,
'login' varchar(255) NOT NULL,
'senha' varchar(255) NOT NULL
PRIMARY KEY ('id')
);

Simples de entender né ?

A partir disso, entre no seu terminal, vá para a pasta de seu aplicativo em Zend, e criemos o formulario de login para colocar na página inicial ( controller index e action index ):

$ zf create form login

Abra o arquivo 'application/forms/Login.php' gerado, e coloque as linhas

class Application_Form_Login extends Zend_Form {

    public function init(){

        // Define a página do action, no caso, o proprio action index de login.
        setAction('index');
 
        // Método de envio do form.
        $this->setMethod('post');
         
        // Nome de usuário.
        $this->addElement('text', 'login', array( 'label'    => 'Login', 
                             'required' => 'true',            
               'validator' => array('noempty')  
                                                )
                         );
 
        // Senha de usuário.
        $this->addElement('password', 'senha', array( 'label'    => 'Senha',
                   'required' => 'true',
                   'validator' => array('noempty')
                                                    )
                         );
        
        // Botão de submissão.
        $this->addElement('submit', 'submit', array('label' => 'Entrar') );
     
    }

}

E agora, no seu controller 'controllers/IndexController.php' escreva as linhas no action 'indexAction'

public function indexAction(){
     
       // Cria o objeto de formulário.
     $loginForm = new Application_Form_Login();

     // É verificado se existem dados enviados via post ( caso de tentativa de login ).

     // Verifica se existem dados enviados via POST.
     if( $this->getRequest()->isPost()  ) {
        
                // Salva os dados enviados via post no array '$data'.
      $data = $this->getRequest()->getPost() ;
 
         // Verifica se os dados são válidos.
         if( $loginForm->isValid($data)  ) {

          // Pega o nome de usuário e a senha enviados pelo POST.
          $login = $loginForm->getValue('login');
                  $pass  = $loginForm->getValue('senha');
                  
             ///////////////////////////////////////////////////////////
             // Pega as informações do adaptador do banco de dados.
             $dbAdapter = Zend_Db_Table::getDefaultAdapter();
                          
             // Inicia o adaptador Zend_Auth para banco de dados.
                // É definido a tabela do db e os campos que serão usados
                // para comparar com os campos de login. 
             $authAdapter = new Zend_Auth_Adapter_DbTable($dbAdapter);
             $authAdapter->setTableName('usuarios')
                     ->setIdentityColumn('login')
                    ->setCredentialColumn('senha')
                     ->setCredentialTreatment('MD5(?)');
                // Aqui, a senha é transformada num hash md5 e só então
                // comparado com a senha registrada no db ( que está em md5 também ).
                // Se você usa SHA1 ou outra codificação, é aqui que vocÊ deve declarar.
                //////////////////////////////////////////////////////////
                 
                ///////////////////////////////////////////////////////////
                // Agora, é comparado os dados digitados com os registrados.
             $authAdapter->setIdentity($login)->setCredential($pass);

                // Pega a instância atual do Zend_Auth.
                $auth = Zend_Auth::getInstance();
                
                // Pega o resultado da comparação dos dados enviados com os registrados.
                $result = $auth->authenticate($authAdapter);
                
                // Caso o resultado seja positivo, o login é efetuado.
                if( $result->isValid() ) {                
                                 
                 // Pega o nome do usuário.
                 $user = $authAdapter->getResultRowObject();
                 
                 // Salva o nome do usuário para uso na sessão.
                 $auth->getStorage()->write($user);
                 
                 // Redireciona para a primeira página após o login.
                 $this->_redirect("index/primeirapagina" );
              
                }
                // Caso não seja positivo ...
                else{
                 
                 // Caso o usuário não esteja registrado, é mostrado uma mensagem mostrando o fato.
                   $this->view->messages = "Não foi possível realizar o login.";
                   
                   // Reimprime o formulário com os dados já digitados.
                   $this->view->loginForm = $loginForm->populate($data);

                }
                ///////////////////////////////////////////////////////////
                                           
           }
           // Caso os dados não foram digitados corretamente, é reimprimido o formulário com os dados para correção.
           else $this->view->loginForm = $loginForm->populate($data);
              
     }
     // Imprime por default o formulário na entrada do site.
     else $this->view->loginForm = $loginForm;
     
}

E a partir desse ponto, você já têm um sistema de login funcional, brinque um pouco com ele para er se está tudo certo, porque agora vamos para a real utilidade de um sistema de login.

Pois bem, se você perceber, ainda pode navegar pelas páginas de sua aplicação Zend sem precisar realizar o login ( digite na url qualquer endereço dela para ver que entra numa boa ainda ).
E a não ser que você tenha um motivo especial para fazer um sistema de login que deixe tudo aberto, o que queremos é impedir o acesso a pessoas não logadas, não ?
Pois bem, a "tranca da porta" de nossa aplicação são essas duas linhas:

// Pega a instância atual do Zend_Auth.
$auth = Zend_Auth::getInstance();
        
// Verifica se o usuário está logado.
if( $auth->hasIdentity() ) { <faz alguma coisa> }

Nessas duas linhas, você verifica se o usuário está logado, se não está, geralmente você o envia para a página inicial, assim

// Pega a instância atual do Zend_Auth.
$auth = Zend_Auth::getInstance();
        
// Verifica se o usuário está logado.
if( $auth->hasIdentity() ) { <faz alguma coisa> }
else $this->_redirect('index/paginainicial');

Essas linhas você pode colocar no action 'init()' de seus controllers que quer restringir acesso - ou em algum action em particular, ou mesmo nas próprias views - e já terá garantido a um pouco de segurança a sua aplicação.

É isso ai. Não, não acabou. Ainda falta uma coisinha.

Quando você se loga, sua identificação no aplicativo fica salvo na instância do Zend_Auth, e voltar para a página inicial simplesmente não resolve isso, o que pode ser perigoso, pois o usuario se loga, navega, sai, mas seu login continua lá para um outro safado sem vergonha usar brincar de graça na sua aplicação.

Para impedir isso é bem simples também. Criemos uma action no 'IndexController.php' com o nome de 'logoutAction'

$ zf create action logout

e acrescente as seguintes linhas

public function logoutAction(){
     
      // Apaga da instância do Zend Auth a identificação no sistema.
      Zend_Auth::getInstance()->clearIdentity();
    
      // Redireciona para a página inicial do site.
      $this->_helper->redirector('index');
        
}

E assim, no seu layout, crie um link escrito 'logout' que aponte para esse action

<?php
$logoutUrl = $this->view->url(array('controller'=>'index', 'action'=>'logout'), null, true);
            
// Imprime a mensagem de boas vindas com o nome do usuário e o link para logout.
print "<a href=".$logoutUrl.">Logout</a>";
?>

Assim, para sair, basta clicar no link 'logout', e a saida do usuário ficará limpa.

Agora é só se divertir montando seus aplicativos, que atgora terão a devida segurança e privacidade que nescessitam. Até a próxima.

Referências:

- Zend Auth : http://framework.zend.com/manual/en/zend.auth.introduction.html

- Autenticação com Zend Framework : http://fernandomantoan.com/frameworks/zend-framework/autenticacao-com-zend-framework/

Vai no chute mesmo :: Como usar o baseUrl no Bootstrap

2012-02-07T17:15:00.000-08:00

Bom, quem já programa em Zend a um tempinho, já sabe que para usar coisas como css , javascript , etc se faz , no modo Zend de ser, no Bootstrap.

Problema que, para fazer isso, ou você usar o caminho até esses arquivos de modo explícito ( colocando o caminho inteiro na mão ), ou vai se embolar com outros modos de tentar chamar o método 'baseUrl()' do Views Helper.

Mas, para sua sorte, encontrei um jeito de fazer isso de forma rápida e limpa - ainda que exótica - de ter a baseUrl em uma linha só.

No seu 'Bootstrap.php', você pode colocar em qualquer método a linha

 $baseUrl = substr($_SERVER['PHP_SELF'], 0, strpos($_SERVER['PHP_SELF'], 'index.php'));

E pronto ! Você terá sua baseUrl para usar onde quiser e na forma que desejar. Até a próxima.

Essa é minha casa ? :: Instalando Zend Framework no Windows com WAMP

2011-12-14T04:03:00.000-08:00

Bom, muita gente usa Windows para produção - sim, sou linuxer, mas não fanático também - então vou dar um "hint" de como criar um ambiente de produção rápida para o Zend Framework .

E como está no título, vamos fazer isso num Windows com wamp server ( Servidor de Apache, Mysql e Php ) instalado e rodando. Bom, eu não fiz um tutorial ainda de como instalar um wamp, mas é facilmente encontrado no Google um monte de tutoriais, e só pra dizer que deixei na mão, podem seguir esse vídeo tutorial aqui.

Instalado e configurado seu wamp, vamos aos passos:

1) Baixe o Zend Framework aqui. Tem o full e o mínimal, baixe o que você precisar.

2) Descompacte o pacote do Zend na pasta 'C:\wamp\apps'. Eu acho mais prático renomear a pasta para simplesmente 'zendframework', assim nas atualizações não precisa mudar as configurações que iremos fazer depois, mas se você lembrar de mudar as configurações depois, pode deixar como está.

3) Abra o arquivo 'C:\wamp\bin\apache\Apachex.x-x\bin\php.ini' e ache a entrada escrito

; Windows: "\path1;\path2"

e acrescente embaixo a linha assim

; Windows: "\path1;\path2"
include_path = ".;c:\wamp\apps\zendframework\library"

No arquivo 'C:\wamp\bin\php\phpx.x.x\php.ini' faça a mesma coisa. Com isso, o zend library vai estar incluso no PATH do phpe você vai poder usar a biblioteca dele em quyalquer aplicação que você criar em sua máquina. EM SUA MAQUINA , não em outra. Se você fizer uma aplicação na sua máquina e mudar para outro lugar ( um servidor de hospedagem por exemplo ), isso não vai funcionar, a não ser que o outro lugar tenha lido meu artigo :D

4) Agora, configuremos o Zend Tools. Para isso, clique no ícone 'Computador'. Como estou no Windows 7, vai abrir a janela 'Painel de Controle\Sistema e Segurança\Sistema'. Clique no link 'Alterar configurações', e irá abrir a janela 'Propriedades do sistema'.
Clique na aba 'Avançado' e então no botão 'Variáveis de ambiente'. Na janela que abrir, clique na linha com 'PATH'e depois no botão 'Editar'.
Na janela que abrir, coloque no fim do campo o trecho

;C:\wamp\apps\zendframework\bin

Não esquece do ponto e vírgula, que serve para separar caminhos do PATH do Windows, sem isso os dois últimos PATHs não funcionarão.

5) Após isso, abra o 'Power Shell' ou o velho 'cmd', digite

C:\> zf show version

Se aparecer

C:\> zf show version
Zend Framework Version: x.x.x

Então está tudo funcionando e você poderá usar tudo do Zend em seu Windows normalmente.

Até a próxima rodada.

Aperitivo grátis :: Mudando a pasta raiz de sua instalação do Magento

2011-11-27T11:58:00.000-08:00

O Magento é um e-commerce feito em Zend, e como esse site fala de Zend, creio não haver problemas em falar do Magento - tirando o fato que eu uso Magento também =)

Então, como primeira dica sobre Magento, vou explicar como resolver o problema de mudar a pasta de instalação de seu Magento DEPOIS que você instalou-o.

Sim, porque , muitas vezes, queremos fazer umas mudanças em nosso site - seja porque queremos colocar um site apenas como seção de outro site, ou apenas está colocando ordem no host no meio de centenas de pastas ... - e resolvemos isso da seguinte maneira:

Na hora de instalação, o magento cria no banco de dados, uma tabela de nome "*core_config_data".
Nessa tabela, existem dois campos de nomes "web/unsecure/base_url" e "web/secure/base_url".
Se você olhar nesses campos, vai perceber que os valores deles são exatamente o diretório raiz da instalação de seu magento.
Nem precisaria dizer o que fazer, mas como sei que têm programador que vai pro trabalho de porre, ou que gosta de ficar codando de madrugada com aquele sono, vou dizer que mude o valor desses campos para o endereço da nova pasta raíz de sua instalação.
Após mudar no banco de dados, apague todo o conteúdo da pasta "var/cache" e rode o magento.

Uma outra maneira de fazer isso é meio sacana.
Você vai até a pasta "app/etc" e muda o nome do arquivo "local.xml" para "local.xml.bkp" ( ou apague de vez o arquivo, o local.xml.bkp" é só por precaução ).
Agora, rode o seu magento. Ele vai entrar na tela de instalação. Siga a instalação normalmente ( mas mantendo o mesmo banco de dados e o mesmo prefixo das tabelas do magento ).
Ao final, os dados sobre o endereço da pasta nova vão estar atualizados.

Se deu tudo certo, volte ao serviço. Até a próxima.

Referências:

CEREBRUM: Mudando manualmente o base URL do Magento

Você é meu amigo, não é ? :: Relacionamento de tabelas simples com Zend Models

2011-11-19T11:26:00.001-08:00

Mais uma pra tentar facilitar a vida dos zendeiros.

Imaginemos a situação onde temos que cadastrar um carro num db.
Vamos registrar o modelo e a cor.
MAS, em vez de usar um campo de cores direto na tabela dos carros, criamos uma tabela de cores separado ( o que ajudaria muito a criar um 'form select' com as opções de cores, por exemplo ) e depois vamos associar a cada carro da tabela de carros, uma cor da tabela de cores.

Sentiram a situação ?

Pois bem, para esse problema, temos as tabelas e os campos

                    carros     cores

                    id         id

                    modelo     cor

                    id_cor

A idéia é intuitiva: a cada 'id' de 'carros', associamos um 'id_cor' que corresponde ao 'id' da tabela 'cores', e dai queremos pegar o nome da cor correspondente ao 'id' em 'cores'.

Pra fazer isso no Zend é bem simples ( agora que aprendi é simples, claro ¬¬ ).

Criemos dois models: um pra tabela 'carros', e outro pra tabela 'cores':

$ zf create model carros
$ zf create model cores

Pois bem, no model 'Carros.php', temos a classe 'Application_Model_Carros'

<?php

class Application_Model_Carros extends Zend_Db_Table_Abstract {

 protected $_name = 'carros';
 protected $_primary = 'id';
 
}

e no model 'Cores.php', temos a classe 'Application_Model_Cores'

<?php

class Application_Model_Cores extends Zend_Db_Table_Abstract {

 protected $_name = 'cores';
 protected $_primary = 'id';
 
}

onde percebe-se que já definimos as tabelas de cada model e os devidos primary keys.
Agora, pra relacionar o campo 'ide_cores' da tabela carros ao campo 'id' da tabela 'cores', declaramos no model 'Application_Model_Carros' a sua dependencia com a tabela 'cores' assim:

<?php

class Application_Model_Carros extends Zend_Db_Table_Abstract {

 protected $_name = 'carros';
 protected $_primary = 'id';

        // Declara a dependencia da tabela 'carros' com a tabela 'cores' 
        // através do model 'Application_Model_Cores'.
 protected $_dependentTables = array('Application_Model_Cores');
 
}

E acabamos com a parte do model para os carros.
No model 'Application_Model_Cores', devemos criar os relacionamentos entre os campos. Para isso, fazemos

<?php

class Application_Model_Cores extends Zend_Db_Table_Abstract {

 protected $_name = 'cores';
 protected $_primary = 'id';

  protected $_referenceMap = array( 
   'refCores' => array( 
    'refTableClass' => 'Application_Model_Carros',
    'refColumns'    => array('id_cor'),
    'columns'       => array('id')
  )
 ); 
}

onde a variável especial '$_referenceMap' cria o mapa de associação desejado entre as tabelas.
Nos arrays, temos que

'refCores' é apenas um label para esse mapeamento, pode ter qualquer nome que você queira
'refTableClass' é classe da tabela pai que depende da tabela 'cores' ( que é a filha )
'refColumns' é o campo da tabela pai que está relacionado com um campo da tabela filha ( no caso, o campo 'id_cor' da tabela pai se relaciona com o campo 'id' da tabela filha )
'columns' é o campo da tabela filha que é requerido pela relação com o campo 'refColumns' da tabela 'pai'.

E isso finaliza o nosso tratamento com os models.
Agora, no controller onde você vai trabalhar ( usaremos aqui como exemplo 'Dados.php' ), digite no seu action

<?php
class DadosController extends Zend_Controller_Action {

    public function init(){
     /* Initialize action controller here */
    }

    public function indexAction(){
 
 // Criamos o objeto do model da tabela 'carros'. 
 $carrosModel = new Application_Model_Carros();

        // Pegamos o carro de 'id' igual a 3.
 $carros = $carroModel->fetchRow('id=3');

        // Aqui pegamos os campos das cores relativos ao carro de 'id'
        // igual a 3.
 $cores = $carros->findDependentRowSet("Application_Model_Cores");
 
        // Imprime o modelo e a cor do carro de 'id' igual a 3.
 print "Modelo :: ".$carros['modelo'];
        print "Cor :: ".$cores[0]['cor'];

    }

}

O que ocorre é simples: fazemos um 'fetchRow' para pegar os campos do carro de 'id' igual a 3 e salvamos no array '$carros'.
Com o método 'findDependentRowSet' pegamos os campos da tabela 'cores' correspondente ao 'id_cor' do carro, conforme as relações entre tabelas que configuramos e salvamos no array '$cores'.
O resto já conhecemos.
Então, podem ir atacando o zend, que mais essa foi resolvida.
Até a próxima.

Referências:

UOL Host : Zend Framework: Relacionamento de tabelas com o Zend_Db_Table

Zend Manual : Zend_Db_Table Relationships

Que cara é essa ? :: Mudando o layout de suas páginas

2011-10-18T17:47:00.000-07:00

Muito mais que mudar apenas o CSS, as vezes lidamos com a situação em que a própria estrutura da página têm de ser diferente das outras - ou talvez queiramos ( por algum motivo MUITO especial ) que todas as páginas tenham um layout diferente umas das outras.

Um exemplo bem simples é um site com login logo na entrada. Na primeira página, o layout é o apropriado para o login, e as páginas a seguir ao login possuem o layout padrão.

Pois bem, assim como nos outros posts, vou mostrar que a coisa não é um bicho de sete cabeças no Zend.

Primeiro, habilite seus layouts com zend tools

$ zf enable layout

Agora, vai ser cirado na pasta "application/layouts" o arquivo padrão de layout do zend, o "layout.phtml", edite como você quiser.

Nessa mesma pasta, crie um arquivo "layout2.phtml" e edite com o layout alternativo que deseja.

Vá até o controller onde está a action da página onde será aplicado o layout alternativo e coloque nessa action a linha

...
$this->_helper->layout->setLayout('layout2');
...

E pronto. Basta abrir o action e terá seu layout alternativo para ele. Se for usar um css alternativo também, basta colocar na action

...
$this->_helper->layout->setLayout('layout2');
$this->view->headLink()->appendStylesheet( $this->view->baseUrl('caminho_do_css/estilo_alternativo.css' )  );
...

E pode repetir essa situação pra quantas views desejar e pra quantos layouts você quiser.

Felizes ? Espero que sim. Abraços a todos e até a próxima.

Referências:

Felipe Djin : Zend_Layout: Templates no Zend Framework

Zend Manual : Zend_Layout Configuration Options

Pra onde vamos ? :: Modificar os links de suas paǵinas com roteamento estático

2011-10-11T06:48:00.000-07:00

É comum que as vezes precisamos mudar o endereço de uma página em particular de nossa aplicação, de forma a ser mais amigável.

Por exemplo, se tivermos "por acaso" uma url da forma

http://meusite.com/secao1/secao2/secao3/secao4

mas a página "secao4" é tão importante, que precisamos facilitar sua escrita na url ( por questões de SEO ) da forma mais simples possível, assim

http://meusite.com/mysection

ou seja, queremos que a url "secao1/secao2/secao3/secao4" tenha o nome "mysection" mas que aponte para "secao1/secao2/secao3/secao4".

Para fazer isso, é muito simples.
Num cenário de exemplo, temos os seguintes links que queremos mudar as urls

http://meusite.com/secao/subsecao1
http://meusite.com/secao/subsecao2
http://meusite.com/secao/subsecao3

e queremos mudar para

http://meusite.com/mysection1
http://meusite.com/mysection2
http://meusite.com/mysection3

Para fazer isso, coloque em seu 'Bootstrap.php'

//

// Inicializa o rotamento pelo bootstrap.

//

protected function _initRouter(){
		
     // Pega a instância do controller.
     $front_controller = Zend_Controller_Front::getInstance();
     $router = $front_controller->getRouter();
		
     // Cria os alias para os roteamentos.
     $link1  = new Zend_Controller_Router_Route_Static('mysection1',array('controller' => 'secao', 'action' => 'subsecao1') );
     $link2  = new Zend_Controller_Router_Route_Static('mysection2',array('controller' => 'secao', 'action' => 'subsecao2') );		
     $link3  = new Zend_Controller_Router_Route_Static('mysection3',array('controller' => 'secao', 'action' => 'subsecao3') );
		
     // Adiciona as rotas.
     $router->addRoute('myroute1', $link1);
     $router->addRoute('myroute2', $link2);
     $router->addRoute('myroute3', $link3);		
}

Explicando: '$link1' é o roteamento do endereço '/secao/subsecao1' para o nome 'mysection1' e 'myroute1' é o nome do roteamento que você irá usar para o zend_navigation.

Sim, se você criou menus com o zend_navigation, vai ter de mudar umas coisinhas se não quiser ter problema.

Supondo que você criou seus menus com um arquivo xml, então você deve ter uma seção para o link '/secao/subsecao1' dessa forma

Meu Link
secao
subsection1

Agora não têm mistério, basta acrescentar '<route>myroute1</route>' nessa parte de seu xml:

Meu Link
secao
subsection1
myroute1

e o link do menu irá pegar o roteamento para 'secao/subsection1'.
Nos outros links do menu, você DEVE acrescentar '<route>default</route>' , pois se não fizer isso, todos os links do menu vão ser roteados para o último router que você definiu no Bootstrap.

Para outros links normais de seu site que apontem para '/secao/subsecao1', não é preciso modificar nada, pois o roteamento é automatico para eles.

Esse roteamento do zend é estático, isso é, apenas para links que não requerem parâmetros. Para outros tipos de roteamento, aguarde próximos artigos.

Até lá =)

Referências:

Zend Manual : The standart router

Aos seus pés :: Como colocar seu javascript no fim da página

2011-10-09T16:37:00.000-07:00

Quem lida com javascript sabe que de vez em sempre, é uma boa prática colocar o seu script no fim da página.

Com o Zend Framework temos mais essa facilidade, e bota fácil nisso.

Para colocar qualquer código javascript no corpo da página, vá em seu arquivo 'layout.phtml', coloque na parte que deseja o view helper inlineScript

<?php print $this->inlineScript(); ?>

E a partir dai, em qualquer view, acrescente o javascript que precisar dessa forma:

<?php $this->inlineScript()->appendFile($caminhodeseujavascript); ?>

E pronto, o seu script vai ser impresso exatamente na posição onde foi colocado o método inlineScript() no seu layout.

Essa mal teve graça de tão simples. Até a próxima dica.

Referências:

stoimen's web log : Zend Framework: Inject JavaScript Code in a Action/View
Zend Manual : View Helpers

Cut off :: Tirando o 'public' do endereço de sua aplicação Zend

2011-08-17T12:32:00.000-07:00

Essa foi plageada descaradamente do cologa Naner do forum ZendBrasil, e postei aqui porque vivo esquecendo onde acho essas dicas.

Todo mundo que inicia no Zend se depara com o fato de todas as páginas aparecerem com o endereço

http://meusiteemzend.com.br/public/umapagina

e uma hora ou outra, vai querer que o endereço fique em uma forma "bonita" - as chamadas URL's limpas, assim:

http://meusiteemzend.com.br/umapagina

Para fazer isso é rápido e simples.
Na raiz de seu projeto ( o primeiro acima do public ai ), crie um arquivo 'index.php':

<?php

    define('RUNNING_FROM_ROOT', true);
    include 'public/index.php';

Não feche o código com '?>'.
Agora, na mesma pasta raiz, crie um arquivo '.htaccess' com o conteudo:

SetEnv APPLICATION_ENV production

RewriteEngine On
RewriteRule .* index.php

E rode a página. Se deu tudo certo, leia outro post meu, porque foi muito rápido e agora você está com tempo livre. :D

AH, e não se esqueça, se antes você colocava nos links do zend a referencia ao 'public' como '/' somente, agora você deve referenciar como '/public/'.

Referências:

Como remover o /public de seu projeto
Zend Manual: Rewrite Configuration Guide

Garçon, os menus :: Como criar multiplos menus com Zend_Navigation

2011-08-17T11:08:00.000-07:00

No momento que escrevo estas linhas estou ciente que não falei p*$$@ nenhuma sobre Zend Navigation e a criação de menus, mas como na net tá lotado de tutoriais que já falam sobre isso, deixarei pra outro dia pra fazer minha própria versão.

Por hora, quero falar sobre o segundo passo sobre menu : como criar 2 menus. Ambicioso não ?

Para nosso tutorial, usaremos o seguinte arquivo XML para menus em '/application/configs/menus.xml' :

Onde 'nav1' e 'nav2' são dois menus diferentes e independentes que queremos usar onde quisermos quando quisermos.

Para realizar tal intento, criamos no '/application/Bootstrap.php' o inicializador de menus:

...

// Inicializa os menus de navegação.
protected function _initNavigation(){
					
    $nav1Config = new Zend_Config_Xml(APPLICATION_PATH . '/configs/menu.xml', 'nav1');
    $navigation1 = new Zend_Navigation($nav1Config);
    Zend_Registry::set('Navigation1', $navigation1);

    $nav2Config = new Zend_Config_Xml(APPLICATION_PATH . '/configs/menu.xml', 'nav2');
    $navigation2 = new Zend_Navigation($nav2Config);		
    Zend_Registry::set('Navigation2', $navigation2);

}

...

Coloque na action do controller da sua página a declaração

public function indexAction(){

    $Navigation1 = Zend_Registry::get('Navigation1');
    $this->view->navigation1 = $Navigation1;

    $Navigation2 = Zend_Registry::get('Navigation2');
    $this->view->navigation2 = $Navigation2;
    
}

E finalmente, na view de sua página coloque:

Menu nav1<?php

$options1 = array('ulClass' => 'menu1');
print $this->navigation()->menu()->renderMenu($this->navigation1, $options1);

?>

Menu nav2<?php

$options2 = array('ulClass' => 'menu2');
print $this->navigation()->menu()->renderMenu($this->navigation2, $options2);

?>

Os '$optionsN' é um extra que coloquei no tutorial para você poder definir classes para cada menu separadamente, uma reles mãozinha para ajudar a fazer seu design :D

E se tudo deu certo, vai aparecer cada menu do xml separadamente, com seus própios itens, com sua própria classe, e você pode colocar na view que quiser e quando quiser.

Agora, essa solução é pra quando você quer acrescentar menus de uma forma particular em certas páginas.
Um jeito de deixar a solução "global", inclusive pra ser usado com 'zend_layout', basta fazer no 'Bootstrap.php'

...

// Inicializa os menus de navegação.
protected function _initNavigation(){
					
    $nav1Config = new Zend_Config_Xml(APPLICATION_PATH . '/configs/menu.xml', 'nav1');
    $navigation1 = new Zend_Navigation($nav1Config);
    Zend_Registry::set('Navigation1', $navigation1);

    $nav2Config = new Zend_Config_Xml(APPLICATION_PATH . '/configs/menu.xml', 'nav2');
    $navigation2 = new Zend_Navigation($nav2Config);		
    Zend_Registry::set('Navigation2', $navigation2);

    // Até aqui não muda nada. Você apenas precisará acrescentar umas 
    // variáveis para mandar para a view :
    $view->navigation1 = Zend_Registry::get('Navigation1');
    $view->navigation2 = Zend_Registry::get('Navigation2');

}

...

e pronto, basta colocar as linhas

...

Meu menu 1
<?php print $this->navigation()->menu()->renderMenu($this->navigation1); ?>

Meu menu 2
<?php print $this->navigation()->menu()->renderMenu($this->navigation2); ?>

...

com ou sem o '$optionsN' em qualquer view ou no layout que será renderizado o menu que você deseja.

Percebam que a técnica pode ser estendida para quantos menus desejar também,basta ir acrescentando um 'nav3', 'nav4', etc ; e ir seguindo o padrão aqui.

Simples, né ?

Referências:

Silêncio na biblioteca : Como usar outras classes em sua biblioteca customizada

2011-07-01T12:45:00.000-07:00

Escrever suas próprias bibliotecas customizadas é essencial quando se faz certos tipos de aplicação.
Mas o bom de orientação a objetos é que podemos reutilizar as variáveis e métodos já existentes em outras classes, e no caso do Zend, é preferível que utilizemos os métodos já definidos nas classes de sua biblioteca, ou ainda, usar alguma classe de controller, model ou helper que você já fez, porque afinal gastar tempo e espaço ( ainda que seja ridiculamente pequeno ) no HD quando podemos utilizá-los não ?

Pois bem, aqui temos dois modos de se reutilizar uma classe criada na estrutura do Zend.

A primeira é a clássica "extends", o mais comum quando se trabalha com objetos:

class Mylib_Minhaclasse extends ClasseDesejada {

...

}

Dai já pode utilizar os métodos e variáveis da classe desejada como se fosse de sua classe. Bem simples.

Um outro modo muito legal que descobri também para utilizar qualquer biblioteca sem precisar extender é esse:

1 - Declare o construtor de sua classe

class Mylib_Minhaclasse {

    public function Mylib_Minhaclasse(){


    }

...

}

2 - Dentro do construtor, chama explicitamente a classe que quer usar usando 'require_once'

class Mylib_Minhaclasse {

    public function Mylib_Minhaclasse(){

          require_once( APPLICATION_PATH."/caminho_pra_classe_desejada/ClasseDesejada.php");

    }

...

}

3 - Crie uma variável na sua classe para criar o objeto da classe desejada:

class Mylib_Minhaclasse {

    protected $obj = null;

    public function Mylib_Minhaclasse(){

          require_once( APPLICATION_PATH."/caminho_pra_classe_desejada/ClasseDesejada.php");
          $obj = new ClasseDesejada.php

    }

...

}

4 - Agora, inicializa o objeto da classe desejada usando o método 'init':

class Mylib_Minhaclasse {

    protected $obj = null;

    public init(){

        $this->Mylib_Minhaclasse();

    }

    public function Mylib_Minhaclasse(){

          require_once( APPLICATION_PATH."/caminho_pra_classe_desejada/ClasseDesejada.php");
          $obj = new ClasseDesejada.php

    }

...

}

E pronto, já pode usar em sua biblioteca customizada qualquer classe que desejar sem precisar extender nada. Achei legal assim, porque você pode usar mais de uma classe, o que extendendo limita a somente uma, e de certo modo, deixa sua classe mais "pura".

Referências: http://framework.zend.com/manual/1.11/en/performance.classloading.html

HELP ! :: Criando Views Helpers no Zend Framework

2011-06-12T20:56:00.000-07:00

Os View Helpers são classes extras que você usa para realizar certas tarefas específicas nas views. Ou seja, como o próprio nome diz, eles servem para auxiliar nas views.
Para criar uma View Helper, basta ir na pasta 'application/views/helpers' criar uma classe 'Minhaviewhelper.php', e no conteúdo coloque

class Zend_View_Helper_Minhaviewhelper extends Zend_View_Helper_Abstract {
  
         public function minhafuncaoviewhelper(){

                       ...

         }
  
}

E pronto, basta ir a qualquer controller e usar

class MeucontrollerController extends Zend_Controller_Action {

                      ...

             public function minhafuncao(){

                      ...

                     $this->view->minhafuncaoviewhelper();

             }

                      ...

}

ou numa view qualquer



blablabla em html

<? $this->minhafuncaoviewhelper(); ?>

blablabla

Feito.

Referências: http://framework.zend.com/manual/en/zend.view.helpers.html

Formule alguma coisa : Criando formulários em Zend Framework parte 3 :: Salvando dados enviados dos formulários

2011-06-10T14:28:00.000-07:00

Agora, após termos criado o formulário ( parte 1 ) e criado os métodos de envio dos dados ( parte 2 ), vamos slavá-los num banco de dados.

Para inserir dados de seu formulario no banco de dados, usamos os models.

Abre um terminal e crie o model

$ zf create model meumodel

Abra o arquivo 'models/Meumodel.php' e veja que dentro está assim, vaziozão:

class Model_Meumodel extends Zend_Db_Table {
 
}

Esse vai ser a classe com que você irá trabalhar os dados do banco de dados com o controller e vice-versa.
Em específico ao nosso caso, vai ser o responsável por salvar os dados do formulário no banco de dados.
Primeiro, setamos a tabela do banco de dados que será trabalhada, acrescentando uma variável protegida no model

class Model_Meumodel extends Zend_Db_Table {

    protected $_name = 'minhatabela';

}

e agora, o campo da tabela que trabalha como seu índice

class Model_Meumodel extends Zend_Db_Table {

    protected $_name = 'minhatabela';
    protected $_primary = 'id';

}

Colocamos o campo 'id' como mera ilustração, pode ser qualquer outro campo, e no caso de você ter esquecido de declarar o campo índice, o Zend toma por padrão o primeiro campo chamado 'id' que porventura tenha na tabela. No caso de não haver um campo 'id' e você não ter declarado o campo índice, não sei o que acontece, por isso, é bem melhor declarar mesmo explicitamente o 'id' pra não correr riscos.
Agora, criemos no model a função que irá cadastrar o usuário

class Model_Meumodel extends Zend_Db_Table {

    protected $_name = 'minhatabela';
    protected $_primary = 'id';

    /*
     * Função que insere dados na tabela
     */
    public function insereDados($data){

        // Insere os dados do array '$data' no banco de dados.
        // Caso não seja possível inserir no banco de dados retorna falso.
        try{ $this->insert($data); return true; }
        catch( Zend_Db_Exception $e){ return false; }

    }

}

'$this->insert()' é o método da classe Zend_Db_Table que faz o trabalho sujo.
Agora, voltando ao nosso controller do formulario da parte 2 de nosso tutorial, lembremos que deixei uma parte escrito '<codigo surpresa>'

// Caso os dados sejam válidos.
if( $form->isValid($data) ){

    <codigo surpresa> <- olha a parte do código surpresa aqui

}

Pois bem, nessa parte, que fica logo depois de termos recebido os dados e depois deles term sido devidamente validados, é onde colocamos o resto do codigo

// Cria o objeto do model.
$objeto_model = new Model_Meumodel();
    
// Tenta inserir os dados no db.
// Caso dê certo, é impresso uma mensagem na view.
if( $objeto_model->insereDados($data) ){

    $mensagens = "Usuário criado com sucesso.";
    $this->view->mensagens = $mensagens;
     
}

// Caso dê algo errado com a inserção no banco de dados,
// é impresso uma mensagem de erro e voltamos ao formulário
// com os dados populado, para caso seja algum problema de 
// digitação.
else{
      $this->view->mensagens = "Não foi possível criar usuário.";
      // Reenvia os dado para o formulário.
      $form->populate($data);
      $this->view->formulario = $form;
}

E assim completamos nosso formulário em Zend. Basta testar e usar.

Referência: http://framework.zend.com/manual/en/zend.form.html http://framework.zend.com/manual/1.11/en/learning.quickstart.create-model.html

Formule alguma coisa : Criando formulários em Zend Framework parte 2 :: Submetendo dados

2011-06-10T14:18:00.000-07:00

Após criar o formulário dado na parte 1 de nosso tutorial, agora vamos submeter os dados recebidos pelo formulário.

No arquivo de formulario, setamos a ação como do form para 'minhaacao'.

class Form_Meuformulario extends Zend_Form{

    public function init(){

        // Ação para a página de envio do form.
        $this->setAction('.../minhaacao');

        // Método de envio do form.
        $this->setMethod('post');
        
        // Uma caixa de texto.
        $this->addElement('text', 'nomedoform',
                          array('label' => 'Label do form')
                         );

        // Botão de submissão.
        $this->addElement('submit', 'submit', 
         array('label'    => 'Enviar')
  );

   }

}

Editemos o arquivo de controller com a acao 'minhaacao' e acrescentamos a linha que irá receber os dados do formulario

class MeucontrollerController extends Zend_Controller_Action{

...

      public function minhaacaoAction(){

             // Cria o objeto de formulario.
             $form = new Form_Meuform();
 
             // Envia para o view o formulario.
             $this->view->formulario = $form;

             // Pega os dados enviados via POST.
             $data = $this->_request->getPost();

      }

...

}

Você pode mandar os dados para o view atraves da linha

...
$this->view->dados = $data;
    ...

e pra visualizar na views é só mandar imprimir com a linha

...
<?php print $this->dados; ?>
    ...

O próximo passo é a autenticação dos dados enviados. Para isso acrescentamos as linhas

class MeucontrollerController extends Zend_Controller_Action{
    
    ...

    public function minhaacaoAction(){

             // Cria o objeto de formulario.
             $form = new Form_Meuform();
 
             // Envia para o view o formulario.
             $this->view->formulario = $form;

             // Verifica se foram enviados dados via post.
             if( $this->_request->isPost() ){
             
                // Pega os dados enviados via POST.
                $data = $this->_request->getPost();

                // Caso os dados sejam válidos.
                if( $form->isValid($data) ){
                      <codigo surpresa>
                }

             }
             else{
                // Imprime na view o formulario por default 
                // assim que entra na página do formulário.
                $this->view->formulario = $form;
             }

      }

...

}

Aqui acrescentamos uma condição para verificar se foram enviados dados via POST. Se foram, então os dados são armazenados em '$data', assim, é verificado com 'isValid($data)' se os dados são validos de acordo com as regras de validação estipuladas pelo formulário que fizemos.
Agora, pra completar essa parte, queremos que, no caso de os dados não forem válidos, retornar ao formulário pra corrigir esses dados. Para não ter que fazer o usuário repetir tudo de novo, repopulamos o formulários com esses mesmos dados.
Para isso, acrescentamos mais umas linhas na ação acima:

class MeucontrollerController extends Zend_Controller_Action{
...

    public function minhaacaoAction(){

        // Cria o objeto de formulario.
        $form = new Form_Meuform();
 
        // Envia para o view o formulario.
        $this->view->formulario = $form;

        // Verifica se foram enviados dados via post.
        if( $this->_request->isPost() ){
             
            // Pega os dados enviados via POST.
            $data = $this->_request->getPost();

            // Caso os dados sejam válidos.
            if( $form->isValid($data) ){
                <codigo surpresa>
            }
            // Caso os dados não sejam válidos.
            else{
                // Se os dados não forem válidos, é reimpresso o
                // formulário com os dados repopulados para serem
                // corrigidos.
                $form->populate($data);
                $this->view->formulario = $form;
            }

        }
        else{
                // Imprime na view o formulario por default 
                // assim que entra na página do formulário.
                $this->view->formulario = $form;
        }

    }

...

}

E assim, nosso formulario esta praticamente completo. Só não está ainda por que, onde está escrito '<codigo surpresa>' podemos colocar dois tipos de códigos dependendo de nossos objetivos:

1 - código para inserir os dados no banco de dados
2 - código para autenticação de um formulário de login

Ou seja, o formulário feito até agora é geral o bastante pra usarmos tanto pra um formulario qualquer quanto para um formulario para fazer login no sistema.

Por isso teremos a terceira parte do formulário em Zend - salvar os dados do formulário no banco de dados, e num outro tutorial iremos apreveitar o que aprendemos até aqui pra criar um sistema de login.

Agora estamos prontos para a terceira parte de nossa série:

Formule alguma coisa : Criando formulários em Zend Framework parte 3 :: Salvando dados enviados dos formulários

Referência: http://framework.zend.com/manual/en/zend.form.html

Formule alguma coisa : Criando formulários em Zend Framework parte 1 :: Criando forms

2011-06-10T14:04:00.000-07:00

Para criar um formulário no Zend Framework, abre um terminal, vá a pasta de seu projeto e digite

$ zf enable form

$ zf create form meuform

Vai ser criada um arquivo com a classe de criação do formulário

/* .../application/forms/Meuform.php */

class Form_Meuform extends Zend_Form{

    public function init(){

    }

}

Coloque na ação 'init()' o código de criação dos forms:

$this->setAction('minhaurl');

para definir a ação do form, e

$this->setMethod('meumetodo');

para definir o método de envio (POST,GET,etc).
Agora, adicione um elemento de form ( text, button, submit, etc ):

$this->addElement($arraydeconfiguracaodoelemento)

Veja o manual do Zend para a configuração de cada elemento.

Um exemplo de um formulário mínimo, com uma caixa de texto e um botão de submissão:

class Form_Meuform extends Zend_Form{

    public function init(){

        // Ação para a página de envio do form.
 $this->setAction('inscricao');

        // Método de envio do form.
        $this->setMethod('post');
        
        // Uma caixa de texto.
        $this->addElement('text', 'nomedoform', 
         array('label' => 'Label do form')
  );

        // Botão de submissão.
        $this->addElement('submit', 'submit', 
         array('label'    => 'Enviar')
  );

   }

}

Criamos a ação 'minhaacao' no controller 'Meucontroller.php', o que terá a view 'minhaacao.phtml'.
Na ação 'minhaacao' do controller, criamos o objeto de formulário

class MeucontrollerController extends Zend_Controller_Action{

...

      public function minhaacaoAction(){

             // Cria o objeto de formulario.
             $form = new Form_Meuform();
 
             // Envia para o view o formulario.
             $this->view->formulario = $form;

      }

...

}

E no view 'application/views/scripts/meucontroller/minhaacao.phtml' coloque

<?php print $this->formulario; ?>

Abra o navegador na página de seu site, e digite

http://meusite.com.br/meucontroller/minhaacao

E se não deu nada errado, seu formulário aparecerá na página.

Veja agora a segunda parte da série

Formule alguma coisa : Criando formulários em Zend Framework parte 2 :: Submetendo dados

Referências:

Zend Manual: Zend Form

Silêncio na biblioteca : Como e onde colocar suas próprias bibliotecas no Zend Framework

2011-06-08T17:28:00.000-07:00

O Zend têm coisa pra caramba em sua biblioteca. Sempre que puder, usae-as, não fique reinventando a roda. Mas quando o Zend não têm o que precisamos, devemos criar nossas próprias bibliotecas.

E surpreendentemente, fazer sua prórpria biblioteca no Zend é moleza.

Apenas crie na pasta '/library' de sua aplicação uma pasta com suas próprias classes.
Pro exemplo, crio uma pasta

/library/Minhabiblioteca/Minhasclasses1

/library/Minhabiblioteca/Minhasclasses2

E sempre escreva a primeira letra de qualquer pasta em '/library' em maiúscula, esse é o padrão do Zend.
Vamos colocar uma classe em cada pasta

/library/Minhabiblioteca/Minhasclasses1/Umaclasse1.php

/library/Minhabiblioteca/Minhasclasses2/Umaclasse2.php

Agora, em cada classe, no cabeçalho de declaração de classes, você coloca

class Minhabiblioteca_Minhasclasses1_Umaclasse1 {

...

}

Percebeu o esquema ? Na declaração da classe, você coloca o nome das pastas, sempre com a primeira letra do nome em maiusculo, unidas por underline, e finaliznado com o nome da classe.

Agora, no arquivo de configuração 'application.ini' coloque a linha

autoloaderNamespaces[] = "Minhabiblioteca"

para sua biblioteca ser adicionada ao PATH da aplicação.

Crie seus métodos e objetos, e poderá usar em qualquer lugar do Zend, basta pra isso você chamar em qualquer local que você queira com

$obj = new Minhabiblioteca_Minhasclasses1_Umaclasse1()

e estarão disponíveis seus métodos e objetos que você criou pra usar ali.
Você pode até mesmo extender alguma classe do Zend, por exemplo, Zend_Front_Controller

class Minhabiblioteca_Minhasclasses1_Umaclasse1 extends Zend_Front_Controller {

...

}

e qualquer outra classe que você precisar usar do Zend.

Acreditem, eu fiquei surpreso de não precisar declara nada no Bootstrap, no config ou no 'index.php' pra fazer minha libs funcionarem no Zend.

Espero que a felicidade agora bata na porta de vocês.

Fonte: http://framework.zend.com/manual/1.11/en/performance.classloading.html

Framework o caramba ! Eu tô usando Zend !

2011-06-07T14:16:00.000-07:00

Antes de mais nada, advirto que foi o estagiário quem escreveu o título.
Daqui em diante eu mesmo assumo.

Pois bem, Zend Framework é SIM um framework.

O que é um framework ?

Um framework é um conjunto de bibliotecas de uma certa linguagem de programação voltados a uma função específica.
Por exemplo, existem frameworks escritos em C para bancos, e como tais, possuem funções específicas para manipulação de transações bancárias e assim programas bancarios poderem ser feitos sem precisar reinventar a roda ( ou seja, criar do zero funções para manipular transações bancárias ).

No caso do Zend, ele é um conjunto de bibliotecas para PHP voltado para fazer sites.
Com Zend, é possível fazer sites dos mais simples, com algumas páginas estáticas, a até sistemas inteiros ( como os netbankings e e-commerces - magento é um deles feito com Zend ).
Se fossem feitos do zero, demoraria um bom tempo até você criar suas próprias bibliotecas, seus próprios esquemas de segurança, etc.
Além do mais, a vantagem de se usar um framework é a padronização. Com padronização entenda que um desenvolvedor usando um framework popilar, vai poder fazer um programa que outro programador - que também conhece o framework - poderá entender e assim continuar a desenvolver de forma mais rápida e eficiente também.

Quer dizer, o uso de um framework não só ajuda individualmente, mas também em trabalho em grupo. Afinal , se cada um faz uma biblioteca diferente para o mesmo projeto, todo mundo vai ter de gastar um tempo tentando entender o que todo mundo fez, ao contrario da situação em que, se todo mundo aprender a usar o mesmo framework, isso não será mais problema.

Existem muitos frameworks em PHP para sites por ai. Alguns pagos, outros de gratuitos.
Dos gratuitos ( que é a preferência da maioria, não sei porque ) temos esses daqui, dentre eles, temos o Zend.

A preferência pelo Zend, na minha opinião, é que ele é desenvolvido pelo próprio grupo que mantêm o PHP, e ao longo das versões, vêm se tornando o padrão preferido de mercado.
A bem da verdade, o Zend inicialmente era um monstrengo complicado e pesado, mas nessa última versão ( v1.11 em 07/06/2011 ) está sendo muito prazeiroso usá-lo e a eficiencia está satisfatória - não sei o quanto, meus projetos ainda são pequenos pra perceber a diferença - no entanto, convido ao leitor a testar tantos frameworks puder para ver qual se adequa as suas nescessidades e gostos, tomando Zend como um opção, não como O framework definitivo.

Este blog criei em primeira instância, para colocar o que aprendi/aprendo em Zend, podendo ser considerado um "querido diário" de programação, pois tive a idéia de fazê-lo pelo tanto de tutoriais que existem por ai, mas muito poucos são fáceis ou intuitivos pra quem quer logo meter a mão na massa, e portanto, pretendo realizar postagens que sejam tão rápidos e práticos quanto possível, se não o for, é porque foi inevitável.

Assim, agradecerei as críticas ( construtivas ) , opiniões e sugestões que os leitores porventura venham a fazer.

Agora, se não vão continuar a ver meu blog, voltem ao trabalho, e boa programação.