vendor/symfony/security-core/User/InMemoryUserProvider.php line 25

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Security\Core\User;
  14. use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
  15. use Symfony\Component\Security\Core\Exception\UserNotFoundException;
  17. /**
  18.  * InMemoryUserProvider is a simple non persistent user provider.
  19.  *
  20.  * Useful for testing, demonstration, prototyping, and for simple needs
  21.  * (a backend with a unique admin for instance)
  22.  *
  23.  * @author Fabien Potencier <fabien@symfony.com>
  24.  */
  25. class InMemoryUserProvider implements UserProviderInterface
  26. {
  27.     /**
  28.      * @var array<string, UserInterface>
  29.      */
  30.     private $users;
  32.     /**
  33.      * The user array is a hash where the keys are usernames and the values are
  34.      * an array of attributes: 'password', 'enabled', and 'roles'.
  35.      *
  36.      * @param array<string, array{password?: string, enabled?: bool, roles?: list<string>}> $users An array of users
  37.      */
  38.     public function __construct(array $users = [])
  39.     {
  40.         foreach ($users as $username => $attributes) {
  41.             $password = $attributes['password'] ?? null;
  42.             $enabled = $attributes['enabled'] ?? true;
  43.             $roles = $attributes['roles'] ?? [];
  44.             $user = new InMemoryUser($username, $password, $roles, $enabled);
  46.             $this->createUser($user);
  47.         }
  48.     }
  50.     /**
  51.      * Adds a new User to the provider.
  52.      *
  53.      * @throws \LogicException
  54.      */
  55.     public function createUser(UserInterface $user)
  56.     {
  57.         // @deprecated since Symfony 5.3, change to $user->getUserIdentifier() in 6.0
  58.         $userIdentifier = strtolower(method_exists($user, 'getUserIdentifier') ? $user->getUserIdentifier() : $user->getUsername());
  59.         if (isset($this->users[$userIdentifier])) {
  60.             throw new \LogicException('Another user with the same username already exists.');
  61.         }
  63.         $this->users[$userIdentifier] = $user;
  64.     }
  66.     /**
  67.      * {@inheritdoc}
  68.      */
  69.     public function loadUserByUsername(string $username)
  70.     {
  71.         trigger_deprecation('symfony/security-core', '5.3', 'Method "%s()" is deprecated, use loadUserByIdentifier() instead.', __METHOD__);
  73.         return $this->loadUserByIdentifier($username);
  74.     }
  76.     public function loadUserByIdentifier(string $identifier): UserInterface
  77.     {
  78.         $user = $this->getUser($identifier);
  80.         // @deprecated since Symfony 5.3, change to $user->getUserIdentifier() in 6.0
  81.         return new InMemoryUser(method_exists($user, 'getUserIdentifier') ? $user->getUserIdentifier() : $user->getUsername(), $user->getPassword(), $user->getRoles(), $user->isEnabled());
  82.     }
  84.     /**
  85.      * {@inheritdoc}
  86.      */
  87.     public function refreshUser(UserInterface $user)
  88.     {
  89.         if (!$user instanceof InMemoryUser && !$user instanceof User) {
  90.             throw new UnsupportedUserException(sprintf('Instances of "%s" are not supported.', get_debug_type($user)));
  91.         }
  93.         // @deprecated since Symfony 5.3, change to $user->getUserIdentifier() in 6.0
  94.         $storedUser = $this->getUser(method_exists($user, 'getUserIdentifier') ? $user->getUserIdentifier() : $user->getUsername());
  95.         $userIdentifier = method_exists($storedUser, 'getUserIdentifier') ? $storedUser->getUserIdentifier() : $storedUser->getUsername();
  97.         // @deprecated since Symfony 5.3
  98.         if (User::class === \get_class($user)) {
  99.             if (User::class !== \get_class($storedUser)) {
  100.                 $accountNonExpired = true;
  101.                 $credentialsNonExpired = $storedUser->getPassword() === $user->getPassword();
  102.                 $accountNonLocked = true;
  103.             } else {
  104.                 $accountNonExpired = $storedUser->isAccountNonExpired();
  105.                 $credentialsNonExpired = $storedUser->isCredentialsNonExpired() && $storedUser->getPassword() === $user->getPassword();
  106.                 $accountNonLocked = $storedUser->isAccountNonLocked();
  107.             }
  109.             return new User($userIdentifier, $storedUser->getPassword(), $storedUser->getRoles(), $storedUser->isEnabled(), $accountNonExpired, $credentialsNonExpired, $accountNonLocked);
  110.         }
  112.         return new InMemoryUser($userIdentifier, $storedUser->getPassword(), $storedUser->getRoles(), $storedUser->isEnabled());
  113.     }
  115.     /**
  116.      * {@inheritdoc}
  117.      */
  118.     public function supportsClass(string $class)
  119.     {
  120.         // @deprecated since Symfony 5.3
  121.         if (User::class === $class) {
  122.             return true;
  123.         }
  125.         return InMemoryUser::class == $class;
  126.     }
  128.     /**
  129.      * Returns the user by given username.
  130.      *
  131.      * @throws UserNotFoundException if user whose given username does not exist
  132.      */
  133.     private function getUser(string $username)/* : InMemoryUser */
  134.     {
  135.         if (!isset($this->users[strtolower($username)])) {
  136.             $ex = new UserNotFoundException(sprintf('Username "%s" does not exist.', $username));
  137.             $ex->setUserIdentifier($username);
  139.             throw $ex;
  140.         }
  142.         return $this->users[strtolower($username)];
  143.     }
  144. }