vendor/symfony/security-core/Authentication/Token/AbstractToken.php line 73

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\Authentication\Token;
  14. use Symfony\Component\Security\Core\User\InMemoryUser;
  15. use Symfony\Component\Security\Core\User\UserInterface;
  17. /**
  18.  * Base class for Token instances.
  19.  *
  20.  * @author Fabien Potencier <fabien@symfony.com>
  21.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  22.  */
  23. abstract class AbstractToken implements TokenInterface, \Serializable
  24. {
  25.     private $user = null;
  26.     private array $roleNames = [];
  27.     private array $attributes = [];
  29.     /**
  30.      * @param string[] $roles An array of roles
  31.      *
  32.      * @throws \InvalidArgumentException
  33.      */
  34.     public function __construct(array $roles = [])
  35.     {
  36.         foreach ($roles as $role) {
  37.             $this->roleNames[] = $role;
  38.         }
  39.     }
  41.     /**
  42.      * {@inheritdoc}
  43.      */
  44.     public function getRoleNames(): array
  45.     {
  46.         return $this->roleNames;
  47.     }
  49.     public function getUserIdentifier(): string
  50.     {
  51.         return $this->user ? $this->user->getUserIdentifier() : '';
  52.     }
  54.     /**
  55.      * {@inheritdoc}
  56.      */
  57.     public function getUser(): ?UserInterface
  58.     {
  59.         return $this->user;
  60.     }
  62.     /**
  63.      * {@inheritdoc}
  64.      */
  65.     public function setUser(UserInterface $user)
  66.     {
  67.         $this->user = $user;
  68.     }
  70.     /**
  71.      * {@inheritdoc}
  72.      */
  73.     public function eraseCredentials()
  74.     {
  75.         if ($this->getUser() instanceof UserInterface) {
  76.             $this->getUser()->eraseCredentials();
  77.         }
  78.     }
  80.     /**
  81.      * Returns all the necessary state of the object for serialization purposes.
  82.      *
  83.      * There is no need to serialize any entry, they should be returned as-is.
  84.      * If you extend this method, keep in mind you MUST guarantee parent data is present in the state.
  85.      * Here is an example of how to extend this method:
  86.      * <code>
  87.      *     public function __serialize(): array
  88.      *     {
  89.      *         return [$this->childAttribute, parent::__serialize()];
  90.      *     }
  91.      * </code>
  92.      *
  93.      * @see __unserialize()
  94.      */
  95.     public function __serialize(): array
  96.     {
  97.         return [$this->user, true, null, $this->attributes, $this->roleNames];
  98.     }
  100.     /**
  101.      * Restores the object state from an array given by __serialize().
  102.      *
  103.      * There is no need to unserialize any entry in $data, they are already ready-to-use.
  104.      * If you extend this method, keep in mind you MUST pass the parent data to its respective class.
  105.      * Here is an example of how to extend this method:
  106.      * <code>
  107.      *     public function __unserialize(array $data): void
  108.      *     {
  109.      *         [$this->childAttribute, $parentData] = $data;
  110.      *         parent::__unserialize($parentData);
  111.      *     }
  112.      * </code>
  113.      *
  114.      * @see __serialize()
  115.      */
  116.     public function __unserialize(array $data): void
  117.     {
  118.         [$user, , , $this->attributes, $this->roleNames] = $data;
  119.         $this->user = \is_string($user) ? new InMemoryUser($user, '', $this->roleNames, false) : $user;
  120.     }
  122.     /**
  123.      * {@inheritdoc}
  124.      */
  125.     public function getAttributes(): array
  126.     {
  127.         return $this->attributes;
  128.     }
  130.     /**
  131.      * {@inheritdoc}
  132.      */
  133.     public function setAttributes(array $attributes)
  134.     {
  135.         $this->attributes = $attributes;
  136.     }
  138.     /**
  139.      * {@inheritdoc}
  140.      */
  141.     public function hasAttribute(string $name): bool
  142.     {
  143.         return \array_key_exists($name, $this->attributes);
  144.     }
  146.     /**
  147.      * {@inheritdoc}
  148.      */
  149.     public function getAttribute(string $name): mixed
  150.     {
  151.         if (!\array_key_exists($name, $this->attributes)) {
  152.             throw new \InvalidArgumentException(sprintf('This token has no "%s" attribute.', $name));
  153.         }
  155.         return $this->attributes[$name];
  156.     }
  158.     /**
  159.      * {@inheritdoc}
  160.      */
  161.     public function setAttribute(string $name, mixed $value)
  162.     {
  163.         $this->attributes[$name] = $value;
  164.     }
  166.     public function __toString(): string
  167.     {
  168.         $class = static::class;
  169.         $class = substr($class, strrpos($class, '\\') + 1);
  171.         $roles = [];
  172.         foreach ($this->roleNames as $role) {
  173.             $roles[] = $role;
  174.         }
  176.         return sprintf('%s(user="%s", roles="%s")', $class, $this->getUserIdentifier(), implode(', ', $roles));
  177.     }
  179.     /**
  180.      * @internal
  181.      */
  182.     final public function serialize(): string
  183.     {
  184.         throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
  185.     }
  187.     /**
  188.      * @internal
  189.      */
  190.     final public function unserialize(string $serialized)
  191.     {
  192.         $this->__unserialize(unserialize($serialized));
  193.     }
  194. }