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

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 Doctrine\Common\Collections\ArrayCollection;
  15. use Doctrine\Common\Collections\Collection;
  16. use Symfony\Component\Security\Core\User\UserInterface as BaseUserInterface;
  18. /**
  19.  * Storage agnostic user object.
  20.  *
  21.  * @author Thibault Duplessis <thibault.duplessis@gmail.com>
  22.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  23.  */
  24. abstract class User implements UserInterface, GroupableInterface
  25. {
  26.     /**
  27.      * @var mixed
  28.      */
  29.     protected $id;
  31.     /**
  32.      * @var string
  33.      */
  34.     protected $username;
  36.     /**
  37.      * @var string
  38.      */
  39.     protected $usernameCanonical;
  41.     /**
  42.      * @var string
  43.      */
  44.     protected $email;
  46.     /**
  47.      * @var string
  48.      */
  49.     protected $emailCanonical;
  51.     /**
  52.      * @var bool
  53.      */
  54.     protected $enabled;
  56.     /**
  57.      * The salt to use for hashing.
  58.      *
  59.      * @var string
  60.      */
  61.     protected $salt;
  63.     /**
  64.      * Encrypted password. Must be persisted.
  65.      *
  66.      * @var string
  67.      */
  68.     protected $password;
  70.     /**
  71.      * Plain password. Used for model validation. Must not be persisted.
  72.      *
  73.      * @var string
  74.      */
  75.     protected $plainPassword;
  77.     /**
  78.      * @var \DateTime|null
  79.      */
  80.     protected $lastLogin;
  82.     /**
  83.      * Random string sent to the user email address in order to verify it.
  84.      *
  85.      * @var string|null
  86.      */
  87.     protected $confirmationToken;
  89.     /**
  90.      * @var \DateTime|null
  91.      */
  92.     protected $passwordRequestedAt;
  94.     /**
  95.      * @var GroupInterface[]|Collection
  96.      */
  97.     protected $groups;
  99.     /**
  100.      * @var array
  101.      */
  102.     protected $roles;
  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.     /**
  122.      * {@inheritdoc}
  123.      */
  124.     public function addRole($role)
  125.     {
  126.         $role = strtoupper($role);
  127.         if ($role === static::ROLE_DEFAULT) {
  128.             return $this;
  129.         }
  131.         if (!in_array($role, $this->roles, true)) {
  132.             $this->roles[] = $role;
  133.         }
  135.         return $this;
  136.     }
  138.     /**
  139.      * {@inheritdoc}
  140.      */
  141.     public function serialize()
  142.     {
  143.         return serialize([
  144.             $this->password,
  145.             $this->salt,
  146.             $this->usernameCanonical,
  147.             $this->username,
  148.             $this->enabled,
  149.             $this->id,
  150.             $this->email,
  151.             $this->emailCanonical,
  152.         ]);
  153.     }
  155.     /**
  156.      * {@inheritdoc}
  157.      */
  158.     public function unserialize($serialized)
  159.     {
  160.         $data = unserialize($serialized);
  162.         if (13 === count($data)) {
  163.             // Unserializing a User object from 1.3.x
  164.             unset($data[4], $data[5], $data[6], $data[9], $data[10]);
  165.             $data = array_values($data);
  166.         } elseif (11 === count($data)) {
  167.             // Unserializing a User from a dev version somewhere between 2.0-alpha3 and 2.0-beta1
  168.             unset($data[4], $data[7], $data[8]);
  169.             $data = array_values($data);
  170.         }
  172.         list(
  173.             $this->password,
  174.             $this->salt,
  175.             $this->usernameCanonical,
  176.             $this->username,
  177.             $this->enabled,
  178.             $this->id,
  179.             $this->email,
  180.             $this->emailCanonical
  181.         ) = $data;
  182.     }
  184.     /**
  185.      * {@inheritdoc}
  186.      */
  187.     public function eraseCredentials()
  188.     {
  189.         $this->plainPassword = null;
  190.     }
  192.     /**
  193.      * {@inheritdoc}
  194.      */
  195.     public function getId()
  196.     {
  197.         return $this->id;
  198.     }
  200.     /**
  201.      * {@inheritdoc}
  202.      */
  203.     public function getUsername()
  204.     {
  205.         return $this->username;
  206.     }
  208.     /**
  209.      * {@inheritdoc}
  210.      */
  211.     public function getUsernameCanonical()
  212.     {
  213.         return $this->usernameCanonical;
  214.     }
  216.     /**
  217.      * {@inheritdoc}
  218.      */
  219.     public function getSalt()
  220.     {
  221.         return $this->salt;
  222.     }
  224.     /**
  225.      * {@inheritdoc}
  226.      */
  227.     public function getEmail()
  228.     {
  229.         return $this->email;
  230.     }
  232.     /**
  233.      * {@inheritdoc}
  234.      */
  235.     public function getEmailCanonical()
  236.     {
  237.         return $this->emailCanonical;
  238.     }
  240.     /**
  241.      * {@inheritdoc}
  242.      */
  243.     public function getPassword()
  244.     {
  245.         return $this->password;
  246.     }
  248.     /**
  249.      * {@inheritdoc}
  250.      */
  251.     public function getPlainPassword()
  252.     {
  253.         return $this->plainPassword;
  254.     }
  256.     /**
  257.      * Gets the last login time.
  258.      *
  259.      * @return \DateTime|null
  260.      */
  261.     public function getLastLogin()
  262.     {
  263.         return $this->lastLogin;
  264.     }
  266.     /**
  267.      * {@inheritdoc}
  268.      */
  269.     public function getConfirmationToken()
  270.     {
  271.         return $this->confirmationToken;
  272.     }
  274.     /**
  275.      * {@inheritdoc}
  276.      */
  277.     public function getRoles()
  278.     {
  279.         $roles = $this->roles;
  281.         foreach ($this->getGroups() as $group) {
  282.             $roles = array_merge($roles, $group->getRoles());
  283.         }
  285.         // we need to make sure to have at least one role
  286.         $roles[] = static::ROLE_DEFAULT;
  288.         return array_values(array_unique($roles));
  289.     }
  291.     /**
  292.      * {@inheritdoc}
  293.      */
  294.     public function hasRole($role)
  295.     {
  296.         return in_array(strtoupper($role), $this->getRoles(), true);
  297.     }
  299.     /**
  300.      * {@inheritdoc}
  301.      */
  302.     public function isAccountNonExpired()
  303.     {
  304.         return true;
  305.     }
  307.     /**
  308.      * {@inheritdoc}
  309.      */
  310.     public function isAccountNonLocked()
  311.     {
  312.         return true;
  313.     }
  315.     /**
  316.      * {@inheritdoc}
  317.      */
  318.     public function isCredentialsNonExpired()
  319.     {
  320.         return true;
  321.     }
  323.     public function isEnabled()
  324.     {
  325.         return $this->enabled;
  326.     }
  328.     /**
  329.      * {@inheritdoc}
  330.      */
  331.     public function isSuperAdmin()
  332.     {
  333.         return $this->hasRole(static::ROLE_SUPER_ADMIN);
  334.     }
  336.     /**
  337.      * {@inheritdoc}
  338.      */
  339.     public function removeRole($role)
  340.     {
  341.         if (false !== $key = array_search(strtoupper($role), $this->roles, true)) {
  342.             unset($this->roles[$key]);
  343.             $this->roles = array_values($this->roles);
  344.         }
  346.         return $this;
  347.     }
  349.     /**
  350.      * {@inheritdoc}
  351.      */
  352.     public function setUsername($username)
  353.     {
  354.         $this->username = $username;
  356.         return $this;
  357.     }
  359.     /**
  360.      * {@inheritdoc}
  361.      */
  362.     public function setUsernameCanonical($usernameCanonical)
  363.     {
  364.         $this->usernameCanonical = $usernameCanonical;
  366.         return $this;
  367.     }
  369.     /**
  370.      * {@inheritdoc}
  371.      */
  372.     public function setSalt($salt)
  373.     {
  374.         $this->salt = $salt;
  376.         return $this;
  377.     }
  379.     /**
  380.      * {@inheritdoc}
  381.      */
  382.     public function setEmail($email)
  383.     {
  384.         $this->email = $email;
  386.         return $this;
  387.     }
  389.     /**
  390.      * {@inheritdoc}
  391.      */
  392.     public function setEmailCanonical($emailCanonical)
  393.     {
  394.         $this->emailCanonical = $emailCanonical;
  396.         return $this;
  397.     }
  399.     /**
  400.      * {@inheritdoc}
  401.      */
  402.     public function setEnabled($boolean)
  403.     {
  404.         $this->enabled = (bool) $boolean;
  406.         return $this;
  407.     }
  409.     /**
  410.      * {@inheritdoc}
  411.      */
  412.     public function setPassword($password)
  413.     {
  414.         $this->password = $password;
  416.         return $this;
  417.     }
  419.     /**
  420.      * {@inheritdoc}
  421.      */
  422.     public function setSuperAdmin($boolean)
  423.     {
  424.         if (true === $boolean) {
  425.             $this->addRole(static::ROLE_SUPER_ADMIN);
  426.         } else {
  427.             $this->removeRole(static::ROLE_SUPER_ADMIN);
  428.         }
  430.         return $this;
  431.     }
  433.     /**
  434.      * {@inheritdoc}
  435.      */
  436.     public function setPlainPassword($password)
  437.     {
  438.         $this->plainPassword = $password;
  440.         return $this;
  441.     }
  443.     /**
  444.      * {@inheritdoc}
  445.      */
  446.     public function setLastLogin(\DateTime $time = null)
  447.     {
  448.         $this->lastLogin = $time;
  450.         return $this;
  451.     }
  453.     /**
  454.      * {@inheritdoc}
  455.      */
  456.     public function setConfirmationToken($confirmationToken)
  457.     {
  458.         $this->confirmationToken = $confirmationToken;
  460.         return $this;
  461.     }
  463.     /**
  464.      * {@inheritdoc}
  465.      */
  466.     public function setPasswordRequestedAt(\DateTime $date = null)
  467.     {
  468.         $this->passwordRequestedAt = $date;
  470.         return $this;
  471.     }
  473.     /**
  474.      * Gets the timestamp that the user requested a password reset.
  475.      *
  476.      * @return \DateTime|null
  477.      */
  478.     public function getPasswordRequestedAt()
  479.     {
  480.         return $this->passwordRequestedAt;
  481.     }
  483.     /**
  484.      * {@inheritdoc}
  485.      */
  486.     public function isPasswordRequestNonExpired($ttl)
  487.     {
  488.         return $this->getPasswordRequestedAt() instanceof \DateTime &&
  489.                $this->getPasswordRequestedAt()->getTimestamp() + $ttl > time();
  490.     }
  492.     /**
  493.      * {@inheritdoc}
  494.      */
  495.     public function setRoles(array $roles)
  496.     {
  497.         $this->roles = [];
  499.         foreach ($roles as $role) {
  500.             $this->addRole($role);
  501.         }
  503.         return $this;
  504.     }
  506.     /**
  507.      * {@inheritdoc}
  508.      */
  509.     public function getGroups()
  510.     {
  511.         return $this->groups ?: $this->groups = new ArrayCollection();
  512.     }
  514.     /**
  515.      * {@inheritdoc}
  516.      */
  517.     public function getGroupNames()
  518.     {
  519.         $names = [];
  520.         foreach ($this->getGroups() as $group) {
  521.             $names[] = $group->getName();
  522.         }
  524.         return $names;
  525.     }
  527.     /**
  528.      * {@inheritdoc}
  529.      */
  530.     public function hasGroup($name)
  531.     {
  532.         return in_array($name, $this->getGroupNames());
  533.     }
  535.     /**
  536.      * {@inheritdoc}
  537.      */
  538.     public function addGroup(GroupInterface $group)
  539.     {
  540.         if (!$this->getGroups()->contains($group)) {
  541.             $this->getGroups()->add($group);
  542.         }
  544.         return $this;
  545.     }
  547.     /**
  548.      * {@inheritdoc}
  549.      */
  550.     public function removeGroup(GroupInterface $group)
  551.     {
  552.         if ($this->getGroups()->contains($group)) {
  553.             $this->getGroups()->removeElement($group);
  554.         }
  556.         return $this;
  557.     }
  559.     /**
  560.      * {@inheritdoc}
  561.      */
  562.     public function isEqualTo(BaseUserInterface $user)
  563.     {
  564.         if (!$user instanceof self) {
  565.             return false;
  566.         }
  568.         if ($this->password !== $user->getPassword()) {
  569.             return false;
  570.         }
  572.         if ($this->salt !== $user->getSalt()) {
  573.             return false;
  574.         }
  576.         if ($this->username !== $user->getUsername()) {
  577.             return false;
  578.         }
  580.         return true;
  581.     }
  582. }