tutorial zend framework
TRANSCRIPT
[ Tutorial ] Zend Framework Parte 0123 de novembro de 2011 Framework , PHP 5, Zend Framework framework , PHP, Tutorial, Zend Framework
Instalação, configuração, criação de projeto
Sumário
Neste tutorial, você vai aprender como baixar e instalar o Zend Framework, assim como ativar o mod_rewrite do Apache e criar um Virtual Host. Vai modificar o arquivo .htaccess para alterar o comportamento do Zend Framework.Você também vai aprender a criar um projeto utilizando o ZF Tool.
NOTA AOS DESENVOLVEDORES : Este tutorial utiliza o Zend Framework versão 1.11.11 1.12.3 e pode não funcionar em versões anteriores do Zend.
Clique aqui para ver todos os tutoriais disponíveis
Instalação e Configuração
Para começar a usar o Framework, precisamos cumprir alguns requisitos:
1 – Baixar o framework
2 – Instalar e ativar o mod_rewrite
3 – Criar um servidor virtual
4 – Criar uma estrutura para a aplicação ou site
5 – e muito mais…
Nota: Para usar o framework é preciso que você tenha o PHP 5 rodando em seu servidor, mas cuidado com versões muito recentes do PHP, no momento da escrita deste tutorial tive problemas com o PHP 5.3.3, mas ele rodou legal no PHP 5.3.8.
Vamos então dividir nosso tutorial em várias partes para poder manter um fluxo no aprendizado saudável e você não arrancar os cabelos antes do tempo ( brincadeirinha ).
Baixando o framework
Para baixar o Zend Framework você deve ir no site oficial do framework http://framework.zend.com. Procure a versão que vamos utilizar neste tutorial, a Zend Framework 1.11.11 1.12.3 Minimal. Caso tenha saído outra versão antes que eu termine as atualizações deste tutorial para a versao que usei clique aqui para baixá-la diretamente.
Configurando o Servidor Apache para mod_rewrite
Antes de instalar o framework precisamos configurar o mod_rewrite no servidor.
Caso você esteja utilizando outro servidor que não seja o apache, você precisará verificar na documentação a forma mais correta de ativar o mod_rewrite deste.
Para o Apache, o procedimento é bem simples.
Como estou usando o Windows vou mostrar como proceder para obter o resultado desejado.
1 – Abra o arquivo httpd. conf do Apache, normalmente ele se encontra dentro da pasta conf
2 – Procure pela linha #LoadModule rewrite_module modules/mod_rewrite.so e retire o sustenido (#) inicial
3 – Procure pela Tag <Directory>
4 – Dentro desta troque Options FollowSymLinks por Options FollowSymLinks Includes
5 – Troque AllowOverride None por AllowOverride All
6 – Agora procure pela Tag <Directory “C:/Apache/htdocs”> que dependendo de sua instalação pode estar diferente, mas que é onde se encontra as configurações da pasta raiz do apache
7 – Tendo encontrado esta Tag, troque Options Indexes por Options Indexes FollowSymLinks
8 – Troque AllowOverride None por AllowOverride All
9 – No final do arquivo adicione a linhaAccessFileName .htaccess e estamos com o Apache configurado para mod_rewrite.
Criando um Virtual Host para simular servidor remoto
Para criar um Virtual Host no apache é bem fácil. Hipotéticamente vamos criar o host virtual “zend.localhost”
1 – Abra o arquivo CAMINHO/PARA/SEU/Apache/conf/httpd. conf2 – Procure pelas linhas:
1 # Virtual hosts
2 # Include conf/extra/httpd-vhosts.conf
O sustenido (#) indica código comentado para o Apache, por isto não será executado.Caso o seu esteja assim, remova o (#) da linha do include:
1 # Virtual hosts
2 Include conf/extra/httpd-vhosts.conf
Feche o arquivo.3 – Abra o arquivo CAMINHO/PARA/SEU/Apache/conf/extra/httpd-vhosts.conf e cole o código abaixo no final do arquivo:
1 DocumentRoot "CAMINHO/PARA/SEU/Apache/htdocs/www/tutorial-zend"
2 ServerName zend.localhost
3 ErrorLog "logs/tutorial-zend-error.log"
4 CustomLog "logs/tutorial-zend-access.log" common
Salve e feche o arquivo.4 – Reinicie O Apache5 – Execute o notepad como administrador (Vista/7 somente, xp não precisa ) e abra o arquivo: C:\windows\system32\drivers\etc\hostsDica: Para iniciar um programa como administrador, procure por ele no Menu Iniciar ou na pasta dele, clique com o botão direito e você terá a Opção “Executar como administrador”.
6 – No início do arquivo insira a linha:
1 127.0.0.1 localhost
2 127.0.0.1 zend.localhost
Salve e feche o arquivo
7 – Crie uma pasta chamada tutorial-zend dentro de CAMINHO/PARA/SEU/Apache/htdocs/www/
8 – No navegador digite: http://zend.localhost e pronto!
Criando a Estrutura de Arquivos
Uma aplicação com Zend Framework vai precisar utilizar um padrão, embora você possa configurar o mesmo de várias formas, bastando alterar os caminhos dos arquivos. Mas, para fins de obter um processo sem complicações, vamos utilizar o padrão.
Vamos criar o projeto dentro da pasta raiz de nosso servidor virtual, simulando um servidor remoto, pois você vai precisar saber fazer isto quando for instalar sua aplicação ou site num servidro remoto. Vamos usar o famoso padrão de redirecionamento com URLs limpas (Clean URLs) que elimina os tradicionais Query Strings ( Ex.
http://zend.localhost/index.php?module=default&controller=produto&action=ver&id=1 vai ficar http://zend.localhost/produto/id/1)
ZF Tool
IMPORTANTE: Confira meu tutorial exclusivo sobre como utilizar o ZF Tool. Clique aqui para acessar. E se você utiliza o Linux, clique aqui.
Eliminamos o sofrimento utilizando uma ferramenta criada pela equipe do Zend, com a finalidade de agilizar e facilitar o desenvolvimento, chamada ZF Tool. Esta ferramenta cria o projeto e tudo o mais que precisarmos relacionado a estrutura, conforme veremos mais adiante.
Vamos então instalar o bichinho, já que ele ajuda e é mansinho, porque fugir dele (risos)!
1 – Extraia o arquivo que você baixou do site da zend e acesse até chegar na pasta onde estão as pastas bin e library.2 – Copia-as e cole em c:\CAMINHO\PARA\Apache\apps\zend3 – Abra a pasta bin e copie os arquivos: zf.bat e zf.php para dentro do diretório de instalação do seu.4 – No mesmo diretório, procure pelo arquivo php.ini e abra-o no bloco de notas ( Se você usa Wamp veja este tutorial ).5 – Procure pela linha:
1 ;include_path = ".;c:\php\includes"
e mude para:
1 include_path = ".;c:/CAMINHO/PARA/Apache/apps/zend/library"
6 – Abra o prompt de comando do DOS ( digite cmd em Executar ou Iniciar) e digite:
1 zf show version
IMPORTANTE (Se voce usa Linux ignore): Seu ZF não será reconhecido como comando interno ou externo, pois seu PHP.exe não foi configurado como variável do ambiente do windows. Para resolver isto siga os procedimentos abaixo:
1 – Clique com o botão direito em Meu Computador2 – Propriedades3 – Configurações Avançadas ou Aba Avançado4 – Variáveis de Ambiente5 – Procure e clique em “Path” e depois no botão “Editar”6 – Adicione ao final do que estiver lá o caminho do php: ; c:\CAMINHO\PARA\SEU\PHP7 – ok, ok, ok8 – Reinicie o computador (Obrigatório).
Se tudo correu certinho, você verá algo assim:
1 Zend Framework Version 1.12.3
Estrutura de Arquivos com ZF Tool
Para criar a estrutura de arquivos com o ZF Tool abra o Prompt de Comando novamente ( digite cmd em Executar ou Iniciar) e acesse a nossa pasta:
CAMINHO/PARA/SEU/Apache/htdocs/www/
Se você não sabe utilizar o Prompt de Comando acesse o tutorial “Comandos Básicos do MS-DOS” – infowester – veja os comandos: CLS, DIR, CHDIR, MKDIR e EXIT! Não precisa mais do que isto para este tutorial)
No Prompt de Comando digite:
1 C:/CAMINHO/PARA/SEU/Apache/htdocs/www/
Para criar a estrutura de arquivos você deve executar o comando:
1 zf create project tutorial-zend
Ao executar o comando acima o ZF Tool criará a estrutura inicial do projeto, conforme a imagem abaixo:
Agora, voce precisa copiar a pasta Zend(23MB), que se encontra dentro de C:/CAMINHO/PARA/SEU/Apache/apps/zend/library para a pasta tutorial-zend/library e sua estrutura ficará parecida com esta:
Agora já podemos começar a explorar nosso projeto e aprender a sobre módulos, controladores e ações
Arquivo .htaccess
O ZF Tool criou o arquivo /tutorial-zend/public/.htaccess para nós, entretanto, ele ainda não está pronto para ser utilizado, pois não sei porque ele não está configurado corretamente e muito menos no local mais ideal!
O conteúdo deste arquivo fará com que todas as solicitações sejam redirecionadas para a pasta public de nossa aplicação, o que torna o acesso direto aos arquivos impossível.
Mude a localição do arquivo de /tutorial-zend/public/.htaccess para /tutorial-zend/.htaccess e modifique seu conteúdo conforme abaixo:
1 RewriteEngine On
2 RewriteCond %{REQUEST_FILENAME} -s [OR]
3 RewriteCond %{REQUEST_FILENAME} -l [OR]
4 RewriteRule !\.(js|gif|jpg|png|css|txt)$ public/index.php [L]5 RewriteCond %{REQUEST_URI} !^/public/
6 RewriteRule ^(.*)$ public/$1 [NC,L]
Este arquivo tem um diferencial do padrão comum que você encontra em outros tutoriais tratando do Framework.
Nele nós alteramos o DocumentRoot do Apache, diferente de alterar nos arquivo de configuração do Apache. Isto é preciso pois em alguns casos o desenvolvedor não tem acesso ao arquivo httpd ou mesmo uma opção de alterar a pasta raiz do servidor. Então, redirecionar com o arquivo .htaccess, mostrou-me ser mais versátil.
Welcome to the Zend Framework!
Para finalizar esta primeira parte de nosso tutorial, acesse http://zend.localhost e você deverá ver a tela conforme a imagem abaixo. Caso apareça algum erro refaça os passos novamente e verifique possiveis erros de digitação, etc.
Conclusão
Nesta parte do tutorial você aprendeu como instalar e configurar a Biblioteca Zend em seu servidor usando o Apache, aprendeu a criar um projeto utilizando o ZF Tool e você também aprendeu a redirecionar as solicitações para a pasta public do projeto que vamos desenvolver.No próximo tutorial vamos colocar a mão na massa e começar nossa viagem ao planeta Zend Framework.Abraço do Giba!
[ Tutorial ] Zend Framework Parte 0223 de novembro de 2011 Framework , PHP 5, Tutorial, Zend Framework controller , model, MVC, Tutorial, view, Zend Framework
MVC, Modules, Controllers, Views, Parameters
Sumário
Nesta parte do tutorial vamos aprender alguns conceitos fundamentais para todo desenvolvedor que utilize o Zend Framework, entre eles o Padrão MVC, Modules, Controllers, Actions, Models, Parameters. Vamos criar um site básico a partir do nosso projeto criado na parte anterior e vamos utilizar os conceitos citados acima.
Clique aqui para ver todos os tutoriais disponíveis
Agora que você já tem o seu Zend Frameword instalado é hora de se aprofundar em alguns conceitos e entender como as coisas mais fundamentais funcionam.
Padrão de Projeto MVC
O Zend Framework é todo Orientado a Objetos, por isto você precisará ter algum conhecimento básico sobre Orientação a Objetos em PHP. O Zend frameowork utiliza um padrão muito famoso chamado MVC. MVC é a abreviatura para Model-View-Controller.
O MVC permite ao desenvolvedor separar o código em 3 camadas: Apresentação, Lógica de negócio e Acesso aos dados.
As 3 camadas citadas acima são as utilizadas pelo MVC:
M – Model ( Acesso aos dados) – Esta é a parte de sua aplicação que define suas funcionalidades básica atrás de um conjunto de abstrações. Acesso a dados e algums lógicas de negócio podem ser definidas dentro de um model.
V – View ( Apresentação ) – Os Views definem exatamente o que é apresentado ao usuário. Normalmente, os Controllers passam os dados para cada View a fim de exibír estes dados em algum formato. Os Views frequentemente também coletam dados do usuário. É onde você provavelmente encontrará a marcação HTML em sua aplicaçao MVC.
C – Controller ( Lógica de Negócio ) – Os Controllers liga todo o padrão MVC. Eles manipulam os Models, decidem qual view exibir baseado na solicitação do usuário e
outros fatores, passam os dados que cada view irá precisar ou repassa o controlle para outro controller.
Module x Model
É importante antecipar aqui a diferença entre Module e Model. Para os falantes do idioma inglês não há muita confusão quanto a estas duas palavras.
Module (módulo) é o que modulariza a aplicação e Model (modelo) o que dá acesso aos dados nas mais diversas formas.
Module não está dentro do MVC mas é utilizado em cada solicitação feita pelo Zend, por isto sua importancia.
Default
Toda aplicação Zend inicia com o Module ‘default’ por padrão.
Veremos mais adiante a estrutura de uma solicitação que explicará melhor.
Estrutura de solicitação: Modules, Controllers, Actions e Parameters
Toda solicitação feita ao Zend Framework possui basicamente 03 (três) elementos.
Module
Parte da aplicação que contem um objetivo distinto e que deve ser utilizado caso você precise controlar várias seções distintas de seu site ou aplicação.
Um exemplo mais básico seria cria um módulo para a Área adminsitrativa do site e utiizar o module Default para o site per si.
Com mais experiência você descobrirá várias formas de utilizar a estrutura de Modules do Zend, mas por hora, a explicação acima basta.
O module default não precisa ser chamado, pois o Zend o carrega automaticamente. Caso você crie um novo Module, você precisará criar uma pasta para o default.
Na pratica já veremos como criar um módulo e você entenderá melhor.
Controller
O controller inicial de qualquer aplicação zend é o ‘index’. O controller index não precisa ser chamado, pois o Zend o carrega automaticamente quando nenhum for passado.
Cada controller possui uma classe exclusiva e única que é extendida da classe abstrata Zend_Controller_Action que é implementada a partir de Zend_Controller_Action_Interface.
Ai você deve estar se perguntando: “Não entendi, Controller que é extendido de uma classe Zend_Controller_Action?”
Pois é, o interessante é que na verdade, o mais importante é a camada de apresentação numa aplicação, pois é nela que o usuário interage com o controller, por isto, e pelo fato do controller controlar primariamente actions que vão conter acesso a tudo o que existe no Zend e no MVC per si, a estrutura de arquivos é carregada a partir dos actions e não dos controllers em si. Os controllers apenas fazem isto: controlam a lógica de negócio e acesso a dados presentes nos actions.
Action
O action inicial de qualquer aplicação zend é o ‘index’. O action index não precisa ser chamado, pois o Zend o carrega automaticamente quando nenhum for passado.
Relação MVC e Solicitação com Module/Controller/Action.
Na parte anterior desta sequencia de tutoriais você criou o projeto e testou a partir do url:
1 http://zend.localhost
Por trás dos panos o Zend na verdade executou isto:
1 http://zend.localhost/default/index/index
O que seria o mesmo que:
1 http://zend.localhost/MODULE/CONTROLLER/ACTION
O MODULE não faz nada se não houver mais do que o módulo default e não fará nada mais do que selecionar a estrutura de arquivos que deverá estar dentro da pasta /modules/NOME_DO_MODULO caso você utilize mais do que o módulo default.
O CONTROLLER tem relação direta com o Controller do MVC e carrega o arquivo que contém o controller em questão que deverá estar dentro da pasta /application/controllers, caso não seja utilizado módulo e dentro de /application/modules/NOME_DO_MODULO/controllers, caso esteja utilizando mais do que um módulo.
O ACTION tem relação direta com o View do MVC e carregará o arquivo do controller anterior que contém os Actions dentro.
Parameters
Este é o item que todos se questionam mais cedo ou mais tarde começam a utilizar o tradicional $_GET e se questionam porque o URL tá ficando cheio de &&&& e nem um pouco amigável.
Bom, vão existir casos em que você precisará utilziar $_GET no seu projeto, mas na maioria das situações, não há necessidade.
O Zend utiliza um padrão onde depois de ter encontrado o Module( caso não seja o default), o Controller e o Action ele considerará cada / como um parametro e a próxima / como o valor para este parametro. Exemplo:
1http://zend.localhost/module/controller/action/PARAMETRO1/VALOR1/PARAMETRO2/VALOR2
Logo, se você quisesse passar a Categoria ‘carros’ e a Marca ‘chevrolet’, ficaria assim:
1http://zend.localhost/module/controller/action/categoria/carros/marca/chevrolet
Legal, não é?
Você vai aprender como pegar estes valores na parte onde tratamos GET e POST.
Por ora basta saber isto, entretanto é importante citar aqui que se você utilizar o controller ou action index e deseja obter parametros do URL, você precisará informar no URL, index/index/ caso contrário, o Zend vai entender que o parametro é o nome do controller e por isto não encontrará e mostrará uma mensagem de erro.
Criando um Site Básico
Durante todo o curso de nosso tutorial vamos trabalhar em cima de um projeto e o mesmo será um site básico sem atrativos visuais, mas que demonstrará todo o potencial do Zend.
Nosso site terá dois módulos:
default – onde residirá todo o código de nosso site acessível pelo usuário final do site.
admin – onde residirá toda o código da área administrativa do site.
Criando os Modules
Vamos trabalhar com módulos pois migrar módulos no zend é muito importante, entretanto, por considerarmos utilizamos o ZF Tool, a abordagem tradicional que você encontra na maioria dos tutoriais por ai pode lhe desanimar, e por isto eu já vou antecipar a solução de seus problemas trabalhando com módulos desde já, a fim de deixá-lo capacitado para criar grandes projetos.
Considero que você tem o ZF Tools funcionando perfeitamente, caso não tenha, veja o post anterior a este e configure-o.
Através do terminal do windows, acesse a pasta do projeto:
1 C:/CAMINHO/PARA/SEU/Apache/htdocs/www/tutorial-zend
E digite o comando:
1 zf create module default
e faça o mesmo para o módulo admin
1 zf create module admin
Verifique que dentro de ‘application’ foi criado uma pasta ‘modules’. Abra esta pasta e verifique que foram criados outras pastas ‘default’ e ‘admin’, ambas contendo sua própria estrutura. Note na imagem abaixo que as pastas ‘controllers’ e ‘views’, criadas no post anterior, ainda estão no mesmo lugar de antes.
Na primeira parte de nosso tutorial nós criamos o projeto e ele automaticamente criou a pasta /controllers e /views.
NOTA: Se você acessar o URL do projeto agora http://zend.localhost você verá um erro.
Corrigindo o IndexController.php e ErrorController.php
Você precisará recrir os controladores Index e Error a fim da aplicação funcionar a partir de agora.
A lógica para criar um controller é a seguinte:
1 zf create controller NOME_DO_CONTROLLER 1 NOME_DO_MODULE
NOTAA linha de comando acima é bem intuitiva, entretando o valor booleano “1″ ficou deslocado. Ele significa que queremos criar a estrutura de arquivos views
Como vamos Utilizar uma estrutura modular e criar os comandos através do ZF Tool, cada controller criado dentro do Module irá prefixar a class do controller com Default_.
Isto acontece porque como vários módulos podem ter controladores com o mesmo nome, esta distinção permitirá que o zend carregue o arquivo correto.
Com o ZF Tool aberto digite:
1 zf create controller index 1 default
e
1 zf create controller error 1 default
Isto criará os arquivos IndexController e ErrorController já com suporte à módulos.Deixe o módulo ‘admin’ como está. O objetivo dele por enquanto é meramente ilustrativo, mais adiante veremos como manipulá-lo.
Modifique o conteúdo do arquivo Error Controller para:
1 class Default_ErrorController extends Zend_Controller_Action
2 {
3 public function init() {}
4
5 public function errorAction()
6 {
7 $errors = $this->_getParam('error_handler');
8
9 if (!$errors) {
10 $this->view->message = 'You have reached the error page';
11 return;
12 }
13
14 switch ($errors->type) {
15 case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ROUTE:
16 case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
17 case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:
18 // 404 error -- controller or action not found
19 $this->getResponse()->setHttpResponseCode(404);
20 $priority = Zend_Log::NOTICE;
21 $this->view->message = 'Page not found';
22 break;
23 default:
24 // application error
25 $this->getResponse()->setHttpResponseCode(500);
26 $priority = Zend_Log::CRIT;
27 $this->view->message = 'Application error';
28 break;
29 }
30
31 // Log exception, if logger available
32 if ($log = $this->getLog()) {
33 $log->log($this->view->message, $priority, $errors->exception);
34 $log->log('Request Parameters', $priority, $request->getParams());
35 }
36
37 // conditionally display exceptions
38 if ($this->getInvokeArg('displayExceptions') == true) {
39 $this->view->exception = $errors->exception;
40 }
41
42 $this->view->request = $errors->request;
43 }
44
45 public function getLog()
46 {
47 $bootstrap = $this->getInvokeArg('bootstrap');
48 if (!$bootstrap->hasResource('Log')) {
49 return false;
50 }
51 $log = $bootstrap->getResource('Log');
52 return $log;
53 }
54 }
55
E crie o Action “error” para o controller Error:
1 zf create action error Error 1 default
Mais abaixo você tem uma explicação melhor sobre estes comandos.
Abra o arquivo gerado /modules/default/views/scripts/error/error.phtml e insira o conteudo abaixo:
1<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
2 <html xmlns="http://www.w3.org/1999/xhtml">
3 <head>
4 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
5 <title>Zend Framework Default Application</title>
6 </head>
7 <body>
8 <h1>An error occurred</h1>
9 <h2><?php echo $this->message ?></h2>
10
11 <?php if (isset($this->exception)): ?>
12
13 <h3>Exception information:</h3>
14 <p>
15 <b>Message:</b> <?php echo $this->exception->getMessage() ?>
16 </p>
17
18 <h3>Stack trace:</h3>
19 <pre><?php echo $this->exception->getTraceAsString() ?>
20 </pre>
21
22 <h3>Request Parameters:</h3>
23 <pre><?php echo var_export($this->request->getParams(), true) ?>
24 </pre>
25 <?php endif ?>
26 </body>
27 </html>
Digite qualquer coisa errada no seu url do projeto e veja que este arquivo será utilizado.Então você poderá modificá-lo de acordo com suas necessidades visuais.
IMPORTANTEAPAGUE as pastas /application/controllers e /application/views.
O método init()
Se você já havia analisado anteriormente quando criamos o projeto na primeira parte, você notou que foi gerado automaticamente dentro da Classe IndexController o método init() e o mesmo aconteceu com o ErrorController.Este método está ai por um motivo muito especial. Todo o código que queremos que seja inicializado em todos os actions da aplicação poderão ser colocados ai, tais como: Configurações globais, Variáveis templae para o View, Chamada para Models, etc. Então o Zend gera ele automaticamente para nós, assim como o indexAction().
Criando os Actions para as Páginas do Site
A lógica para criar um action é a seguinte:
1 zf create action NOME_DO_ACTION NOME_DO_CONTROLLER 1 NOME_DO_MODULE
O valor booleano ’1′ indica que queremos que o ZF Tool crie o arquivo ‘.phtml’.
Como nosso site é um site simples, vamos criar as páginas básicas:
Home – que já existe Quem Somos Produtos Serviços Contato
Como vamos criar as páginas e futuramente você vai aprender como criar Routes com o Zend, vamos criá-las a partir do Controller Index, pois por se tratar de um site, toda seção será secundária à Home do site. Caso você fosse criar um Breadcrumb esta lógica faria mais sentido.
Você está aqui: Home
Você está aqui: Home -> Quem Somos
Você está aqui: Home -> Produtos
Você está aqui: Home -> Serviços
Você está aqui: Home -> Contatos
Caso você queira produzir um site com mais subseções, você poderá projetar em cima de outros Controllers, mas por ora, o que vamos aprender basta.
Ainda na pasta do projeto que acessamos anteriormente, digite os comandos para criar as actions.
NOTA: digite ENTER após cada linha abaixo:
1 zf create action quemSomos Index 1 default
1 zf create action servicos Index 1 default
1 zf create action produtos Index 1 default
1 zf create action contato Index 1 default
Abra o arquivo /application/modules/default/IndexController.php e veja que foram adicionados métodos correspondendo com os actions que criamos acima.
Justamente por ser o controller Index que irá controlar as ações de nosso site é que eles foram criados dentro deste arquivo.
Para cada action criado, um arquivo /modules/NOME_DIR_DO_MODULO/NOME_DIR_CONTROLLER/NOME_DO_ACTION.phtml é criado.Os comandos acimas irão gerar a estrutura:
/application/modules/views/scripts/index/quem-somos.phtml /application/modules/views/scripts/index/servicos.phtml /application/modules/views/scripts/index/produtos.phtml /application/modules/views/scripts/index/contato.phtml
LEMBRANDO: Preste atenção nos comandos acima, e note que utilizamos “1 default” no final. Fizemos isto para indicar que queremos que o Zend crie NÃO SOMENTE os métodos actions dentro do controller MAS TAMBÉM as pastas e os arquivos dentro do módulo ‘default’.
CURIOSIDADESe você deseja criar nomes de action tal como “quem-somos”, “resultado-busca”, etc. Que são separados por hífen, você deve unir as palavras do nome desejado e Capitalizar cada palavra dentro da string. Este foi o nosso caso, onde utilizamos “quemSomos” para criar o action “quem-somos”.
CURIOSIDADE: Se você não quiser prefixar as classes do módulo default, basta abrir o arquivo /application/config/application.ini e modificar o valor da linha:
1 resources.frontController.params.prefixDefaultModule = "1"
para
1 resources.frontController.params.prefixDefaultModule = "0"
No entanto, quando você for criar outro controller no módulo default, o ZF Tool irá adicionar o Prefixo e o controlador de erros irá disparar um erro informando que a classe não existe. Então é melhor utilizar o Prefixo.
Testando os actions
Você pode testar agora através dos URL’s:
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
Note que estamos utilizando ‘index’ em todos os urls. Nós gostaríamos de algo como:
http://zend.localhost/home http://zend.localhost/quem-somos http://zend.localhost/servicos http://zend.localhost/produtos http://zend.localhost/contato
Na próxima parte de nosso tutorial, vamos descobrir como fazer isto através de Routes.
Criando um Controller – Sitemap?
Criar um Controller é tão facil quanto criar um action.
A lógica é a seguinte:
1 zf create controller NOME_DO_CONTROLLER 1 NOME_DO_MODULE
Vamos criar um constroller bem peculiar que futuramente utilizaremos para rastreamento de nosso site.
Após aprender a utilizar Routes iremos criar um arquivo sitemap.xml chamado diretamente pelo URL
http://zend.localhost/sitemap.xml
Para criar o controller digite:
1 zf create controller sitemap 1 default
Este comando criará o arquivo /modules/default/controllers/SitemapController.php e o arquivo /modules/default/view/scripts/sitemap/index.phtml.
NOTA Novamente aqui preste atenção em 1 default. Estes parametros tem a mesma função que a vista anteriormente para o Action: “criar as pastas e arquivos”.Quando criamos um novo controller, por padrão o ZF Tool cria o View para o action ‘index’.Confira dentro da pasta /application/modules/default/controllers/ que foi criado o arquivo SitemapController.php e foi criado o arquivo /application/modules/default/view/scripts/sitemap/index.phtml.
DICA: Crie outros projetos testes com o ZF Tool e teste a criação de Actions e Controllers.
Conclusão
Nesta parte do tutorial você aprendeu os conceitos mais importantes e fundamentais sobre o Zend Framework. Aprendeu como utilizar o ZF Tool para criar modules, actions e controllers. Nas próximas parte vamos aprender como criar Routes, Layouts, Forms e criar um Model para registrar nossos contatos no banco de dados e vamos aprender a enviar emails com o Zend Framework. Até a próxima.Abraço do Giba!
[ Tutorial ] Zend Framework – Parte 036 de dezembro de 2011 Tutorial , Zend Framework application.ini. layout , route, script, template, Tutorial, view, Zend Framework
Routes, Layout, View
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.
Clique aqui para ver todos os tutoriais disponíveis
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 -> CategoriasProdutos -> ResultadosPRodutos -> 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:
1 ;
2 [production]
3 resources.router.routes.home.route = /home
4 resources.router.routes.home.defaults.module = default5 resources.router.routes.home.defaults.controller = index
6 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‘:
1 resources.router.routes.home.route = /home
A segunda linha define o module, no nosso caso ‘default‘ que é o modulo padrão:
1 resources.router.routes.home.defaults.module = default
A terceira linha define o controller (index) :
1 resources.router.routes.home.defaults.controller = index
E a quarta define o action (index) :
1 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:
1 ;
2 [production]
3 ; home
4 resources.router.routes.home.route = /home
5 resources.router.routes.home.defaults.module = default
6 resources.router.routes.home.defaults.controller = index7 resources.router.routes.home.defaults.action = index
8
9 ;quemsomos
10 resources.router.routes.quemsomos.route = /quem-somos
11 resources.router.routes.quemsomos.defaults.module = default
12 resources.router.routes.quemsomos.defaults.controller = index13 resources.router.routes.quemsomos.defaults.action = quem-somos
14
15 ;servicos
16 resources.router.routes.servicos.route = /servicos
17 resources.router.routes.servicos.defaults.module = default
18 resources.router.routes.servicos.defaults.controller = index19 resources.router.routes.servicos.defaults.action = servicos
20
21 ;produtos
22 resources.router.routes.produtos.route = /produtos
23 resources.router.routes.produtos.defaults.module = default
24 resources.router.routes.produtos.defaults.controller = index25 resources.router.routes.produtos.defaults.action = produtos
26
27 ; contato
28 resources.router.routes.contato.route = /contato
29 resources.router.routes.contato.defaults.module = default
30 resources.router.routes.contato.defaults.controller = index31 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:
1 zf enable layout
Este comando criará uma pasta e um arquivo em ‘/application/layouts/scripts/layout.phtml’ com a linha:
1 <?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:
1 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:
1 <html>
2 <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
3 <title>Meu Projeto Zend Framework</title>
4 <body>
5 <div id="header">{Meu Cabeçalho aqui}</div>
6 <div id="content">
7 <?php echo $this->layout()->content; ?>
8 </div>
9 <div id="footer">{Meu rodapé aqui}</div>
10 </body>
11 </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:
1 <?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:
1 // pagina home
2 ...
3 <title>Seja Bem Vindo - Tutorial Zend</title>
4 ...
5 <h1>Seja Bem vindo</h1>
6
7 ...
8
9 // pagina quem-somos
10 ...
11 <title>Quem Somos - Tutorial Zend</title>
12 ...
13 <h1>Quem Somos</h1>
14
15 ...
16
17 /**
18 * E ASSIM POR DIANTE!!!!19 */
Para fazermos isto, precisamos utilizar o View da seguinte forma:
Abra o arquivo IndexController.php
E insira as linhas dentro do método indexAction():
1 ...
2 public function indexAction()
3 {
4 $this->view->pageTitle = 'Seja Bem-vindo - Tutorial Zend';5 $this->view->contentTitle = 'Seja Bem-vindo';
6 }
7 ...
No arquivo view/scripts/index/index.phtml remova todo o conteúdo gerado automaticamente e coloque:
1 <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:
1 ...
2 <title><?= $this->pageTitle;?></title>3 ...
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:
1 $this->view->CHAVE = VALOR;
E no view script (arquivo .html do action):
1 $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!
[ Tutorial ] Zend Framework – Parte 048 de dezembro de 2011 Tutorial , Zend Framework application.ini , getParam, getRequest, router, Tutorial, Zend Framework
getRequest, getParam, Routes, Views
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.
Clique aqui para ver todos os tutoriais disponíveis
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:
1 // Como citado anteriormente, o método init é o melhor lugar
2 // para guardarmos configurações e outras variáveis globais
3 // aos nossos actions dentro de um controller
4 // por isto vamos testar nosso controller aqui
5 public function init()
6 {
7 $this->request = $this->getRequest();
8 }
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:
1 public function init()
2 {
3 $this->request = $this->getRequest();
4
5 // passamos alguns valores para o view
6 $this->view->module = $this->request->getModuleName();
7 $this->view->controller = $this->request->getControllerName();
8 $this->view->action = $this->request->getActionName();
9 }
Abra o arquivo /modules/default/view/scripts/index.phtml e adicione as linhas:
1 ...
2 <h2>Teste de Objeto Request</h2>
3 <strong>Modulo: </strong> <?= $this->module; ?>
4 <br />
5 <strong>Controller: </strong> <?= $this->controller; ?>
6 <br />
7 <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:
1 ...
2 <h2>Teste de Objeto Request</h2>
3 <strong>Modulo: </strong> <?= $this->module; ?>
4 <br />
5 <strong>Controller: </strong> <?= $this->controller; ?>
6 <br />
7 <strong>Action: </strong> <?= $this->action; ?>
Acesso o url do action http://zend.localhost/servicosComo 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:
1 public function produtosAction()
2 {
3 $produtos = array(
4 1 => array(
5 'nome' => 'TV',
6 'descricao' => 'Descrição da TV aqui'
7 ),
8 2 => array(
9 'nome' => 'Celular',
10 'descricao' => 'Descrição do Celular aqui'
11 ),
12 3 => array(
13 'nome' => 'Notebook',
14 'descricao' => 'Descrição do Notebook aqui'
15 ),
16 4 => array(
17 'nome' => 'Aparelho de Som',
18 'descricao' => 'Descrição do Aparelho de Som aqui'
19 ),
20 );
21
22 $id = $this->request->getParam( 'id' );
23
24 if( $id != false ) :
25 // vamos definir os valore encontrados nas chaves do vetor
26 // e passar os mesmos para o View a fim de obter
27 // estes valores no arquivo produtos.phtml
28 $this->view->nome = $produtos[$id]['nome'];
29 $this->view->descricao = $produtos[$id]['descricao'];
30 endif;
31
32 }
Abra o aquivo produtos.phtml dentro da pasta dos views e insira o código abaixo:
1 <h1><?= $this->contentTitle; ?>
2 <?php if( $this->id != '' ) : ?>
3 <h2><?= $this->nome; ?></h2>
4 <div>
5 <?= $this->descricao; ?>
6 </div>
7 <?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:
1 array (
2 'controller' => 'produtos',
3 'action' => 'id',
4 'module' => 'default',
5 )
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:
1 ;produtos/id/
2 resources.router.routes.produtosId.route = /produtos/id/:id
3 resources.router.routes.produtosId.defaults.module = default
4 resources.router.routes.produtosId.defaults.controller = index
5 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 pararesources.router.routes.produtosId.routeSerá 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/1Bastaria modificar o roteamento para:
1 ;produtos/:id
2 resources.router.routes.produtos.route = /produtos/:id
3 resources.router.routes.produtos.defaults.module = default
4 resources.router.routes.produtos.defaults.controller = index
5 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:
1;/produtos/fab/:fabricante/cat/:categoria/marcar/:marca/mod/:modelo/cor/:cor/
2resources.router.routes.produtos.route = /produtos/fab/:fabricante/cat/:categoria/marcar/:marca/mod/:modelo/cor/:cor/
3 ...
Ou simplesmente:
1;/produtos/:fabricante/cat/:categoria/marcar/:marca/mod/:modelo/cor/:cor/
2resources.router.routes.produtosEx.route = /produtos/:fabricante/:categoria/:marca/:modelo/:cor/
3 ...
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!
[ Tutorial ] Zend Framework – Parte 0510 de dezembro de 2011 Tutorial , Zend Framework formularios , post, Tutorial, validação, Zend Framework, zend_mail
Formulários, Zend_Mail
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.
Clique aqui para ver todos os tutoriais disponíveis eAqui para baixar os arquivos do projeto usados neste tutorial
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:
1 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
1 <?php
2
3 class Application_Form_Contato extends Zend_Form
4 {
5
6 public function init()
7 {
8 /* Form Elements & Other Definitions Here ... */9 }
10
11
12 }
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
1 ...
2 public function contatoAction
3 {
4 $form = new Application_Form_Contato();5 $this->view->form = $form;
6 }
7 ...
e no arquivo view contato.phtml coloque em qualquer lugar a sentença:
1 <?= $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:
1 resources.router.routes.contato.route = /contato
2 resources.router.routes.contato.defaults.module = default3 resources.router.routes.contato.defaults.controller = index
4 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:
1 <form enctype="application/x-www-form-urlencoded" action="" method="post"><dl class="zend_form">
2 </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.
1 <?php
2 class Default_Form_Contato extends Zend_Form
3 {
4 public function init()
5 {
67 /*******************************************
8 * As definições abaixo são obrigatórias
9 * todo formulário deve conter
10 *******************************************/
11 /**
12 * Vai gerar o atributo/valor name="contato"
13 */
14 $this->setName( 'contato' );
15 /**
16 * Vai gerar o atributo/valor action="/contato"
17 */
18 $this->setAction( '/contato' );
19 /**
20 * Vai gerar o atributo/valor method="post"
21 */
22 $this->setMethod( 'post' );
23
24 /**********************************************
25 * As definições abaixo são opcionais
26 * e dependem de peculiaridades de seu FORM
27 *********************************************/
28 $this->setAttrib('enctype', 'multipart/form-data');
29 /**
30 * Vai gerar o atributo/valor id="form-contato"
31 */
32 $this->setAttribute( 'id', 'form-contato' );33 }
34 }
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:
1 class Application_Form_Contato extends Zend_Form
2 {
3 public function init()
4 {
5 /**
6 * Definições para o FORM
7 */
8 $this->setName( 'contato' );9 $this->setAction( '/contato' );
10 $this->setMethod( 'post' );
11 $this->setAttrib( 'enctype', 'multipart/form-data' );
12 $this->setAttrib( 'id', 'form-contato' );
13
14 /**15 * Elementos do formulário
16 */
17 $tratamento = new Zend_Form_Element_Radio('tratamento');18 $tratamento->setLabel('Como gostaria de ser atendido?')19 ->addMultiOptions(
20 array(
21 'Você' => 'Você',
22 'Sr(a).' => 'Sr(a)',23 'Pelo Nome' => 'Pelo Nome',
24 )
25 )
26 ->setValue('Pelo Nome');
27
28 $nome = new Zend_Form_Element_Text( 'nome' );29 $nome->setLabel( 'Nome' );
30
31 $email = new Zend_Form_Element_Text( 'email' );
32 $email->setLabel( 'E-mail' );
33
34 $assunto = new Zend_Form_Element_Select( 'assunto' );35 $assunto->setLabel('Assunto')
36 ->addMultiOptions(
37 array(
38 '' => ' - - Escolha um assunto - - ', // em branco
39 'Dúvidas' => 'Dúvidas',40 'Elogios' => 'Elogios',41 'Reclamações' => 'Reclamações',
42 'Outros' => 'Outros',
43 )
44 );
45
46 $mensagem = new Zend_Form_Element_Textarea( 'mensagem' );47 $mensagem->setLabel( 'Mensagem' );
48
49 $newsletter = new Zend_Form_Element_MultiCheckbox( 'newsletter' );
50 $newsletter->setLabel('Gostaria de Assinar Nosso Newsletter?')
51 ->addMultiOptions(
52 array(
53 'Tecnologia' => 'Tecnologia',
54 'Entretenimento' => 'Entretenimentos',55 'Curiosidades' => 'Curiosidades',
56 'Produtos' => 'Produtos',
57 'Nenhum' => 'Não quero receber'
58 )
59 )
60 ->setValue( 'Nenhum' );
61
62 $submit = new Zend_Form_Element_Submit( 'submit' );63 $submit->setLabel( 'Enviar' );
64 $this->addElements(
65 array(
66 $tratamento,
67 $nome,
68 $email,
69 $assunto,
70 $mensagem,71 $newsletter,
72 $submit
73 )
74 );
75
76 }77 }
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
1 $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:
1 ...
2 $nome = new Zend_Form_Element_Text( 'nome' );
3 $nome->setLabel( 'Nome' )
4 ->setRequired( true )5 ->addValidator( 'NotEmpty' )
6 ->addFilter( 'StripTags' )
7 ->addFilter( 'StringTrim' )
8 ->addErrorMessage('Informe o seu nome');9
10
11 $email = new Zend_Form_Element_Text( 'email' );
12 $email->setLabel( 'E-mail' )
13 ->setRequired( true )
14 ->addValidator( 'NotEmpty' )
15 ->addFilter( 'StripTags' )
16 ->addFilter( 'StringTrim' )17 ->addErrorMessage('Informe o seu email');
18
19 $assunto = new Zend_Form_Element_Select( 'assunto' );
20 $assunto->setLabel('Assunto')
21 ->addMultiOptions(
22 array(
23 '' => ' - - Escolha um assunto - - ', // em branco
24 'Dúvidas' => 'Dúvidas',
25 'Elogios' => 'Elogios',
26 'Reclamações' => 'Reclamações',27 'Outros' => 'Outros',
28 )
29 )
30 ->setRequired( true )31 ->addErrorMessage('Escolha o assunto');
32
33 $mensagem = new Zend_Form_Element_Textarea( 'mensagem' );
34 $mensagem->setLabel( 'Mensagem' )
35 ->setRequired( true )
36 ->addValidator( 'NotEmpty' )
37 ->addFilter( 'StripTags' )
38 ->addFilter( 'StringTrim' )39 ->addErrorMessage('Escreva uma mensagem');
40 ...
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:
1 $nome = new Zend_Form_Element_Text( 'nome' );
2 $nome->setLabel( 'Nome' )
3 // Marca o campo como obrigatório
4 ->setRequired( true )
5 // Não pode estar vazio
6 ->addValidator( 'NotEmpty' )
7 // Remove TAGS HTML
8 ->addFilter( 'StripTags' )9 // Remove espaços brancos no inicio e fim
10 ->addFilter( 'StringTrim' )
11 // Define uma mensagem de erro personalizada
12 ->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:
1 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:
1 ...
2 public function contatoAction()3 {
4
5 $form = new Application_Form_Contato();
6 $this->view->form = $form;
7
8 $dadosFormulario = $this->getRequest()->getPost();
9
10 if( $this->getRequest()->isPost() ) {
11
12 if( $form->isValid( $dadosFormulario ) ) {
13 } else {
14 $form->populate( $dadosFormulario );15 }16 }17 }
18 ...
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:
1 $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 nada2 – Se for falso popula o formulário novamente incluindo as mensagens de erros passadas pela validação.
1 ...
2 if( $this->getRequest()->isPost() ) {
3
4 if( $form->isValid( $dadosFormulario ) ) {
5 } else {
6 $form->populate( $dadosFormulario );7 }
8 }
9 ...
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:
1 if( $form->isValid( $dadosFormulario ) ) {
2 $this->_redirect( '/contato' );
3 // ou
4 // $this->_redirect( '/qualquer-pagina-com-mensagem' );5 }
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:
1 ...
2 public function contatoAction()3 {
4
5 $form = new Application_Form_Contato();
6 $this->view->form = $form;
7
8 $dadosFormulario = $this->getRequest()->getPost();
9
10 if( $this->getRequest()->isPost() ) {
11
12 if( $form->isValid( $dadosFormulario ) ) {
13
14 $tratamento = $form->getValue('tratamento');
15 $nome = $form->getValue('nome');
16 $email = $form->getValue('email');
17 $assunto = $form->getValue('assunto');
18 $mensagem = $form->getValue('mensagem');19 $newsletter = $form->getValue('newsletter');
20
21 $conteudo = sprintf('
22 Assunto: <STRONG>%s</STRONG><BR>
23 <HR>
24 Tratamento: <STRONG>%s</STRONG><BR>
25 Nome: <STRONG>%s</STRONG><BR>
26 E-mail: <STRONG>%s</STRONG><BR>
27 Mensagem: <STRONG>%s</STRONG><BR>
28 Newsletter: <STRONG>%s</STRONG><BR>
29 '
30 , $assunto31 , $tratamento
32 , $nome
33 , $email
34 , nl2br( $mensagem )35 , implode(', ', $newsletter )
36 );
37
38 $to = '[email protected]';
39
40 $subject = utf8_decode( "Contato pelo site por: " . $nome );
41 $html = "
42 <html>
43 <body>
44 ".$conteudo."45 </body>46 </html>47 ";
48
49 $mail = new Zend_Mail('utf-8');
50 $mail->setBodyHtml( $html );
51 // poderia ser somente texto
52 //$mail->setBodyText( $text );
53 $mail->setFrom( $email, $nome );
54 $mail->addTo( $to, 'Contato Site');55 $mail->setSubject( $subject );
56 $mail->send();
575859 $this->_redirect( '/contato' );
60 // ou
61 // $this->_redirect( '/qualquer-pagina-com-mensagem' );
62 } else {
63 $form->populate( $dadosFormulario );
64 }
65 }
66
67 }
68 ...
Creio que o código acima é bem intuitivo.Abraços do Giba!
[ Tutorial ] Zend Framework – Parte 0614 de dezembro de 2011 Tutorial , Zend Framework db-table , delete, fetchrow, INSERT, model, update, Zend Framework, zend_db_table_abstract
Models, CRUD, Zend_Db_Table
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.
Clique aqui para ver todos os tutoriais disponíveis eAqui para baixar os arquivos do projeto usados neste tutorial
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
1 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:
1 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:
1 zf create db-table Usuario usuarios
E acesse o arquivo gerado em /application/models/DbTable/Usuario.php.Ele deve conter:
1 class Application_Model_DbTable_Usuario extends Zend_Db_Table_Abstract
2 {
3 protected $_name = 'usuarios';
4 }
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:
1 [production]
2 resources.db.adapter = "Pdo_Mysql"3 resources.db.params.host = "localhost"
4 resources.db.params.username = "root"
5 resources.db.params.password = ""
6 resources.db.params.dbname = "tutorial-zend"7 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.
Utilizando o Zend Tools para configurar a Conexão Adicionado: 25/06/13
Você também poderia utilizar o ZF para configurar a conexão com o banco de dados.Para tal, considerando as configurações anteriores que você colocou no application.ini, você deverá acessar o diretório onde você criou o projeto com o ZF e digitar a linha de comando:
1zf configure db-adapter "adapter=Pdo_Mysql&host=localhost&username=root&password=&dbname=tutorial-zend&charset=utf8"
Ao executar o comando acima, o código gerará todos os parametros de configuração que definimos manualmente antes.Note que todos os parametros de configuração são passados como se fosse um URL separado por &CHAVE=VALOR.
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.
1 CREATE TABLE IF NOT EXISTS `usuarios` (
2 `id` int(10) unsigned NOT NULL AUTO_INCREMENT,3 `nome` varchar(120) COLLATE utf8_unicode_ci NOT NULL,
4 `email` varchar(120) NOT NULL,
5 `login` varchar(120) NOT NULL,
6 `senha` varchar(30) NOT NULL,
7 PRIMARY KEY (`id`)
8 ) 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:
1 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’.
1 class Admin_UsuarioController extends Zend_Controller_Action
2 {
3
4 public function init()
5 {
6 /* Initialize action controller here */7 }
8
9 public function indexAction()
10 {
11 // action body
12 }
13 }
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.
1 ...
2 public function init()
3 {
4 // Não preciso explicar não eh?
5 $this->_db = new Application_Model_DbTable_Usuario();
6 }
7 ...
E para testar, vamos criar um action dentro do controller Usuario do módulo Admin.
1 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.
1 ...
2 public function addAction()
3 {
4 $dados = array(
5 'id' => null,
6 'nome' => 'Zé Ninguém',7 'email' => '[email protected]',
8 'login' => 'zeninguem',
9 'senha' => md5('123456'),
10 );
11 $res = $this->_db->insert( $dados );
12 }
13 ...
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:
1 zf create action update usuario 1 admin
E no método updateAction():
1 ...
2 public function updateAction()
3 {
4 $dados = array(
5 'nome' => 'Seu Nome Aqui',
6 'email' => '[email protected]',
7 'login' => 'seu_login',
8 'senha' => md5('sua_senha'),9 );
10
11 $this->_db->update( $dados, 'id = 1' );
12 }
13 ...
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.
1 zf create action delete usuario 1 admin
e no método deleteAction():
1 ...
2 public function deleteAction()
3 {
4 $this->_db->delete( 'id = 2' );5 }
6 ...
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:
1 zf create action list usuario 1 admin
E no método listAction():
1 ...
2 public function listAction()
3 {
4 $usuario = $this->_db->fetchRow( 'id = 1' );5 $this->view->usuario = $usuario;
6 }
7 ...
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:
1 <h2>Informações do Usuário</h2>
2 <table>
3 <tr>
4 <th>Nome</th>5 <td><?= $this->usuario->nome; ?>
6 </tr>
7 <tr>
8 <th>Login</th>9 <td><?= $this->usuario->login; ?>
10 </tr>
11 <tr>
12 <th>E-mail</th>13 <td><?= $this->usuario->email; ?>
14 </tr>
15 </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:
1 ...
2 $usuario = $this->_db->fetchRow( 'id = 1')->toArray();3 ...
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!
