vendor/friendsofsymfony/user-bundle/Model/User.php line 23

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the FOSUserBundle package.
  5.  *
  6.  * (c) FriendsOfSymfony <http://friendsofsymfony.github.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 FOS\UserBundle\Model;
  14. use Symfony\Component\Security\Core\User\EquatableInterface;
  15. use Symfony\Component\Security\Core\User\UserInterface as BaseUserInterface;
  17. /**
  18.  * Storage agnostic user object.
  19.  *
  20.  * @author Thibault Duplessis <thibault.duplessis@gmail.com>
  21.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  22.  */
  23. abstract class User implements UserInterface, EquatableInterface, \Serializable
  24. {
  25.     /**
  26.      * @var mixed
  27.      */
  28.     protected $id;
  30.     /**
  31.      * @var string
  32.      */
  33.     protected $username;
  35.     /**
  36.      * @var string
  37.      */
  38.     protected $usernameCanonical;
  40.     /**
  41.      * @var string
  42.      */
  43.     protected $email;
  45.     /**
  46.      * @var string
  47.      */
  48.     protected $emailCanonical;
  50.     /**
  51.      * @var bool
  52.      */
  53.     protected $enabled;
  55.     /**
  56.      * The salt to use for hashing.
  57.      *
  58.      * @var string
  59.      */
  60.     protected $salt;
  62.     /**
  63.      * Encrypted password. Must be persisted.
  64.      *
  65.      * @var string
  66.      */
  67.     protected $password;
  69.     /**
  70.      * Plain password. Used for model validation. Must not be persisted.
  71.      *
  72.      * @var string|null
  73.      */
  74.     protected $plainPassword;
  76.     /**
  77.      * @var \DateTime|null
  78.      */
  79.     protected $lastLogin;
  81.     /**
  82.      * Random string sent to the user email address in order to verify it.
  83.      *
  84.      * @var string|null
  85.      */
  86.     protected $confirmationToken;
  88.     /**
  89.      * @var \DateTime|null
  90.      */
  91.     protected $passwordRequestedAt;
  93.     /**
  94.      * @var array
  95.      */
  96.     protected $roles;
  98.     /**
  99.      * User constructor.
  100.      */
  101.     public function __construct()
  102.     {
  103.         $this->enabled = false;
  104.         $this->roles = [];
  105.     }
  107.     /**
  108.      * @return string
  109.      */
  110.     public function __toString()
  111.     {
  112.         return (string) $this->getUsername();
  113.     }
  115.     public function __serialize(): array
  116.     {
  117.         return [
  118.             $this->password,
  119.             $this->salt,
  120.             $this->usernameCanonical,
  121.             $this->username,
  122.             $this->enabled,
  123.             $this->id,
  124.             $this->email,
  125.             $this->emailCanonical,
  126.         ];
  127.     }
  129.     public function __unserialize(array $data): void
  130.     {
  131.         if (13 === count($data)) {
  132.             // Unserializing a User object from 1.3.x
  133.             unset($data[4], $data[5], $data[6], $data[9], $data[10]);
  134.             $data = array_values($data);
  135.         } elseif (11 === count($data)) {
  136.             // Unserializing a User from a dev version somewhere between 2.0-alpha3 and 2.0-beta1
  137.             unset($data[4], $data[7], $data[8]);
  138.             $data = array_values($data);
  139.         }
  141.         list(
  142.             $this->password,
  143.             $this->salt,
  144.             $this->usernameCanonical,
  145.             $this->username,
  146.             $this->enabled,
  147.             $this->id,
  148.             $this->email,
  149.             $this->emailCanonical
  150.         ) = $data;
  151.     }
  153.     /**
  154.      * @internal
  155.      */
  156.     final public function serialize()
  157.     {
  158.         return serialize($this->__serialize());
  159.     }
  161.     /**
  162.      * @internal
  163.      */
  164.     final public function unserialize($serialized)
  165.     {
  166.         $this->__unserialize(unserialize($serialized));
  167.     }
  169.     /**
  170.      * {@inheritdoc}
  171.      */
  172.     public function addRole($role)
  173.     {
  174.         $role = strtoupper($role);
  175.         if ($role === static::ROLE_DEFAULT) {
  176.             return $this;
  177.         }
  179.         if (!in_array($role, $this->roles, true)) {
  180.             $this->roles[] = $role;
  181.         }
  183.         return $this;
  184.     }
  186.     /**
  187.      * {@inheritdoc}
  188.      */
  189.     public function eraseCredentials()
  190.     {
  191.         $this->plainPassword = null;
  192.     }
  194.     /**
  195.      * {@inheritdoc}
  196.      */
  197.     public function getId()
  198.     {
  199.         return $this->id;
  200.     }
  202.     public function getUserIdentifier(): string
  203.     {
  204.         return $this->username;
  205.     }
  207.     /**
  208.      * {@inheritdoc}
  209.      *
  210.      * @return string
  211.      */
  212.     public function getUsername()
  213.     {
  214.         return $this->username;
  215.     }
  217.     /**
  218.      * {@inheritdoc}
  219.      */
  220.     public function getUsernameCanonical()
  221.     {
  222.         return $this->usernameCanonical;
  223.     }
  225.     /**
  226.      * {@inheritdoc}
  227.      */
  228.     public function getSalt(): ?string
  229.     {
  230.         return $this->salt;
  231.     }
  233.     /**
  234.      * {@inheritdoc}
  235.      */
  236.     public function getEmail()
  237.     {
  238.         return $this->email;
  239.     }
  241.     /**
  242.      * {@inheritdoc}
  243.      */
  244.     public function getEmailCanonical()
  245.     {
  246.         return $this->emailCanonical;
  247.     }
  249.     /**
  250.      * {@inheritdoc}
  251.      */
  252.     public function getPassword(): ?string
  253.     {
  254.         return $this->password;
  255.     }
  257.     /**
  258.      * {@inheritdoc}
  259.      */
  260.     public function getPlainPassword()
  261.     {
  262.         return $this->plainPassword;
  263.     }
  265.     /**
  266.      * Gets the last login time.
  267.      *
  268.      * @return \DateTime|null
  269.      */
  270.     public function getLastLogin()
  271.     {
  272.         return $this->lastLogin;
  273.     }
  275.     /**
  276.      * {@inheritdoc}
  277.      */
  278.     public function getConfirmationToken()
  279.     {
  280.         return $this->confirmationToken;
  281.     }
  283.     /**
  284.      * {@inheritdoc}
  285.      */
  286.     public function getRoles(): array
  287.     {
  288.         $roles = $this->roles;
  290.         // we need to make sure to have at least one role
  291.         $roles[] = static::ROLE_DEFAULT;
  293.         return array_values(array_unique($roles));
  294.     }
  296.     /**
  297.      * {@inheritdoc}
  298.      */
  299.     public function hasRole($role)
  300.     {
  301.         return in_array(strtoupper($role), $this->getRoles(), true);
  302.     }
  304.     public function isEnabled()
  305.     {
  306.         return $this->enabled;
  307.     }
  309.     /**
  310.      * {@inheritdoc}
  311.      */
  312.     public function isSuperAdmin()
  313.     {
  314.         return $this->hasRole(static::ROLE_SUPER_ADMIN);
  315.     }
  317.     /**
  318.      * {@inheritdoc}
  319.      */
  320.     public function removeRole($role)
  321.     {
  322.         if (false !== $key = array_search(strtoupper($role), $this->roles, true)) {
  323.             unset($this->roles[$key]);
  324.             $this->roles = array_values($this->roles);
  325.         }
  327.         return $this;
  328.     }
  330.     /**
  331.      * {@inheritdoc}
  332.      */
  333.     public function setUsername($username)
  334.     {
  335.         $this->username = $username;
  337.         return $this;
  338.     }
  340.     /**
  341.      * {@inheritdoc}
  342.      */
  343.     public function setUsernameCanonical($usernameCanonical)
  344.     {
  345.         $this->usernameCanonical = $usernameCanonical;
  347.         return $this;
  348.     }
  350.     /**
  351.      * {@inheritdoc}
  352.      */
  353.     public function setSalt($salt)
  354.     {
  355.         $this->salt = $salt;
  357.         return $this;
  358.     }
  360.     /**
  361.      * {@inheritdoc}
  362.      */
  363.     public function setEmail($email)
  364.     {
  365.         $this->email = $email;
  367.         return $this;
  368.     }
  370.     /**
  371.      * {@inheritdoc}
  372.      */
  373.     public function setEmailCanonical($emailCanonical)
  374.     {
  375.         $this->emailCanonical = $emailCanonical;
  377.         return $this;
  378.     }
  380.     /**
  381.      * {@inheritdoc}
  382.      */
  383.     public function setEnabled($boolean)
  384.     {
  385.         $this->enabled = (bool) $boolean;
  387.         return $this;
  388.     }
  390.     /**
  391.      * {@inheritdoc}
  392.      */
  393.     public function setPassword($password)
  394.     {
  395.         $this->password = $password;
  397.         return $this;
  398.     }
  400.     /**
  401.      * {@inheritdoc}
  402.      */
  403.     public function setSuperAdmin($boolean)
  404.     {
  405.         if (true === $boolean) {
  406.             $this->addRole(static::ROLE_SUPER_ADMIN);
  407.         } else {
  408.             $this->removeRole(static::ROLE_SUPER_ADMIN);
  409.         }
  411.         return $this;
  412.     }
  414.     /**
  415.      * {@inheritdoc}
  416.      */
  417.     public function setPlainPassword($password)
  418.     {
  419.         $this->plainPassword = $password;
  421.         return $this;
  422.     }
  424.     /**
  425.      * {@inheritdoc}
  426.      */
  427.     public function setLastLogin(\DateTime $time = null)
  428.     {
  429.         $this->lastLogin = $time;
  431.         return $this;
  432.     }
  434.     /**
  435.      * {@inheritdoc}
  436.      */
  437.     public function setConfirmationToken($confirmationToken)
  438.     {
  439.         $this->confirmationToken = $confirmationToken;
  441.         return $this;
  442.     }
  444.     /**
  445.      * {@inheritdoc}
  446.      */
  447.     public function setPasswordRequestedAt(\DateTime $date = null)
  448.     {
  449.         $this->passwordRequestedAt = $date;
  451.         return $this;
  452.     }
  454.     /**
  455.      * Gets the timestamp that the user requested a password reset.
  456.      *
  457.      * @return \DateTime|null
  458.      */
  459.     public function getPasswordRequestedAt()
  460.     {
  461.         return $this->passwordRequestedAt;
  462.     }
  464.     /**
  465.      * {@inheritdoc}
  466.      */
  467.     public function isPasswordRequestNonExpired($ttl)
  468.     {
  469.         return $this->getPasswordRequestedAt() instanceof \DateTime &&
  470.                $this->getPasswordRequestedAt()->getTimestamp() + $ttl > time();
  471.     }
  473.     /**
  474.      * {@inheritdoc}
  475.      */
  476.     public function setRoles(array $roles)
  477.     {
  478.         $this->roles = [];
  480.         foreach ($roles as $role) {
  481.             $this->addRole($role);
  482.         }
  484.         return $this;
  485.     }
  487.     /**
  488.      * {@inheritdoc}
  489.      */
  490.     public function isEqualTo(BaseUserInterface $user): bool
  491.     {
  492.         if (!$user instanceof self) {
  493.             return false;
  494.         }
  496.         if ($this->password !== $user->getPassword()) {
  497.             return false;
  498.         }
  500.         if ($this->salt !== $user->getSalt()) {
  501.             return false;
  502.         }
  504.         if ($this->username !== $user->getUsername()) {
  505.             return false;
  506.         }
  508.         return true;
  509.     }
  510. }