Diego Henrique » Zend Framework

Publicando um projeto desenvolvido em ZF em um shared host

Diego Henrique — Fri, 08 Jan 2010 11:45:01 +0000

Para a grande maioria que utiliza um shared host, publicar um projeto desenvolvido com Zend Framework pode ser uma dor de cabeça, pois a estrutura recomendada de diretórios pede que a pasta da sua aplicação e do framework fiquem um nivel abaixo do nivel da pasta publica (wwwroot ou public), e muitos shared hosts não permitem que você faça isso.

Uma das formas de resolver este problema sem mudar toda a estrutura recomendada pelo ZF é colocar toda a estrutura da forma como é gerada pelo Zend Tool (ou criada manualmente) no diretório raiz do servidor web e usar um .htaccess para redirecionar todas as requisições para o ZF de forma correta. O .htaccess ficaria assim:

RewriteEngine on
RewriteRule ^$ public/ [L]
RewriteRule (.*) public/$1 [L]

Estas regras simplesmente direcionam todas as requisições da raiz do seu diretório web para o diretório public que contem o index.php que inicializa a aplicação. Solução simples e que funciona muito bem.

Traduzindo as mensagens do componente Zend Validate

Diego Henrique — Thu, 19 Nov 2009 19:31:53 +0000

Começamos a pouco tempo um projeto para traduzir e manter um repositório com as mensagens de tradução do Zend Validate. O projeto que já conta com 3 colaboradores alem de mim, já percorreu uma boa trilha (ainda há muito o que fazer). Vou mostrar aqui como usar as mensagens traduzidas do nosso repositório.

O primeiro passo, obvio, é fazer o download dos arquivos no github. Após isso, no seu bootstrap, adicione um método _initTranslate e no escopo dele instancie o Zend Translate passando por parâmetro o arquivo baixando do repositório, após isso defina sua instância do Zend Translate como padrão para o componente Zend_Validate_Abstract, como no exemplo abaixo:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap

{

        public function _initTranslate()

        {

                $translate = new Zend_Translate(

                        ‘gettext’,

                        APPLICATION_PATH . ‘/../data/translate/validate/pt_br.mo’

                );

                Zend_Validate_Abstract::setDefaultTranslator($translate);

        }

}

Prontinho, agora todas as suas mensagens de validação estarão em português.

Ah, se você quiser colaborar com o projeto, entre em contato, toda ajuda é sempre bem vinda.

Tradução para as validações do Zend Framework

Diego Henrique — Fri, 13 Nov 2009 12:16:30 +0000

Estou disponibilizando a todos os arquivos de tradução das mensagens do Zend Framework, inclusive peço a ajuda de quem estiver utilizando pra podermos deixarmos este arquivo sempre atualizado, ou seja, colaborações são muito bem vindas.

Para downloads e colaborações: http://github.com/diegoholiveira/Zend-Validate—Messages-pt-br

Em breve irei postar um tutorial sobre como usar este arquivo.

Usando o Ez Components com o Zend Framework

Diego Henrique — Tue, 11 Aug 2009 01:48:55 +0000

Nenhum framework é perfeito, todos sabemos disso, e exatamente por isso em alguns casos torna-se necessario juntar peças de um e de outro pra poder obter um bom resultado.
Em busca de um bom componente pra trabalhar com geração de graficos acabei encontrando o framework / biblioteca Ez Components, pra quem não conheçe eu recomendo muito dar uma olhada: http://ezcomponents.org. No Ez temos uma otima biblioteca de graficos, e decidi por fim a usa-la no meu projeto.

Para integra-la com o Zend Framework é muito simples, visto que o ZF facilita muito as coisas. Depois de ter feito o download copie a pasta do Ez Componentes para pasta library da sua aplicação.
Após isso abra o arquivo de inicialização da sua aplicação, como eu estou usando o ZF 1.8 meu arquivo chama-se Bootstrap.php, porem se você tiver usando o Zf 1.7 ou anterior a ideia é a mesma.

No meu bootstrap eu já tinha um metodo de inicialização pro autoloader, chamado _initAutoloader, que configura o autoload padrão do ZF, neste mesmo incrementei o autoload do Ez Componentes, ficando assim:

protected function _initAutoloader()

{

        // Autoloader dos recursos padrões

        $autoloader = new Zend_Application_Module_Autoloader(array(

                ‘namespace’     => ”,

                ‘basePath’      => APPLICATION_PATH

        ));

        // Configurando o autoloader do EzComponents

        require_once ‘ezc/Base/src/base.php’;

        $loader = Zend_Loader_Autoloader::getInstance();

        $loader->pushAutoloader(array(‘ezcBase’, ‘autoload’), ‘ezc’);

}

O que metodo pushAutoloader faz é registrar o metodo estatico autoload da classe ezcBase como autoloader padrão para as classes que inicial com ezc, e isso é feito usando a função spl_autoload_register() da SPL.

Prontinho. Agora é só usar o Ez Components a vontade.

Validando formulários com Zend Form, jQuery e Ajax.

Diego Henrique — Fri, 22 May 2009 02:44:53 +0000

Sabemos que validar formulários hoje em dia é uma obrigação de todo bom desenvolvedor. E não validar apenas no cliente usando javascript, mas validar também no servidor. Validação é o primeiro de muitos passos para tornar sua aplicação mais segura.

Uma técnica que eu acabei descobrindo recentemente e estou usando bastante é juntar o poder do componente Zend_Form com o beleza do jQuery, o que me trouxe resultados muito bons, principalmente nos quesitos qualidade e desenvolvimento ágil.

Para demostrar essa técnica que eu estou utilizando eu vou partir do pressuposto que você já esta familiarizado com o ambiente do Zend Framework. Partindo disso, vou mostrar o código simples do formulário de cadastro:

class Cadastro_Form extends Zend_Form {

        public function init() {

                $this->setAttrib(‘id’, ‘cadastro’)

                     ->setAction(‘/index/index’)

                     ->setMethod(‘post’);

                $this->addElement( ‘text’, ‘nome’, array(

                        ‘label’                 => ‘Nome’,

                        ‘required’              => true,

                        ‘validators’    => array(

                                ‘NotEmpty’,

                                array(‘StringLength’, false, array(0, 60) )

                        )

                ));

                $this->addElement(‘text’, ‘email’, array(

                    ‘label’         => ‘E-mail’,

                    ‘required’      => true,

                    ‘validators’   => array(

                        ‘NotEmpty’,

                        ‘EmailAddress’

                    )

                ));

                $this->addElement( ‘submit’, ‘submit’, array(

                        ‘ignore’        => true,

                        ‘label’         => ‘Entrar’

                ));

                $this->getElement(‘submit’)->removeDecorator(‘label’);

        }

}

Agora que nosso formulário de cadastro já é um componente do projeto, vamos fazer as paginas, vou supor aqui que estamos trabalhando no controller index, portando criaremos duas actions para que nosso controller aqui fique da seguinte maneira:

class IndexController extends Zend_Controller_Action {

        /** Nesta action iremos exibir o formulario */

        public function indexAction() {}

        /** Nesta action iremos receber o dados por ajax para validação */

        public function validarAction() {}

}

Temos o básico para começarmos a trabalhar. Agora a ideia é validarmos estes dados na tela do cliente via ajax, para que antes do cliente submeter os dados ele consiga visualizar os possíveis erros e já corrigi-los. Lembrando também que isso NÃO descarta a validação no servidor.

Vamos ver como fica nosso metodo indexAction():

public function indexAction() {

        $form = new Cadastro_Form;

        if ($this->_request->isPost()) {

                if ($form->isValid( $this->_request->getPost() )) {

                        $this->view->mensagem = ‘Formulario valido’;

                }

                else {

                        $this->view->mensagem = ‘Ops. Formulario invalido.’;

                        $form->populate( $this->_request->getPost() );

                }

        }

        $this->view->form = $form;

}

E agora nossa index.phtml

if(isset($this->mensagem)){?>
 echo $this->mensagem; ?>

 echo $this->form; ?>

Não podemos esquecer de adicionar a biblioteca jQuery a nossa camada view, pois ela irá nos ajudar muito no processo, vejamos o nosso código javascript para a validação:

$(document).ready(function() {

        $(‘#submit’).bind(‘click’, function (e) {

                e.preventDefault();

                var nome = $(‘#nome’).val();

                var email = $(‘#email’).val();

                $.ajax({

                        url: ‘/index/validar’,

                        type: ‘post’,

                        dataType: ‘json’,

                        data: {

                                nome: nome,

                                email: email

                        }

                        success: function (data) {

                                $(‘.form-errors’).remove();

                                if (data == true) alert( ‘Passou…’ );

                                else {

                                        for (campo in data) {

                                                $(‘#’+campo).after(‘+campo+‘_errors" class="form-errors">’);

                                                for (mensagem in data[campo]) {

                                                        $(‘#’+campo+‘_errors’).append(‘’+data[campo][mensagem]+‘
’);

                                                }

                                        }

                                }

                        }

                });

        });

});

Como vocês podem ver, nosso método validar irá retornar um objeto json para o jQuery poder trabalhar, e com o for iremos percorrer este objeto colocando cada mensagem em seu devido lugar. É um bom método por não fazer você ter que escrever duas validações, uma para javascript e outra para php. Você escreve apenas uma e utiliza em ambas as validações.

Agora nosso método validar:

public function validarAction() {

        if ($this->_request->isXmlHttpRequest()) {

                $form = new Cadastro_Form;

                echo $form->processAjax($this->_request->getPost());

        }

}

Como vocês viram, devido ao nosso componente de formulário já está pronto tudo ficou muito mais simples, com apenas algumas linhas validamos e retornamos o resultado para o javascript poder exibir ao usuário.

O resultado desta combinação é muito interessante, pois mantem nossa aplicação modularizada, de forma que para adicionar novos campos no nosso formulário de cadastro não é necessário se preocupar com html e validação javascript, basta editar o componente Cadastro_Form.

Qualquer duvida deixa nos comentários ai que vamos trocando uma ideia.

Referencias:

http://framework.zend.com/manual/en/zend.form.html

http://framework.zend.com/manual/en/zend.validate.html

http://docs.jquery.com/Ajax

Zend Framework: Surviving The Deep End

Diego Henrique — Sun, 04 Jan 2009 23:55:47 +0000

Já no primeiro dia do ano temos boas noticias pros usuarios do Zend Framework: Pádraic Brady lançou um livro online sobre o Zend Framework. O livro não esta completo ainda, ate o momento ele já publicou dois capitulos. Vale a pena dar uma conferida e esperar pelos proximos capitulos.

Site do livro: http://www.survivethedeepend.com/
Indice do livro: http://www.survivethedeepend.com/zendframeworkbook/en/1.0/
Blog do autor: http://blog.astrumfutura.com/

Zend Framework 1.6

Diego Henrique — Tue, 02 Sep 2008 19:38:18 +0000

Acabou de sair a versão final do Zend Framework 1.6!

Uma das novidades é que agora existem duas distribuições:

- Full (13.6 MB): Contem o Dojo, testes e demos.

- Minimal (3.5 MB): Contem apenas o ZF. Note que neste pacote tambem é possivel usar o Dojo integrado, porem este precisa ser baixado a parte, enquanto no pacote full ele já esta incluso.

Outra novidade que eu gostei é o Zend Captcha, que vai trazer mais poder ainda ao Zend Form, assunto do meu post anterior.

[update]
Duas novidades que eu só vi agora:

- Upload: o ZF permite fazer upload atraves do componente Zend Form e Zend File Transfer. Vou testar mais esses componentes e quem sabe vira um post aqui.

- Agora o manual esta disponivel em PDF para download, porem não sei porque ele não esta disponivel na pagina do framework, e sim no site da Zend, aqui: http://www.zend.com/community/downloads
[/update]

Downloads e mais informações: http://framework.zend.com/download/current/

Referência: http://devzone.zend.com/article/3812-Zend-Framework-1.6-Now-Available

Introdução ao Zend Form

Diego Henrique — Sun, 24 Aug 2008 16:10:00 +0000

Um dos melhores componentes do Zend Framework é sem duvidas o Zend Form, inclusive me arrisco a dizer que usar o ZF sem usa-lo é perda de tempo. O Zend Form nos ajuda a gerar formulários html e a valida-los com muita eficacia, e sua operação é extremamente simples. Vou dar um exemplo de como gerar um formulário de login usando-o. Eu não gosto muito de ficar falando de teoria portanto vou mostrar o exemplo todo comentado e espero que ele demostre com clareza o funcionamento do Zend Form.

Nota.: Eu estou partindo do pressuposto que você já tem um ambiente do ZF configurado, caso contrario recomendo a leitura deste artigo do Julio Martini no Imasters:
http://imasters.uol.com.br/artigo/4609/php/zend_framework_-_uma_visao_geral/

Arquivo do Controller: IndexController.php

/**

 * Controlador principal

 */

class IndexController extends Zend_Controller_Action {

        /**

         * Metodo Index

         */

        public function indexAction() {

                // Inclui o componente Zend Form

                require( ‘Zend/Form.php’ );

                // Instancia um novo formulario

                $form = new Zend_Form();

                // Configura o action e o method (para os dados serão enviados e através de que metodo (get ou post)

                $form->setAction(‘/index/index’)->setMethod(‘post’);

                // Instancia um campo do tipo texto

                $usuario_email = new Zend_Form_Element_Text(‘usuario_email’, array(

                        // Define o label do campo

                        ‘label’                 => ‘E-mail: ‘,

                        // Define que o campo é obrigatório (por padrão esta opção é falso)

                        ‘required’              => true,

                        // Adiciona filtros para o campo (estes filtros são elementos do Zend Validate)

                        ‘validators’    => array(

                                ‘NotEmpty’, // Define que este campo não pode ser vazio

                                ‘EmailAddress’ // Define que este campo deve ser um endereço de email valido

                        )

                ));

                // Adiciona as mensagens de erro

                $usuario_email->getValidator(‘NotEmpty’)->setMessages( array(

                        Zend_Validate_NotEmpty::IS_EMPTY        => ‘Este campo não pode ser vazio!’

                ));

                $usuario_email->getValidator(‘EmailAddress’)->setMessages( array(

                        Zend_Validate_EmailAddress::INVALID => ‘Email invalido!’

                        // Existem varias outras validções de email, inclusive de host valido!

                ));

                // Obs.: Por padrão as mensagens de erro do Zend Validate estão em inglês, em outro post mostrarei como traduzi-las

                // de uma só vez através do componente Zend Translate

                // Instancia um campo do tipo password

                $usuario_senha = new Zend_Form_Element_Password(‘usuario_senha’, array(

                        // Define o label do campo

                        ‘label’                 => ‘Senha: ‘,

                        // Define que o campo é obrigatorio (por padrão esta opção é falso)

                        ‘required’              => true,

                        // Adiciona os filtos

                        ‘validators’    => array(

                                array(‘NotEmpty’, true), // Não pode ser vazio

                                // Definimos aqui o tamanho da string para um valor entre 6 e 20 caracteres

                                array(‘StringLength’, false, array(6, 20)) 

                        )

                ));

                // Adiciona as mensagens de erro

                $usuario_senha->getValidator(‘NotEmpty’)->setMessages( array(

                        Zend_Validate_NotEmpty::IS_EMPTY        => ‘Este campo não pode ser vazio!’

                ));

                $usuario_senha->getValidator(‘StringLength’)->setMessages( array(

                        Zend_Validate_StringLength::TOO_SHORT   => ‘Senha deve ter mais de 6 caracteres’,

                        Zend_Validate_StringLength::TOO_LONG    => ‘String deve ter menos de 20 caracteres’

                ));

                // Instancia um campo do tipo checkbox para persistir a sessão do usuário

                $usuario_mantemLogado = new Zend_Form_Element_Checkbox(‘usuario_mantemLogado’, array(

                        // Define o label do campo

                        ‘label’                 => ‘Permanecer logado’

                ));

                // Aqui invertemos a ordem com que ele exibirá o label, deixando o mesmo após o campo

                $usuario_mantemLogado->getDecorator(‘label’)->setOption(‘placement’, ‘APPEND’);

                // Por padrão o Zend Form gera o label antes do campo (PREPEND)

                // Instancia um botão do tipo submit

                $submit = new Zend_Form_Element_Submit(‘submit’, array(

                        // Define o label do botão

                        ‘label’ => ‘Entrar’

                ));

                // Aqui removemos a tag , ela não é necessária em um botão

                $submit->removeDecorator(‘label’);

                // Adiciona os campos ao formulário

                $form->addElements( array( $usuario_email, $usuario_senha, $usuario_mantemLogado, $submit ));

                // Vamos verificar se o formulário foi enviado

                if ($this->_request->isPost()) {

                        // Obtém os dados do formulário

                        $data = $this->_request->getPost();

                        // Verifica se o formulário é valido

                        if ($form->isValid( $data )) {

                                // Aqui você define a ação de um formulário valido

                        }

                        // Caso o formulário não seja valido continuamos a executar a pagina para exibir as mensagens de erro do usuário

                }

                // Coloca o formulário na view

                $this->view->form = $form;

        }

}

Arquivo da View: index/index.php

// Renderiza o formulário.

echo $this->form;

// Simples. Não?

Observações: Uma maneira melhor de trabalhar com o Zend Form é estendendo a classe Zend_Form e configurando seu formulário como um objeto, desta forma:

/**

 * Cria um formulário estendendo a classe Zend Form

 */
Class Form_Login extends Zend_Form {
        /**

         * Inicializa e configura o formulário

         * Por padrão todas as classes do Zend Framework usam um método init logo após o construtor,

         * é uma forma de estender as classes sem sobrescrever o construtor original

         */

        public function init() {

                // Configuração do form aqui!

        }

}

É isso ai. Teve duvidas? Deixa nos comentários ai.

Referências:

http://framework.zend.com/manual/en/zend.form.html

http://framework.zend.com/manual/en/zend.validate.html