domingo, 25 de agosto de 2013

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

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.

domingo, 18 de agosto de 2013

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

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á.

segunda-feira, 25 de março de 2013

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

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.

  1. Na pasta 'module/Application/src/Application/Controller', crie seu controller com o nome que desejar. Aqui usaremos 'Meucontroller' e criaremos o arquivo 'MeucontrollerController.php'.

  2. 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.

  3. 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'.

  4. 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'
            ),
        ),
    
  5. 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

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.

  1. 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.

  2. 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/.

  3. 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.

  4. 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.

  5. No controller 'IndexController.php', crie uma action com o nome que quiser ( aqui usaremos 'minhaaction' ):

    function minhaactionAction(){
        print "Alô mamãe !";
    }
    
  6. Agora, crie uma 'view' para 'minhaaction' na pasta 'module/Application/view/application/index' de nome 'minhaaction.phtml', e escreva algo dentro.
  7. 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á.

terça-feira, 6 de novembro de 2012

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

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




domingo, 19 de fevereiro de 2012

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

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


domingo, 12 de fevereiro de 2012

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

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/