Autorizzazione

L’autorizzazione è quel processo in cui il sistema stabilisce se un utente loggato ha o meno accesso ad una determinata risorsa. In Zend Framework il processo di autorizzazione è gestito dall’oggetto Zend_Acl ( Access Control List ) .

Prima di procedere con l’implementazione vera e propria, introduciamo alcuni termini che saranno spesso utilizzati parlando di autorizzazione:

  • Role: con il termine Role ( Ruolo o Gruppo ) si indica un gruppo di utenti
  • Resource: con il termine si indica una risorsa del sistema, come una determinata action di un certo controller o anche solo un dato record, come potrebbe essere una pagina di un sito.
  • Privilege: il tipo di accesso richiesto. Per privilegio si intende read, update, insert ecc

Un ruolo definisce il livello di attività che un utente può compiere all’interno del sistema, i ruoli in zend framework sono gestiti dall’oggetto Zend_Acl_Role, come nel seguente esempio:

$gruppoUtente = new Zend_Acl_Role('utente'); 

Con la precedente linea di codice abbiamo creato un oggetto che definisce un nuovo gruppo all’interno del sistema, il gruppo ‘utenti’ nel nostro caso, che successivamente andrà aggiunto all’oggetto Zend_Acl. Da notare che il nome del gruppo una volta creato non può essere più modificato e deve essere un nome unico.

$acl = new Zend_Acl(); 
$acl->addRole($gruppoUtente); 

Per ogni ruolo può essere definito un ruolo padre, in modo tale che, il nuovo ruolo creato potrà fare tutto quello che il ruolo parent poteva fare seguendo il concetto di ereditarietà.

$acl = new Zend_Acl(); 
$acl->addRole(new Zend_Acl_Role('utente')); 
$acl->addRole(new Zend_Acl_Role('moderatore'), 'utente'); 

In questa situazione il gruppo ‘moderatore’ può compiere qualsiasi azione legata al gruppo ‘utente’ oltre che compiere tutte le azioni ad esso direttamente legate.

Una risorsa è un contenuto in cui vogliamo stabilire e differenziare le regole di accesso. La creazione di una risorsa segue lo stesso procedimento della creazione di un ruolo, l’oggetto che gestisce le risorse è Zend_Acl_Resource. Poniamo il caso di voler creare la risorsa di un possibile forum del nostro sistema:

$forumResource = new Zend_Acl_Resource('forum'); 

Come per quanto riguarda i ruoli, anche le risorse vanno aggiunte all’oggetto Zend_Acl, in maniera molto simile per i ruoli, come da questo esempio:

$acl = new Zend_Acl(); 
$acl->addRole(new Zend_Acl_Role('utente')); 
$acl->addRole(new Zend_Acl_Role('moderatore'), 'utente'); 
$acl->addResource(new Zend_Acl_Resource('forum')); 
$acl->addResource(new Zend_Acl_Resource('posts'), 'forum'); 
$acl->addResource(new Zend_Acl_Resource('threads'), 'forum');

In questo esempio abbiamo creato la risorsa forum, da cui discendono le risorse post e threads. Se noi volessimo mappare le risorse all’interno del nosro sistema, la risorsa ‘forum’ sarebbe il controller, ‘posts’ e ‘threads’ sarebbero le actions.

La parte finale del settaggio dello Zend_Acl riguarda la gestione dei privilegi, che vengono attribuiti tramite lìutilizzo dei metodi allow() e deny() come nel seguente esempio

$acl->allow('utente', 'forum', 'read'); 
$acl->allow('moderatore', 'forum', array('update', 'blacklist');

In questo esempio abbiamo attribuito il permesso di lettura al forum per il gruppo ‘utente’ ed inoltre i permessi ‘update’ e ‘blacklist’ per il gruppo ‘moderatore’. Essendo direttamente discendente dal gruppo ‘utente’, il gruppo ‘moderatore’ eredita i permessi del gruppo padre, in modo tale da aver attribuito il permesso di lettura per la risorsa forum.

Applicazione della teoria

Il seguente è un esempio dello schema delle tabelle da utilizzare per l’integrazione pratica di Zend_Acl all’interno del sistema.

Struttura Tabelle Zend_Acl

Niente paura, qui potete scaricare il file sql contenente il codice per la creazione di queste tabelle con inclusi i record dei roles, della risorsa index_index in lettura ed eliminazione e l’attribuzione del privilegio lettura per il gruppo superadministrator ( a voi inserire il resto ).

Passiamo ora alla implementazione vera e propria. Prima di tutto dovremo creare una directory all’interno della directory ‘library’ di Zend Framework, questa cartella dovrà avere lo stesso nome del nostro progetto, in questo caso Paesidelmondo. All’interno di questa directory creiamo un file chiamato Acl.php che conterrà l’oggetto Paesidelmondo_Acl che estenderà Zend_Acl.

Paesidelmondo_Acl si occuperà di inserire i ruoli presenti nel database all’interno dell’oggetto Zend_Acl.

Acl.php

< ?php
  
  class Paesidelmondo_Acl extends Zend_Acl 
  { 
    public function __construct() { 
      $db = Zend_Registry::get('db');
      $rolesArray = Array();
      $query = "SELECT a.acl_role_name, b.acl_role_name AS acl_role_parent_name FROM 
      ( acl_role a LEFT JOIN acl_role b ON a.acl_role_parent_id = b.acl_role_id ) ORDER BY a.acl_role_sort ASC"; 
      $tbRoleRowset = $db->fetchAll($query); 
      foreach($tbRoleRowset AS $k => $v){
        if(!array_key_exists($v["acl_role_name"],$rolesArray)){
          $rolesArray[$v["acl_role_name"]] = Array($v["acl_role_parent_name"]);
        }else{
         array_push($rolesArray[$v["acl_role_name"]],$v["acl_role_parent_name"]);
        }
      }
      $this->_addRoles($rolesArray); 
    }
    
    protected function _addRoles($roles){ 
      foreach($roles as $name => $parents){
        if (!$this->hasRole($name)){
          $parents = $parents[0] === null ? null : $parents;
          $this->addRole(new Zend_Acl_Role($name), $parents); 
        }
      } 
    }
  }

Il codice di questo oggetto non credo abbia bisogno di molte spiegazioni, segue le regole dette in precedenza sull’aggiunta dei ruoli all’interno di Zend_Acl, recuperandoli dal database. Questo oggetto sarà istanziato nel nostro file bootstrap, tramite l’aggiunta di questa linea di codice:

$acl = new Paesidelmondo_Acl();

A questo punto sorge spontanea una domanda: e le risorse?

Per evitare inutili sprechi di memoria e di elaborazioni le risorse non saranno caricate in Zend_Acl nella loro totalità ad ogni nuova chiamata. Invece, le risorse saranno inserite in Zend_Acl tenendo conto del controller e dell’action richiesta dall’utente. L’applicazione di questa teoria può essere svolta tramite la creazione di un action helper.

Un Action Helper si inserisce nell’MVC dispatch system al controller level, permettendoci di accedere alle regole dell’Acl prima che il metodo preDispatch() del controller sia chiamato. Questo avviene prima della esecuzione della action e quindi è il luogo ideale per effettuare il controllo.
Inoltre possiamo utilizzare sempre il medesimo helper per inserire la risorsa corrente all’interno di Zend_Acl nonchè abilitare i privilegi per il gruppo a cui appartiene l’utente corrente.

L’action controller si chimerà Paesidelmondo_Controller_Action_Helper_Acl ed estenderà Zend_Controller_Action_Helper_Abstract

Paesidelmondo/Controller/Action/Helper/Acl.php

< ?php

  class Paesidelmondo_Controller_Action_Helper_Acl extends Zend_Controller_Action_Helper_Abstract 
  { 
    protected $_db; 
    protected $_action; 
    protected $_auth; 
    protected $_acl; 
    protected $_controllerName;
    protected $_actionName;
    protected $_resourceName;  
    protected $_privileges = Array();
    protected $_roleIds = Array();
    
    public function __construct(Zend_View_Interface $view = null, array $options = array() ) { 
      $this->_auth = Zend_Auth::getInstance(); 
      $this->_db = Zend_Registry::get('db');
      $this->_acl = $options['acl'];
    }
    
    public function init(){
      // Ricaviamo controller, action e creiamo il nome risorsa
      $this->_action = $this->getActionController(); 
      $this->_controllerName = $this->_action->getRequest()->getControllerName(); 
      $this->_actionName = $this->_action->getRequest()->getActionName(); 
      $this->_resourceName = $this->_controllerName."_".$this->_actionName;
      
      // Aggiungiamo la risorsa in Zend_Acl
      // ATTENZIONE: la possibilità di indicare il parent non è stata presa in considerazione!
      if(!$this->_acl->has($this->_resourceName)){ 
        $this->_acl->add(new Zend_Acl_Resource($this->_resourceName)); 
      }
      
      // Ricaviamo il ruolo dell'utente loggato, altrimenti gli attribuiamo 'guest' id = 1
      list($roleId,$userRole) = $this->getUserRole();
      
      // Aggiungiamo $roleId nell'array che comprenderà anche i suoi id parente
      $this->_roleIds[] = $roleId;
      
      // Aggiungiamo gli id parente in $this->_roleIds
      $this->fillRoleIds($userRole);
      
      // Inseriamo i privilegi per l'utente corrente in $this->_privileges
      $this->fillPrivileges($this->_roleIds);
      
      // Cicliamo l'array ottenuto per inserire i privilegi di questo gruppo per la risorsa corente all'interno di Zend_Acl
      foreach($this->_privileges AS $k => $v){
        $this->$k($userRole,$v);
      }
    }
    
    public function getUserRole(){
      if($this->_auth->hasIdentity()){
        $user = $this->_auth->getIdentity();
        $roleId = (int)$user->id_gruppo;
        $query = "SELECT acl_role_name FROM acl_role WHERE acl_role_id = '".$roleId."' ";
        $tbRoleRowset = $this->_db->fetchAll($query); 
        $userRole = $tbRoleRowset[0]["acl_role_name"];
      }else{
        $roleId = 1;
        $userRole = 'guest';
      }
      return array($roleId,$userRole);
    }
    
    protected function fillPrivileges($roleIds){
      $roleIds = is_array($roleIds) ? implode(",",$roleIds) : $roleIds;
      $query = "SELECT c.acl_privilege_name AS privilege, c.acl_privilege_type AS type, e.acl_role_parent_id AS parent FROM (((( acl_controller a LEFT JOIN acl_resource b ON a.acl_controller_id = b.acl_controller_id )  
                LEFT JOIN acl_privilege c ON b.acl_resource_id = c.acl_resource_id )  
                LEFT JOIN acl_role_privilege d ON c.acl_privilege_id = d.acl_privilege_id )  
                LEFT JOIN acl_role e ON d.acl_role_id = e.acl_role_id ) 
                WHERE a.acl_controller_name = '".$this->_controllerName."' AND b.acl_resource_name = '".$this->_actionName."' 
                AND e.acl_role_id IN(".$roleIds.") ";
      $privileges = $this->_db->fetchAll($query); 
      foreach($privileges AS $k => $v){
        $this->_privileges[$v['type']][] = $v['privilege'];
      }
    }
    
    protected function fillRoleIds($roleName){
      $query = "SELECT a.acl_role_parent_id, b.acl_role_name FROM acl_role a LEFT JOIN acl_role b ON a.acl_role_parent_id = b.acl_role_id WHERE a.acl_role_name = '".$roleName."' ";
      $parents = $this->_db->fetchAll($query); 
      foreach($parents AS $k => $v){
        if(!in_array($v['acl_role_parent_id'],$this->_roleIds)){
          $this->_roleIds[] = $v['acl_role_parent_id'];
        }
        if($v['acl_role_parent_id'] > 0){
          $this->fillRoleIds($v['acl_role_name']);
        }
      }
    }
    
    public function allow($roles = null, $actions = null) { 
      $resource = $this->_resourceName; 
      //echo 'allow '.$roles.' to '.implode(',',$actions).' '.$resource.'
'; $this->_acl->allow($roles, $resource, $actions); return $this; } public function deny($roles = null, $actions = null) { $resource = $this->_resourceName; //echo 'deny '.$roles.' to '.implode(',',$actions).' '.$resource.'
'; $this->_acl->deny($roles, $resource, $actions); return $this; } public function getAcl(){ return $this->_acl; } }

Il codice è commentato e quindi dovrebbe essere abbastanza comprensibile. L’unica nota è per il metodo fillRoleIds, che si ricava tutti i parent dell’attuale gruppo utente in modo da ereditare eventuali privilegi ad essi associati.

Per poter utilizzare questo helper dobbiamo registrarlo. Subito dopo aver creato l’oggetto acl nel bootstrap aggiungiamo le seguenti 2 righe di codice:

  $aclHelper = new Paesidelmondo_Controller_Action_Helper_Acl(null, array('acl'=> $acl));
  Zend_Controller_Action_HelperBroker::addHelper($aclHelper);

Infine non ci manca che modificare il metodo init dei controller in cui vogliamo effettuare il controllo dei permessi. Il seguente è il codice del metodo init() dell’indexController:

    public function init(){
      $response = $this->getResponse();
      $response->insert('header', $this->view->render('header.phtml')); 
      $response->insert('menu', $this->view->render('menu.phtml')); 
      $response->insert('columnLeft', $this->view->render('columnLeft.phtml'));
      $response->insert('columnRight', $this->view->render('columnRight.phtml')); 
      $response->insert('footer', $this->view->render('footer.phtml')); 
      
      $request = $this->getRequest();
      $resourceName = $request->getControllerName().'_'.$request->getActionName();
      
      $errorMessage = "";
      $acl = $this->_helper->_acl->getAcl();
      list($roleId,$userRole) = $this->_helper->_acl->getUserRole();
      $readPrivilege = $acl->isAllowed($userRole, $resourceName, 'read');
      
      if(!$acl->hasRole($userRole)){
        $errorMessage.= "

Il ruolo utente non esiste, permesso negato

"; } if(!$readPrivilege){ $errorMessage.= "

ERRORE: Accesso Negato

"; } /* if(!$acl->has($resourceName)){ $errorMessage.= "

La risorsa ".str_replace("_","/",$resourceName). "non esiste!

"; } */ if(!empty($errorMessage)){ Zend_Layout::getMvcInstance()->getView()->errorMessage = $errorMessage; $request->setControllerName('error'); $request->setDispatched(false); } }

In questo caso abbiamo verificato se il gruppo dell’attuale utente possiede i permessi in lettura per la risorsa. Nel database non abbiamo attribuito questo permesso a nessun ruolo, quindi inevitabilmente saremo redirezionati all’errorController che visualizzerà il messaggio di errore ( se non lo avete, create il file index.phtml negli script della vista relativi all’errorController ).

Come potete notare abbiamo utilizzato 2 metodi mai visti prima d’ora di Zend_Acl: hasRole e has. Il primo controlla se il gruppo utente è realmente esistente ( quindi se è stato inserito in Zend_Acl quando questo è stato istanziato OVVERO se è presente nel database ), mentre il secondo controlla se la risorsa è effettivamente presente. In questo caso ho commentato quella porzione di codice in quanto il nostro acl helper attualmente aggiunge la risorsa senza controllare della sua esistenza nel database. Questo perchè non sarebbe di utilità, infatti se la risorsa non esistesse non arriveremo mai a eseguire quel codice ma il sistema ci avvertirebbe della non presenza dello script ( ma solo alla situazione attuale, in cui abbiamo settato $frontController->throwExceptions(true); nel nostro bootstrap ). Vedremo prossimamente come reindirizzare eventuali chiamate a controller non esistenti.

Con questo si conclude questo tutorial, che non voleva spiegare l’implementazione definitiva di Zend_Acl per ogni caso, ma solo una possibile sua implementazione ( funzionante ). Alcune cose sono state volutamente tralasciate, come l’ereditarietà tra risorse o la creazione dei modelli per le nuove tabelle del database. Per eventuali domande, dimenticanze o suggerimenti il consiglio è sempre quello di scrivere qui sotto.

1 Star2 Stars3 Stars4 Stars5 Stars (4 votes, average: 5,00 out of 5)
Loading...Loading...

32 commenti

  1. Complimenti per i tutorial, sono molto ben fatti! Andrai a scrivere qualcosa anche su Zend_dojo e Zend_translate ?

  2. Sergio Rinaudo

    Grazie,
    spero prima o poi di vedere tutti i componenti di Zend Framework, in ogni caso do più importanza a quelli che mi sono richiesti, ad esempio Zend_Form l’ho visto dopo che un lettore l’ha richiesto tramite commento. Quindi spero di poter scrivere qualcosa anche per quanto riguarda i componenti da te citati al più presto. Nel frattempo se mastichi qualcosa di inglese ti consiglio sempre la documentazione ufficiale.
    Ciao e torna a trovarmi spesso :)

  3. Pingback: Zend Framework: gestione dei moduli ed esempio modulo di amministrazione | Hello World!

  4. Ciao, interessanti e ben fatti i tutorial sullo Zend Framework, complimenti.
    Quello che manca però sono i file da scaricare a fine tutorial, in modo da poter eventualmente consultarli off-line.
    A presto ….. e continua cosi.

  5. Ciao,
    in questo articolo http://razorblade.netsons.org/2008/10/27/zend-search-lucene-e-utf-8-unicode-con-zend-framework/ avevo messo l’applicazione completa da scaricare. In quell’applicazione alcune cose sono mancanti, tipo il recapcha e alcune altre cose che ho visto successivamente. Inoltre ho fatto un po’ di refactoring ed ho modificato proprio la parte riguardante l’autorizzazione, migliorandola. Al più presto scriverò qualcosa a proposito.
    In ogni modo il codice discusso in questo articolo puoi trovarlo nel file in download al termine dell’articolo segnalato, provalo e fammi sapere!
    Ciao e passa spesso a trovarmi.

  6. Complimenti per il tutorial!!!
    Sei chiaro nella spiegazione ed ordinato nella presentazione del tutorial.
    Completerai il tutorial ? Mi piacerebbe approfondire le parti mancanti, te ne sarei veramente grato!

  7. Sergio Rinaudo

    Ciao,
    grazie per il commento.
    In realtà una nuova implementazione di Zend_Acl l’ho sviluppata, con l’implementazione gerarchica delle risorse e la gestione degli asserts.
    Inoltre ho modificato un po’ il design delle tabelle mysql in modo da rendere il tutto più funzionale.
    Pubblicherò un articolo a proposito il prima possibile.
    Ciao

  8. OK. Grazie Sergio. Fammi sapere appena lo pubblichi.

    Buon Lavoro

  9. Una domanda al volo:

    la funzione:

    public function init(){…} deve essere inserita in ogni controller che si intende gestire con ACL?

    Grazie

  10. Risolto avevo letto male! ma continuo a non capire bene la struttura delle tabelle del DB.

    1. Quali sono i passi da effettuare?
    2. Per ogni risorsa-pagina devo creare una voce in qualche tabella? In quale?
    3. Come devo gestire la mia semplice tabella degli utenti? Devo aggiungere qualche campo nella mia tabella?
    4. Come lego i permessi ACL agli utenti registrati nella mia applicazione?
    5. Ci sono 5 tabelle. Si possono ridurre nel numero? Sono tutte indispensabili? Si può migliorare la leggibilità diretta?

    Grazie del tuo aiuto

  11. Il campo $user->id_gruppo mi da un errore: Notice: Undefined property: stdClass::$id_gruppo in /var/www/myisp/library/Myisp/Controller/Action/Helper/Acl.php on line 55
    Perchè?

  12. Sergio Rinaudo

    Ciao,
    rispondo alla tua prima domanda: non hai la necessità di inserire il codice di ACL in ogni initi di ogni controller, puoi estendere Zend_Controller_Action con un Tuo_Controller_Action e creare i vari controler estendendo Tuo_Controller_Action. Ovviamente l’unico init che conterra il controllo di ACL sarà quello in Tuo_Controller_Action ( in questo modo non devi ripetere il codice ).

    Per le altre richieste ti rimando a questo articolo http://razorblade.netsons.org/2008/10/27/zend-search-lucene-e-utf-8-unicode-con-zend-framework/ dove dovresti trovare l’applicazione completa da scaricare, con il database incluso.
    Detto ciò ripeto che ho sviluppato un’altra versione di ACL, non so quando la pubblicherò, ma comunque non si discosta in maniera eccessiva da quella discussa in questo articolo, cambia la gestione del db ( in meglio, più chiara ) e l’implementazione delle gerarchie di risorse e degli asserts. Se non hai tempo di attendere potresti provare a fare una tua implementazione, utilizzando le informazioni di questa pagina ma anche della documentazione ufficiale.

    Per l’errore ti rimando al download dell’applicazione, se la installi correttamente funziona tutto.
    Ciao

  13. Grazie ho risolto tutto.

  14. Ciao Sergio,

    Da un paio di settimane mi sono avvicinato a Zend Framework. Cerco in rete tutorial e devo dire ke questo è uno dei più chiari e dettagliati, complimenti.
    Sto studiando sull’ultima versione di zend (la 1.8.1), volevo sapere se la gestione delle acl cosi come le implementi tu è applicabile sulla nuova versione.
    Grazie mille.

  15. Sergio Rinaudo

    Ciao,
    l’ultima versione è la 1.8.2, comunque non fa differenza.
    Per quanto riguarda l’acl non è cambiato nulla, quindi il tutorial è valido. Il tutorial di questa pagina però non tiene conto dell’ereditarietà tra le risorse, qualche mese fa ne ho fatto una nuova versione che invece ne tiene conto, purtroppo attualmente non ho proprio il tempo di scrivere. Inoltre ho modificato un po le tabelle del database, aggiungendone anche una per gli assert.

    Come base di partenza direi che non è male, ti consiglierei però di aprire la documentazione ufficiale ed eventualmente implementarci tutto quello che non è implementato.

  16. Ciao Sergio,
    ho un problema sulla restituzione dell’errore se l’utente non ha i permessi.

    Sto utilizzando Zend Framework 1.8.2

    nell’init ho aggiunto la verifica dell’acl per l’utente loggato. Se nn è autorizzato vorrei reidirizzare la pagina al controller error action access come posso fare?
    Ho provato a scrivere :
    $this->view->errorMsg = $errorMessage;
    $request->setControllerName(‘error’)->setActionName(‘access’);

    ma funziona solo se nel controller in cui modifico l’init è presente l’action access.

    Dove sbaglio?

    Grazie mille

  17. Sergio Rinaudo

    Io ho usato il controller helper redirect, ed inoltre ho creato una route apposta per la pagina di login

    $this->_redirect(‘/login.html’);

    Dove [miosito]/login.html corrisponde ad una route specifica

    Per maggiori info cerca a proposito di _redirect nella documentazione ufficiale.

    Ciao

  18. Ho fatto cosi:

    $this->_helper->redirector(‘access’, ‘error’,false, array(‘errorMsg’ => $errorMessage));
    ed ora va alla pagina specificata e mi porta anche il messaggio di errore.
    Nell’action access del controller Error prendo la variabile e la stampo sul phtml.

    $request = $this->getRequest();
    $this->view->errorMsg = $request->getParam(‘errorMsg’);

    Il problema è che il messaggio di errore mi passa come variabile get e quindi è visibile nella barra degli indirizzi.
    C’è un altro modo per passarla?

  19. Sergio Rinaudo

    Potresti usare il flash messenger

    http://framework.zend.com/manual/en/zend.controller.actionhelpers.html

    funziona all’incirca come la sessione, difatti credo che internamente usi la sessione

  20. Grazie mille ora funziona tutto.

    Senti volevo chiederti un altro aiuto su un’altra problematica.

    Vorrei creare una struttura cosi:

    Application
    – configs
    – Admin
    – controllers
    – models
    – views
    – User
    – controllers
    – models
    – views

    dove il modulo user è quello di default.

    Cosa devo modificare sul file di bootstrap per far funzionare il tutto?

    miosito/admin/
    miosito/user o miosito/

    Grazie.

  21. Sergio Rinaudo

    Attualmente la struttura della mia applicazione, generata con Zend Tool, contiene le directories del modulo di default dirattamente all’interno di application.

    Per gli altri moduli invece ho creato la cartella modules ( quindi application/modules ) dove al suo interno ci sono i vari moduli.

    Sinceramente non so dove bisogna modificare per avere la struttura che dici, io da quando sono riuscito finalmente a capire come si gestivano i moduli dalla 1.8 in poi mi sono accontentato della struttura che ti ho descritto.

  22. Potrebbe andare bene anche la struttura cosi come dici tu.
    Cosa devo modificare per creare:

    Application
    – controllers
    – views
    – models
    – modules
    — admin
    — controllers
    — views
    — models

  23. Sergio Rinaudo

    Mi spiace,
    questo è il punto dolente.
    Non posso spiegartelo via un commento perchè ci sarebbe bisogno di un intero tutorial.

    Quando sono finalmente riuscito ad integrare questa cosa non era disponibile nemmeno la documentazione in inglese, non so se attualmente esiste.

    In ogni caso è stata questa:

    http://www.nabble.com/ZF1.8-Switching-layouts-between-modules.-td23433040.html

    la discussione che ho aperto sulla mailing list di Zend Framework e che mi ha aiutato a risolvere. Spero che tu conosca un po di inglese.

    Ciao

  24. Ciao, questo tuo tutorial è compatibile anche con la versione 1.9.7?
    Grazie lo stesso e saluti!

  25. Ciao per caso questo tutorial è compatibile anche con la versione 1.9.7?
    Saluti e Grazie!

  26. Ciao, se metto in ./application/boostrap.php o ./public/index.php le seguenti righe per far riconoscere le due classi ACL:
    $acl = new Model_Acl();
    $aclHelper = new Application_Controllers_Helpers_Acl(null, array(‘acl’=> $acl));
    Zend_Controller_Action_HelperBroker::addHelper($aclHelper);

    ottengo un errore di class not found.
    Mettendole invece nella init() di indexController ottengo l’errore solo per il secondo, ovvero l’Action Helper.

  27. Ho risolto la questione del ‘class not found’ aggiungendo le seguenti righe a Bootstrap.php:
    require_once ‘Zend/Loader/Autoloader.php';
    $loader = Zend_Loader_Autoloader::getInstance();
    $loader->registerNamespace(‘Custom_’);
    $loader->setFallbackAutoloader(true);
    E inserendo le due classi Acl rispettivamente in ../library/custom/ e ../library/custom/controller/action/helper
    Adesso mi trovo a dover risolvere un altro problema: è possibile modificare la funzione isAllowed($userRole, $resourceName, ‘read’) in modo che il terzo parametro venga caricato dinamicamente in base alla action del controller a cui si punta?

  28. Ciao,
    complimenti per aver trovato la soluzione al tuo problema, in effetti era proprio quello.
    Per quanto riguarda il tuo nuovo problema ti rispondo con una domanda, perchè hai la necessità di fare questa cosa?
    Puoi semplicemente omettere il terzo parametro, in modo da attribuire tutti i permessi.
    Fammi sapere.
    Ciao

  29. Diciamo che ho cambiato approccio, eliminando un po’ di tabelle e mappando il controller direttamente nella tabella permesso, non curandomi di controllare ogni singola action. Adesso devo trovare un modo elegante per effettuare la connessione al db, visto che nel resto dell’applicazione utilizzo sempre i model per accederci.

  30. Ciao, e complimenti per questo articolo da cui stò prendento spunto per una mia web application. Ho letto nei vari commenti (di più di un anno fà) di una nuova versione di questa implemenmtazione ACL.
    Per caso è visionalbile per poter darvi un’occhiata?

    Grazie

  31. Ho seguito il consiglio di uastasi ma non riesco ancora a risolvere il problema della classe non trovata. Ho una struttura simile:
    Application
    library
    –custom
    –Zend
    public
    tests
    Dove dovrei piazzare le classi in questo caso!? Ma soprattutto, cosa devo aggiungere al file index.php affinché tutto proceda per il verso giusto!?

Lascia un Commento

L'indirizzo email non verrà pubblicato. I campi obbligatori sono contrassegnati *

È possibile utilizzare questi tag ed attributi XHTML: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>