PHP UserProviderInterface::loadUserByUsername方法代码示例

 /**
  * Loads the user for the given username.
  *
  * This method must throw UsernameNotFoundException if the user is not
  * found.
  *
  * @param string $username The username
  *
  * @return UserInterface
  *
  * @see UsernameNotFoundException
  *
  * @throws UsernameNotFoundException if the user is not found
  */
 public function loadUserByUsername($username)
 {
     if ($this->provider) {
         return $this->provider->loadUserByUsername($username);
     }
     throw new UsernameNotFoundException();
 }

 /**
  * Load user from payload, using username by default.
  * Override this to load by another property.
  *
  * @param array $payload
  *
  * @return \Symfony\Component\Security\Core\User\UserInterface
  */
 protected function getUserFromPayload(array $payload)
 {
     if (!isset($payload[$this->userIdentityField])) {
         throw new AuthenticationException('Invalid JWT Token');
     }
     return $this->userProvider->loadUserByUsername($payload[$this->userIdentityField]);
 }

 /**
  * Authenticate a token according to the user provider.
  *
  * @param \Symfony\Component\Security\Core\Authentication\Token\TokenInterface $token
  *
  * @return \Symfony\Component\Security\Core\User\UserProviderInterface
  *
  * @throws SecurityException Occures on invalid connection
  */
 public function authenticate(TokenInterface $token)
 {
     if (!$this->supports($token)) {
         return;
     }
     $username = $token->getUsername();
     if (empty($username)) {
         $username = 'NONE_PROVIDED';
     }
     $user = $this->_userProvider->loadUserByUsername($username);
     if (false === is_array($user)) {
         $user = array($user);
     }
     $authenticatedToken = false;
     while (false === $authenticatedToken) {
         if (null !== ($provider = array_pop($user))) {
             $authenticatedToken = $this->authenticateUser($token, $provider);
         } else {
             break;
         }
     }
     if (false === $authenticatedToken) {
         throw new SecurityException('Invalid authentication informations', SecurityException::INVALID_CREDENTIALS);
     }
     return $authenticatedToken;
 }

 /**
  * Get user from cached, otherwise get it from the source User Provider.
  * @param string $username
  * @return type
  */
 public function loadUserByUsername($username)
 {
     if (!isset($this->cachedUsers[$username])) {
         $this->cachedUsers[$username] = $this->userProvider->loadUserByUsername($username);
     }
     return $this->cachedUsers[$username];
 }

 /**
  * @param TokenInterface $token
  * @return BlockCypherUserToken
  */
 public function authenticate(TokenInterface $token)
 {
     //        if (!$userProvider instanceof ApiKeyUserProvider) {
     //            throw new \InvalidArgumentException(
     //                sprintf(
     //                    'The user provider must be an instance of ApiKeyUserProvider (%s was given).',
     //                    get_class($userProvider)
     //                )
     //            );
     //        }
     //$blockCypherToken = null;
     $blockCypherToken = $token->getCredentials();
     $username = $blockCypherToken;
     // DEBUG
     //var_dump($blockCypherToken);
     //die();
     /** @var User $user */
     $user = $this->userProvider->loadUserByUsername($username);
     // DEBUG
     //var_dump($user);
     //die();
     if ($user) {
         $blockCypherToken = $user->getBlockCypherToken();
     }
     if ($user && $this->validateBlockCypherToken($blockCypherToken)) {
         $authenticatedToken = new BlockCypherUserToken($user, $blockCypherToken, 'blockcypher', $user->getRoles());
         //$authenticatedToken->setUser($user);
         return $authenticatedToken;
     }
     throw new AuthenticationException('BlockCypher token empty or invalid.');
 }

 /**
  * @param string $username
  * @param UsernamePasswordToken $token
  * @return null|UserInterface
  */
 public function retrieveUser($username, UsernamePasswordToken $token)
 {
     try {
         return $this->userProvider->loadUserByUsername($username);
     } catch (NoResultException $e) {
         return null;
     }
 }

 /**
  * {@inheritDoc}
  */
 public function authenticate(TokenInterface $token)
 {
     $username = $this->oauthProvider->getUsername($token->getCredentials());
     $user = $this->userProvider->loadUserByUsername($username);
     $token = new OAuthToken($token->getCredentials(), $user->getRoles());
     $token->setUser($user);
     $token->setAuthenticated(true);
     return $token;
 }

 /**
  * {@inheritdoc}
  */
 public function authenticate(TokenInterface $token)
 {
     $user = $this->userProvider->loadUserByUsername($token->getUsername());
     if ($user && $this->validateDigest($token->digest, $token->nonce, $token->created, $user->getPassword())) {
         $authenticatedToken = new WsseToken($user->getRoles());
         $authenticatedToken->setUser($user);
         return $authenticatedToken;
     }
     throw new AuthenticationException('The WSSE authentication failed.');
 }

 public function authenticate(TokenInterface $token)
 {
     $user = $this->userProvider->loadUserByUsername($token->getUsername());
     if ($user && ($token->isAuthenticated() || $this->crowd->isauthenticationvalid($token->getUsername(), $token->getCredentials()))) {
         $authenticatedToken = new CrowdToken($user->getRoles());
         $authenticatedToken->setUser($user);
         return $authenticatedToken;
     }
     throw new AuthenticationException('The Crowd authentication failed.');
 }

 public function __invoke($username, $password)
 {
     try {
         $user = $this->userProvider->loadUserByUsername($username);
     } catch (UsernameNotFoundException $e) {
         // in order to prevent timing attacks, we call the same method on a dummy user
         // this way it is not revealed that the user by that username does not exist in DB
         $this->passwordEncoder->isPasswordValid(AccountUser::dummy(), 'dummy');
         return false;
     }
     return $this->passwordEncoder->isPasswordValid($user, $password) ? $username : false;
 }

 private function getTokenForUsername($username, $attributes = array())
 {
     /** @var User $user */
     $user = $this->userProvider->loadUserByUsername($username);
     if (!$user) {
         throw new AuthenticationException("No user by the name of '{$username}'");
     }
     $token = new SspToken($user->getRoles());
     $token->setUser($user);
     $token->setAttributes($attributes);
     return $token;
 }

 /**
  * @param TokenInterface $token
  *
  * @return WsseUserToken
  */
 public function authenticate(TokenInterface $token)
 {
     /** @var WsseUserToken $token */
     $user = $this->userProvider->loadUserByUsername($token->getUsername());
     $secret = $user->getApiKey() . '{' . $user->getSalt() . '}';
     if ($this->validateDigest($token->digest, $token->nonce, $token->created, $secret)) {
         $authenticatedToken = new WsseUserToken($user->getRoles());
         $authenticatedToken->setUser($user);
         return $authenticatedToken;
     }
     throw new AuthenticationException('The WSSE authentication failed.');
 }

 /**
  * Attempts to authenticate a TokenInterface object.
  *
  * @param TokenInterface $token The TokenInterface instance to authenticate
  *
  * @return TokenInterface An authenticated TokenInterface instance, never null
  *
  * @throws AuthenticationException if the authentication fails
  */
 public function authenticate(TokenInterface $token)
 {
     if (!$this->supports($token)) {
         return;
     }
     if (!($user = $token->getUser())) {
         throw new AuthenticationException('JWT auth failed');
     }
     $user = $this->userProvider->loadUserByUsername($user);
     $this->userChecker->checkPostAuth($user);
     $token = new JWTToken($user, $token->getCredentials(), $this->providerKey, $this->getRoles($user, $token));
     return $token;
 }

 /**
  * Attempts to authenticate a TokenInterface object.
  *
  * @param TokenInterface $token The TokenInterface instance to authenticate
  *
  * @return TokenInterface An authenticated TokenInterface instance, never null
  *
  * @throws AuthenticationException if the authentication fails
  */
 public function authenticate(TokenInterface $token)
 {
     $userName = $token->getUsername();
     $user = $this->userProvider->loadUserByUsername($userName);
     if (null != $user) {
         $lastContext = $token->getTokenContext();
         $token = new JWTToken($user->getRoles());
         $token->setTokenContext($lastContext);
         $token->setUser($user);
         return $token;
     }
     throw new AuthenticationException('JWT auth failed');
 }

 /**
  * Authenticate API user by API key
  *
  * @param  TokenInterface          $token
  * @return Token
  * @throws AuthenticationException
  */
 public function authenticate(TokenInterface $token)
 {
     $user = $this->userProvider->loadUserByUsername($token->getUsername());
     if ($user && $user->getApi()) {
         if ($this->validateDigest($token->getAttribute('digest'), $token->getAttribute('nonce'), $token->getAttribute('created'), $user->getApi()->getApiKey(), $user->getSalt())) {
             $authToken = new Token($user->getRoles());
             $authToken->setUser($user);
             $authToken->setAuthenticated(true);
             return $authToken;
         }
     }
     throw new AuthenticationException('WSSE authentication failed.');
 }