Zend FR

/**
 * Gestion des ACL personnalisés.
 * Les rôles, ressources et privilèges sont définis manuellement mais à terme ils doivent être inscrit dans une bd et
 * générer automatiquement.
 * 
 * Dans mon application : 
 *             - un Role         = un type d'utilisateur : guest, member, publisher, admin, super admin
 *             - une ressource = un module (structure, appart, etc.)
 *             - un Privilège     = une action (ajouter, modifier, supprimer, détail, rechercher)
 * @author Yvan
 */
class MyAcl extends Zend_Acl
{
    /**
     * Constructeur : je défini en bourrin mes acls ici
     *
     * @param Zend_Auth $auth
     */
    public function __construct(Zend_Auth $auth)
    {
        //parent::__construct();
        
        $roleGuest = new Zend_Acl_Role('guest');
        
        //==============================================================================//
        //                        DEFINITION DES RESSOURCES                                //
        //==============================================================================//
        $this->add(new Zend_Acl_Resource('default'));
        $this->add(new Zend_Acl_Resource('structure'));
        $this->add(new Zend_Acl_Resource('appart'));
        $this->add(new Zend_Acl_Resource('pretendant'));
        $this->add(new Zend_Acl_Resource('locataire'));
        $this->add(new Zend_Acl_Resource('location'));
        $this->add(new Zend_Acl_Resource('facture'));
        $this->add(new Zend_Acl_Resource('plainte'));
        $this->add(new Zend_Acl_Resource('dette'));            //-- zone ou le client pourra avoir un suivi de ses commandes
        $this->add(new Zend_Acl_Resource('reclamation'));                    
        $this->add(new Zend_Acl_Resource('collaborateur'));                    //-- bon de livraison, bon de commande        
        $this->add(new Zend_Acl_Resource('quitance'));
        $this->add(new Zend_Acl_Resource('configuration'));
        $this->add(new Zend_Acl_Resource('user'));
        $this->add(new Zend_Acl_Resource('portal_user'));
        
        
        //==============================================================================//
        //                        CREATION DES ROLES                                        //
        //==============================================================================//
        $this->addRole(new Zend_Acl_Role('guest'));                //-- rôle "invité"
        $this->addRole(new Zend_Acl_Role('member'));            //-- rôle "membre"
        $this->addRole(new Zend_Acl_Role('publisher'));            //-- rôle "publisher"
        $this->addRole(new Zend_Acl_Role('admin'));                //-- rôle "administrateur"
        $this->addRole(new Zend_Acl_Role('super_admin'));        //-- rôle "super administrateur"
        
        
        //-- Affectation des rôles 
        $this->allow('guest', 'default');        // Les invités peuvent uniquement voir la home

        //==============================================================================//
        //                        GESTION DES MEMBRES                                        //
        //==============================================================================//
        //-- Autorisation --//
        $tabMembreAllow = array('index', 'detail', 'rechercher');
        
        $this->allow('member', 'default');    
        $this->allow('member', 'structure',     $tabMembreAllow);    
        $this->allow('member', 'appart',         $tabMembreAllow);
        $this->allow('member', 'pretendant',    $tabMembreAllow);
        $this->allow('member', 'locataire',     $tabMembreAllow);
        $this->allow('member', 'location',        $tabMembreAllow);
        $this->allow('member', 'facture',         $tabMembreAllow);
        $this->allow('member', 'plainte',        $tabMembreAllow);
        $this->allow('member', 'reclamation',     $tabMembreAllow);
        $this->allow('member', 'quitance',        $tabMembreAllow);
        //$this->allow('member', 'configuration',    $tabMembreAllow);    //-- Seul l'admin gère les utilisateurs
        //$this->allow('member', 'user',            $tabMembreAllow);    //-- seul l'admin gère les utilisateurs
        $this->allow('member', 'portal_user',    $tabMembreAllow);

        //-- Refuser --//
        $tabMembreDeny = array('supprimer', 'modifier','ajouter');
        
        $this->deny('member', 'structure',         $tabMembreDeny);    
        $this->deny('member', 'appart',         $tabMembreDeny);
        $this->deny('member', 'pretendant',     $tabMembreDeny);
        $this->deny('member', 'locataire',         $tabMembreDeny);
        $this->deny('member', 'location',         $tabMembreDeny);
        $this->deny('member', 'facture',         $tabMembreDeny);
        $this->deny('member', 'plainte',         $tabMembreDeny);
        $this->deny('member', 'reclamation',     $tabMembreDeny);
        $this->deny('member', 'quitance',         $tabMembreDeny);
        $this->deny('member', 'configuration');                            //-- Seul l'admin gère les utilisateurs
        $this->deny('member', 'user');                                    //-- seul l'admin gère les utilisateurs
        $this->deny('member', 'portal_user',     $tabMembreDeny);

              //-- IDEM POUR LES AUTRES ROLES

    }
}

 //extrait de mon bootstrap
//============================================================================================================
//                         Gestion des rôles avec Acl et Auth
//============================================================================================================
$auth             = Zend_Auth::getInstance();
$authAdapter     = new Zend_Auth_Adapter_DbTable($db);
$loginAuth         = new LoginAuth($db,$authAdapter,$auth);        //-- LoginAuth est une classe perso qui va gérer l'interface utilisateur
$registry->set('loginAuth', $loginAuth);                        //-- Instance LoginAuth qui sera utilisé dans le Controlleur AuthController

Zend_Loader::loadClass('MyAcl');                        //-- Charge les ACL
$acl = new MyAcl($auth); 
Zend_Registry::set('acl', $acl);

Zend_Loader::loadClass('MyPluginAuth');                                //-- Plugin  Gestion des acl et authentification
$frontController->registerPlugin(new MyPluginAuth($auth, $acl));    //-- Enregistrement du plugin
//==========================================
<?php 
/**
 * Type : Plugin
 * 
 * Ce plugin gère l'Authentification et les ACL. Il est appelé par la méthode preDispatch() à chaque visite d'une page.
 * Suivant le controlleur, le module et l'action visité par l'utilisateur, on détermine s'il est authentifié et s'il respecte
 * les Acl mis en place.
 * 
 * L'authentification propre est géré via la classe : LoginAuth.php
 * Les Acls sont gérés via la classe : MyAcl.php
 *
 * @author Yvan
 */
class MyPluginAuth extends Zend_Controller_Plugin_Abstract
{
    /**
     * Instance d'authentification 
     *
     * @var Zend_Auth::getInstance 
     */
    private $_auth;
    
    /**
     * ACL en cours : Définis dans la classe MyACL
     *
     * @var Zend::Acl
     */
    private $_acl;

    /**
     * Utilisateur non authentifié : redirection vers la page de login
     *
     * @var array
     */
    private $_noauth = array('module' =>'default',
                            'controller' => 'auth',
                            'action' => 'login');

    /**
     * Utilisateur ne respectant pas les ACL : redirection vers la page par défaut
     *
     * @var array
     */
    private $_noacl = array('module' => 'default',
                            'controller' => 'index',
                            'action' => 'index');

    /**
     * Constructeur : Initialise les variables privés d'Authentification et de gestion des ACL
     *
     * @param Zend_Auth::getInstance() $auth récupéré grâce à la méthode getInstance() de ZF
     * @param Zend::Acl $acl
     */
    public function __construct($auth, $acl)
    {
        $this->_auth = $auth;
        $this->_acl = $acl;
    }

    /**
     * Est appelé en PreDispatch et décide pour chaque page visité si l'utilsiateur est identifié et respecte les ACL
     *
     * @param Zend_Controller_Request_Abstract $request
     */
    public function preDispatch(Zend_Controller_Request_Abstract $request)
    {
        //-- Utilisateur Est identifié ? Par défaut c'est un invité
        if ($this->_auth->hasIdentity()) 
        {
            $identity = $this->_auth->getIdentity();            
            $role = $identity->ROLE;
        } else {
            $role = 'guest';
        }
        
        //-- Récupère le Controlleur + l'Action + le Module visité par l'utilisateur en cours
        $controller     = $request->getControllerName();
        $action         = $request->getActionName();
        $module         = $request->getModuleName();
        
        //-- Détermine qu'est ce que la RESSOURCE et le PRIVILEGE dans notre cas --//
        $resource         = $module;    //-- ressource
        $privilege        = $action;    //-- Privilège
                
        //-- Si la ressource existe --//
        if (!$this->_acl->has($resource)) 
        {
            $resource = null;
        }

        //-- Si l'accès à la ressource + priviliège est autorisé  est autorisé --//
        if (!$this->_acl->isAllowed($role, $resource, $privilege)) 
        {
            //-- Si l'utilisateur n'est pas identifié, on le redirige vers la page de connexion
            if (!$this->_auth->hasIdentity()) {
                $module     = $this->_noauth['module'];
                $controller = $this->_noauth['controller'];
                $action     = $this->_noauth['action'];
            }
            else //-- Sinon l'utilisateur est enregistré mais n'a pas les droits ACL, on redirige vers la page par défaut
            {                
                $module     = $this->_noacl['module'];
                $controller = $this->_noacl['controller'];
                $action     = $this->_noacl['action'];
            }
        }

        //-- redirection vers le module + controlleur + action en sortant du plugin --//
        $request->setModuleName($module);
        $request->setControllerName($controller);
        $request->setActionName($action);
    }
}

<?php
/**
 *  Classe de gestion de l'authentification selon ZF
 * L'authentification utilise un objet de type Zend::Auth. Cet objet se connectera à la table USERS et récupère le champs ROLE qui 
 * contient le rôle utilisé par l'ACL.
 * 
 * @author Yvan 
 */
class LoginAuth 
{
    /**
     * Adaptateur contenant la connexion à la bd
     *
     * @var Zend_Db
     */
    protected $dbAdapter;
    
    /**
     * Connexion d'auhtentification 
     *
     * @var Zend_Auth_Adapter_DbTable
     */
    protected $authAdapter;
    
    /**
     * Objet ZF d'authentification
     *
     * @var Zend::Auth
     */
    protected $auth;

    /**
     * Constructeur
     *
     * @param Zend_Db $dbAdaptateur
     * @param Zend_Auth_Adapter_DbTable $authAdaptater
     * @param Zend::Auth $auth
     */
    public function __construct($dbAdaptateur, $authAdaptater, $auth)
    {
        $this->dbAdapter     = $dbAdaptateur;
        $this->authAdapter     = $authAdaptater;
        $this->auth            = $auth;
    }
    
    
    /**
     * Authentification d'un utilisateur en utilisant l'objet Zend::Auth
     *
     * @param string $username nom d'utilisateur
     * @param string $password mot de passe
     * @return Zend::Zend_Auth_Result
     */
    public function authenticate($username, $password)
    {                                        
        //-- Défini la table User et indique les nom Username et Password que l'on vient de récupérer
        $this->authAdapter->setTableName('users');
        $this->authAdapter->setIdentityColumn('username');
        $this->authAdapter->setCredentialColumn('password');
                
        // Set the input credential values to authenticate against
        $this->authAdapter->setIdentity($username);
        $this->authAdapter->setCredential($password);
                
                
        //-- Test si l'authentification est ok, et sauvegarde automatiquement dans la session
        $result = $this->auth->authenticate($this->authAdapter);
        
        return $result;
    }
    
    /**
     * Retourne VRAI si l'utilisateur est identifié
     *
     * @return booléen : true, utilisateur identifié, false sinon
     */
    public function hasIdentity()
    {
        return ($this->auth && $this->auth->hasIdentity());
    }

    /**
     * Enregistre les informations de l'utilisateurs identifié dans l'objet Auth
     * Nous ne sauvegardons pas le mot de passe par sécurité
     */
    public function storeLoggedUser()
    {
        //$dbAdapter = Zend_Registry::get('dbAdapter');
        //$authAdapter = new Zend_Auth_Adapter_DbTable($dbAdapter);        
        
        if ($this->authAdapter) {
            $data = $this->authAdapter->getResultRowObject(null, 'PASSWORD');
            $this->auth->getStorage()->write($data);
        }
    }
    
    /**
     * Test si l'utilisateur/password existe dans la table User et l'authentifie dans Auth 
     *
     * @param $string $username nom d'utilisateur
     * @param $string $password mot de passe
     * @return booleen true si l'utilisateur existe
     */
    public function isUserExist($username, $password)
    {
         $result = $this->authenticate($username, $password);        
         return $result->isValid();
    }

    /**
     * Déconnexion de l'utilisateur
     */
    public function clearIdentity()
    {
        $this->auth->clearIdentity();
    }

    /**
     * Retourne l'identité d'un utilisateur authentifié
     *
     * @return mixed Zend_Auth_Result
     */
    public function getUser()
    {        
        if($this->hasIdentity()) 
        {
            $user = $this->auth->getIdentity();
            return $user;    
        }        
    }        
}
?>

<?php
/**
 * Controlleur Index
 * Gère l'authentification sur le site    
 * @author Yvan 
 */
class AuthController extends Zend_Controller_Action
{
    protected $pathCtrl;
    protected $pathImg;

    /**
     * Classe LoginAuth assurant la gestion de l'authentification avec le composant Zend::Auth
     * Contiens les fonctions de connexions.
     *
     * @var Class LoginAuth 
     */
    protected $loginAuth;

    /**
     * Initialisation du controlleur
     */
    function init()
    {
        //========================================================================
        //    Processus d'identification LoginAuth
        //========================================================================
        Zend_Loader::loadClass('Zend_Auth_Adapter_DbTable');
        $dbAdapter         = Zend_Registry::get('dbAdapter');
        $authAdapter     = new Zend_Auth_Adapter_DbTable($dbAdapter);
        $auth             = Zend_Auth::getInstance();
        
        $this->loginAuth = Zend_Registry::get('loginAuth');    
        
        //========================================================================
        //    Initialisation des paths de la page
        //========================================================================
        $pathCtrl = $this->_request->getBaseUrl();
        $this->initView();
        $this->view->baseUrl = $pathCtrl;
        $this->view->url_auth_login = $pathCtrl.'/auth/login';
        
        //-- path des images pour l'affichage .phtml
        $this->pathImg =  $this->_request->getBaseUrl().'/public/images/connexion/';
        $this->view->pathImg = $this->pathImg;
        
    }
    
       /**
     * Index : redirige vers le controller par défaut. Pas de gestion de Layout
     */
    function indexAction()
    {        
        $this->_helper->layout->disableLayout();        //-- Desactive le layout
        $this->_redirect('/');
    }

    /**
     * Login : traitement de l'utilisateur. L'utilisateur se connecte et envoie son nom d'utilsateur et mot de passe
     */
    function loginAction()
    {
        $this->_helper->layout->disableLayout();        //-- Desactive le Zend::Layout ()
        $this->view->message = '';
        
        //-- Si un post est envoyé
        if ($this->_request->isPost()) 
        {
            
            // collect the data from the user
            Zend_Loader::loadClass('Zend_Filter_StripTags');
            $f = new Zend_Filter_StripTags();
            
            //-- Récupère les infos par post
            $username = $f->filter($this->_request->getPost('username'));
            $password = $f->filter($this->_request->getPost('password'));
            
            //-- Si le nom est vide
            if (empty($username)) 
            {
                $this->view->message = TXT_INVALIDE_NAME;
            } 
            else 
            {                
                //-- Test si l'utilisateur existe -> lance le processus Authenticate()
                if ($this->loginAuth->isUserExist($username, $password)) 
                {
                    $this->loginAuth->storeLoggedUser();    //-- Enregistre l'utilisateur
                    $this->_redirect('/');        //-- redrection vers la page par défault
                } 
                else     //-- echec de l'authentification
                {
                    $this->view->message = TXT_ERROR_CONNEXION;
                }
            }
        }
        $this->view->title = TXT_TITRE_CONNEXION;
        $this->render();
    }
    
    /**
     * Déconnexion : Action Logout
     */
    function logoutAction()
    {
        $this->loginAuth->clearIdentity();
        $this->_redirect('/');
    }    
}

CREATE TABLE `users` (
  `ID` int(11) NOT NULL auto_increment,
  `USERNAME` varchar(128) default NULL,
  `PASSWORD` varchar(128) default NULL,
  `REAL_NAME` varchar(128) default NULL,
  `ROLE` varchar(255) default NULL,
  PRIMARY KEY  (`ID`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=2 ;

-- 
-- Contenu de la table `users`
-- 

INSERT INTO `users` (`ID`, `USERNAME`, `PASSWORD`, `REAL_NAME`, `ROLE`) VALUES 
(1, 'admin', 'admin', 'admin', 'admin');

 $acl->isAllow("role","ressource")

$this->allow('member', 'structure',     'lire');

echo "role : $role, ressource : $ressource, privilege $privilege, controlleur : $controller"; exit();