vendor/gesdinet/jwt-refresh-token-bundle/Security/Provider/RefreshTokenProvider.php line 23

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the GesdinetJWTRefreshTokenBundle package.
  5.  *
  6.  * (c) Gesdinet <http://www.gesdinet.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 Gesdinet\JWTRefreshTokenBundle\Security\Provider;
  14. use ReflectionClass;
  15. use Symfony\Component\Security\Core\User\InMemoryUser;
  16. use Symfony\Component\Security\Core\User\UserProviderInterface;
  17. use Symfony\Component\Security\Core\User\User;
  18. use Symfony\Component\Security\Core\User\UserInterface;
  19. use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
  20. use Gesdinet\JWTRefreshTokenBundle\Model\RefreshTokenManagerInterface;
  21. use Gesdinet\JWTRefreshTokenBundle\Model\RefreshTokenInterface;
  23. trigger_deprecation('gesdinet/jwt-refresh-token-bundle', '1.0', 'The "%s" class is deprecated, configure the user provider for the `refresh_jwt` authenticator instead.', RefreshTokenProvider::class);
  25. if ((new ReflectionClass(UserProviderInterface::class))->getMethod('supportsClass')->hasReturnType()) {
  26.     /**
  27.      * Compatibility layer for Symfony 7.0 and later, where {@see UserProviderInterface::supportsClass()} has a return type.
  28.      *
  29.      * @internal
  30.      */
  31.     abstract class CompatRefreshTokenProvider implements UserProviderInterface
  32.     {
  33.         /**
  34.          * @param class-string<UserInterface> $class
  35.          */
  36.         public function supportsClass(string $class): bool
  37.         {
  38.             return $this->doSupportsClass($class);
  39.         }
  41.         /**
  42.          * @param class-string<UserInterface> $class
  43.          */
  44.         abstract protected function doSupportsClass(string $class): bool;
  45.     }
  46. } else {
  47.     /**
  48.      * Compatibility layer for Symfony 6.4 and earlier, where {@see UserProviderInterface::supportsClass()} does not have a return type.
  49.      *
  50.      * @internal
  51.      */
  52.     abstract class CompatRefreshTokenProvider implements UserProviderInterface
  53.     {
  54.         /**
  55.          * @param class-string<UserInterface> $class
  56.          *
  57.          * @return bool
  58.          */
  59.         public function supportsClass($class)
  60.         {
  61.             return $this->doSupportsClass($class);
  62.         }
  64.         /**
  65.          * @param class-string<UserInterface> $class
  66.          */
  67.         abstract protected function doSupportsClass(string $class): bool;
  68.     }
  69. }
  71. /**
  72.  * @deprecated configure the user provider for the `refresh_jwt` authenticator instead
  73.  */
  74. class RefreshTokenProvider extends CompatRefreshTokenProvider
  75. {
  76.     /**
  77.      * @var RefreshTokenManagerInterface
  78.      */
  79.     protected $refreshTokenManager;
  81.     /**
  82.      * @var UserProviderInterface
  83.      */
  84.     protected $customUserProvider;
  86.     public function __construct(RefreshTokenManagerInterface $refreshTokenManager)
  87.     {
  88.         $this->refreshTokenManager = $refreshTokenManager;
  89.     }
  91.     /**
  92.      * @return void
  93.      */
  94.     public function setCustomUserProvider(UserProviderInterface $customUserProvider)
  95.     {
  96.         $this->customUserProvider = $customUserProvider;
  97.     }
  99.     /**
  100.      * @param string $token
  101.      *
  102.      * @return string|null
  103.      */
  104.     public function getUsernameForRefreshToken($token)
  105.     {
  106.         $refreshToken = $this->refreshTokenManager->get($token);
  108.         if ($refreshToken instanceof RefreshTokenInterface) {
  109.             return $refreshToken->getUsername();
  110.         }
  112.         return null;
  113.     }
  115.     /**
  116.      * @param string $username
  117.      *
  118.      * @return UserInterface
  119.      *
  120.      * @deprecated use loadUserByIdentifier() instead
  121.      */
  122.     public function loadUserByUsername($username)
  123.     {
  124.         return $this->loadUserByIdentifier($username);
  125.     }
  127.     public function loadUserByIdentifier(string $identifier): UserInterface
  128.     {
  129.         if (null !== $this->customUserProvider) {
  130.             if (method_exists($this->customUserProvider, 'loadUserByIdentifier')) {
  131.                 return $this->customUserProvider->loadUserByIdentifier($identifier);
  132.             }
  134.             return $this->customUserProvider->loadUserByUsername($identifier);
  135.         }
  137.         if (class_exists(InMemoryUser::class)) {
  138.             return new InMemoryUser(
  139.                 $identifier,
  140.                 null,
  141.                 ['ROLE_USER']
  142.             );
  143.         }
  145.         return new User(
  146.             $identifier,
  147.             null,
  148.             ['ROLE_USER']
  149.         );
  150.     }
  152.     public function refreshUser(UserInterface $user): UserInterface
  153.     {
  154.         if (null !== $this->customUserProvider) {
  155.             return $this->customUserProvider->refreshUser($user);
  156.         }
  158.         throw new UnsupportedUserException();
  159.     }
  161.     /**
  162.      * @param class-string<UserInterface> $class
  163.      */
  164.     protected function doSupportsClass(string $class): bool
  165.     {
  166.         if (null !== $this->customUserProvider) {
  167.             return $this->customUserProvider->supportsClass($class);
  168.         }
  170.         if (class_exists(InMemoryUser::class) && InMemoryUser::class === $class) {
  171.             return true;
  172.         }
  174.         return class_exists(User::class) && User::class === $class;
  175.     }
  176. }