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 Doctrine\Common\Collections\ArrayCollection;
  15. use Doctrine\Common\Collections\Collection;
  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, GroupableInterface {
  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
  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 GroupInterface[]|Collection
  95.      */
  96.     protected $groups;
  98.     /**
  99.      * @var array
  100.      */
  101.     protected $roles;
  103.     /**
  104.      * User constructor.
  105.      */
  106.     public function __construct() {
  107.         $this->enabled = false;
  108.         $this->roles = array();
  109.     }
  111.     /**
  112.      * @return string
  113.      */
  114.     public function __toString() {
  115.         return (string) $this->getUsername();
  116.     }
  118.     /**
  119.      * {@inheritdoc}
  120.      */
  121.     public function addRole($role) {
  122.         $role = strtoupper($role);
  123.         if ($role === static::ROLE_DEFAULT) {
  124.             return $this;
  125.         }
  127.         if (!in_array($role, $this->roles, true)) {
  128.             $this->roles[] = $role;
  129.         }
  131.         return $this;
  132.     }
  134.     /**
  135.      * {@inheritdoc}
  136.      */
  137.     public function serialize() {
  138.         return serialize(array(
  139.             $this->password,
  140.             $this->salt,
  141.             $this->usernameCanonical,
  142.             $this->username,
  143.             $this->enabled,
  144.             $this->id,
  145.             $this->email,
  146.             $this->emailCanonical,
  147.         ));
  148.     }
  150.     /**
  151.      * {@inheritdoc}
  152.      */
  153.     public function unserialize($serialized) {
  154.         $data = unserialize($serialized);
  156.         if (13 === count($data)) {
  157.             // Unserializing a User object from 1.3.x
  158.             unset($data[4], $data[5], $data[6], $data[9], $data[10]);
  159.             $data = array_values($data);
  160.         } elseif (11 === count($data)) {
  161.             // Unserializing a User from a dev version somewhere between 2.0-alpha3 and 2.0-beta1
  162.             unset($data[4], $data[7], $data[8]);
  163.             $data = array_values($data);
  164.         }
  166.         list(
  167.                 $this->password,
  168.                 $this->salt,
  169.                 $this->usernameCanonical,
  170.                 $this->username,
  171.                 $this->enabled,
  172.                 $this->id,
  173.                 $this->email,
  174.                 $this->emailCanonical
  175.                 ) = $data;
  176.     }
  178.     /**
  179.      * {@inheritdoc}
  180.      */
  181.     public function eraseCredentials() {
  182.         $this->plainPassword = null;
  183.     }
  185.     /**
  186.      * {@inheritdoc}
  187.      */
  188.     public function getId() {
  189.         return $this->id;
  190.     }
  192.     /**
  193.      * {@inheritdoc}
  194.      */
  195.     public function getUsername() {
  196.         return $this->username;
  197.     }
  199.     /**
  200.      * {@inheritdoc}
  201.      */
  202.     public function getUsernameCanonical() {
  203.         return $this->usernameCanonical;
  204.     }
  206.     /**
  207.      * {@inheritdoc}
  208.      */
  209.     public function getSalt() {
  210.         return $this->salt;
  211.     }
  213.     /**
  214.      * {@inheritdoc}
  215.      */
  216.     public function getEmail() {
  217.         return $this->email;
  218.     }
  220.     /**
  221.      * {@inheritdoc}
  222.      */
  223.     public function getEmailCanonical() {
  224.         return $this->emailCanonical;
  225.     }
  227.     /**
  228.      * {@inheritdoc}
  229.      */
  230.     public function getPassword() {
  231.         return $this->password;
  232.     }
  234.     /**
  235.      * {@inheritdoc}
  236.      */
  237.     public function getPlainPassword() {
  238.         return $this->plainPassword;
  239.     }
  241.     /**
  242.      * Gets the last login time.
  243.      *
  244.      * @return \DateTime|null
  245.      */
  246.     public function getLastLogin() {
  247.         return $this->lastLogin;
  248.     }
  250.     /**
  251.      * {@inheritdoc}
  252.      */
  253.     public function getConfirmationToken() {
  254.         return $this->confirmationToken;
  255.     }
  257.     /**
  258.      * {@inheritdoc}
  259.      */
  260.     public function getRoles() {
  261.         $roles = $this->roles;
  263.         foreach ($this->getGroups() as $group) {
  264.             $roles = array_merge($roles, $group->getRoles());
  265.         }
  267.         // we need to make sure to have at least one role
  268.         $roles[] = static::ROLE_DEFAULT;
  270.         return array_unique($roles);
  271.     }
  273.     /**
  274.      * {@inheritdoc}
  275.      */
  276.     public function hasRole($role) {
  277.         return in_array(strtoupper($role), $this->getRoles(), true);
  278.     }
  280.     /**
  281.      * {@inheritdoc}
  282.      */
  283.     public function isAccountNonExpired() {
  284.         return true;
  285.     }
  287.     /**
  288.      * {@inheritdoc}
  289.      */
  290.     public function isAccountNonLocked() {
  291.         return true;
  292.     }
  294.     /**
  295.      * {@inheritdoc}
  296.      */
  297.     public function isCredentialsNonExpired() {
  298.         return true;
  299.     }
  301.     public function isEnabled() {
  302.         return $this->enabled;
  303.     }
  305.     /**
  306.      * {@inheritdoc}
  307.      */
  308.     public function isSuperAdmin() {
  309.         return $this->hasRole(static::ROLE_SUPER_ADMIN);
  310.     }
  312.     /**
  313.      * {@inheritdoc}
  314.      */
  315.     public function removeRole($role) {
  316.         if (false !== $key = array_search(strtoupper($role), $this->roles, true)) {
  317.             unset($this->roles[$key]);
  318.             $this->roles = array_values($this->roles);
  319.         }
  321.         return $this;
  322.     }
  324.     /**
  325.      * {@inheritdoc}
  326.      */
  327.     public function setUsername($username) {
  328.         $this->username = $username;
  330.         return $this;
  331.     }
  333.     /**
  334.      * {@inheritdoc}
  335.      */
  336.     public function setUsernameCanonical($usernameCanonical) {
  337.         $this->usernameCanonical = $usernameCanonical;
  339.         return $this;
  340.     }
  342.     /**
  343.      * {@inheritdoc}
  344.      */
  345.     public function setSalt($salt) {
  346.         $this->salt = $salt;
  348.         return $this;
  349.     }
  351.     /**
  352.      * {@inheritdoc}
  353.      */
  354.     public function setEmail($email) {
  355.         $this->email = $email;
  357.         return $this;
  358.     }
  360.     /**
  361.      * {@inheritdoc}
  362.      */
  363.     public function setEmailCanonical($emailCanonical) {
  364.         $this->emailCanonical = $emailCanonical;
  366.         return $this;
  367.     }
  369.     /**
  370.      * {@inheritdoc}
  371.      */
  372.     public function setEnabled($boolean) {
  373.         $this->enabled = (bool) $boolean;
  375.         return $this;
  376.     }
  378.     /**
  379.      * {@inheritdoc}
  380.      */
  381.     public function setPassword($password) {
  382.         $this->password = $password;
  384.         return $this;
  385.     }
  387.     /**
  388.      * {@inheritdoc}
  389.      */
  390.     public function setSuperAdmin($boolean) {
  391.         if (true === $boolean) {
  392.             $this->addRole(static::ROLE_SUPER_ADMIN);
  393.         } else {
  394.             $this->removeRole(static::ROLE_SUPER_ADMIN);
  395.         }
  397.         return $this;
  398.     }
  400.     /**
  401.      * {@inheritdoc}
  402.      */
  403.     public function setPlainPassword($password) {
  404.         $this->plainPassword = $password;
  406.         return $this;
  407.     }
  409.     /**
  410.      * {@inheritdoc}
  411.      */
  412.     public function setLastLogin(\DateTime $time = null) {
  413.         $this->lastLogin = $time;
  415.         return $this;
  416.     }
  418.     /**
  419.      * {@inheritdoc}
  420.      */
  421.     public function setConfirmationToken($confirmationToken) {
  422.         $this->confirmationToken = $confirmationToken;
  424.         return $this;
  425.     }
  427.     /**
  428.      * {@inheritdoc}
  429.      */
  430.     public function setPasswordRequestedAt(\DateTime $date = null) {
  431.         $this->passwordRequestedAt = $date;
  433.         return $this;
  434.     }
  436.     /**
  437.      * Gets the timestamp that the user requested a password reset.
  438.      *
  439.      * @return null|\DateTime
  440.      */
  441.     public function getPasswordRequestedAt() {
  442.         return $this->passwordRequestedAt;
  443.     }
  445.     /**
  446.      * {@inheritdoc}
  447.      */
  448.     public function isPasswordRequestNonExpired($ttl) {
  449.         return $this->getPasswordRequestedAt() instanceof \DateTime &&
  450.                 $this->getPasswordRequestedAt()->getTimestamp() + $ttl > time();
  451.     }
  453.     /**
  454.      * {@inheritdoc}
  455.      */
  456.     public function setRoles(array $roles) {
  457.         $this->roles = array();
  459.         foreach ($roles as $role) {
  460.             $this->addRole($role);
  461.         }
  463.         return $this;
  464.     }
  466.     /**
  467.      * {@inheritdoc}
  468.      */
  469.     public function getGroups() {
  470.         return $this->groups ?: $this->groups = new ArrayCollection();
  471.     }
  473.     /**
  474.      * {@inheritdoc}
  475.      */
  476.     public function getGroupNames() {
  477.         $names = array();
  478.         foreach ($this->getGroups() as $group) {
  479.             $names[] = $group->getName();
  480.         }
  482.         return $names;
  483.     }
  485.     /**
  486.      * {@inheritdoc}
  487.      */
  488.     public function hasGroup($name) {
  489.         return in_array($name, $this->getGroupNames());
  490.     }
  492.     /**
  493.      * {@inheritdoc}
  494.      */
  495.     public function addGroup(GroupInterface $group) {
  496.         if (!$this->getGroups()->contains($group)) {
  497.             $this->getGroups()->add($group);
  498.         }
  500.         return $this;
  501.     }
  503.     /**
  504.      * {@inheritdoc}
  505.      */
  506.     public function removeGroup(GroupInterface $group) {
  507.         if ($this->getGroups()->contains($group)) {
  508.             $this->getGroups()->removeElement($group);
  509.         }
  511.         return $this;
  512.     }
  514. }