PHP AuthenticationService::getAdapter方法代码示例

 public function indexAction()
 {
     $request = $this->getRequest();
     $user = new User();
     $this->connexionForm->bind($user);
     if ($request->isPost()) {
         $data = $request->getPost();
         $this->connexionForm->setData($data);
         if ($this->connexionForm->isValid()) {
             /** @var User $user */
             $user = $this->connexionForm->getData();
             $adapter = $this->authenticationService->getAdapter();
             $adapter->setIdentityValue($user->getUsername());
             $adapter->setCredentialValue($user->getPassword());
             $result = $this->authenticationService->authenticate();
             if ($result->isValid()) {
                 $this->flashMessenger()->addSuccessMessage($this->getTranslation('FORM_SUCCESS_LOGIN'));
                 return $this->redirect()->toRoute('admin/posts');
             }
         }
         $this->flashMessenger()->addErrorMessage($this->getTranslation('FORM_ERROR_LOGIN'));
         return $this->redirect()->toRoute('admin');
     }
     return new ViewModel(array('form' => $this->connexionForm));
 }

 /**
  * @param $data
  * @return mixed
  */
 public function login($data)
 {
     /** @var ObjectRepository $adapter */
     $adapter = $this->authService->getAdapter();
     $adapter->setIdentityValue($data->login);
     $adapter->setCredentialValue($data->password);
     $result = $adapter->authenticate();
     switch ($result->getCode()) {
         case Result::SUCCESS:
             $identity = $result->getIdentity();
             $this->authService->getStorage()->write($identity);
             if (isset($data->rememberMe)) {
                 $this->sessionManager->rememberMe(1209600);
             }
             $toJson['user'] = $identity->toArray();
             $toJson['session_id'] = $this->sessionManager->getId();
             $toJson['success'] = true;
             return json_decode(json_encode($toJson));
         case Result::FAILURE_IDENTITY_NOT_FOUND:
             return ['success' => false, 'message' => 'User not found.'];
         case Result::FAILURE_CREDENTIAL_INVALID:
             return ['success' => false, 'message' => 'Invalid password'];
         default:
             return ['success' => false, 'message' => 'Error while login'];
     }
 }

 public function authenticateAction()
 {
     if ($this->identity()) {
         return $this->redirect()->toRoute($this->routes['redirect']['name'], $this->routes['redirect']['params'], $this->routes['redirect']['options'], $this->routes['redirect']['reuseMatchedParams']);
     }
     $form = new SigninForm();
     $form->setAttribute('action', $this->url()->fromRoute($this->routes['authenticate']['name'], $this->routes['authenticate']['params'], $this->routes['authenticate']['options'], $this->routes['authenticate']['reuseMatchedParams']));
     $request = $this->getRequest();
     if ($request->isPost()) {
         $post = $request->getPost();
         $form->setData($post);
         if ($form->isValid()) {
             $authAdapter = $this->authenticationService->getAdapter();
             $authAdapter->setIdentityValue($form->get('username')->getValue());
             $authAdapter->setCredentialValue(sha1(sha1($form->get('password')->getValue())));
             $authResult = $this->authenticationService->authenticate();
             if ($authResult->isValid()) {
                 $identity = $authResult->getIdentity();
                 $authStorage = $this->authenticationService->getStorage();
                 if ($form->get('remember-me')->getValue() == 1) {
                     $authStorage->setRememberMe(1);
                 }
                 $authStorage->write($identity);
                 $this->flashMessenger()->addSuccessMessage(_('Sign in with success!'));
                 return $this->redirect()->toRoute($this->routes['redirect']['name'], $this->routes['redirect']['params'], $this->routes['redirect']['options'], $this->routes['redirect']['reuseMatchedParams']);
             } else {
                 $this->flashMessenger()->addErrorMessage(_('Username or password is invalid.'));
             }
         }
     }
     return $this->redirect()->toRoute($this->routes['signin']['name'], $this->routes['signin']['params'], $this->routes['signin']['options'], $this->routes['signin']['reuseMatchedParams']);
 }

 public function __construct(AuthenticationService $authService)
 {
     parent::__construct('login');
     $this->filter = new InputFilter();
     $email = new Element\Email('email');
     $email->setAttribute('required', true);
     $email->setAttribute('placeholder', 'Email Address');
     $this->add($email);
     $emailFilter = new Input('email');
     $emailFilter->setRequired(true);
     $this->filter->add($emailFilter);
     $password = new Element\Password('password');
     $password->setAttribute('required', true);
     $password->setAttribute('placeholder', 'Password');
     $this->add($password);
     $passwordFilter = new Input('password');
     $passwordFilter->setRequired(true);
     $passwordFilter->getValidatorChain()->attach(new AuthValidator\Authentication(array('message' => 'Invalid email address or password', 'service' => $authService, 'adapter' => $authService->getAdapter(), 'identity' => 'email', 'credential' => 'password')));
     $this->filter->add($passwordFilter);
     $buttons = new Form('buttons');
     $buttons->setOption('twb-layout', 'inline');
     $buttons->setAttribute('class', 'form-group');
     $submit = new Element\Submit('submit');
     $submit->setAttribute('class', 'btn-primary pull-right');
     $submit->setOption('glyphicon', 'log-in');
     $submit->setLabel('Log In');
     $buttons->add($submit);
     $forgot = new Element\Submit('forgot');
     $forgot->setAttribute('formnovalidate', true);
     $forgot->setAttribute('class', 'btn-warning pull-right');
     $forgot->setOption('glyphicon', 'question-sign');
     $forgot->setLabel('Forgot Password');
     $buttons->add($forgot);
     $this->add($buttons);
 }

 /**
  * Handle authentication
  *
  * @param  GetResponseEvent $event
  * @throws RuntimeException
  */
 public function onKernelRequest(GetResponseEvent $event)
 {
     $request = $event->getRequest();
     if (!$this->isRequestNeedProcessing($request) || $this->authentication->hasIdentity()) {
         return;
     }
     /* @var $adapter \SilexCMF\ZendAuthentication\Adapter\Http\HttpBasedAdapter */
     $adapter = $this->authentication->getAdapter();
     if (!$adapter || !$adapter instanceof HttpBasedAdapter) {
         throw new RuntimeException(sprintf('Unsupported adapter type %s', is_object($adapter) ? get_class($adapter) : gettype($adapter)));
     }
     $result = $this->authentication->authenticate();
     if (!$result->isValid()) {
         $event->setResponse($adapter->getResponse());
     }
 }

 public function loginAction()
 {
     if ($this->authenticationService->hasIdentity()) {
         return $this->redirect()->toRoute('home');
     }
     $this->layout('layout/layout-blank');
     $resultModel = new JsonResultModel();
     if ($this->getRequest()->isPost()) {
         $jsonData = $this->getRequest()->getPost('login');
         $data = Json::decode($jsonData, Json::TYPE_ARRAY);
         // If you used another name for the authentication service, change it here
         $adapter = $this->authenticationService->getAdapter();
         $adapter->setIdentityValue($data['username']);
         $adapter->setCredentialValue($data['password']);
         $authResult = $this->authenticationService->authenticate();
         //@todo remember me
         if ($authResult->isValid()) {
             if ($data['rememberMe']) {
                 $this->authenticationService->getStorage()->getManager()->rememberMe(36000);
             }
             return $resultModel;
         } else {
             $resultModel->addErrors('password', '登录名或密码错误');
             return $resultModel;
         }
     }
 }

 public function __invoke(Request $req, Response $res)
 {
     if ($req->isPost()) {
         $adapter = $this->authService->getAdapter();
         if ($adapter instanceof ValidatableAdapterInterface) {
             $adapter->setIdentity($req->getParam('identity'));
             $adapter->setCredential($req->getParam('credential'));
         }
         $result = $this->authService->authenticate($adapter);
         if (!$result->isValid()) {
             $this->flash->addMessage('danger', reset($result->getMessages()));
             return $res->withRedirect($req->getUri());
         }
         return $res->withRedirect($this->successUrl);
     }
     return $this->view->render($res, 'user/login.twig', []);
 }

 /**
  * Authentificate user by username/password pair
  *
  * @param string $username
  * @param string $password
  * @param boolean $remember
  * @return \Zend\Authentication\Result
  * @throws \Exception
  */
 public function authentificate($username, $password, $remember = false)
 {
     $adapter = $this->authService->getAdapter();
     if (!$adapter instanceof \Zend\Authentication\Adapter\DbTable) {
         throw new \Exception('invalid auth adapter type');
     }
     $adapter->setIdentity($username)->setCredential($password);
     $result = $this->authService->authenticate();
     if ($result->getCode() == \Zend\Authentication\Result::SUCCESS) {
         if ($remember) {
             $this->sessionContainer->getManager()->rememberMe();
         }
         $this->sessionContainer->userEntity = (array) $adapter->getResultRowObject();
     } else {
         $this->sessionContainer->userEntity = null;
     }
     return $result;
 }

 /**
  * Test if authentication is valid
  * 
  * @see \Zend\Validator\ValidatorInterface::isValid()
  * @param mixed $value
  * @param array $context
  * @return boolean
  */
 public function isValid($value, array $context = null)
 {
     $context = (array) $context;
     if (!array_key_exists($this->identity, $context) || empty($context[$this->identity])) {
         //             $this->error(self::IDENTITY_EMPTY);
         return false;
     }
     if (!array_key_exists($this->credential, $context) || empty($context[$this->credential])) {
         //             $this->error(self::CREDENTIAL_EMPTY);
         return false;
     }
     $authAdapter = $this->auth->getAdapter();
     $authAdapter->setIdentity($context[$this->identity]);
     $authAdapter->setCredential($context[$this->credential]);
     $result = $this->authResult = $this->auth->authenticate();
     if (!$result->isValid()) {
         $this->error($result->getCode());
         return false;
     }
     return true;
 }

 /**
  * authenticate
  *
  * Perform the authentication.
  *
  * @param  mixed  $data  The authentication data.
  *
  * @return boolean
  *
  * @throws \InvalidArgumentException  If $data is not an array.
  */
 public function authenticate($data)
 {
     if (!is_array($data)) {
         throw new \InvalidArgumentException(sprintf('The \'data\' argument must be of type \'array\'; \'%s\' given in \'%s\'.', gettype($data), __METHOD__));
     }
     $eventManager = $this->getEventManager();
     /** @var AuthenticationEvent $event */
     $event = $this->getEvent();
     $event->setName(AuthenticationEvent::EVENT_PREPARE)->setAdapter($this->auth->getAdapter())->setStorage($this->auth->getStorage())->setParams($data);
     // trigger authentication 'prepare' event
     $eventManager->trigger($event);
     // trigger the authentication event
     $event->setName(AuthenticationEvent::EVENT_AUTHENTICATE);
     $eventManager->trigger($event);
     if ($this->hasIdentity()) {
         $event->setName(AuthenticationEvent::EVENT_SUCCESS);
         $eventManager->trigger($event);
         return true;
     }
     $event->setName(AuthenticationEvent::EVENT_FAILURE);
     $eventManager->trigger($event);
     return false;
 }

 public static function authenticateUser($user, $pass, AuthenticationService $authService)
 {
     $authService->getAdapter()->setIdentity($user)->setCredential($pass);
     $result = $authService->authenticate();
     return $result;
 }

 /**
  * Authenticates user
  *
  * @param  string                                         $email    User email
  * @param  string                                         $password User password
  * @return Zend\Authentication\Result
  * @throws Zend\Authentication\Exception\RuntimeException
  */
 public function authenticate($email, $password)
 {
     $adapter = $this->auth->getAdapter();
     $adapter->setCredentials($email, $password);
     return $this->auth->authenticate();
 }