Zend Framework 2 Brasil: julho 2015

sexta-feira, 31 de julho de 2015

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);
},
)
);

}

quinta-feira, 30 de julho de 2015

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

quinta-feira, 23 de julho de 2015

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/

quarta-feira, 22 de julho de 2015

Forms no Zend Framework 2

Criar um formulário no Zend Framework 2 é muito simples. Para criar um formulário usando o Zend Framework 2 temos de criar uma classe para gerenciar os elementos. Nós criaremos a classe do formulário dentro da pasta src do módulo.

Existem várias formas de criarmos formulários com o Zend Framework 2, hoje vamos aprender uma dessas formas. Usando como exemplo o módulo Administrador que criamos no post anterior, vamos seguir os passos abaixo:

1 - Acesse o diretório module/Administrador/src/Administrador/Form/.

2 - Crie a classe AdministradorForm.

3 - Quando criamos uma classe a primeira coisa que temos que fazer é definir o namespace. Para nossa classe definimos: namespace Administrador\Form;.

4 - Nossa classe deverá ficar assim:

<?php

namespace Usuario\Form;

use Zend\Form\Form;
use Zend\Form\Element\Hidden;
use Zend\Form\Element\Text;
use Zend\Form\Element\Password;
use Zend\Form\Element\Submit;

class AdministradorForm extends Form{

public function __construct() {

parent::__construct(null);

$this->setAttributes(
array('method' => 'post', 'class' => 'form-horizontal')
);

$id= new Hidden();
$id->setName('adm_id');
$this->add($id);

$nome = new Text();
$nome->setName('adm_nome');
$nome->setLabel('Nome:');
$nome->setAttribute('class', 'form-control');
$this->add($nome);

$email = new Text();
$email->setName('adm_email');
$email->setLabel('E-mail:');
$email->setAttribute('class', 'form-control');
$this->add($email);

$senha = new Password();
$senha->setName('adm_senha');
$senha->setLabel('Senha');
$senha->setAttribute('class', 'form-control');
$this->add($senha);

$submit = new Submit();
$submit->setName('btnLogin');
$submit->setAttribute('class', 'btn btn-success');
$submit->setValue('Entrar');
$this->add($submit);

}


}

?>

5 - Vamos acessar o arquivo index.phtml que está no diretório: module/Administrador/view/administardor/.

6 - Vamos deixar o arquivo da seguinte forma:

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

?>

7 - Agora abra o terminal e vamos acessar a pasta public da nossa aplicação:
cd /var/www/html/meu_zf2/public/

8 - Então vamos iniciar o servidor embutido: php -S localhost:8888

9 - Abra o brower e digite: http://localhost:8888/adm

10 - A tela com o formulário deverá aparecer.

segunda-feira, 20 de julho de 2015

Criando um módulo no Zend Framework 2

Já sabemos a estrutura básica de um módulo no zend framework 2 quando utilizamos o Zend Skeleton Application, agora vamos entender o que é um módulo. Mas antes de sabemos que é um módulo é válido lembrar que o zend framework 2 foi totalmente reconstruído e agora trabalha de forma 100% modular, ou seja, cada módulo é independente um do outro isso significa que para cada módulo que criarmos teremos suas configurações próprias. Falando e reaproveitamento, podemos afirmar que podemos sim reaproveitar um módulo para várias aplicações.

O que é um módulo?

Um módulo é uma determinada área da sua aplicação responsável pelas funções de uma entidade especifica, por exemplo: administradores, clientes, fornecedores, usuários. Geralmente teremos para cada tabela do banco de dados um módulo respectivo.

Criando um módulo

Vamos seguir a mesma estrutura do Module Application que é instalado por padrão junto ao Zend Skeleton Application. Vamos criar o module Administrador.

1 - Dentro da pasta module/ crie uma pasta Administrador, este é o nome do nosso módulo.

2 - Entre em module/Administrador. Crie as três pastas: config, src, view.

3 - Vá em module/Application/config e copie o arquivo module.config.php para o pasta do nosso módulo module/Administrador/config.

4 - Agora abra o arquivo module.config.php mude o nome da rota de home para adm e o modo de acesso "route" de "/" para "/adm".

5 - Dentra da pasta src vamos criar uma pasta. Sempre essa pasta deverá ter o nome do nosso módulo. Então vamos criar a pasta Administrador.

6 - Em module/Administrador/src/Administrador vamos criar as seguintes pastas para montarmos a estrutura inicial. Crie as pastas controller, form, service, entity.

7 - Volte ao módulo padrão Application e entre na pasta view. Copie as pastas layout e error para a pasta view do nosso modulo Administrador.

8 - Ainda dentro de module/Administrador/view/ cria a pasta administrador novamente essa pasta deve conter o nome do nosso módulo.

9 - Vamos voltar ao módulo Application e na root podemos encontrar o arquivo Module.php. Vamos copia-lo para a root do nosso módulo Administrador.

10 - Vamos abrir o arquivo Module.php e vamos alterar o namespace de Application para Module.

Colocando pra funciona.

1 - Em module/Administrador/config no arquivo module.config.php vamos deixar nossa rota adm da seguinte forma:

'route' => '/adm',
'defaults' => array(
'controller' => 'Administador\Controller\Administador',
'action' => 'index',
),

2 - Ainda no arquivo module.config.php vamos alterar o indice controller, deixando assim:

'controllers' => array(
'invokables' => array(
'Administador\Controller\Administador' => 'Administador\Controller\Administador',
),
),

3 - Vamos em module/Administrador/src/Administrador/Controller e vamos criar a classe AdministradorController.php

4 - A classe AdministradorController deve ficara assim:

<?php

namespace Administrador\Controller;

use Zend\Mvc\Controller\AbstractActionController;
use Zend\View\Model\ViewModel;

class AdministradorController extends AbstractActionController
{
public function indexAction()
{
return new ViewModel();
}
}

5 - Em module/Administrador/view/administrador vamos criar as pasta administrador e dentro dela o arquivo index.phtml. Vamos entender a estrutura da view: Sempre iremos criar uma pasta com o nome do nosso módulo no caso é administrador, dentro dela vamos criar uma pasta com o nome do nosso controller administrador novamente e a extenção do nosso arquivo sempre deverá ser .phtml e o nome dele é o nome da nossa action indexAction então teremos index.phtml.

6 - Vamos acessar o arquivo application.config.php para registrarmos nosso modulo. Ele não está dentro do nosso módulo mas na pasta config do zend framework.

7 - Agora abra o terminal e vamos acessar a pasta public da nossa aplicação:
cd /var/www/html/meu_zf2/public/

8 - Então vamos iniciar o servidor embutido: php -S localhost:8888

9 - Abra o brower e digite: http://localhost:8888/adm

10 - A tela do zend framework deverá aparecer sem erros.

Mais informações:

http://framework.zend.com/manual/current/en/modules/zend.module-manager.intro.html

http://framework.zend.com/manual/current/en/modules/zend.module-manager.best-practices.html

http://framework.zend.com/manual/current/en/user-guide/modules.html