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.      *
  100.      * @var string|null
  101.      */
  102.     protected $avatar;
  104.     /**
  105.      * User constructor.
  106.      */
  107.     public function __construct()
  108.     {
  109.         $this->enabled = false;
  110.         $this->roles = [];
  111.     }
  113.     /**
  114.      * @return string
  115.      */
  116.     public function __toString()
  117.     {
  118.         return (string) $this->getUsername();
  119.     }
  121.     public function __serialize(): array
  122.     {
  123.         return [
  124.             $this->password,
  125.             $this->salt,
  126.             $this->usernameCanonical,
  127.             $this->username,
  128.             $this->enabled,
  129.             $this->id,
  130.             $this->email,
  131.             $this->emailCanonical,
  132.         ];
  133.     }
  135.     public function __unserialize(array $data): void
  136.     {
  137.         if (13 === count($data)) {
  138.             // Unserializing a User object from 1.3.x
  139.             unset($data[4], $data[5], $data[6], $data[9], $data[10]);
  140.             $data = array_values($data);
  141.         } elseif (11 === count($data)) {
  142.             // Unserializing a User from a dev version somewhere between 2.0-alpha3 and 2.0-beta1
  143.             unset($data[4], $data[7], $data[8]);
  144.             $data = array_values($data);
  145.         }
  147.         list(
  148.             $this->password,
  149.             $this->salt,
  150.             $this->usernameCanonical,
  151.             $this->username,
  152.             $this->enabled,
  153.             $this->id,
  154.             $this->email,
  155.             $this->emailCanonical
  156.             ) = $data;
  157.     }
  159.     /**
  160.      * @internal
  161.      */
  162.     final public function serialize()
  163.     {
  164.         return serialize($this->__serialize());
  165.     }
  167.     /**
  168.      * @internal
  169.      */
  170.     final public function unserialize($serialized)
  171.     {
  172.         $this->__unserialize(unserialize($serialized));
  173.     }
  175.     /**
  176.      * {@inheritdoc}
  177.      */
  178.     public function addRole($role)
  179.     {
  180.         $role = strtoupper($role);
  181.         if ($role === static::ROLE_DEFAULT) {
  182.             return $this;
  183.         }
  185.         if (!in_array($role, $this->roles, true)) {
  186.             $this->roles[] = $role;
  187.         }
  189.         return $this;
  190.     }
  192.     /**
  193.      * {@inheritdoc}
  194.      */
  195.     public function eraseCredentials()
  196.     {
  197.         $this->plainPassword = null;
  198.     }
  200.     /**
  201.      * {@inheritdoc}
  202.      */
  203.     public function getId()
  204.     {
  205.         return $this->id;
  206.     }
  208.     public function getUserIdentifier(): string
  209.     {
  210.         return $this->username;
  211.     }
  213.     /**
  214.      * {@inheritdoc}
  215.      *
  216.      * @return string
  217.      */
  218.     public function getUsername()
  219.     {
  220.         return $this->username;
  221.     }
  223.     /**
  224.      * {@inheritdoc}
  225.      */
  226.     public function getUsernameCanonical()
  227.     {
  228.         return $this->usernameCanonical;
  229.     }
  231.     /**
  232.      * {@inheritdoc}
  233.      */
  234.     public function getSalt(): ?string
  235.     {
  236.         return $this->salt;
  237.     }
  239.     /**
  240.      * {@inheritdoc}
  241.      */
  242.     public function getEmail()
  243.     {
  244.         return $this->email;
  245.     }
  247.     /**
  248.      * {@inheritdoc}
  249.      */
  250.     public function getEmailCanonical()
  251.     {
  252.         return $this->emailCanonical;
  253.     }
  255.     /**
  256.      * {@inheritdoc}
  257.      */
  258.     public function getPassword(): ?string
  259.     {
  260.         return $this->password;
  261.     }
  263.     /**
  264.      * {@inheritdoc}
  265.      */
  266.     public function getPlainPassword()
  267.     {
  268.         return $this->plainPassword;
  269.     }
  271.     /**
  272.      * Gets the last login time.
  273.      *
  274.      * @return \DateTime|null
  275.      */
  276.     public function getLastLogin()
  277.     {
  278.         return $this->lastLogin;
  279.     }
  281.     /**
  282.      * {@inheritdoc}
  283.      */
  284.     public function getConfirmationToken()
  285.     {
  286.         return $this->confirmationToken;
  287.     }
  289.     /**
  290.      * {@inheritdoc}
  291.      */
  292.     public function getRoles(): array
  293.     {
  294.         $roles = $this->roles;
  296.         // we need to make sure to have at least one role
  297.         $roles[] = static::ROLE_DEFAULT;
  299.         return array_values(array_unique($roles));
  300.     }
  302.     /**
  303.      * {@inheritdoc}
  304.      */
  305.     public function hasRole($role)
  306.     {
  307.         return in_array(strtoupper($role), $this->getRoles(), true);
  308.     }
  310.     public function isEnabled()
  311.     {
  312.         return $this->enabled;
  313.     }
  315.     /**
  316.      * {@inheritdoc}
  317.      */
  318.     public function isSuperAdmin()
  319.     {
  320.         return $this->hasRole(static::ROLE_SUPER_ADMIN);
  321.     }
  323.     /**
  324.      * {@inheritdoc}
  325.      */
  326.     public function removeRole($role)
  327.     {
  328.         if (false !== $key = array_search(strtoupper($role), $this->roles, true)) {
  329.             unset($this->roles[$key]);
  330.             $this->roles = array_values($this->roles);
  331.         }
  333.         return $this;
  334.     }
  336.     /**
  337.      * {@inheritdoc}
  338.      */
  339.     public function setUsername($username)
  340.     {
  341.         $this->username = $username;
  343.         return $this;
  344.     }
  346.     /**
  347.      * {@inheritdoc}
  348.      */
  349.     public function setUsernameCanonical($usernameCanonical)
  350.     {
  351.         $this->usernameCanonical = $usernameCanonical;
  353.         return $this;
  354.     }
  356.     /**
  357.      * {@inheritdoc}
  358.      */
  359.     public function setSalt($salt)
  360.     {
  361.         $this->salt = $salt;
  363.         return $this;
  364.     }
  366.     /**
  367.      * {@inheritdoc}
  368.      */
  369.     public function setEmail($email)
  370.     {
  371.         $this->email = $email;
  373.         return $this;
  374.     }
  376.     /**
  377.      * {@inheritdoc}
  378.      */
  379.     public function setEmailCanonical($emailCanonical)
  380.     {
  381.         $this->emailCanonical = $emailCanonical;
  383.         return $this;
  384.     }
  386.     /**
  387.      * {@inheritdoc}
  388.      */
  389.     public function setEnabled($boolean)
  390.     {
  391.         $this->enabled = (bool) $boolean;
  393.         return $this;
  394.     }
  396.     /**
  397.      * {@inheritdoc}
  398.      */
  399.     public function setPassword($password)
  400.     {
  401.         $this->password = $password;
  403.         return $this;
  404.     }
  406.     /**
  407.      * {@inheritdoc}
  408.      */
  409.     public function setSuperAdmin($boolean)
  410.     {
  411.         if (true === $boolean) {
  412.             $this->addRole(static::ROLE_SUPER_ADMIN);
  413.         } else {
  414.             $this->removeRole(static::ROLE_SUPER_ADMIN);
  415.         }
  417.         return $this;
  418.     }
  420.     /**
  421.      * {@inheritdoc}
  422.      */
  423.     public function setPlainPassword($password)
  424.     {
  425.         $this->plainPassword = $password;
  427.         return $this;
  428.     }
  430.     /**
  431.      * {@inheritdoc}
  432.      */
  433.     public function setLastLogin(\DateTime $time = null)
  434.     {
  435.         $this->lastLogin = $time;
  437.         return $this;
  438.     }
  440.     /**
  441.      * {@inheritdoc}
  442.      */
  443.     public function setConfirmationToken($confirmationToken)
  444.     {
  445.         $this->confirmationToken = $confirmationToken;
  447.         return $this;
  448.     }
  450.     /**
  451.      * {@inheritdoc}
  452.      */
  453.     public function setPasswordRequestedAt(\DateTime $date = null)
  454.     {
  455.         $this->passwordRequestedAt = $date;
  457.         return $this;
  458.     }
  460.     /**
  461.      * Gets the timestamp that the user requested a password reset.
  462.      *
  463.      * @return \DateTime|null
  464.      */
  465.     public function getPasswordRequestedAt()
  466.     {
  467.         return $this->passwordRequestedAt;
  468.     }
  470.     /**
  471.      * {@inheritdoc}
  472.      */
  473.     public function isPasswordRequestNonExpired($ttl)
  474.     {
  475.         return $this->getPasswordRequestedAt() instanceof \DateTime &&
  476.                $this->getPasswordRequestedAt()->getTimestamp() + $ttl > time();
  477.     }
  479.     /**
  480.      * {@inheritdoc}
  481.      */
  482.     public function setRoles(array $roles)
  483.     {
  484.         $this->roles = [];
  486.         foreach ($roles as $role) {
  487.             $this->addRole($role);
  488.         }
  490.         return $this;
  491.     }
  493.     /**
  494.      * {@inheritdoc}
  495.      */
  496.     public function isEqualTo(BaseUserInterface $user): bool
  497.     {
  498.         if (!$user instanceof self) {
  499.             return false;
  500.         }
  502.         if ($this->password !== $user->getPassword()) {
  503.             return false;
  504.         }
  506.         if ($this->salt !== $user->getSalt()) {
  507.             return false;
  508.         }
  510.         if ($this->username !== $user->getUsername()) {
  511.             return false;
  512.         }
  514.         return true;
  515.     }
  516. }