Forums Développement Multimédia

Les formations Mediabox
Les formations Mediabox



Authentification Avec Flex Et Zend (2/2) - Côté PHP

Compatible Flex Builder 3. Cliquer pour en savoir plus sur les compatibilités.Compatible ActionScript 3. Cliquer pour en savoir plus sur les compatibilités.Compatible PHP. Cliquer pour en savoir plus sur les compatibilités.Par slyc3 (Steve Domin), le 11 mai 2009

Cette page est la deuxième partie de ce tutoriel, un exemple complet d'authentification avec Flex et Zend AMF.

Il s'agit d'une traduction de Build a better Login with Adobe Flex, Zend_Amf, Zend_Auth, and Zend_Acl – On The PHP Side , de Keith Craigo, placé sous license Creative Commons Attribution-Share Alike 3.0 United States License.

La première partie se trouve ici.

Traduction

Voici la partie serveur de mon tutoriel sur l'authentification avec Flex, Zend_Amf, Zend_Auth et Zend_Acl - Partie Flex”.
Consulter la première partie de ce tutoriel pour voir ce qui est requis pour ce projet.

Nous avons précédemment créer un dossier appelé frameworks dans le repertoire d'installation de MAMP pour nous permettre d'y placer toute la bibliothèque Zend. Nous avons maintenant besoin de créer un nouveau dossier qui servira d'emplacement pour mettre tout la partie serveur de notre code.

Créer un nouveau dossier nommé AccessControlExample dans le répertoire MAMP/htdocs.
Créer dans ce dossier un nouveau dossier nommé phplib, ce sera l'emplacement pour les fichiers principaux de notre application.
Dans le dossier AccessControlExample, créer un nouveau fichier nommé index.php, ce fichier se trouve être le fichier bootstrap bien connu des utilisateurs de Zend. Si vous avez besoin de plus d'information à propos de ce fichier bootstrap ou d'une autre partie du framework Zend, consulter le guide de référence du framework Zend .

Remplacer le contenu du fichier index.php par ceci :

<?php// Error Reporting

error_reporting(E_ALL|E_STRICT);
 
// Turn to off when released to productionini_set(”display_errors”,”on”);
 
// Modify include_path to include the
Zend library and the utils dirini_set(”include_path”, ini_get(”include_path”).PATH_SEPARATOR.../../frameworks/.
PATH_SEPARATOR.../../utils/);
 
// Zend Framework Includesrequire_once ‘Zend/Loader.php’;

Zend_Loader::registerAutoload();
 
require_once ‘Zend/Amf/Server.php’;
require_once ‘ConnectionHelper.php’;

require_once ‘phplib/LoginVO.php’;

require_once ‘phplib/LoginManager.php’;
 
$server = new Zend_Amf_Server();

$server->setClass(’LoginManager’);

$server->setClass(”LoginVO”);
 
// Change this to true when released to production

$server->setProduction(false);
 
//Mapping the ActionScript VO to the PHP VO

//you don’t have to add the package name$server->setClassMap(”LoginVO”,”LoginVO”);
 
echo($server->handle());

Basiquement ce fichier fournit le chemin framework Zend et toutes les bibliothèques personnalisés que nous créons pour notre application en auront besoin pour fonctionner.
Nous faisons aussi le lien entre nos Value Objects PHP et ceux en Actionscript.
Transférer des Value Objects est beaucoup plus efficace que de faire plusieurs appels pour envoyer les données séparément.

Créer un nouvelle classe PHP dans le dossier MAMP/utils nommé ConnectionHelper.php avec le code suivant :

<?phpclass ConnectionHelper
{public function __construct() {
        $this->host=’localhost’;

        $this->dbname=’AccessControlExample’;

        $this->username =’root’;

        $this->password = ‘root’;
    }}

Modifier ce fichier en fonction de vs besoins.
Vous pouvez fermer le fichier ConnectionHelper.php.

Très bien, maintenant nous devons créer les trois fichiers de classe php dont notre application a besoin.

  1. LoginManager.php - c'est le cerveau de la partie serveur de notre code. C'est par ici que passe les informations de connexion de l'utilisateur pour procéder à l'authentification et l'autoriser à utiliser notre application. Souvenez-vous qu'authentifier (Zend_Auth) et autoriser (Zend_Acl) sont deux chose différentes.
  1. LoginVO.php - c'est un Value Object, une structure simple qui décrit les attributs de la connexion de l'utilisateur.
  1. AccessPrivsVO.php - c'est un Value Object, une structure simple qui décrit les privilèges du rôle de notre utilisateur.

Dans le fichier LoginManager.php copier le code suivant :

<?php
require_once ‘ConnectionHelper.php’;

require_once ‘LoginVO.php’;

require_once ‘AccessPrivsVO.php’;

require_once ‘Zend/Auth.php’;

require_once ‘Zend/Acl.php’;
 
/*
* LoginManager
*
* Verify’s the users login credentials and
checks the users role against the ACL for access rights.
*
* 
       @return Access Privileges
 */

 
class LoginManager {
 
     private $dbAdapter;
private $authAdapter;
    /**
* @return mixed
*/

 
    public function __construct() {
        // Get a reference to the
singleton instance of Zend_Auth

        $this->auth = Zend_Auth::getInstance();
 
         // Create database connection

         try {$conn = new ConnectionHelper();

               $this->dbAdapter =
 Zend_Db::factory(’Mysqli’, array(
                              ’host’ => $conn->host,

                              ‘dbname’ => $conn->dbname,

                              ‘username’ => $conn->username,
                              
‘password’ => $conn->password));

         }
         
catch ( Zend_Db_Exception $e)
         {return “Caught exception:. get_class($e) .
“\n Message:. $e->getMessage() . “\n”;
         
}}
 
    // test
    /**
* @return void
*/public function test() {return “Success! Test Completed Normally”;
}
 
 
     /**
*
* Authenticates the user
*
* 
           @todo add routine to verify using SSO
*
* 
           @return mixed
*
*/public function verifyUser(LoginVO $user)
     {
          $userRole=”;
          
// Configure the instance
with constructor parameters…

          $authAdapter = new Zend_Auth_Adapter_DbTable($this->dbAdapter,
‘admin’,
‘username’,
‘password’);
 
          $usr=htmlspecialchars($user->username);
 
          $pwd=htmlspecialchars($user->password);
 
          
if($usr ==)
          {$authAdapter->setIdentity(’guest’)->setCredential(’guest’);
          
}
          else
          {$authAdapter->setIdentity($usr)->setCredential($pwd);
          
}
 
          
$result = $authAdapter->authenticate();
 
          switch ($result->getCode()) {
                  case  Zend_Auth_Result::FAILURE_IDENTITY_NOT_FOUND:$userRole = “guest”;
                        
break;
 
                  case Zend_Auth_Result::FAILURE_CREDENTIAL_INVALID:$userRole = “guest”;
return “FAILURE_CREDENTIAL_INVALID”;
                         
break;
 
                  case Zend_Auth_Result::FAILURE:$userRole = ‘guest’;
break;
 
                  case Zend_Auth_Result::FAILURE_IDENTITY_AMBIGUOUS:$userRole = ‘guest’;
break;
 
                  case Zend_Auth_Result::FAILURE_UNCATEGORIZED:$userRole = ‘guest’;
break;
 
                  case Zend_Auth_Result::SUCCESS:
                         $this->sessionid=$this->getSessionID(); 
                         //revised 2/22/2009

                         // We need to return the authenticated
users role, this will be passed into the Zend_Acl// getResultRowObject returns a stdClass
object so we need to dereference the role in this manner.

                        $r=$authAdapter->getResultRowObject(array(’role’));
                        
$userRole = $r->role;
break;
 
                 default:return “Internal Error! If this problem persist,
please contact your network administrator”;

                        break;

          }
 
         // Set up the ACL (Access Control List)

        $acl = new Zend_Acl();

        // Add groups to the Role registry using Zend_Acl_Role

        // Guest does not inherit access controls.

        // Order matters here, we go from the most
restricted to the least restricted
 
        $acl->addRole(new Zend_Acl_Role(’guest’));
        
$acl->addRole(new Zend_Acl_Role(’manager’), ‘guest’);

        $acl->addRole(new Zend_Acl_Role(’admin’), ‘manager’);
 
        // Administrator does not inherit access controls,
All access is granted

        $acl->addRole(new Zend_Acl_Role(’Super’));
 
        // setup the resource privs

        $acl->add(new Zend_Acl_Resource(’viewPublicUI’));
        
$acl->add(new Zend_Acl_Resource(’viewRestrictedUI’));

        $acl->add(new Zend_Acl_Resource(’viewLogs’));

        $acl->add(new Zend_Acl_Resource(’createManager’));
 
        // Guest may only view the public interface$acl->allow(’guest’, null, ‘viewPublicUI’);
 
        // manager inherits viewPublicUI privilege from guest,
but also needs additional// privileges

        $acl->allow(’manager’, null, array(’viewRestrictedUI’));
 
        // admin inherits viewRestrictedUI privilege from

        // manager, but also needs additional privileges$acl->allow(’admin’, null, array(’createManager’));
 
        // Super inherits nothing, but is allowed all privileges

        $acl->allow(’Super’);
 
        // userRoleVO to Privs Map

        $userRolePrivs = new AccessPrivsVO();

        $userRolePrivs->userRole = $userRole;

        $userRolePrivs->viewPublicUI =$acl->isAllowed($userRole, null, ‘viewPublicUI’) ?
“allowed” : “denied”;

        $userRolePrivs->viewRestrictedUI =$acl->isAllowed($userRole, null, ‘viewRestrictedUI’) ?
“allowed” : “denied”;
$userRolePrivs-  >createManager =$acl->isAllowed($userRole, null, ‘createManager’) ?
“allowed” : “denied”;
$userRolePrivs->viewLogs =$acl->isAllowed($userRole, null, ‘viewLogs’) ?
“allowed” : “denied”;
 
        return $userRolePrivs;
    }}

Dans le fichier LoginVO.php copier le code suivant :

<?phpclass LoginVO
{//public $_explicitType = ‘LoginVO’;public $userName=”;

public $password=”;

}

La variable $_explicitType est un autre moyen de mapper les VO Actionscript aux VO PHP.

Copier le code suivant dans AccessPrivsVO.php :

<?phpclass AccessPrivsVO
{public $userRole=”;

public $viewPublicUI=”;

public $createManager = ”;

public $viewRestrictedUI = ”;

public $viewLogs = ”;
}

Vous avez peut-être remarqué que je n'ai délibérément pas inséré la “balise” de fermeture en php ?>, ceci dans le but d'éviter d'ennuyantes erreurs à cause des espaces blancs en trop.

Voilà, c'est terminé. Vous avez maintenant un système d'authentification solide avec Flex, PHP, Zend_Auth et Zend_Acl qui peut-être modifié à votre convenance pour répondre à vos besoins

En savoir plus