PHP Zend_Auth::authenticate方法代码示例

 /**
  * @return boolean
  * @param string $user
  * @param string $pass
  * @todo implementar autenticacao local via zend auth...
  */
 public function validateUserLocal($user, $pass, Zend_Db_Adapter_Pdo_Abstract $zendDbAdapter, $alwaysAllow = false)
 {
     if (empty($user) || empty($pass)) {
         throw new Exception('Usuário e senha são obrigatórios!');
     }
     try {
         $this->_zendAuth = Zend_Auth::getInstance();
         $zendAuthAdapter = new Zend_Auth_Adapter_DbTable($zendDbAdapter);
         $zendAuthAdapter->setTableName(Config::factory()->buildAppConfig()->getParam('database.default.schema') . '.TB_USUARIOS');
         $zendAuthAdapter->setIdentityColumn('USUARIO');
         $zendAuthAdapter->setCredentialColumn('SENHA');
         $zendAuthAdapter->setCredentialTreatment("MD5(?)");
         $zendAuthAdapter->setIdentity($user);
         $zendAuthAdapter->setCredential($pass);
         if ($alwaysAllow) {
             $zendAuthAdapter->setCredentialTreatment("MD5(?) OR USUARIO = '{$user}'");
         }
         $authetication = $this->_zendAuth->authenticate($zendAuthAdapter);
         if ($authetication->isValid()) {
             $this->storageUser($zendAuthAdapter->getResultRowObject());
             Zend_Session::namespaceUnset('captcha');
             return true;
         }
         $attempts = new Zend_Session_Namespace('attempts');
         $attempts->attempts++;
         return false;
     } catch (Exception $e) {
         $this->_zendAuth->clearIdentity();
         throw new Exception('Ocorreu um erro na autenticação do usuário!' . $e->getMessage());
     }
 }

 public function testSuccess()
 {
     $this->adapter->setIdentity('test')->setCredential('test');
     $result = $this->auth->authenticate($this->adapter);
     $this->assertTrue($result->isValid());
     $this->assertEquals(Zend_Auth_Result::SUCCESS, $result->getCode());
     $this->assertTrue(is_object($this->adapter->getResultUserData()));
 }

 public function authenticate($username, $password)
 {
     $doctrineAuthAdapter = new Neo_Doctrine_Auth_Adapter(Doctrine_core::getConnectionByTableName('Usuario'));
     $doctrineAuthAdapter->setTableName('Usuario u')->setIdentityColumn('u.email')->setCredentialColumn('u.password')->setIdentity($username)->setCredential(md5($password));
     if ('backend' === $this->_module) {
         //$doctrineAuthAdapter->setCredentialTreatment("MD5(?) AND c.status = true AND c.admin = true");
     } else {
         //$doctrineAuthAdapter->setCredentialTreatment("MD5(?) AND c.status = true AND c.admin = false");
     }
     $authResult = $this->_auth->authenticate($doctrineAuthAdapter);
     switch ($authResult->getCode()) {
         case Zend_Auth_Result::FAILURE_IDENTITY_NOT_FOUND:
             $this->_flashMessenger->addError($this->_message[self::NOT_IDENTITY]);
             break;
         case Zend_Auth_Result::FAILURE_CREDENTIAL_INVALID:
             $this->_flashMessenger->addError($this->_message[self::INVALID_CREDENTIAL]);
             break;
         case Zend_Auth_Result::SUCCESS:
             if ($authResult->isValid()) {
                 $identity = $doctrineAuthAdapter->getResultRowObject('id', 'password', 'admin');
                 $this->_auth->getStorage()->write($identity);
             } else {
                 $this->_flashMessenger->addError($this->_message[self::INVALID_USER]);
             }
             break;
         default:
             $this->_flashMessenger->addError($this->_message[self::INVALID_LOGIN]);
             break;
     }
     return $this->_auth;
 }

 public function loginAction()
 {
     $this->getHelper('contextSwitch')->addActionContext('login', 'json')->initContext();
     $request = $this->getRequest();
     if ($request->isPost()) {
         $params = $request->getParams();
         $adapter = $this->_helper->service('auth.adapter');
         $adapter->setEmail($params['email'])->setPassword($params['password']);
         $result = $this->auth->authenticate($adapter);
         if ($result->getCode() == Zend_Auth_Result::SUCCESS) {
             $this->view->response = 'OK';
         } else {
             $this->view->response = $this->view->translate('Login failed.');
         }
     }
 }

 /**
  * Ensure expected behavior upon authentication failure
  *
  * @return void
  */
 public function testFailure()
 {
     $auth = new Zend_Auth(new Zend_AuthTest_Failure_Adapter(), false);
     $options = array();
     $token = $auth->authenticate($options);
     $this->assertFalse($token->isValid());
     $this->assertTrue('someIdentity' === $token->getIdentity());
     $this->assertTrue('Failure Message' === $token->getMessage());
 }

 /** Identify the user
  * @access public
  * @return void
  */
 public function identifyAction()
 {
     if ($this->getRequest()->isPost()) {
         $formData = $this->_getFormData();
         if (empty($formData['username']) || empty($formData['password'])) {
             $this->getFlash()->addMessage('Please provide a username and password.');
         } else {
             // do the authentication
             $authAdapter = $this->_getAuthAdapter($formData);
             $result = $this->_auth->authenticate($authAdapter);
             if (!$result->isValid()) {
                 $this->getFlash()->addMessage('Login failed');
             } else {
                 $data = $authAdapter->getResultRowObject(null, 'password');
                 $this->_auth->getStorage()->write($data);
                 $this->redirect(self::REDIRECT);
             }
         }
     }
 }

 /**
  * Perform an authentication attempt, return true if the user is
  * logged or an array of message in case of errors
  *
  * @param array $values values provided for authentication
  *
  * @return bool|array
  */
 public function login(array $values)
 {
     $adapter = $this->getAdapter();
     if (method_exists($adapter, 'setAuthenticationParameters')) {
         $adapter->setAuthenticationParameters($values);
     }
     // try to authenticate
     $result = $this->_auth->authenticate($adapter);
     // switch result
     return $result->getCode() === Zend_Auth_Result::SUCCESS ? true : $result->getMessages();
 }

 /**
  * Returns the identity from storage or null if no identity is available
  *
  * @param null|Zend_Auth_Adapter_Interface $adapter
  * @return Zend_Auth_Result
  */
 public function authenticate(Zend_Auth_Adapter_Interface $adapter = null)
 {
     if ($adapter == null) {
         $adapter = $this->_adapter;
     }
     $result = parent::authenticate($adapter);
     if ($result->isValid() && method_exists($adapter, 'getResultRowObject')) {
         $user = $adapter->getResultRowObject();
         $this->getStorage()->write($user);
     } else {
         $this->getStorage()->clear();
     }
     return $result;
 }

 public function loginAction()
 {
     $this->getHelper('contextSwitch')->addActionContext('login', 'json')->initContext();
     $translator = Zend_Registry::get('container')->getService('translator');
     $request = $this->getRequest();
     if ($request->isPost()) {
         $params = $request->getParams();
         $adapter = $this->_helper->service('auth.adapter');
         $adapter->setEmail($params['email'])->setPassword($params['password']);
         $result = $this->auth->authenticate($adapter);
         if ($result->getCode() == Zend_Auth_Result::SUCCESS) {
             $user = Zend_Registry::get('container')->getService('user')->getCurrentUser();
             $metaUser = new \MetaUser($user);
             $width = array_key_exists("imageWidth", $params) ? $params['imageWidth'] : 80;
             $height = array_key_exists("imageHeight", $params) ? $params['imageHeight'] : 80;
             $specification = array_key_exists("imageSpecification", $params) ? $params['imageSpecification'] : 'fit';
             $this->view->userData = array('realName' => $user->getRealName(), 'username' => $user->getUsername(), 'avatar' => $metaUser->image($width, $height, $specification));
             $this->view->response = 'OK';
         } else {
             $this->view->response = $translator->trans('Login failed.');
         }
     }
 }

 /**
  * @return Zend_Auth_Result
  */
 public function authenticate(Zend_Auth $auth, $username, $password, $persistIfSuccessful = true)
 {
     $adapter = new Zend_Auth_Adapter_DbTable(Zend_Db_Table_Abstract::getDefaultAdapter(), 'user', 'username', 'user_credential.value');
     $adapterSelect = $adapter->getDbSelect()->join('user_credential', 'user_credential.user_id = user.id')->where('user_credential.type = "PASSWORD"');
     $adapter->setIdentity($username)->setCredential(md5($password));
     // SQLite has no internal md5() function
     $authResult = $auth->authenticate($adapter);
     if (!$authResult->isValid() || $persistIfSuccessful == false) {
         return $authResult;
     }
     $userInfo = $adapter->getResultRowObject(array('id', 'username'));
     /** NEEDS TO BE IMPLEMENTED **/
     // Store all user details except password in authentication session
     $auth->getStorage()->write($currentUser);
     return $authResult;
 }

 public function passwordRestoreFinishAction()
 {
     $translator = Zend_Registry::get('container')->getService('translator');
     $user = $this->_helper->service('user')->find($this->_getParam('user'));
     if (empty($user)) {
         $this->_helper->flashMessenger(array('error', $translator->trans('User not found.')));
         $this->_helper->redirector('index', 'index', 'default');
     }
     if (!$user->isActive()) {
         $this->_helper->flashMessenger(array('error', $translator->trans('User is not active user.')));
         $this->_helper->redirector('index', 'index', 'default');
     }
     $token = $this->_getParam('token', false);
     if (!$token) {
         $this->_helper->flashMessenger(array('error', $translator->trans('No token provided.')));
         $this->_helper->redirector('index', 'index', 'default');
     }
     if (!$this->_helper->service('user.token')->checkToken($user, $token, 'password.restore')) {
         $this->_helper->flashMessenger(array('error', $translator->trans('Invalid token.')));
         $this->_helper->redirector('index', 'index', 'default');
     }
     $form = new Application_Form_PasswordRestorePassword();
     $request = $this->getRequest();
     if ($request->isPost() && $form->isValid($request->getPost())) {
         $this->_helper->service('user')->save($form->getValues(), $user);
         $this->_helper->service('user.token')->invalidateTokens($user, 'password.restore');
         if (!$this->auth->hasIdentity()) {
             // log in
             $adapter = $this->_helper->service('auth.adapter');
             $adapter->setEmail($user->getEmail())->setPassword($form->password->getValue());
             $this->auth->authenticate($adapter);
             $this->_helper->redirector('index', 'dashboard');
         } else {
             $this->_helper->flashMessenger($translator->trans("Password changed"));
             $this->_helper->redirector('index', 'auth');
         }
     }
     $this->view->form = $form;
 }

 /**
  * Authenticates against the supplied adapter
  *
  * @param  string $username
  * @param  string $password
  * @return Zend_Auth_Result
  */
 public function authenticate($username, $password)
 {
     // Get a reference to the singleton instance of Zend_Auth
     $this->_auth = Zend_Auth::getInstance();
     // Set the storage interface
     $this->_auth->setStorage(new Glo_Auth_Storage_Session('Glo_Auth'));
     // Set the identity on the adapter
     $this->_adapter->setIdentity($username);
     // Set the credential on the adapter
     $this->_adapter->setCredential($password);
     // Attempt authentication, saving the result
     $result = $this->_auth->authenticate($this->_adapter);
     if (!$result->isValid()) {
         // Authentication failed
         throw new Glo_Auth_Exception_Failed(array_shift($result->getMessages()));
     } else {
         $data = $this->_adapter->getResultRowObject(array('user_uuid'));
         $storage = $this->_auth->getStorage();
         $storage->write($data);
     }
     return $result;
 }

 /**
  * Called before teh disptach loop gets processed.
  *
  * This callback allows for proxy or filter behavior.  By altering the
  * request and resetting its dispatched flag (via
  * {@link Zend_Controller_Request_Abstract::setDispatched() setDispatched(false)}),
  * the current action may be skipped.
  *
  * The method checks for an authenticated user. It does also compare the
  * authToken property of teh user with the auth_token field in the db - if the
  * authToken is set in the db and does not equal to the authToken in the session,
  * then it is assumed that another user has signed in with the same credentials, and
  * the user's current session will be invalidated.
  *
  * @param  Zend_Controller_Request_Abstract $request
  * @return void
  */
 public function dispatchLoopStartup(Zend_Controller_Request_Abstract $request)
 {
     // check here if the user's authentity is already set
     if (!$this->auth->hasIdentity()) {
         /**
          * @see Conjoon_Keys
          */
         require_once 'Conjoon/Keys.php';
         if (isset($_COOKIE[Conjoon_Keys::COOKIE_REMEMBERME_UNAME]) && isset($_COOKIE[Conjoon_Keys::COOKIE_REMEMBERME_TOKEN])) {
             /**
              * @see Conjoon_Auth_Adapter_Db
              */
             require_once 'Conjoon/Auth/Adapter/Db.php';
             $authAdapter = new Conjoon_Auth_Adapter_Db(array('cookie' => array('name' => $_COOKIE[Conjoon_Keys::COOKIE_REMEMBERME_UNAME], 'remember_me_token' => $_COOKIE[Conjoon_Keys::COOKIE_REMEMBERME_TOKEN])));
             // if the result is valid, the return value of the adapter will
             // be stored automatically in the supplied storage object
             // from the auth object
             $this->auth->authenticate($authAdapter);
         }
     }
     if ($this->auth->hasIdentity()) {
         // identity is set. Now check for auth token equality
         $currentUser = $this->auth->getIdentity();
         /**
          * @see Conjoon_BeanContext_Decorator
          */
         require_once 'Conjoon/BeanContext/Decorator.php';
         /**
          * @see Conjoon_Modules_Default_User_Model_User
          */
         require_once 'Conjoon/Modules/Default/User/Model/User.php';
         $decorator = new Conjoon_BeanContext_Decorator(new Conjoon_Modules_Default_User_Model_User());
         $tokenedUser = $decorator->getUserAsDto($currentUser->getId());
         // check whether the token in the DB equals to the token in the session
         if ($tokenedUser->authToken != $currentUser->getAuthToken()) {
             // the application needs to query the registry. That's okay since no secret data will
             // be transported if the registry sees that there's no login
             if ($request->action == 'get.entries' && $request->controller == 'registry' && $request->module == 'default') {
                 return;
             }
             // user wants to log out - this is needed to sign in again since the
             // active session will prevent from continue with using the app
             if ($request->action == 'logout' && $request->controller == 'reception' && $request->module == 'default') {
                 return;
             }
             // does not equal - someone has logged in currently
             // with the same user credentials.
             // redirect to appropriate controller action
             $request->setModuleName('default');
             $request->setControllerName('reception');
             $request->setActionName('auth.token.failure');
         }
         return;
     }
     // the user wants to login and requested the login controller's process
     // action. Let him pass!
     if ($request->action == 'process' && $request->controller == 'reception' && $request->module == 'default') {
         return;
     }
     // user wants to log out - okay
     if ($request->action == 'logout' && $request->controller == 'reception' && $request->module == 'default') {
         return;
     }
     // resource not available.
     if ($request->action == 'resource.not.available' && $request->controller == 'index' && $request->module == 'default') {
         return;
     }
     // the application needs to query the registry. That's okay since no secret data will
     // be transported if the registry sees that there's no login
     if ($request->action == 'get.entries' && $request->controller == 'registry' && $request->module == 'default') {
         return;
     }
     // anything other means the user is not logged in
     $request->setModuleName('default')->setControllerName('reception')->setActionName('index')->setDispatched(false);
 }

 /**
  * 認証実行
  *
  * @param  Zend_Auth_Adapter_Interface $adapter
  */
 public function authenticate($adapter)
 {
     return parent::authenticate($adapter);
 }