Archive for category Zend Framework

Workshop Online de Zend Framework – School of Net: 31/07/2010

Posted by Thiago Colares in Eventos, Zend Framework on July 1, 2010

,

No Comments

Controle de acesso com Zend_Acl

Posted by Thiago Colares in PHP, Zend Framework on May 5, 2010

A muito tempo não posto um bom “php” por aqui, então vamos lá… A algum tempo postei sobre Zend_Auth e fiquei devendo um post sobre Zend_Acl.

Problemas com controle de acesso viram soluções com Zend_Acl. A alguns meses precisei implementar o controle de acesso para um sistema com ZF e me encantei com a facilidade e praticidade do Acl. Primeiro, alguns conceitos básicos…

Roles: São os perfis definidos. Basicamente, quem tem ou não acesso.

Resources: São as funcionalidades a serem controladas.

Usarei como exemplo o código que implementei já citado anteriormente. Criamos uma tabela simples para as funcionalidades, uma para perfis e duas tabelas associativas: uma entre perfis e funcionalidades e outra entre usuários e funcionalidades. Para abreviar, vou mostrar somente a tabela de funcionalidades:

CREATE TABLE funcionalidade (
  1. cd_funcionalidade NUMBER NOT NULL,
  2. descricao VARCHAR2(150) NOT NULL,
  3. funcionalidade VARCHAR2(200) NOT NULL,
  4. PRIMARY KEY(cd_funcionalidade));

Nesta tabela de funcionalidades será cadastrado uma descrição e a url da funcionalidade (resource).  Ex: /usuarios ou /administracao/perfil

Assim que o usuário se autentica no sistema, redireciono ele para um controller chamado “acesso” para montar o objeto Acl. Neste exemplo, o usuário pode ter as funcionalidades definidas pelo perfil ou definidas diretamente para ele. Da seguinte forma…

  1.  
  2. //Model da tabela associativa entre Usuário e Perfil
  3. $objPerfilUsuario = new PerfilUsuario();
  4.  
  5. //Model da tabela de funcionalidades
  6. $objFuncionalidade = new Funcionalidade();
  7.  
  8. //Dados da autenticação do usuário…
  9. $nsAutenticacao = new Zend_Session_Namespace('autenticacao');
  10.  
  11. $idUser = $nsAutenticacao->id;
  12.  
  13. //Recuperando os dados do perfil do usuário
  14. $arrPerfil = $objPerfilUsuario->getPerfilUsuario($idUser);
  15.  
  16. $nsAutenticacao->idPerfil  = $arrPerfil['idPerfil'];
  17. $nsAutenticacao->perfil  = $arrPerfil['perfil'];
  18.  
  19. //Criando o objeto Acl
  20. $acl = new Zend_Acl();
  21.  
  22. //Crio uma role com o nome do perfil do usuário
  23. $acl->addRole(new Zend_Acl_Role($arrPerfil['perfil']));
  24.  
  25. //Funcionalidades definidas por perfil
  26.  
  27. //Recupero as funcionalidades definidas para o perfil…
  28. $arrFuncionalidades = $objFuncionalidade->getFuncionalidadesAcl($arrPerfil['idPerfil']);
  29.  
  30. //Em um foreach, adiciono ao objeto Acl as funcionalidades (resources) e a permissão
  31. foreach($arrFuncionalidades['allow'] as $array) {
  32.  $acl->add(new Zend_Acl_Resource($array));
  33.  $acl->allow($arrPerfil['perfil'],$array);
  34. }
  35.  
  36. if(isset($arrFuncionalidades['deny'])){
  37.  foreach($arrFuncionalidades['deny'] as $array) {
  38.   $acl->add(new Zend_Acl_Resource($array));
  39.   $acl->deny($arrPerfil['perfil'],$array);
  40.  }
  41. }
  42.  
  43. //Funcionalidades definidas por usuário
  44.  
  45. //Model da tabela associativa entre usuário e funcionalidade…
  46. $objUserFunc = new UsuarioFuncionalidade();
  47.  
  48. //Recupero as funcionalidades definidas para o usuário
  49. $arrFuncUser = $objUserFunc->getFuncionalidadesAcl($idUser);
  50.  
  51. //Como a role já está criada no objeto Acl, apenas adiciono as permissões…
  52. foreach($arrFuncUser as $arr) {
  53.  $acl->allow($arrPerfil['perfil'],$arr);
  54. }
  55.  
  56. //Crio um namespace para o objeto Acl
  57. $ns = new Zend_Session_Namespace();
  58. $ns->acl = $acl;

Obs: Nos métodos getFuncionalidadesAcl() das modelos utilizadas retorno um array com a seguinte estrutura: array(’idDaFuncionalidade’ => ‘Url da funcionalidade’). No caso da model Funcionalidades, existe uma particularidade: o array “deny”:

  1.  
  2.  public function getFuncionalidadesAcl($idPerfil) {
  3.  
  4.   $select = 'Seu sql';
  5.  
  6.   $rs = $this->fetchAll($select)->toArray();
  7.   $arrFinal = array();
  8.  
  9.   foreach($rs as $arrAllow) {
  10.  
  11.    $arrFinal['allow'][$arrAllow['cd_funcionalidade']] = $arrAllow['TX_URL'];
  12.  
  13.   }
  14.  
  15.   unset($rs);
  16.  
  17.   $rs = $this->fetchAll()->toArray();
  18.  
  19.   /** Neste foreach eu verifico se existe alguma funcionalidade que está cadastrada na tabela funcionalidades
  20.   * mas não está definida para o perfil. Se existir, precisamos tirar a permissão de acesso a ela.
  21.   * Toda funcionalidade que não estiver cadastrada na tabela de funcionalidades tem seu acesso liberado.
  22.   */
  23.  
  24.  
  25.   foreach($rs as $arrDeny) {
  26.    if((!array_key_exists($arrDeny['cd_funcionalidade'], $arrFinal['allow'])) AND ($arrDeny['funcionalidade'])) {
  27.     $arrFinal['deny'][$arrDeny['cd_funcionalidade']] = $arrDeny['funcionalidade'];
  28.    }
  29.   }
  30.  
  31.   return $arrFinal;
  32.  
  33.  }

Pronto, o objeto Acl está criado e com as permissões setadas. Agora basta fazer a verificação sempre que o usuário tentar acessar os controllers do sistema. No caso deste exemplo, temos uma classe que extende da Zend_Controller_Action, ou seja, qualquer redirecionamento do sistema passará por ela. Nesta classe, adicionei o seguinte código para realizar a verificação da permissão:

  1.  
  2. //Recupero o objeto Acl do namespace…
  3. $ns = new Zend_Session_Namespace();
  4.  
  5. if(isset($ns->acl)) {
  6.  $acl = $ns->acl;
  7.         //Monto a Url que está tentando ser acessada para a verificação…
  8.  $url = '/'.$this->_request->getControllerName().'/'.$this->_request-getActionName();
  9.  
  10.  if($acl->has($url)) {
  11.  
  12.   //Recupero os dados de autenticação do usuário…
  13.   $nsAutenticacao = new Zend_Session_Namespace('autenticacao');
  14.  
  15.                 //Verifico se o perfil do usuário tem acesso à url
  16.   if(!$acl->isAllowed($nsAutenticacao->perfil, $url)) {
  17.  
  18.    //Caso não seja, redireciono o usuário para algum lugar avisando que ele não tem acesso…
  19.    $this->_redirect('/index/sem-acesso');
  20.   }
  21.  }
  22. }

Caso o usuário tenha o acesso, não preciso fazer nada… Apenas deixo a requisição continuar a sua execução e o usuário chegará à url.

Simples, não? Caso tenha alguma dúvida ou tenha alguma crítica ou sugestão para melhorar, deixe seu comentário ou entre em contato por email ;)

Um abraço!

, , ,

3 Comments

Zend Framework Tutorial Series (por Adler Medrado)

Posted by Thiago Colares in PHP, Zend Framework on January 20, 2010

Programar em PHP profissionalmente sem um framework decente é impráticavel. Em 2008 comecei a estudar (na teoria) o Zend Framework e em 2009 participei pela primeira vez em um projeto de grande porte utilizando o ZF. Hoje indico o ZF a todos que estiverem procurando um framework completo e descomplicado.

Estava pensando em escrever um tutorial básico sobre o ZF, mas ao acessar o blog do Adler Medrado hoje ví que ele está preparando uma série de tutoriais semanais sobre o ZF, do básico ao avançado. Não vou escrever um tutorial só pra ter o meu nome nele. Aproveitem e se deliciem com essa série que tenho certeza que vai ser ótima!

Parabéns ao Adler pela iniciativa! Vou atualizando o post à medida que forem saindo os outros capítulos…

Zend Framework Tutorial Series – Capítulo 1

Zend Framework Tutorial Series – Capítulo 2

,

No Comments

Autenticação com Zend_Auth

Posted by Thiago Colares in PHP, Zend Framework on November 10, 2009

Falar em Zend Framework sem citar o Zend_Auth é impossível. Afinal, qual sistema não possui autenticação de usuários? Nesse post darei um exemplo prático do uso do Zend Auth.

É importante lembrar a diferença entre o Zend_Auth e o Zend_Acl, pois apesar deles se complementarem, tem funções totalmente diferenes. O Zend_Auth é responsável somente pela autenticação, e o Zend_Acl é responsável por mapeamento de permissões do sistema. Falaremos do Zend_Acl em outra oportunidade.

Inicialmente, temos a configuração inicial no bootstrap:

//Bootstrap
  1.  
  2. //Criando um objeto Registry para utilização posterior
  3. $registry = Zend_Registry::getInstance();
  4.  
  5. //Determinando a conexão através de um arquivo INI (ou qualquer outra forma à sua escolha)
  6. $configDb = new Zend_Config_Ini('./application/config/db.ini', 'identificador') ;
  7. $db = Zend_Db::factory ( $configDb->db->adapter, $configDb->db->config->toArray() ) ;
  8.  
  9. //Setando no registro a conexão criada
  10. $registry->set( 'dbSistema', $db ) ;
  11.  
  12. //Definição do Zend_Auth
  13. $authAdapter = new Zend_Auth_Adapter_DbTable($db);
  14. $registry->set( 'authAdapter', $authAdapter ) ;

Não vamos entrar na questão do formulário, vamos direto para a action do controller, onde só chamaremos uma função do model e verificaremos o seu retorno:

//Controller
  1.  
  2. $login = new User();
  3. $result = $login->login($_POST);
  4.  
  5. if($result){
  6. //Usuário autenticado
  7. } else {
  8. //Autenticação inválida
  9. }

Agora a parte mais importante, a função da model:

//Model
  1.  public function login($objPost){
  2.   //Recuperando o objeto que registramos no bootstrap
  3.   $authAdapter = Zend_Registry::get('authAdapter');
  4. //Setando a tabela e as colunas de identificação do usuário no banco
  5.   $authAdapter
  6.   ->setTableName('USUARIO')
  7.   ->setIdentityColumn('LOGIN')
  8.   ->setCredentialColumn('SENHA');
  9.  
  10. //Recebendo os dados do POST
  11.   $authAdapter
  12.   ->setIdentity(strtolower($objPost['input_usuario']))
  13.   ->setCredential(md5($objPost['input_senha']));
  14.  
  15. //Autenticação
  16.   $result = $authAdapter->authenticate();
  17.  
  18. //Verificando a autenticação…
  19.   if($result->isValid()){
  20.  
  21.    return true;
  22.   }
  23.   else{
  24.    return false;
  25.   }
  26.  }

Simples, não? Espero ter ajudado… Um abraço a todos!

Documentação oficial do Zend_Auth: http://framework.zend.com/manual/en/zend.auth.html

, ,

2 Comments

Implementação de cache automático com Zend_Cache

Posted by Thiago Colares in PHP, Zend Framework on September 21, 2009

Trabalhando em uma estrutura Zend Framework a alguns meses atrás, tivemos a necessidade de um sistema de cache automático para a grande maioria das consultas de um sistema. Depois de pesquisar bastante chegamos à conclusão de que não havia essa possibilidade no ZF, então desenvolví uma solução que atendeu muito bem à nossa necessidade e creio que também vai atender à outras pessoas, fazendo com que o cache seja uma propriedade do objeto model. Vamos lá.

Classe abstrata que extende da Zend_Db_Table_Abstract

  1. abstract class Base_Db_Table extends Zend_Db_Table_Abstract{
  2. /**
  3. * Definições das configurações de cache
  4. *
  5. * @var $cacheFrontendOptions
  6. * @var $cacheBackendOptions
  7. * @var $cacheName
  8. * @var $cacheObject
  9. */
  10.  
  11. protected $cacheFrontendOptions = array();
  12. protected $cacheBackendOptions = array();
  13. protected $cacheName;
  14. protected $cacheObject;
  15.  
  16. public function init(){
  17.   //Iniciando cache automaticamente
  18.   $this->startCaching();
  19. }
  20.  
  21.  /* Seta o prefixo do nome do arquivo cache
  22.   * @param  string $cacheName
  23.   */
  24.  public function setNameCaching($cacheName) {
  25.   $this->cacheName = $cacheName;
  26.  }
  27.  
  28.  /* Seta as configurações de cache
  29.   * @param array $cacheFrontendOptions – Array de configurações de frontend
  30.   * @param string $cacheName – Nome do prefixo do arquivo cache
  31.   */
  32.  public function setCaching($cacheFrontendOptions = null, $cacheName = null) {
  33.  
  34.   if($cacheFrontendOptions == null) {
  35.  
  36.    $frontendOptions = array(
  37.           'lifetime' => 7200,
  38.           'automatic_serialization' => true);
  39.  
  40.   } else {
  41.    $frontendOptions = $cacheFrontendOptions;
  42.   }
  43.  
  44.   if($cacheName == null) {
  45.    $cacheName = $this->_name.'_'.date('dmy');
  46.   }
  47.  
  48.   $cacheBackendOptions = array('cache_dir' => './application/cache_dir/');
  49.  
  50.   $this->cacheFrontendOptions = $frontendOptions;
  51.   $this->cacheBackendOptions = $cacheBackendOptions;
  52.   $this->cacheName = $cacheName;
  53.  
  54.   $this->startCaching();
  55.  }
  56.  
  57. /* Verifica se a cache está ativa no objeto Model
  58.  * @return  bool
  59.  */
  60. public function isCaching() {
  61.  if($this->cacheObject) {
  62.   return true;
  63.  } else {
  64.   return false;
  65.  }
  66. }
  67.  
  68. /* Retorna um array com as configurações de cache
  69.  * @return array $arrayCacheConfigs
  70.  */
  71. public function getCaching() {
  72.  if($this->cacheFrontendOptions) {
  73.   $arrayCacheConfigs = array(
  74. 'cacheFrontendOptions' => $this->cacheFrontendOptions, 'cacheBackendOptions'=>$this->cacheBackendOptions, 'cacheName' => $this->cacheName);
  75.    return $arrayCacheConfigs;
  76.   } else {
  77.    return false;
  78.   }
  79.  }
  80.  
  81. /* Inicia o cache
  82.  */
  83. public function startCaching() {
  84.  if($this->isCaching()) {
  85.   echo "
  86. <pre>";
  87.   print_r('Cache já iniciada anteriormente: startCaching()');
  88.   print_r("
  89. ");
  90.   die(__FILE__.' – Linha '.__LINE__);
  91.  }
  92.  else {
  93.   if(!$this->getCaching()) {
  94.    $this->setCaching();
  95.   }
  96.   $cache = Zend_Cache::factory('Core',
  97.                              'File',
  98.   $this->cacheFrontendOptions,
  99.   $this->cacheBackendOptions);
  100.   $this->cacheObject = $cache;
  101.  }
  102. }
  103.  
  104. public function removeCaching() {
  105.  $this->cacheObject->remove($this->cacheName);
  106.  $this->cacheObject = null;
  107. }
  108.  
  109. public function disableCaching() {
  110.  $this->cacheName = null;
  111.  $this->cacheFrontendOptions = null;
  112.  $this->cacheBackendOptions = null;
  113.  $this->cacheObject = null;
  114. }
  115.  
  116. public function saveCaching($param) {
  117.  if($this->isCaching()) {
  118.   $this->cacheObject->save($param, $this->cacheName);
  119.  } else {
  120.   echo "
  121. <pre>";
  122.   print_r('Cache não iniciada: saveCaching()');
  123.   print_r("
  124. ");
  125.   die(__FILE__.' – Linha '.__LINE__);
  126.  }
  127. }
  128.  
  129. public function fetchAll($where = null, $order = null, $count = null, $offset = null)
  130. {
  131.  if (!($where instanceof Zend_Db_Table_Select)) {
  132.   $select = $this->select();
  133.  
  134.   if ($where !== null) {
  135.    $this->_where($select, $where);
  136.   }
  137.  
  138.   if ($order !== null) {
  139.    $this->_order($select, $order);
  140.   }
  141.  
  142.   if ($count !== null || $offset !== null) {
  143.    $select->limit($count, $offset);
  144.   }
  145.  
  146.   } else {
  147.    $select = $where;
  148.   }
  149.  
  150.  if($this->isCaching()) {
  151.   if(!$result = $this->cacheObject->load($this->cacheName)) {
  152.    $rows = $this->_fetch($select);
  153.    $data  = array(
  154.              'table'    => $this,
  155.              'data'     => $rows,
  156.              'readOnly' => $select->isReadOnly(),
  157.              'rowClass' => $this->_rowClass,
  158.              'stored'   => true
  159.   );
  160.  
  161.   if (!class_exists($this->_rowsetClass)) {
  162.    require_once 'Zend/Loader.php';
  163.    Zend_Loader::loadClass($this->_rowsetClass);
  164.   }
  165.  
  166.    $result = new $this->_rowsetClass($data);
  167.    $this->saveCaching($result);
  168.   }
  169.  
  170.   } else {
  171.  
  172.    $rows = $this->_fetch($select);
  173.    $data  = array(
  174.           'table'    => $this,
  175.               'data'     => $rows,
  176.               'readOnly' => $select->isReadOnly(),
  177.               'rowClass' => $this->_rowClass,
  178.               'stored'   => true
  179.    );
  180.  
  181.    if (!class_exists($this->_rowsetClass)) {
  182.     require_once 'Zend/Loader.php';
  183.     Zend_Loader::loadClass($this->_rowsetClass);
  184.    }
  185.  
  186.    $result = new $this->_rowsetClass($data);
  187.   }
  188.  
  189.   return $result;
  190.  }

Com esta implementação, todas as consultas realizadas com o método fetchAll() serão salvas em cache no arquivo que foi definido no $cacheBackendOptions (linha 52). Se o nome do arquivo cache não for definido pelo desenvolvedor, será definido automaticamente na linha 44. Antes de realizar a consulta no banco, é verificado se já existe o arquivo no cache, caso não exista a consulta é realizada e o arquivo é criado no cache, caso existe, s resultado é retornado do cache.

Criando as configurações manualmente

Caso haja a necessidade de alterar qualquer configuração de front-end manualmente, não é necessário alterar a classe abstrata. Todas as configurações podem ser enviadas como argumento através do método setCaching() (linha 32).

Exemplo:

  1. $objModel = new ObjModel();
  2.  
  3. $frontendOptions = array(
  4.           'lifetime' => 120,
  5.           'automatic_serialization' => false);
  6.  
  7. $cacheName = "Nome_do_arquivo";
  8.  
  9. $objModel->setCaching($frontEndOptions, $cacheName);

Se por algum motivo você precisar desabilitar o cache para um determinado model, utilize o método disableCaching().

Exemplo:

  1. $objModel = new ObjModel();
  2. $objModel->disableCaching();

Para verificar se o cache está habilitado para determinada model, utilize o método isCaching().

Exemplo:

  1. $objModel = new ObjModel();
  2. if($objModel->isCaching()) {
  3. echo "Cache habilitada!";
  4. } else {
  5. echo "Cache desabilitada!";
  6. }

Para a minha necessidade não precisei criar a definição manual do diretório em que os arquivos serão salvos, mas se você precisar, apenas dinamize a definição das configurações de back-end.

Enfim, é isso. Espero que seja útil. Caso tenha alguma crítica ou sugestão para a melhoria, terei prazer em recebê-la!

Documentação oficial do Zend_Cache: http://framework.zend.com/manual/en/zend.cache.html

, ,

4 Comments