Bom, a solução a seguir é destinada a quem utiliza o Contact Form 7.

Após instalado o plugin, para se criar um formulário você acessa a página através do menu “Contato” que é gerado pelo plugin e ao clicar na opção criar novo ele já gera para você o código.

Para evitar spams, instale o plugin ‘akismet’, caso você o tenha removido, pois ele vem instalado no wordpress.

Após instalado e ativado o Akismet, vá no site e crie uma conta gratuita para obter uma chave.

Acesse a página de configuração do Akismet no seu wordpress e insira a chave que foi enviada para o seu email.

Agora vá no Contact Form que você criou e insira as opções:

akismet:author
Adicione esta opção para o campo que aceita o nome do remetente.
Exemplo: [text* your-name akismet:author]

akismet:author_email
Adicione esta opção para o campo que aceita o email do remetente.
Exemplo: [email* your-email akismet:author_email]

akismet:author_url
Adicione esta opção no campo que aceita o URL do remetente.
Exemplo: [text your-url akismet:author_url]

Salve e para testar, no nome do remetente coloque ‘viagra-test-123′.

Preencha todos os demais campos normalmente e envie.

Uma mensagem com a borda laranja vai ser exibida, isto que dizer que o plugin bloqueou o envio pois identificou como SPAM.

Logo, SPAM enviados automaticamente sofrerão o mesmo bloqueio.

É isto ai!

Sumário

Na parte anterior aprendemos como criar Forms e enviar emails utilizando o Zend_Mail.
Vamos agora aprender a trabalhar com banco de dados e ver o conceito de Models dentro do Zend Framework utilizando o DbTable e as operações básicas com o paradigma CRUD.

Models

Basicamente, quando falamos de Models falamos de Banco de Dados ou uma coleção de Métodos dentro de uma Classe Model que permite agilizar processos relacionados a banco de dados.
O Model é manipulado pelo Controller e os dados retornados ficam disponíveis para você utilizar em qualquer lugar de sua aplicação.
Apesar de Model estar relacionado com banco de dados, na verdade, qualquer operação que modele dados pode ser considerado um model, como por exemplo, uma classe de Manipulação de Imagens.

CRUD

Com o sistema de Models do Zend é possível criar um sistema CRUD facilmente, pois ele possui métodos disponíveis através da classe Zend_Db_Table_Abstract. Para quem não conhece o significado de CRUD, o mesmo é um acrônimo para as quatro operações básicas em bancos de dados relacionais:

• Create - Criar ou adicionar novas entradas
• Read (Retrived) – Ler, recuperar ou ver entradas existentes
• Update - Atualizar ou editar entradas existentes
• Delete (Destroy) – Remover entradas existentes

Criando o Model

Para criar um Model basta digitar a linha de comando abaixo

zf create model NOME_DO_MODEL

Isto criará o arquivo NOME_DO_MODEL.php dentro da pasta /application/models.

Mas para trabalhar com bancos de Dados e utilizar a class Zend_Db_Table_Abstract é preciso adicionar o parametro ‘db-table‘ ao invés de model:

zf create db-table NOME_DO_MODEL NOME_TABElA_NO_BANCO

Isto criará uma pasta dentro de models chamada DbTable e dentro dela o arquivo NOME_DO_MODEL.php.

Vamos ver isto na prática criando o Model “Usuario” que vamos utilizar para criar nosso Sistema de Autenticação.

Digite a linha abaixo:

zf create db-table Usuario usuarios

E acesse o arquivo gerado em /application/models/DbTable/Usuario.php.
Ele deve conter:

class Application_Model_DbTable_Usuario extends Zend_Db_Table_Abstract
{
    protected $_name = 'usuarios';
}

Como você pode ver o ZF Tool criou uma classe Application_Model_DbTable_Usuario que é estendida de Zend_Db_Table_Abstract e dentro da classe a propriedade $_name. Esta propriedade é o nome da tabela no banco de dados que passamos na linha de comando. Você pode alterar manualmente, caso precise futuramente. E também pode chamar $this->_name dentro dos métodos para trocar de tabela caso necessário.

Métodos CRUD

O Zend_Db_Table_Abstract é uma interface orientada a objetos para as tabelas do banco de dados. Ela oferece métodos para muitas operações comuns em tabelas. A classe é extensível, por isto fica fácil modificar e adaptar conforme nossas necessidades.

Esta interface foi desenvolvida como implementação do Padrão de Projeto “Table Data Gateway” e também inclui uma classe que implementa o Padrão “Row Data Gateway”.

Os métodos mais comuns são:

• insert()
• update()
• delete()
• find()
• fetchAll()
• fetchRow()

Nós poderíamos utilizar diretamente estes métodos ou inventar moda e criar métodos do tipo:

• getUsuario()
• addUsuario
• updateUsuario
• deleteUsuario

Mas para mantermos as coisas no lugar, vamos utilizar diretamente os métodos da interface.

Conexão Com o Banco de Dados

Pois é! Antes de mais nada precisamos informar ao Zend como se conectar ao banco de dados.
Isto é algo fácil, relativamente.
Para configurar uma conexão utilizaremos o nosso arquivo de configuração application.ini.
Abra o arquivo e na seção [production] insira as linhas:

[production]
resources.db.adapter = "Pdo_Mysql"
resources.db.params.host = "localhost"
resources.db.params.username = "root"
resources.db.params.password = ""
resources.db.params.dbname = "tutorial-zend"
resources.db.params.charset = utf8

NOTA Creio que não preciso dizer para você colocar as suas configurações ai!

As linhas acima são bem intuitivas, mas a mais interessante é a primeira onde informamos ao Zend que vamos utilizar o PDO. Nesta linha está o poder da abstração. Se amanhã ou depois você quiser trocar de banco de dados, basta modificar o valor de resources.db.adapter e você não precisará fazer mais nada, caso você tenha utilizado somente as interfaces do Zend para manipulação de banco de dados.

Tabela de Usuários

Antes de prosseguirmos com os experimentos, vamos criar a tabela que o zend irá se comunicar para realizar as operações CRUD que vamos aprender logo abaixo.

Eu utilizei o MySQL, mas se você tem experiencia com outro banco de dados, sinta-se à vontade para utilizar o mesmo. Apenas não modifique os nomes dos campos ainda, para que não haja incompatibilidades com os passos do tutorial.

CREATE TABLE IF NOT EXISTS `usuarios` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `nome` varchar(120) COLLATE utf8_unicode_ci NOT NULL,
  `email` varchar(120) NOT NULL,
  `login` varchar(120) NOT NULL,
  `senha` varchar(30) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

IMPORTANTE: A tabela acima é simples justamente para facilitar no aprendizado e não tomar tempo desnecessário.

Método insert()

Para inserir um novo registro utilizamos o método insert() juntamente com um array contendo os campos da tabela e os valores a serem registrados.

Administração de Usuários

Vamos então criar agora um controller dentro do módulo admin a fim de manipularmos os usuários de nossa aplicação.

Abra o Prompt de Comando do DOS ou o Terminal, acesse a pasta do projeto e digite:

zf create controller usuario 1 admin

Esta linha de comando irá gerar os arquivos do Controller e View para UsuarioController.
Vale a pena notar que o nome da classe apareceu agora prefixado com ‘Admin_’ e para acessar o nosso controller temos que utilizar ‘admin’ ao invés de ‘default’.

class Admin_UsuarioController extends Zend_Controller_Action
{

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

    public function indexAction()
    {
        // action body
    }
}

Você pode testar acessando: http://zend.localhost/admin/usuario. Neste caso, o action será ‘index‘ e o controller ‘usuario‘.

Note que o layout carregado é o mesmo do módulo default.

Por ora deixe como está, mais adiante veremos como trocar de layout.

Feito isto, vamos informar ao zend que queremos utilizar nosso Model. Para tal, dentro do método init() do Controller Usuario, vamos criar um objeto a partir de nossa classe Model.

...
    public function init()
    {
        // Não preciso explicar não eh?
        $this->_db = new Application_Model_DbTable_Usuario();
    }
...

E para testar, vamos criar um action dentro do controller Usuario do módulo Admin.

zf create action add usuario 1 admin

Creio que você já sabe o que a linha acima significa!

Feito isto, vamos criar o código para controlar a criação de um novo usuário.

...
    public function addAction()
    {
        $dados = array(
	        'id' => null,
	        'nome' => 'Zé Ninguém',
	        'email' => 'zeninguem@teste.com',
	        'login' => 'zeninguem',
	        'senha' => md5('123456'),
        );
        $res = $this->_db->insert( $dados );
    }
...

Fácil, né? Pois é, nós criamos um array e passamos ele como valor para o método insert().
Note que foi utilizado o tipo null para o campo ‘id’.
Isto precisa ser feito assim para que o método insert() retorne o último ID inserido CASO você precise.
Como estamos utilizando uma interface, o Zend já se encarregou de fazer a conexão com o banco de dados que configuramos no arquivo de configuração. Para que a conexão aconteça, basta chamar o Model desejado. Por isto que criamos a propriedade $_db em nossa classe controladora de usuários, para deixar a conexão disponível em todo o controller.

Acesse agora a página do action que criamos para processar o código que criamos para inserir um novo usuário.

O URL ficou assim: http://zend.localhost/admin/usuario/add

Verifique no banco de dados que foi inserido um registro contendo as informações passadas no vetor acima.

O Método update()

Se você gostaria de atualizar alguma informação, você utilizará o método update(). Este método também precisará de um array contendo os campos e valores.

Este método espera que você passe um ID e como estamos trabalhando com CRUD que normalmente somente atualiza um registro por vez, há uma limitação para este método, que é justamente funcionar somente para um registro por vez.
Apesar de ter formas de atualizar mais de um registro utilizando o método update(), é mais interessante utilizar o método query() do Zend_Db, conforme veremos mais adiante.

NOTA: Nós poderíamos utilizar um formulário de cadastro para realizar estas operações CRUD, mas vamos deixar para ver isto mais adiante na autenticação e controle de usuário, pois até lá você vai ter tempo para fuçar e descobrir coisas sozinho.

Para atualizar o nosso usuário vamos primeiro criar um novo action:

zf create action update usuario 1 admin

E no método updateAction():

...
    public function updateAction()
    {
        $dados = array(
	        'nome' => 'Seu Nome Aqui',
	        'email' => 'seu@email.com',
	        'login' => 'seu_login',
	        'senha' => md5('sua_senha'),
        );

        $this->_db->update( $dados, 'id = 1' );
    }
...

Modifique as informações e abra a página: http://zend.localhost/admin/usuario/update. Verifique no banco de dados que as informações foram atualizadas!

Simples, né?
O Método update() possui um parâmetro adicional que aceita o que seria as clausulas para filtrar a atualização. Se você não passar nada, ele exibirá uma mensagem de Erro mas fará a alteração em todas as linhas da tabela.

O Método delete()

Para excluir um usuário é tão fácil quando as demais operações, e o método delete() aceita um único parametro que deve conter o ID a ser excluido.

Crie outro usuário teste para termos outro ID além do 1 e não perdemos nosso querido usuário criado anteriormente.
Feito isto, vamos criar o action para excluir este usuário.

zf create action delete usuario 1 admin

e no método deleteAction():

...
    public function deleteAction()
    {
        $this->_db->delete( 'id = 2' );
    }
...

Nem vou comentar! Muito fácil de entender!

O Método fetchRow()

Para obter um resultado da tabela, nós utilizamos o método fetchRow() e em casos mais específicos vamos chamar o método select() que está disponível dentro de nossa classe DbTable.

Para listar um usuário, vamos criar um action:

zf create action list usuario 1 admin

E no método listAction():

...
    public function listAction()
    {
        $usuario = $this->_db->fetchRow( 'id = 1' );
        $this->view->usuario = $usuario;
    }
...

Basicamente, o resultado foi passado para a variável $usuario que vamos passar para o nosso View usuario a fim de recuperar as informações no arquivo view script list.phtml.

Abra o arquivo /modules/admin/views/scripts/usuario/list.phtml e insira o código abaixo:

<h2>Informações do Usuário</h2>
<table>
	<tr>
		<th>Nome</th>
		<td><?= $this->usuario->nome; ?>
	</tr>
	<tr>
		<th>Login</th>
		<td><?= $this->usuario->login; ?>
	</tr>
	<tr>
		<th>E-mail</th>
		<td><?= $this->usuario->email; ?>
	</tr>
</table>

Acesse a página http://zend.localhost/admin/usuario/list e você verá as informações do usuário com ID 1 listadas na tela.

NOTA: O método fetchRow() retorna um objeto. Se você desejar utilizar um array, faça a modelagem adicionando toArray(), conforme abaixo:

...
$usuario = $this->_db->fetchRow( 'id = 1')->toArray();
...

Conclusão

Nesta parte de nosso tutorial você conhece o Zend_Db_Table_Abstract e aprendeu a trabalhar com banco de dados e a criar Models através do ZF Tool. Também aprendeu como realizar as operações básicas de um CRUD.
Nas proximas partes vamos ver como criar um sistema de autenticação e conhecer outros métodos de manipulação de banco de dados.
É isto aí! Abraços do Giba!

<?php get_sidebar(); ?>

Logo acima de get_footer():

<?php get_sidebar(); ?>
<?php get_footer(); ?>

Até ai tudo bem. Agora se você for acessar o post ou página. Vai ver que o CSS tá todo quebrado na página.

Bom, ai isto são outros quinhentos. ( risos )

Abraço do Giba!

Sumário

Na parte anterior vimos o Objeto Request e aprender como trabalhar com parametros do URL e fazer redirecionamentos baseados em parametros e fizemos uma revisita no Layout e Views. Vamos aprender agora como criar Forms e enviar emails utilizando o Zend_Mail.

Formulários

Criar formulários com o Zend é relativamente muito fácil.
Você deve estar se questionando o que este assunto tem de importante, pois você melhor do que ninguém sabe como criar formulários em HTML e PHP, ou atém mesmo utiliza alguma classe que gera formulários para você.
Bom, este tema é muito importante em todos os casos, pois além de gerar os formulários você pode integrar os formulários gerados pelo Zend de diversas formas e realizar validações, filtragens de dados, autenticação tudo de uma forma natural sem sobrecarregar a aplicação

Criando Formulários com o Zend Framework

Para entender, nada melhor que colocar a mão na massa.
Então vamos lá. Abra o seu prompt de comando ou terminal e acesse a pasta de nosso projeto.

Digite o comando:

zf create form contato

A linha de comando acima irá criar um arquivo chamado Contato.php contendo uma classe Application_Form_Contato dentro da pasta /application/forms/

IMPORTANTE: É possível trabalhar com formulários distintos por módulos. Entretanto, como o mesmo envolve muitas configurações, e possui alguns ‘bugs’, vamos criar o formulário da maneira mais simples.

O arquivo gerado pelo ZF Tool contem o nome da classe que é extendida de Zend_Form e o método init() que tem a mesma finalidade vista para os Controllers.

/application/forms/Contato.php

<?php

class Application_Form_Contato extends Zend_Form
{

    public function init()
    {
        /* Form Elements & Other Definitions Here ... */
    }

}

Para testar o formulário gerado pelo ZF Tool, abra o arquivo IndexController.php do módulo default.
Vamos criar um view que disponibilizará o formulário no nosso arquivo script views/scripts/index/contato.phtml do módulo default.

Para chamar o objeto instanciamos desta forma no controlador:

/application/modules/default/controllers/IndexController.php

...
public function contatoAction
{
    $form = new Application_Form_Contato();
    $this->view->form = $form;
}
...

e no arquivo view contato.phtml coloque em qualquer lugar a sentença:

<?= $this->form; ?>

IMPORTANTE:Na parte 03 eu não coloquei a rota para a página ‘contato’ no arquivo de configuração. Se você está seguindo este tutorial a risca e for testar agora, vai receber um erro, então logo abaixo das linhas onde configuramos as rotas, insira as linhas:

resources.router.routes.contato.route = /contato
resources.router.routes.contato.defaults.module = default
resources.router.routes.contato.defaults.controller = index
resources.router.routes.contato.defaults.action = contato

Agora abra a página http://zend.localhost/contato e você não verá nada ( risos ).
Claro! Não criamos nenhum elemento ainda.
Mas para fins de curiosidade, veja o código-fonte.
Repare que o Zend criou a tag FORM com alguns atributos mais uma tag DL:

<form enctype="application/x-www-form-urlencoded" action="" method="post"><dl class="zend_form">
</dl></form>

Formulário de Contato

Vamos então definir atributos para nosso formulário e adicionar elementos.
Como o objetivo deste tutorial é ser didático, vamos criar um formulário contendo um exemplo dos elementos HTML que mais utilizamos em formulários.

• radio [tratamento]
• input [nome, email]
• select [assunto]
• textarea [mensagem]
• checkbox [newsletter]
• submit [enviar]

Para criar os elementos do formulário, é claro, teremos que digitar (risos).

Atributos da tag FORM

Antes de criamos os elementos, precisamos definir os atributos do formulário em si, tais como:

• method
• action
• name
• id
• enctype - embora não vamos fazer uploads e podemos utilizar o gerado pelo Zend, vou deixar a dica

Vou deixar os comentários dentro do código abaixo para não saturar o texto do tutorial, então analise o código abaixo.

<?php
class Default_Form_Contato extends Zend_Form
{
    public function init()
    {

        /*******************************************
         * As definições abaixo são obrigatórias
         * todo formulário deve conter
         *******************************************/
        /**
         * Vai gerar o atributo/valor name="contato"
         */
        $this->setName( 'contato' );
        /**
         * Vai gerar o atributo/valor action="/contato"
         */
        $this->setAction( '/contato' );
        /**
         * Vai gerar o atributo/valor method="post"
         */
        $this->setMethod( 'post' );

        /**********************************************
         * As definições abaixo são opcionais
         * e dependem de peculiaridades de seu FORM
         *********************************************/
        $this->setAttrib('enctype', 'multipart/form-data');
        /**
         * Vai gerar o atributo/valor id="form-contato"
         */
        $this->setAttribute( 'id', 'form-contato' );
    }
}

NOTA: Como você deve ter notado todas as definições foram feitas dentro do método init().

Vamos criar os elementos agora. Analise o código abaixo, creio que ele seja bem intuitivo em relação ao qual campo do formulário estamos criando:

class Application_Form_Contato extends Zend_Form
{
    public function init()
    {
        /**
         * Definições para o FORM
         */
        $this->setName( 'contato' );
        $this->setAction( '/contato' );
        $this->setMethod( 'post' );
        $this->setAttrib( 'enctype', 'multipart/form-data' );
        $this->setAttrib( 'id', 'form-contato' );

        /**
         * Elementos do formulário
         */
        $tratamento = new Zend_Form_Element_Radio('tratamento');
        $tratamento->setLabel('Como gostaria de ser atendido?')
            ->addMultiOptions(
                array(
                    'Você' => 'Você',
                    'Sr(a).' => 'Sr(a)',
                    'Pelo Nome' => 'Pelo Nome',
                )
            )
            ->setValue('Pelo Nome');   

        $nome = new Zend_Form_Element_Text( 'nome' );
        $nome->setLabel( 'Nome' );

        $email = new Zend_Form_Element_Text( 'email' );
        $email->setLabel( 'E-mail' );

        $assunto = new Zend_Form_Element_Select( 'assunto' );
        $assunto->setLabel('Assunto')
            ->addMultiOptions(
                array(
                    '' => ' - - Escolha um assunto - - ', // em branco
                    'Dúvidas' => 'Dúvidas',
                    'Elogios' => 'Elogios',
                    'Reclamações' => 'Reclamações',
                    'Outros' => 'Outros',
                )
            );

        $mensagem = new Zend_Form_Element_Textarea( 'mensagem' );
        $mensagem->setLabel( 'Mensagem' );

        $newsletter = new Zend_Form_Element_MultiCheckbox( 'newsletter' );
        $newsletter->setLabel('Gostaria de Assinar Nosso Newsletter?')
            ->addMultiOptions(
                array(
                    'Tecnologia' => 'Tecnologia',
                    'Entretenimento' => 'Entretenimentos',
                    'Curiosidades' => 'Curiosidades',
                    'Produtos' => 'Produtos',
                    'Nenhum' => 'Não quero receber'
                )
            )
            ->setValue( 'Nenhum' );

        $submit = new Zend_Form_Element_Submit( 'submit' );
        $submit->setLabel( 'Enviar' );
        $this->addElements(
            array(
                $tratamento,
                $nome,
                $email,
                $assunto,
                $mensagem,
                $newsletter,
                $submit
            )
        );

    }
}

Salve o arquivo e abra novamente a página de contato. Veja que o formulário apareceu.

Entendendo o código

Como você pode ter notado, para cada elemento existe uma classe correspondente que chamamos através de

$nome_do_elemento = new Zend_Form_Element_<TIPO_DO_ELEMENTO>( VALOR_DO_ATRIB_NAME );

O protótipo acima deixa bem claro o que cada coisa significa.
Para cada elemento existem disponíveis vários métodos.
Em todos elementos utilizamos setLabel() que define o texto que o usuário verá na tela a fim de identificar o campo em questão.
[IMPORTANTE]Para elementos do tipo Submit e Button, o setLabel() funciona como o atributo value do elemento, como é o caso do botão Enviar que não possui Label, mas utilizamos setLabel(‘Enviar’).

No caso de campos como Radio, Checkbox e Select utilizamos o método addMultiOptions() para definir os valores desejados. Este método espera que um array seja passado contendo CHAVE => VALOR, conforme definimos para os campos tratamento|assunto|newsletter.

Para os elementos que precisam de um valor default quando o formulário é carregado, utilizamos setValue( VALOR ). Quando utilizado em elementos que o valor é parte de um addMultiOptions(), ele é sensível ao caso, ou seja você precisa passar EXATAMENTE o mesmo valor da chave, veja o caso do campo tratamento. Se colocassemos ‘pelo nome‘ ao invés de ‘Pelo Nome‘, ele não definiria nada. Ele funciona como checked para checkboxes e radios e selected para selects. Para outros campos de valor único funciona como value=”ALGUM VALOR”.

E por fim, temos o método addElements() do Zend_Form, que vai esperar um array contendo os objetos criados para cada elemento(campo) de nosso formulário. Os valores passados são as próximas variáveis, já que elas são os objetos.

CURIOSIDADE Abra o código-fonte da página contado e veja que o Zend adicionou algumas Marcações HTML utilizando listas de definição.

Outros elementos

Além dos elementos que criamos em nosso formulário, também estão disponíveis criar elementos:

• button
• reset
• password
• hidden
• image
• captcha [captcha] – apesar de não ser um elemento, atualmente utiliza-se muito e é algo bem elaborado no Zend

Qual a Vantagem de se criar Formulários com o Zend

No momento você pode estar pensando nisto, entretanto, apenas criamos o formulário.
Vamos ver agora como aplicar validação e filtros para entender o poder de se criar formulários com o Zend.

Validando o Formulário

Supondo que os campos nome|email|assunto|mensagem são obrigatórios e que os usuários poderiam passar código malicioso aos nossos códigos ou banco de dados através de nosso formulário, é interessante aplicar filtros e no caso de algum campo não ser enviado em branco, vamos informar que estes campos são obrigatórios.

Modifique o código:

...
        $nome = new Zend_Form_Element_Text( 'nome' );
        $nome->setLabel( 'Nome' )
            ->setRequired( true )
            ->addValidator( 'NotEmpty' )
            ->addFilter( 'StripTags' )
            ->addFilter( 'StringTrim' )
            ->addErrorMessage('Informe o seu nome');

        $email = new Zend_Form_Element_Text( 'email' );
        $email->setLabel( 'E-mail' )
            ->setRequired( true )
            ->addValidator( 'NotEmpty' )
            ->addFilter( 'StripTags' )
            ->addFilter( 'StringTrim' )
            ->addErrorMessage('Informe o seu email');                

        $assunto = new Zend_Form_Element_Select( 'assunto' );
        $assunto->setLabel('Assunto')
            ->addMultiOptions(
                array(
                    '' => ' - - Escolha um assunto - - ', // em branco
                    'Dúvidas' => 'Dúvidas',
                    'Elogios' => 'Elogios',
                    'Reclamações' => 'Reclamações',
                    'Outros' => 'Outros',
                )
            )
            ->setRequired( true )
            ->addErrorMessage('Escolha o assunto');

        $mensagem = new Zend_Form_Element_Textarea( 'mensagem' );
        $mensagem->setLabel( 'Mensagem' )
            ->setRequired( true )
            ->addValidator( 'NotEmpty' )
            ->addFilter( 'StripTags' )
            ->addFilter( 'StringTrim' )
            ->addErrorMessage('Escreva uma mensagem');
...

Se você executar o código agora, não vai acontecer nada!

Antes de fazer a coisa funcionar vamos explicar as linhas adicionadas aos elementos nome|email|assunto|mensagem.

Preste atenção nos comentários:

        $nome = new Zend_Form_Element_Text( 'nome' );
        $nome->setLabel( 'Nome' )
            // Marca o campo como obrigatório
            ->setRequired( true )
            // Não pode estar vazio
            ->addValidator( 'NotEmpty' )
            // Remove TAGS HTML
            ->addFilter( 'StripTags' )
            // Remove espaços brancos no inicio e fim
            ->addFilter( 'StringTrim' )
            // Define uma mensagem de erro personalizada
            ->addErrorMessage('Informe o seu nome');

Existem vários validadores e filtros entre os mais usados são os que você viu acima, mas ainda existem vários outros disponíveis.

No caso do email, além dos que utilizamos para os outros campos, utilizamos:

addValidator('EmailAddress', true);

Obtendo os dados enviados

Para que a validação ocorra de verdade é preciso que o Zend envie o formulário e faça algumas verificações. Caso ele identifique o valor de um dos elementos não corresponde com a validação solicitada, ele volta para a página do formulário e popula novamente o mesmo com os dados.

Para fazer isto, abra o arquivo IndexController.php e dentro do método contatoAction() insira o código abaixo:

...
    public function contatoAction()
    {

        $form = new Application_Form_Contato();
        $this->view->form = $form;

        $dadosFormulario = $this->getRequest()->getPost();

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

            if( $form->isValid( $dadosFormulario ) ) {
            } else {
                $form->populate( $dadosFormulario );
            }
        }
    }
...

Entendendo o Código – Solicitação POST

Tem bastante informação nova disponível agora, mas creio ser fácil de entender. Todo o código gira em torno de uma solicitação POST. Ao invés de utilizar $_POST o Zend oferece métodos exclusivos para tal.

Para obter os dados do Formulário utilizamos o Objeto Request que já conhecemos junto com o método getPost().

Este método pega a solicitação POST realizada e guarda todos os valores passados pelo formulário.

Isto é feito na linha:

$dadosFormulario = $this->getRequest()->getPost();

Para verificar se uma solicitação POST foi realizada o Objeto Request utiliza o método isPost().

Na estrutura de controle onde verificamos se há uma solicitação POST há uma condição que verifica se os dados do formulário correspondem com o que solicitamos ao Zend validar. Isto é feito através do método isValid().

1 – Se isValid() for verdadeiro, não acontece nada
2 – Se for falso popula o formulário novamente incluindo as mensagens de erros passadas pela validação.

...
        if( $this->getRequest()->isPost() ) {

            if( $form->isValid( $dadosFormulario ) ) {
            } else {
                $form->populate( $dadosFormulario );
            }
        }
...

Tente enviar o formulário vazio e veja o resultado.
As mensagens de erro apareceram logo abaixo do campo solicitado validação.

Agora se você preencher corretamente os dados ele vai mostrar o formulário com todos os dados carregados novamente.
Como boa prática de programação web, sempre que você enviar um formulário e os dados estiverem preenchidos corretamente, você deve redirecionar o usuário para outra página com alguma mensagem ou para a mesma página.
Podemos redirecionar o usuário para outra página ou para a mesma utilizando:

 if( $form->isValid( $dadosFormulario ) ) {
     $this->_redirect( '/contato' );
     // ou
     // $this->_redirect( '/qualquer-pagina-com-mensagem' );
 } 

Seria interessante se fossemos notificados do contato ou salvássemos os dados no banco de Dados.
Como este tutorial se estendeu demais sobre o assunto, vou terminar por aqui e vou pular para a parte de envio de emails com Zend_mail, deixando ai como dica e curiosidade para os mais ‘metidos’ e ensinar como criar Models na próxima parte.

Conclusão

Nesta parte de nosso tutorial você aprendeu a criar Forms e enviar email utilizando o Zend_Mail.
Na próxima parte de nosso tutorial vamos aprender como criar criar um sistema de autenticação utilizando Zend_Auth.

BONUS E-Mails com Zend_mail

IMPORTANTEEste procedimento somente é disponível em servidores locais configurados para enviar emails ou em servidores remotos. Você não conseguirá enviar email do localhost.
Então se você dispõe de um servidor dedicado, VPS, cloud, revenda, hospedagem, etc… Crie um subdominio no seu site chamado “zend” e envie os arquivos por FTP e faça o teste abaixo.

O Zend Dispõe de uma ferramenta muito legal para envio de Emails.
Ainda com o arquivo IndexController aberto no método contatoAction(), adicione as linhas abaixo:

...
    public function contatoAction()
    {

        $form = new Application_Form_Contato();
        $this->view->form = $form;

        $dadosFormulario = $this->getRequest()->getPost();

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

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

                $tratamento = $form->getValue('tratamento');
                $nome = $form->getValue('nome');
                $email = $form->getValue('email');
                $assunto = $form->getValue('assunto');
                $mensagem = $form->getValue('mensagem');
                $newsletter = $form->getValue('newsletter');

                $conteudo = sprintf('
                        Assunto: <STRONG>%s</STRONG><BR>
                        <HR>
                        Tratamento: <STRONG>%s</STRONG><BR>
                        Nome: <STRONG>%s</STRONG><BR>
                        E-mail: <STRONG>%s</STRONG><BR>
                        Mensagem: <STRONG>%s</STRONG><BR>
                        Newsletter: <STRONG>%s</STRONG><BR>
                    '
                    , $assunto
                    , $tratamento
                    , $nome
                    , $email
                    , nl2br( $mensagem )
                    , implode(', ', $newsletter )
                );

                $to = 'contato@seusite.com';

                $subject = utf8_decode( "Contato pelo site por: " . $nome );
                $html = "
                    <html>
                    <body>
                        ".$conteudo."
                    </body>
                    </html>
                ";

                $mail = new Zend_Mail('utf-8');
                $mail->setBodyHtml( $html );
                // poderia ser somente texto
                //$mail->setBodyText( $text );
                $mail->setFrom( $email, $nome );
                $mail->addTo( $to, 'Contato Site');
                $mail->setSubject( $subject );
                $mail->send();

                $this->_redirect( '/contato' );
                // ou
                // $this->_redirect( '/qualquer-pagina-com-mensagem' );
            } else {
                $form->populate( $dadosFormulario );
            }
        }

    }
...

Creio que o código acima é bem intuitivo.
Abraços do Giba!

Sumário

No a parte anterior de nosso tutorial vimos como criar Rotas, Layouts e aprendemos sobre Views.
Vamos conhecer agora o Objeto Request e aprender como trabalhar com parametros do URL e fazer redirecionamentos baseados em parametros e rever o Layout e Views.

Objeto Request

Antes de prosseguirmos, vamos analisar brevemente um dos objetos mais utilizados pelo Zend, o Request.
Este objeto é um objeto de solicitação muito simples que é passado entre as classes de roteamento, dispatchers e controladoras. Ele empacota os nomes dos modules, controllers, actions e parametros opcionais, assim como o resto das solicitações do ambiente, quer seja HTTP, que é o que nos interessa, e para os mais avançados e curiosos, CLI ou PHP-GTK.

O objeto é passado através de Zend_Controller_Front e está disponível em toda aplicação através da chamada $this->getRequest() e pode ser usado da seguinte forma dentro de nossa aplicação:

// Como citado anteriormente, o método init é o melhor lugar
// para guardarmos configurações e outras variáveis globais
// aos nossos actions dentro de um controller
// por isto vamos testar nosso controller aqui
public function init()
{
    $this->request = $this->getRequest();
}

A partir desta declaração podemos então acessar vários recursos, tais como Nome do Module, Nome do Controller, Nome do Action e obter os Parametros a partir do URL

Vamos testar algumas funcionalidades básicas e já aproveitar para relembrar o Views:

public function init()
{
    $this->request = $this->getRequest();

    // passamos alguns valores para o view
    $this->view->module = $this->request->getModuleName();
    $this->view->controller = $this->request->getControllerName();
    $this->view->action = $this->request->getActionName();
}

Abra o arquivo /modules/default/view/scripts/index.phtml e adicione as linhas:

...
<h2>Teste de Objeto Request</h2>
<strong>Modulo: </strong> <?= $this->module; ?>
<br />
<strong>Controller: </strong> <?= $this->controller; ?>
<br />
<strong>Action: </strong> <?= $this->action; ?>

Acesse o url do projeto e veja que apareceram as informações que o Objeto Request definiu no View de nossa Aplicação.
Agora você começa a entender melhor o funcionamento do VC do MVC.
O que aconteceu aqui foi uma lógica de negócio processada pelo Controller e passada ao View no arquivo de apresentação.

E para verificar que o método init() está disponível em todos actions de sua aplicação faça o mesmo com o action servicos.

Abra o arquivo /modules/default/view/scripts/servicos.phtml e adicione as linhas:

...
<h2>Teste de Objeto Request</h2>
<strong>Modulo: </strong> <?= $this->module; ?>
<br />
<strong>Controller: </strong> <?= $this->controller; ?>
<br />
<strong>Action: </strong> <?= $this->action; ?>

Acesso o url do action http://zend.localhost/servicos
Como você pode ver, os valores passados no método init() para o View permaneceram disponíveis e somente houve uma alteração no valor de action, pois o module e o controller continuam os mesmos.

Obtendo Parâmetros do URL

Como estamos utilizando MVC seria interessante obtermos valores diretamente do URL para operações básicas.
Vamos fazer uma simulação aqui.
Suponhamos que você tenha produtos na página produto que gostaria de acessar pelo ID, que tradicionalmente seria algo do tipo:

http://zend.localhost/produtos?id=1

No nosso caso, para algo mais interessante, queremos aproveitar a deixa dos famosos URL’s limpos e MVC, então gostaríamos de algo assim:

http://zend.localhost/produtos/id/1

Para fazer isto basta construir o URL deste tipo e obter os parâmetros através do objeto Request pelo método getParam(CHAVE).

Como já vimos anteriormente, o zend entende o URL da seguinte maneira:

URL/MODULE/CONTROLLER/ACTION/PARAMETRO1/VALOR1/PARAMETRO2/VALOR2/etc…

Então, no URL http://zend.localhost/produtos/id/1 ID é um parametro com a chave ‘id’.

Vamos utilizar o action produtos para tal simulação e, como não estamos trabalhando com banco de dados ainda, vamos criar um vetor simples contendo alguns produtos:

public function produtosAction()
{
    $produtos = array(
	1 => array(
            'nome' => 'TV',
	    'descricao' => 'Descrição da TV aqui'
	),
	2 => array(
	    'nome' => 'Celular',
	    'descricao' => 'Descrição do Celular aqui'
	),
	3 => array(
	    'nome' => 'Notebook',
	    'descricao' => 'Descrição do Notebook aqui'
	),
	4 => array(
	    'nome' => 'Aparelho de Som',
	    'descricao' => 'Descrição do Aparelho de Som aqui'
	),
    );

    $id = $this->request->getParam( 'id' );

    if( $id != false ) :
    // vamos definir os valore encontrados nas chaves do vetor
    // e passar os mesmos para o View a fim de obter
    // estes valores no arquivo produtos.phtml
    $this->view->nome = $produtos[$id]['nome'];
    $this->view->descricao = $produtos[$id]['descricao'];
    endif;

}

Abra o aquivo produtos.phtml dentro da pasta dos views e insira o código abaixo:

<h1><?= $this->contentTitle; ?>
<?php if( $this->id != '' ) : ?>
<h2><?= $this->nome; ?></h2>
<div>
	<?= $this->descricao; ?>
</div>
<?php endif; ?>

Se você acessar o URL http://zend.localhost/produtos?id=1, você vai receber uma bela mensagem de erro informando que a página não existe e que o controlador ‘produtos’ não existe.

Neste caso, como vimos o Zend irá entender o URL da seguinte forma:

array (
  'controller' => 'produtos',
  'action' => 'id',
  'module' => 'default',
)

Para resolver isto teríamos que chamar:

http://zend.localhost/index/produtos/id/1

O que nos fez voltar ao maldito ‘index’ no URL novamente.

Então a solução seria criar um Route para este padrão de URL.

No arquivo application.ini no final do bloco de Routes que criamos anteriormente adicione as linhas:

;produtos/id/
resources.router.routes.produtosId.route = /produtos/id/:id
resources.router.routes.produtosId.defaults.module = default
resources.router.routes.produtosId.defaults.controller = index
resources.router.routes.produtosId.defaults.action = produtos

Atualizado em 16/12/2011: produtosId deve ser o nome do novo roteamento.
Atualizado em 16/12/2011: Código-fonte para download nas partes 5 e 6.

Acesse o URL http://zend.localhost/produtos/id/1 e veja que está acessando agora!
NOTA: Você precisa passar um novo nome para o roteamento de produtos através do ID, no caso, eu nomeei produtosId mas poderia ser qualquer coisa. Lembre-se de sempre dar nomes ÚNICOS para cada roteamento, mesmo que sejam 100 roteamos envolvendo o mesmo controller, todos precisarão ter um nome único.

IMPORTANTE
O que você passar para
resources.router.routes.produtosId.route
Será o que o Zend irá aceitar no URL e o :id é o nome do parametro que queremos passar para o controller. Poderia ser qualquer coisa, e esta seria a chave que obteríamos em :
$this->request->getParam( CHAVE );

Então, se quisermos podemos eliminar totalmente a chave do URL e ficarmos com algo do tipo:
http://zend.localhost/index/produtos/1
Bastaria modificar o roteamento para:

;produtos/:id
resources.router.routes.produtos.route = /produtos/:id
resources.router.routes.produtos.defaults.module = default
resources.router.routes.produtos.defaults.controller = index
resources.router.routes.produtos.defaults.action = produtos

Mas para fins didáticos, vamos ficar com o /produtos/id/:id e não /produtos/:id

Você pode colocar inúmeros parametros num redirecionamento tal como:

;/produtos/fab/:fabricante/cat/:categoria/marcar/:marca/mod/:modelo/cor/:cor/
resources.router.routes.produtos.route = /produtos/fab/:fabricante/cat/:categoria/marcar/:marca/mod/:modelo/cor/:cor/
...

Ou simplesmente:

;/produtos/:fabricante/cat/:categoria/marcar/:marca/mod/:modelo/cor/:cor/
resources.router.routes.produtosEx.route = /produtos/:fabricante/:categoria/:marca/:modelo/:cor/
...

Conclusão

Nesta parte de nosso tutorial conheceu o Objeto Request e aprendeu como obter parametros a partir do URL e como criar um redirecionamento baseado nestes parametros. Na próxima parte veremos como criar Forms e enviar emails com o Zend_Mail.
Abraços do Giba!

Aceito sugestões e críticas. Tudo é bem vindo.

Abraço do Giba!

Bom, para resolver isto é bem fácil.

Desabilitando Rascunhos e auto salvamento

Abra o arquivo wp-admin/post-new.php e procure pela linha:

wp_enqueue_script('autosave');

e comente a mesma:

//wp_enqueue_script('autosave');

Desabilitando Revisões Automáticas

Abra o arquivo wp-config.php e no final adicione a linha:

define( 'WP_POST_REVISIONS', false );

E pronto! WordPress vai ficar quieto e não vai superpopular a tabela ( risos ).

Sumário

Continuando com o nosso projeto disponível nas partes anteriores deste tutorial em minha página Zend Framework, nesta parte do tutorial vamos aprender como criar Routes, uma forma prática de redirecionar sua aplicação para as mais diversas situações, entre elas, quando alguma página mudou de lugar na sua aplicação. E seguindo a solicitação de alguns leitores, como criar trabalhar com Layouts e aprender o conceito básico de View.

Agora que você já sabe como trabalhar com módulos, actions e controllers e respondendo a uma pergunta dos amigos que utilizaram meus tutoriais como fonte de aprendizado, ai vai a resposta:

Pergunta: A maioria dos tutoriais na internet não utiliza ou cita Módulos, preciso mesmo utilizar Módulos?
Resposta: Não. Não precisa! Mas seria uma perca de tempo e recursos. O objetivo deste tutorial é fornecer algo mais sólido e próximo de um projeto real para o desenvolvedor que deseja realizar projetos ousados.

A pergunta acima foi feita por vários desenvolvedores que entraram em contato nas últimas 2 semanas depois que atualizei os tutoriais e achei interessante citá-la.

Routes

O que são Routes? Rotas, do inglês! O Leitor deve estar perguntando se eu estou tirando da cara dele. Mas não! Normalmente, as palavras bem definidas fazem com que fixemos o objetivo e não criemos confusão antecipada.
Uma rota é um ponto de acesso ou trajeto definido e delimitado após uma experiência ou análise prévia.
No Zend, é o processo de pegar o ponto final de URI, decompor o mesmo, e definindo qual módulo, controller, action deverá servexecutado na solicitação ( request ).

O Roteamento ocorre somente uma vez quando uma solicitação é feita; antes do controller ser chamado.

Utilizando Routers

Existem duas formas fundamentais de se criar Routes com o Zend.
A primeira é através do arquivo application.ini e outra através de um dos 6 tipos:

• Zend_Controller_Router_Route
• Zend_Controller_Router_Route_Static
• Zend_Controller_Router_Route_Regex
• Zend_Controller_Router_Route_Hostname
• Zend_Controller_Router_Route_Chain
• Zend_Controller_Router_Rewrite

Por questões de praticidade, eu sempre utilizo a primeira, pois a equipe do Zend criou uma interface que faz todo o trabalho para você direto no arquivo de configuração. ‘Routes’ não são o tipo de coisa que você deve se preocupar demais num projeto, sem desprezar sua importância, é claro, por isto a sacada foi boa! E seria perca de tempo se matar digitando um monte de código PHP quando você pode fazer o mesmo com algumas linhas no arquivo de configuração, e se isto existe é para isto que foi criado. Mais adiante, veremos como programar Routes, utilizando o batalhão de classes acima, mas por hora vamos entender como as coisas funcionam no arquivo de configuração.

Anteriormente na Parte 02

Nós criamos o controlador ‘index’ automaticamente anteriormente no momento da criação do projeto, e depois alguns actions que resultaram nos URLs:

• http://zend.localhost/index/index
• http://zend.localhost/index/quem-somos
• http://zend.localhost/index/servicos
• http://zend.localhost/index/produtos
• http://zend.localhost/index/contato

Mas estas URLs com ‘index’ não ficaram legal.

Nós poderíamos ter criado um controlador para cada caso:

QuemSomos, Servicos, Produtos e Contato

Mas necessariamente, não faria sentido, a menos que cada página do site tivesse sub-páginas, algo do tipo.

Produtos -> Categorias
Produtos -> Resultados
PRodutos -> Ver

Etc…

Por questões de aprendizagem de Refatoração do Projeto, mais adiante nós modificaremos a funcionalidade da seção ‘Produtos’ de nosso site a fim de corresponder com nossas necessidades, mas por ora, ele é apenas uma página que lista os tipos de produtos, ou uma ação dentro do controlador index.

O que nós atualmente queremos é algo do tipo:

• http://zend.localhost/home
• http://zend.localhost/quem-somos
• http://zend.localhost/servicos
• http://zend.localhost/produtos
• http://zend.localhost/contato

Que é o que vamos fazer agora!

Abra o seu arquivo /application/configs/application.ini e procure pela seção [production].

Cole as linhas abaixo:

;
[production]
resources.router.routes.home.route = /home
resources.router.routes.home.defaults.module = default
resources.router.routes.home.defaults.controller = index
resources.router.routes.home.defaults.action = index

Vamos entender o que aconteceu.

A primeira linha define o que deverá ser chamado, no nosso caso ‘home‘:

resources.router.routes.home.route = /home

A segunda linha define o module, no nosso caso ‘default‘ que é o modulo padrão:

resources.router.routes.home.defaults.module = default

A terceira linha define o controller (index) :

resources.router.routes.home.defaults.controller = index

E a quarta define o action (index) :

resources.router.routes.home.defaults.action = index

Repare na estrutura e veja que somente foi modificada a última parte de cada linha (module|controller|action). A lógica é esta:

resources.router.routes.NOME_DA_ROTA.MODULO.CHAVE = VALOR

O NOME_DA_ROTA deverá ser único para cada rota, como veremos mais abaixo.
O MODULO, apesar de ser ‘default‘ em nossa aplicação, para este caso deverá ser passado como ‘defaults‘.

Agora você pode testar:

http://zend.localhost/home

Que seria o mesmo que:

http://zend.localhost/ ou http://zend.localhost/index/index

Se você não entendeu, releia. Se entendeu vamos fazer o mesmo para as próximas páginas de nosso projeto:

;
[production]
; home
resources.router.routes.home.route = /home
resources.router.routes.home.defaults.module = default
resources.router.routes.home.defaults.controller = index
resources.router.routes.home.defaults.action = index

;quemsomos
resources.router.routes.quemsomos.route = /quem-somos
resources.router.routes.quemsomos.defaults.module = default
resources.router.routes.quemsomos.defaults.controller = index
resources.router.routes.quemsomos.defaults.action = quem-somos

;servicos
resources.router.routes.servicos.route = /servicos
resources.router.routes.servicos.defaults.module = default
resources.router.routes.servicos.defaults.controller = index
resources.router.routes.servicos.defaults.action = servicos

;produtos
resources.router.routes.produtos.route = /produtos
resources.router.routes.produtos.defaults.module = default
resources.router.routes.produtos.defaults.controller = index
resources.router.routes.produtos.defaults.action = produtos

; contato
resources.router.routes.contato.route = /contato
resources.router.routes.contato.defaults.module = default
resources.router.routes.contato.defaults.controller = index
resources.router.routes.contato.defaults.action = contato

IMPORTANTE: Note que nomeamos cada rota e alteramos as primeiras e quartas linhas de cada bloco.

Agora você pode acessar cada página:

• http://zend.localhost/home
• http://zend.localhost/quem-somos
• http://zend.localhost/servicos
• http://zend.localhost/produtos
• http://zend.localhost/contato

Fácil não?

Mais adiante veremos como passar parametros e como recuperá-los.

Layouts

Conforme solicitado pelos amigos leitores, vou ensinar nesta terceira parte sobre Layouts.

O que é um Layout?

De repente você esteja acostuma com o termo ‘tema’, ‘template’, ‘design’, etc mas não tenha intimidade com ‘layout’.
Um Layout é basicamente uma estrutura hierárquica em sua aplicação que mantém partes de código que se repetirão em todas ou algumas páginas da aplicação.
Toda aplicação web é composta por uma estrutura HTML padrão que precisa ser mantida e normalmente o que muda de uma pagina para outra é o conteúdo, e se mantém sempre o cabeçalho, rodapé, laterais.
Um Layout no Zend Framework é parte do MVC e utiliza-se do ViewRenderer que oferece uma vasta gama de recursos que são carregados automaticamente para o objeto $view.

Enable Layout

No Zend Framework o Layout é habilitado pelo ZF Tool, digitando a linha abaixo:

zf enable layout

Este comando criará uma pasta e um arquivo em ‘/application/layouts/scripts/layout.phtml’ com a linha:

<?php echo $this->layout()->content; ?>

Esta linha carregará o conteudo do arquivo view script do action sendo chamado.

Dentro do arquivo de configuração application.ini foi adicionada a linha:

resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts/"

Acesse sua aplicação e veja que nada mudou.

Agora modifique o arquivo layout.phtml para que o mesmo fique assim:

<html>
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
    <title>Meu Projeto Zend Framework</title>
    <body>
	<div id="header">{Meu Cabeçalho aqui}</div>
	<div id="content">
	<?php echo $this->layout()->content; ?>
	</div>
	<div id="footer">{Meu rodapé aqui}</div>
    </body>
</html>

Acesse todas as páginas de nosso projeto e verifique que a estrutura se manteve a mesma.

Então se você deseja criar alguma navegação no topo, lateral, rodapé ou outros blocos de HTML você poderá fazê-los neste arquivo.

NOTA: Não remova a declaração $this->layout()->content:

<?php echo $this->layout()->content; ?>

Do contrário o conteúdo dos arquivos view não serão exibidos.

Mais adiante veremos como adicionar Scripts e CSS e como criar uma esquema de temas.

Views e Templates

Outra coisa interessante no desenvolvimento web, além de Layouts são as ferramentas de template. Existem várias por ai tais como Smarty, PHP Template, etc… eu mesmo até já fiz uma (risos).
No Zend não há necessidade de se utilizar uma ferramenta de templates, pois o View faz isto.

O que é o View?

O View é uma classe que trabalha com a parte View que já aprendemos anteriormente ( não estou tirando de novo – risos ), ou seja, ele existe para auxiliar a manter o view script (arquivos dos actions) separado dos arquivos Model e Controller. Ele oferece um sistema de Helpers, Filters e variáveis escapadas.

Um Exemplo para entender

CASO: Você deseja que determinados valores sejam carregados automaticamente em cada página, variando de acordo com o controlador e o action, no caso o valor da tag ‘TITLE’ de cada página e o ‘Titulo da página’ para identificar onde o usuário está.
No nosso projeto, precisamos identificar cada página com títulos distintos:

// pagina home
...
<title>Seja Bem Vindo - Tutorial Zend</title>
...
<h1>Seja Bem vindo</h1>

...

// pagina quem-somos
...
<title>Quem Somos - Tutorial Zend</title>
...
<h1>Quem Somos</h1>

...

/**
 * E ASSIM POR DIANTE!!!!
 */

Para fazermos isto, precisamos utilizar o View da seguinte forma:

Abra o arquivo IndexController.php

E insira as linhas dentro do método indexAction():

...
public function indexAction()
{
    $this->view->pageTitle = 'Seja Bem-vindo - Tutorial Zend';
    $this->view->contentTitle = 'Seja Bem-vindo';
}
...

No arquivo view/scripts/index/index.phtml remova todo o conteúdo gerado automaticamente e coloque:

<h1><?=$this->contentTitle;?></h1>

Acesse a página home de nosso projeto e veja que o título apareceu lá.

No entanto, ainda falta definir o TITLE de cada página, isto será feito no arquivo layouts.phtml:

...
<title><?= $this->pageTitle;?></title>
...

Atualize a página e veja que agora o TITLE possui a string que definimos.

[NOTA] : Faça o mesmo dentro de cada método action de nosso controlador para cada página modifique o arquivo view correspondente (quem-somos, servicos, produtos, contato).

Em resumo é isto:

No action você usa:

$this->view->CHAVE = VALOR;

E no view script (arquivo .html do action):

$this->CHAVE; // NOTE QUE NÃO HÁ O view

Bom, vamos ficar por aqui. Mais adiante veremos muita coisa boa.

Resumo

Nesta terceira parte de nosso tutorial você aprendeu o conceito fundamental de Routes e aprendeu como definir facilmente rotas no arquivo de configuração. Também aprendeu como habilitar Layout no Zend framework e modificou o arquivo gerado. Vimos como utilizar o View para trabalharmos com o paradigma de Templates.
Nas próximas partes continuaremos e veremos pegar os parametros do URL e como obter valores via GET e POST através de Forms criados pelo Zend.
Abraço do Giba!

A primeira vista achei que fosse paddings e margins exagerados que eu houvesse definido, foi quando utilizando a ferramenta para inspeção de DOM do Chrome que vi umas tag ‘P’ não autorizadas em meu HTML (risos)

Bom, a solução é bem pratica e não precisa mais do que uma linha de código.

Abra o arquivo function.php de seu tema e insira a linha:

remove_filter ("the_content", "wpautop");

O que estas linha de código faz é remover o filtro wpautop. Este filtro adiciona paragrafos automaticamente ao wordpress quando a função ‘the_content’ é executada na exibição do POST.

Bom, é isto ai. Abraço do Giba!

Eu estava desenvolvendo um Plugin para uma imobiliária e me deparei com um problema:

Na Visualização do Rascunho o conteúdo estava sendo exibido corretamente, porém, após publicado aparecia o Erro 404 ( Page not found ).

Para resolver isto não precisa de muita coisa.

Basta simplesmente Ir em Configurações -> Links Permanentes e Pronto!

O wordpress atualiza alguma coisa que não tive tempo para analisar.

Quando eu descobrir eu posto aqui.

Descobri – ( suspense )

Eu fiz uma análise e achei o que acontece.
Toda vez que um post é criado o WordPress faz um Flush ( limpeza, descarrega o que já existe e recria de novo ) nas regras de Rewrite executando este método:

$wp_rewrite->flush_rules();

Então se você quiser que seus tipos de conteúdo asseguradamente apareçam quando forem criados, insira estas linhas em algum lugar do seu plugin relativos a criação do custom post type:

global $wp_rewrite;
$wp_rewrite->flush_rules();

Abraço do Giba!