Inslatar o Zend Framework 2 "sem" o composer.phar

Esses dias fui instalar o zend framework 2 fazendo o clone pelo git como sempre fiz e percebi que o pacote não tinha o arquivo composer.phrar. Pesquisando na internet consegui encontrar a solução.

Segue abaixo o passo-a-passo da instalação (linux/mac):

1 - Vá até o diretório desejado
cd /var/www/html/

2 - Criar pasta do projeto
mkdir zf2teste

3 - Baixar o composer.phrar
curl -s https://getcomposer.org/installer | php --

4 - Instalar o Zend Framework 2 no diretório desejado
php composer.phar create-project --stability="dev" zendframework/skeleton-application zf2teste

5 - Mover o arquivo composer.phrar para a pasta do projeto, para futuras atualizações
mv composer.phar /zf2teste

6 - Iniciando o servidor emputido
cd zf2teste/public
php -S localhost:8888

7 - Para testar se a instalação está correta, abra o navegador e acesse:
http://localhost:8888

8 - Para instalar o doctrine 2, vá na pasta root do zend framework onde está o arquivo composer.phrar e digite o seguinte comando:
php composer.phar require doctrine/doctrine-orm-module

Mais informações:

http://framework.zend.com/manual/current/en/ref/installation.html

https://github.com/zendframework/ZendSkeletonApplication

https://github.com/doctrine/DoctrineORMModule

Sessions no Zend Framework 2

Existem diversos modos de utilizarmos as sessões no Zend Framework 2, vamos aprender um dos modos mais simples que é usando a classe Container.

segue abaixo um exemplo de como utilizar:


01 - criando a sessão e setando valores

use Zend\Session\Container;

$sessionContainer = new Container('admin_auth');
$sessionContainer->usuario_id = $data->getAdminId();
$sessionContainer->usuario_email = $data->getAdminEmail();

02 - Recuperando os dados setados na sessão

$sessionContainer = new Container('admin_auth');
$serviceLog = $this->getServiceLocator()->get('Usuario\Service\AdminLogService');

return $serviceLog->insert(array('admin_id' => $sessionContainer->admin_id, 'admin_data' => date('Y-m-d')));

Mais informações:

http://framework.zend.com/manual/current/en/modules/zend.session.container.html

FlashMessager no Zend Framework 2

O Zend Framework 2 possui um componente chamado FlashMessager que nos ajuda a mostrar mensagens nas views.

Segue um exemplo de como utilizar esse recurso:

01 - Na classe de controller:

public function deleteAction($id){
     
     $service = $this->getServiceLocator()->get('Administrador\Service\');

     if($service->delete($id)){
          $this->flashMessenger()->addSuccessMessage('Excluído com sucesso.');
     }
     else{
          $this->flashMessenger()->addErrorMessage('Erro ao excluir.');
     }

     return $this->redirect()->toRoute('adm-home');

}

02 - Na view

<?php
     
     echo $this->flashMessenger()->renderCurrent('success', array('alert', 'alert-success'));
     echo $this->flashMessenger()->renderCurrent('error', array('alert', 'alert-danger'));

?>

Mais informações:

http://framework.zend.com/manual/current/en/modules/zend.view.helpers.flash-messenger.html

http://framework.zend.com/apidoc/2.2/classes/Zend.Mvc.Controller.Plugin.FlashMessenger.html

Hydrator - Zend Framework 2

O Hydrator é um componente do Zend Framework 2 que nos ajuda a transformar um objeto em array e um array em objeto.

Segue um exemplo de como usa-lo na sua classe de serviço:

<?php

namespace Administrador\Service;

use Zend\Stdlib\Hydrator\ClassMethods;

class AdministradorService{

private function toArray($obj) {        
$classMethod = new ClassMethods();        
       return $classMethod->extract($obj);
}
   
private function toObject(Array $data, $entity) {        
$classMethod = new ClassMethods();        
return $classMethod->hydrate($data, $entity);
}

}

?>

Mais informações:

http://framework.zend.com/manual/current/en/modules/zend.stdlib.hydrator.html

http://framework.zend.com/manual/current/en/modules/zend.stdlib.hydrator.strategy.html

CRUD no Zend Framework 2 - Delete

A última parte do crud é o delete. Vamos ver como excluir um registro do banco de dados usando o Zend Framework2 e o Doctrine 2.

01 - A rota para acessar o controller deve ser Segment pois iremos passa o id do registro pela url. Vamos acessar module/Administrador/config/module.config.php e adicionar a rota:

'adm-delete' => array(
                'type' => 'Segment',
                'options' => array(
                    'route' => '/administrador/delete[/:id]',
                    'constraints' => array(
                        'id' => '\d+'
                    ),
                    'defaults' => array(
                        'controller' => 'Administrador\Controller\Administrador',
                        'action' => 'delete',
                    ),
                )

            ),

02 - O controller deve conter o método deleteAction para enviar os dados a classe de serviços: A classe AdministradorController está localizada em: module/Administrador/src/Administrador/Controller/

public function deleteAction() {

        //pegando o parâmetro da rota
        $admId = $this->params()->fromRoute('id', 0);

        $admService = $this->getServiceLocator()->get('Administrador\Service\AdministradorService');
        $delete = $admService ->delete($admId);
        if (is_null($delete)) {
            $this->flashMessenger()->addSuccessMessage('Excluído com sucesso.');
        } else {
            $this->flashMessenger()->addErrorMessage('Erro ao excluir.');
        }
        return $this->redirect()->toRoute('adm-home');

    }

03 - A classe de serviço recebe o id do registro recupera os dados do registro no banco de dados e então exclui o mesmo. Em module/Administrador/src/Administrador/Service/ podemos encontrar a classe AdministardorService:

public function delete($id) {
        $entity = $this->em->getReference($this->entity, $id);
        if ($entity) {
            $this->em->remove($entity);
            return $this->em->flush();
        } else {
            return false;
        }

    }

CRUD no Zend Framework 2 - Update

O processo de alteração de registros no banco de dados é sempre o mais burocrático, pois antes de fazer todo o processo de alteração temos de recuperar o registro que queremos alterar. Vamos ver como fazer estes dois processo com usando o Zend Framework 2 e o Doctrine 2.

01 - A rota é o primeiro passo. Temos que criar duas rotas uma para carregar o formulário com os dados vindo do banco de dados (update) e outra para enviar os dados ao banco de dados (edit). Vamos acessar module/Administrador/config/module.config.php.


'adm-edit' => array(
                'type' => 'Zend\Mvc\Router\Http\Literal',
                'options' => array(
                    'route' => '/adm/edit',
                    'defaults' => array(
                        'controller' => 'Administrador\Controller\Administrador',
                        'action' => 'edit',
                    ),
                ),
            ),
'carro-update' => array(
                'type' => 'Segment',
                'options' => array(
                    'route' => '/adm/update[/:id]',
                    'constraints' => array(
                        'id' => '\d+'
                    ),
                    'defaults' => array(
                        'controller' => 'Administrador\Controller\Administrador',
                        'action' => 'update',
                    ),
                )
            ),

02 - Vamos criar os métodos no controller. A classe do controller fica em module/Administrador/src/Administrador/Controller/AdministradorController.php

public function editAction() {
        $admService = $this->getServiceLocator()->get('Administrador\Service\AdministradorService');
        if ($this->getRequest()->isPost()) {
            $data = $this->getRequest()->getPost()->toArray();
            $up = $admService ->update($data);
            if (is_null($up)) {
                $this->flashMessenger()->addSuccessMessage('Alterado com sucesso.');
            } else {
                $this->flashMessenger()->addErrorMessage('Erro ao alterar.');
            }
            return $this->redirect()->toRoute('adm-home');
        } 
    }

    public function updateAction(){
        $admService = $this->getServiceLocator()->get('Administrador\Service\AdministradorService');
        $admId = $this->params()->fromRoute('id', 0);
        $data['form'] = $admService ->popForm($admId);
        return new ViewModel($data);
    }

03 - Vamos acessar a nossa classe de serviços para criarmos três métodos: um para recuperar os dados do registro do banco de dados, um para popular o formulário com o registro recuperado e o último para efetuar a alteração dos registros. A classe de serviços do módulo está localizada em module/Administrador/src/Administrador/Service/AdministradorService.php

use Carro\Form\CarroForm;

public function getById($adm_id) {
        $admRepository = $this->em->getRepository('Administrador\Entity\Administrador');
        return $admRepository ->get(array('adm_id' => $adm_id));
    }    
    
    //populando o formulario (alterar)
    public function popForm($id){       
        $administrador= $this->getById($id);        
        $array = $this->toArray($administrador);        
        $form = new AdministardorForm();       
        $form->populateValues($array);        
        return $form;
    }
    
    public function update(Array $data){
        $entity = $this->em->getReference($this->entity, $data['adm_id']);
        $obj = $this->toObject($data, $entity);
        $this->em->persist($obj);
        return $this->em->flush();

    }

04 - A nossa classe de repository precisa de mais um método get() onde passamos um array com as condições que queremos fazer a busca (where).

//pegando os registros pelos parametros passados
public function get($where=array()){      
    return $this->findOneBy($where);

}

05 -  O último é acessar module/Administrador/view/administrador/administrador/ e criar o arquivo update.phtml

<?php
$form = $this->form;
$form->setAttribute('action', $this->url('adm-edit'));
$form->prepare();
echo $this->form()->openTag($form);
echo $this->formCollection($form);
echo $this->form()->closeTag();

CRUD no Zend Framework 2 - Select

Vamos utilizar o Repository do Doctrine 2 para recuperar os registros do banco de dados no Zend Framework 2.

Segue abaixo o passo-a-passo:

01 - Vamos adicionar a rota em module/config/module.config.php:

'adm-home' => array(
                'type' => 'Zend\Mvc\Router\Http\Literal',
                'options' => array(
                    'route' => '/adm-home',
                    'defaults' => array(
                        'controller' => 'Administrador\Controller\Administrador',
                        'action' => 'select',
                    ),
                ),

            ),

02 - No controller iremos criar o método responsável por recebemos os dados da classe de serviços e enviarmos a view. Então acessando module/Administrador/src/Administrador/Controller/AdministradorController.php:

public function selectAction() {

        //instanciando a classe de serviços
        $admService = $this->getServiceLocator()->get('Administrador\Service\AdministradorService');  
      
        //recuperando os registros do banco de dados
        $data['administradores'] = $admService ->getAll();

        //retornando os dados para a view
        return new ViewModel($data);


    }

03 - Na classe de serviços do módulo temos que fazer a conexão com o Repository da entidade. A classe está em module/Administrador/src/Administrador/Service:

Vamos adicionar a chamada da classe EntityManager do Doctrine:
use Doctrine\ORM\EntityManager;

Então criar o método para se conectar com o repository e retornar os registros ao controller:
public function getAll() {
        $admRepository = $this->em->getRepository('Administrador\Entity\Administrador');
        return $admRepository ->get();

}

04 - Vamos acessar o diretório module/Administrador/src/Administrador/Entity para criarmos o método get();

//pegando os registros pelos parâmetros passados
public function get(){      
     return $this->findAll();

}

05 - Vamos criar o arquivo select.phtml em module/Administrador/view/administrador/administrador/ para exibirmos os registros:

<table class="table table-condensed table-hover table-striped">
                <thead>
                    <tr>
                        <th>ID</th>
                        <th>Nome</th>
                        <th>E-mail</th>                        
                    </tr>
                </thead>
                <tbody>
                    <?php
                    foreach ($administradores as $adm) {                   
                        
                        echo
                        "<tr>
                            <td>{$adm->getAdministradorId()}</td> 
                            <td>{$adm->getAdministradorNome()}</td>
                            <td>{$adm->getAdministradorEmail()}</td>
                        </tr>";
                    }
                    ?>
                </tbody>

            </table>

CRUD no Zend Framework 2 - Insert

Vamos começar a fazer um crud (inserir, selecionar, alterar e excluir registros do banco de dados) com zend framework 2 utilizando o doctrine 2.

Vamos seguir os passos abaixo para aprendermos como cadastrar um registro no banco de dados:

01 - Registrar a rota na action do formulário que deverá chamar o controller e action para o cadastro.

Então vamos abrir nosso arquivo .phtml localizado em module/Administrador/view/administrador/administrador/index/index.phtml, deixando a action assim:

$form->setAttribute('action', $this->url('adm-insert'));

02 - Em module/Administrador/config/module.config.php, vamos adicionar uma nova rota do tipo literal:

'adm-insert' => array(
                'type' => 'Zend\Mvc\Router\Http\Literal',
                'options' => array(
                    'route' => '/adm-insert',
                    'defaults' => array(
                        'controller' => 'Administrador\Controller\Administrador',
                        'action' => 'insert',
                    ),
                ),

            ),

03 - O nosso controller deverá conter a action responsável por instanciar o serviceManager e enviar os dados vindo do formulário ao service para então serem inseridos no banco de dados.

Vamos acessar o diretório module/Administrador/src/Administrador/Controller/AdministradorController.php
public function insertAction() {

        //verificando se a requisão é via POST
        if ($this->getRequest()->isPost()) {

            //convertendo dados recebido via POST em array
            $data = $this->getRequest()->getPost()->toArray();

            //localizando o service manager do módulo
            $serviceAdm = $this->getServiceLocator()->get('Administrador\Service\AdministradorService');

            //chamando o método responsavel pela inserção e verificando se não retorna nulo
            if (is_null($serviceAdm->insert($data))) {

                //caso volte nulo (cadastro realizado com sucesso) gera uma mensagem
                $this->flashMessenger()->addSuccessMessage('Cadastrado com sucesso.');
            } else {

                //caso não volte nulo (erro ao cadastrar) gera uma mensagem de erro
                $this->flashMessenger()->addErrorMessage('Erro ao cadastrar.');
            }

            //redirecionando para a página inicial
            return $this->redirect()->toRoute('adm-home');

        }

    }

04 - Devemos criar a classe service e já declarar o método responsavel por tratar e incluir os registros no banco de dados. Nossa classe AdministradorService deverá ser criada em module/Administrador/src/Administrador/Service/ e deverá ficar da seguinte forma:

<?php

namespace Administrador\Service;

use Doctrine\ORM\EntityManager;
use Administrador\Entity\Administradoras AdministradorEntity;

use Zend\Stdlib\Hydrator;

class AdministradorService {

    private $em;
    private $entity = 'Administrador\Entity\Administrador';

    public function __construct(EntityManager $em) {
        $this->em = $em;
    }

    public function insert(Array $data = array()) {
        $entity = new AdministradorEntity();

        //o doctrine espera receber um objeto para inserir-lo no banco de dados
        //então criamos um método para converter um array em objeto
        $obj = $this->toObject($data, $entity);

        $this->em->persist($obj);
        return $this->em->flush();
    }    

    private function toObject(Array $data, $entity) {
        return (new Hydrator\ClassMethods())->hydrate($data, $entity);

    }  


}

05 - Devemos registrar nosso serviço no arquivo Module.php localizado na root do nosso Modulo.

O primeiro passo é chamar a classe de serviço :

use Administrador\Service\AdministradorService;

Agora podemos declara o método getServiceConfig:

public function getServiceConfig() {
        return array(
            'factories' => array(
                'Administrador\Service\AdministradorService' => function($sm) {
                    $em = $sm->get('Doctrine\ORM\EntityManager');
                    return new AdministradorService($em);
                },
            )
        );

    }

Repository do Doctrine 2 no Zend Framework2

A classe Repository usanda pelo Doctrine é utilizada para recuperar os registros do banco de dados através da classe EntityRepository.

Para utilizarmos o Reposository primeiro devemos acessar a classe da nossa entidade em:
module/src/Administrador/Entity.

1 - Devemos adicionar a linha para registrarmos a localização da classe do repository.


/**
 * Administrador
 *
 * @ORM\Table(name="administrador")
 * @ORM\Entity
* @ORM\Entity(repositoryClass="Administrador\Entity\AdministradorRepository")
 */

2 - No diretório Administrador/Entity/ criamos a classe AdministradorRepository.php

<?php

namespace Administrador\Entity;

use Doctrine\ORM\EntityRepository;

class AdministradorRepository extends EntityRepository {
    
    //pegando os registros pelos parâmetros passados, retornando apenas 1 registro
    public function get($where=array()){      
        return $this->findOneBy($where);
    }
    
    //pegando os registros pelos parâmetros passados, retornando N registros
    function getWhere($where=array()){
        return $this->findBy($where);
    }
    
}

Mais informações:

http://www.doctrine-project.org/api/orm/2.2/class-Doctrine.ORM.EntityRepository.html

Entity no Zend Framework 2

A classe Entity é a responsável por encapsular os dados de envio e retorno entre o banco de dados e a aplicação.

Seguem abaixo um exemplo de entidade criada para ser consumida pelo Doctrine:

No diretório module/Administrador/src/Administrador/Entity, criamos a classe Administrador.php.

<?php

namespace Administrador\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * Administrador
 *
 * @ORM\Table(name="administrador")
 * @ORM\Entity
 */
class Administrador {

    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue
     * @var int
     */
    protected $adm_id;

    /**
     * @ORM\Column(type="text", name="adm_nome_completo")
     * @var string
     */
    protected $adm_nome;

    /**
     * @ORM\Column(type="text")
     * @var string
     */
    protected $adm_email;

    /**
     * @ORM\Column(type="text", length=32)
     * @var string
     */
    protected $adm_senha;

    /***********getters and setters***********/

    public function setAdmId($var) {
        $this->adm_id = $var;
    }

    public function getAdmId() {
        return $this->adm_id;
    }

    public function setAdmNome($var) {
        $this->adm_nome = $var;
    }

    public function getAdmNome() {
        return $this->adm_nome;
    }

    public function setAdmEmail($var) {
        $this->adm_email = $var;
    }

    public function getAdmEmail() {
        return $this->adm_email;
    }

    public function setAdmSenha($var) {
        $this->adm_senha = md5($var);
    }

    public function getAdmSenha() {
        return $this->adm_senha;
    }  

}

?>

As informações entre /**/ são chamadas de Annotations, é o modo passar o doctrine algumas informações como: tipo de dado que será encapsulado, o nome da coluna referente no banco de dados, tamanho da coluna no banco de dados e etc

Mais Informações:

http://doctrine-orm.readthedocs.org/en/latest/reference/basic-mapping.html

http://doctrine-orm.readthedocs.org/en/latest/reference/annotations-reference.html

Instalação do Doctrine2 e Hounddog no Zend Framework 2

O Doctrine 2 é um ORM (Mapeado de Objeto Relacionar), ou seja é a camada de intermediária entre a aplicação e o banco de dados. O Doctrine 2 manipula os objetos PHP para fazer as interações com o banco de dados.

Vamos ver o passa-a-passo de como instalar no Doctrine 2 no Zend Framework 2.

01 - No Composer.json localizado na root do framework.

{

"name": "zendframework/skeleton-application",

"description": "Skeleton Application for ZF2",

"license": "BSD-3-Clause",

"keywords": [

"framework",

"zf2"

],

"homepage": "http://framework.zend.com/",

"minimum-stability": "dev",

"require": {

"php": ">=5.3.3",

"zendframework/zendframework": "2.*",

"doctrine/doctrine-module": "dev-master",

"doctrine/doctrine-orm-module": "dev-master",

"hounddog/doctrine-data-fixture-module": "dev-master"

}

}

No Terminal

01 - php composer.phar self-update

02 - php composer.phar install

03 - cd public

04 - php -S localhost:8888

No browser

01 - localhost:8888

No zendframework

01 - Em config/application.config.php

'modules' => array(

        'Application',

        'DoctrineModule',

        'DoctrineORMModule',

        'DoctrineDataFixtureModule'

    ),

Mais informações:

http://www.doctrine-project.org

http://www.schoolofnet.com/2013/07/o-que-e-doctrine-2/