Zend FR

A la fin du login controller, je teste Zend_Auth::getInstance()->hasIdentity() qui est TRUE. La session est crée, les données récupérées suite au login figurent dans la session, bref tout est OK.

Pourtant, dans le plugin de gestion des ACL, le même test est systématiquement à FALSE.

Je dois mal utiliser la session ou Zend_Auth.  Pouvez-vous m'aider, je suis un peu perdu...

Jean

le Bootstrap :

$session = $this->getResource('session');
        $storage = new App_Auth_Storage_Session($session);
        $auth = Zend_Auth::getInstance();
        $auth->setStorage($storage);     

private function  _initSession() {
        $session = new Zend_Session_Namespace('vivier',true);
        }

La classe Session :

class App_Auth_Storage_Session implements Zend_Auth_Storage_Interface
{
    protected $_session;

    public function __construct($session)
    {
        $this->_session  = $session;
    }

    /**
     * Defined by Zend_Auth_Storage_Interface
     *
     * @return boolean
     */
    public function isEmpty()
    {
        return !isset($this->_session->{'user_id'});
    }

    /**
     * Defined by Zend_Auth_Storage_Interface
     *
     * @return mixed
     */
    public function read()
    {
        return array(
                'user_id'=>$this->_session->{'user_id'},
                'user_name'=>$this->_session->{'user_name'},
                'user_realname'=>$this->_session->{'user_realname'},
                'user_email'=>$this->_session->{'user_email'},
                'user_role'=>$this->_session->{'user_role'});
    }

    /**
     * Defined by Zend_Auth_Storage_Interface
     *
     * @param  mixed $contents
     * @return void
     */
    public function write($contents)
    {
        $this->_session->{'user_id'}         = $contents['user_id'];       
        $this->_session->{'user_name'}         = $contents['user_name'];
        $this->_session->{'user_realname'}     = $contents['user_realname'];
        $this->_session->{'user_email'}     = $contents['user_email'];
        $this->_session->{'user_role'}         = $contents['user_role'];   
    }

    /**
     * Defined by Zend_Auth_Storage_Interface
     *
     * @return void
     */
    public function clear()
    {
        unset($this->_session->{'user_id'});
        unset($this->_session->{'user_name'});
        unset($this->_session->{'user_realname'});
        unset($this->_session->{'user_email'});
        unset($this->_session->{'user_role'});
    }

    public function getUserName()
    {
        return $this->_session->{'user_name'};
    }

    public function setUserName($username)
    {
        $this->_session->{'user_name'}=$username;
    }

    public function getUserId()
    {
        return $this->_session->{'user_id'};
    }
    public function getUserRealName()
    {
        return $this->_session->{'user_realname'};
    }
    public function getUserEmail()
    {
        return $this->_session->{'user_email'};
    }

    public function getUserRole()
    {
        return $this->_session->{'user_role'};
    }
}

L'adapter est celui de l'application Dodo (adapté) :

class App_Auth_Adapter_Web implements Zend_Auth_Adapter_Interface
{
    private $_username;
    private $_password;

    /**
     * Donne username et password pour authentication
     *
     * @return void
     */
    public function __construct($username, $password)
    {
        $this->_username = $username;
        $this->_password = $password;
    }

    public function getIdentity(){
        return $this->_username;
    }

    /**
     * Etape d'autentification
     *
     * @throws Zend_Auth_Adapter_Exception si l'autentification échoue
     * @return Zend_Auth_Result
     */
    public function authenticate()
    {
        $model = new Model_DbTable_User();

        // recherche l'utilisateur dans la base de données (username)
        $user = null;
        try{
            $user = $model->getUserByUsername($this->_username);

        }catch (Exception $e){
            // exception si l'utilisateur est introuvable
            return new Zend_Auth_Result(Zend_Auth_Result::FAILURE_IDENTITY_NOT_FOUND,
                    array('user_name'=>$this->_username),
                    array(App_Translate::translate('utilisateur inconnu')));
        }

        // fait un "hash" du password en utilisant le salt de la base de données
        $signature = strtolower(md5($this->_password . $user['salt']));

        // validate credentials
        if ($signature !== $user['password']){

            // password is not valid...
            return new Zend_Auth_Result(Zend_Auth_Result::FAILURE_CREDENTIAL_INVALID,
                    array('user_name'=>$this->_username),
                    array(App_Translate::translate('mot de passe invalide')));
        }

        // stockage des données dans Zend Auth (voir App_Auth_Storage_Session)
        return new Zend_Auth_Result(Zend_Auth_Result::SUCCESS,
            array(
               'user_id'=>$user['id'],
               'user_name'=>$this->_username,
               'user_realname'=>$user['realname'],
               'user_email'=>$user['email'],
               'user_role'=>$user['role']),
                  array(App_Translate::translate('accès autorisé')));
    }
}

Le plugin de controle des ACL :

class Plugin_Acl extends Zend_Controller_Plugin_Abstract
{
    public function preDispatch(Zend_Controller_Request_Abstract $request)
    {   
        if (Zend_Auth::getInstance()->hasIdentity()) {
            // le rôle existe
            // il a été écrit par le login controller
            //$role = Zend_Auth::getStorage()->read('user_role');
            $role = Zend_Auth::getInstance()->getStorage()->getUserRole();
        }
        else {
            // non connecté : le rôle "invite" est affecté
            $role = 'invite';
        }
     
        // Ressources demandées
        $module     = $request->getModuleName();
        $controller = $request->getControllerName();
        $action     = $request->getActionName();
       
        $ressource     = $module . '/' . $controller;
       
        // instance de la classe contenant les ACL
        $acl = new App_AccessList();
       
        // vérif : le controlleur existe dans l'acl ?
        if(!$acl->has($ressource)){
            throw new Zend_Exception('La ressource ' . $resource . ' est inconnue');
        }

       
        // Vérification des droits d'accès définis dans l'ACL
        // Si OK, je vais au (module, controller, action) demandé
        // Si pas OK, exception et redirection       
        if (!$acl->isAllowed(
                $role,             // le role récupéré par la connexion
                $ressource,        // la ressource (module/controller) auquel on veut accéder
                $action )        // l'action à laquelle on veut accéder
            )
        {
             if (Zend_Auth::getInstance()->hasIdentity()) {
                // si authentifié : retour à l'accueil
                //echo " ACL hasIdentity ";
                $request->setModuleName('public');
                $request->setControllerName('index');
                $request->setActionName('index');
            } else {
                //echo " ACL sans hasIdentity ";               
                // si pas authentifié : retour au login
                $request->setModuleName('public');
                $request->setControllerName('login');
                $request->setActionName('index');

                if(!Zend_Registry::isRegistered('erreur')){
                    $message = 'Accès réservé. Vous devez vous authentifier.';
                    Zend_Registry::set('erreur',$message);
                }
            }
        }
     }
}

Dernière modification par jean (22-11-2009 22:32:32)