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

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of the FOSUserBundle package.
  4.  *
  5.  * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  10. namespace FOS\UserBundle\Model;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use Doctrine\Common\Collections\Collection;
  13. /**
  14.  * Storage agnostic user object.
  15.  *
  16.  * @author Thibault Duplessis <[email protected]>
  17.  * @author Johannes M. Schmitt <[email protected]>
  18.  */
  19. abstract class User implements UserInterfaceGroupableInterface
  20. {
  21.     /**
  22.      * @var mixed
  23.      */
  24.     protected $id;
  25.     /**
  26.      * @var string
  27.      */
  28.     protected $username;
  29.     /**
  30.      * @var string
  31.      */
  32.     protected $usernameCanonical;
  33.     /**
  34.      * @var string
  35.      */
  36.     protected $email;
  37.     /**
  38.      * @var string
  39.      */
  40.     protected $emailCanonical;
  41.     /**
  42.      * @var bool
  43.      */
  44.     protected $enabled;
  45.     /**
  46.      * The salt to use for hashing.
  47.      *
  48.      * @var string
  49.      */
  50.     protected $salt;
  51.     /**
  52.      * Encrypted password. Must be persisted.
  53.      *
  54.      * @var string
  55.      */
  56.     protected $password;
  57.     /**
  58.      * Plain password. Used for model validation. Must not be persisted.
  59.      *
  60.      * @var string
  61.      */
  62.     protected $plainPassword;
  63.     /**
  64.      * @var \DateTime|null
  65.      */
  66.     protected $lastLogin;
  67.     /**
  68.      * Random string sent to the user email address in order to verify it.
  69.      *
  70.      * @var string|null
  71.      */
  72.     protected $confirmationToken;
  73.     /**
  74.      * @var \DateTime|null
  75.      */
  76.     protected $passwordRequestedAt;
  77.     /**
  78.      * @var GroupInterface[]|Collection
  79.      */
  80.     protected $groups;
  81.     /**
  82.      * @var array
  83.      */
  84.     protected $roles;
  85.     /**
  86.      * User constructor.
  87.      */
  88.     public function __construct()
  89.     {
  90.         $this->enabled false;
  91.         $this->roles = array();
  92.     }
  93.     /**
  94.      * @return string
  95.      */
  96.     public function __toString()
  97.     {
  98.         return (string) $this->getUsername();
  99.     }
  100.     /**
  101.      * {@inheritdoc}
  102.      */
  103.     public function addRole($role)
  104.     {
  105.         $role strtoupper($role);
  106.         if ($role === static::ROLE_DEFAULT) {
  107.             return $this;
  108.         }
  109.         if (!in_array($role$this->rolestrue)) {
  110.             $this->roles[] = $role;
  111.         }
  112.         return $this;
  113.     }
  114.     /**
  115.      * {@inheritdoc}
  116.      */
  117.     public function serialize()
  118.     {
  119.         return serialize(array(
  120.             $this->password,
  121.             $this->salt,
  122.             $this->usernameCanonical,
  123.             $this->username,
  124.             $this->enabled,
  125.             $this->id,
  126.             $this->email,
  127.             $this->emailCanonical,
  128.         ));
  129.     }
  130.     /**
  131.      * {@inheritdoc}
  132.      */
  133.     public function unserialize($serialized)
  134.     {
  135.         $data unserialize($serialized);
  136.         if (13 === count($data)) {
  137.             // Unserializing a User object from 1.3.x
  138.             unset($data[4], $data[5], $data[6], $data[9], $data[10]);
  139.             $data array_values($data);
  140.         } elseif (11 === count($data)) {
  141.             // Unserializing a User from a dev version somewhere between 2.0-alpha3 and 2.0-beta1
  142.             unset($data[4], $data[7], $data[8]);
  143.             $data array_values($data);
  144.         }
  145.         list(
  146.             $this->password,
  147.             $this->salt,
  148.             $this->usernameCanonical,
  149.             $this->username,
  150.             $this->enabled,
  151.             $this->id,
  152.             $this->email,
  153.             $this->emailCanonical
  154.         ) = $data;
  155.     }
  156.     /**
  157.      * {@inheritdoc}
  158.      */
  159.     public function eraseCredentials()
  160.     {
  161.         $this->plainPassword null;
  162.     }
  163.     /**
  164.      * {@inheritdoc}
  165.      */
  166.     public function getId()
  167.     {
  168.         return $this->id;
  169.     }
  170.     /**
  171.      * {@inheritdoc}
  172.      */
  173.     public function getUsername()
  174.     {
  175.         return $this->username;
  176.     }
  177.     /**
  178.      * {@inheritdoc}
  179.      */
  180.     public function getUsernameCanonical()
  181.     {
  182.         return $this->usernameCanonical;
  183.     }
  184.     /**
  185.      * {@inheritdoc}
  186.      */
  187.     public function getSalt()
  188.     {
  189.         return $this->salt;
  190.     }
  191.     /**
  192.      * {@inheritdoc}
  193.      */
  194.     public function getEmail()
  195.     {
  196.         return $this->email;
  197.     }
  198.     /**
  199.      * {@inheritdoc}
  200.      */
  201.     public function getEmailCanonical()
  202.     {
  203.         return $this->emailCanonical;
  204.     }
  205.     /**
  206.      * {@inheritdoc}
  207.      */
  208.     public function getPassword()
  209.     {
  210.         return $this->password;
  211.     }
  212.     /**
  213.      * {@inheritdoc}
  214.      */
  215.     public function getPlainPassword()
  216.     {
  217.         return $this->plainPassword;
  218.     }
  219.     /**
  220.      * Gets the last login time.
  221.      *
  222.      * @return \DateTime|null
  223.      */
  224.     public function getLastLogin()
  225.     {
  226.         return $this->lastLogin;
  227.     }
  228.     /**
  229.      * {@inheritdoc}
  230.      */
  231.     public function getConfirmationToken()
  232.     {
  233.         return $this->confirmationToken;
  234.     }
  235.     /**
  236.      * {@inheritdoc}
  237.      */
  238.     public function getRoles()
  239.     {
  240.         $roles $this->roles;
  241.         foreach ($this->getGroups() as $group) {
  242.             $roles array_merge($roles$group->getRoles());
  243.         }
  244.         // we need to make sure to have at least one role
  245.         $roles[] = static::ROLE_DEFAULT;
  246.         return array_unique($roles);
  247.     }
  248.     /**
  249.      * {@inheritdoc}
  250.      */
  251.     public function hasRole($role)
  252.     {
  253.         return in_array(strtoupper($role), $this->getRoles(), true);
  254.     }
  255.     /**
  256.      * {@inheritdoc}
  257.      */
  258.     public function isAccountNonExpired()
  259.     {
  260.         return true;
  261.     }
  262.     /**
  263.      * {@inheritdoc}
  264.      */
  265.     public function isAccountNonLocked()
  266.     {
  267.         return true;
  268.     }
  269.     /**
  270.      * {@inheritdoc}
  271.      */
  272.     public function isCredentialsNonExpired()
  273.     {
  274.         return true;
  275.     }
  276.     public function isEnabled()
  277.     {
  278.         return $this->enabled;
  279.     }
  280.     /**
  281.      * {@inheritdoc}
  282.      */
  283.     public function isSuperAdmin()
  284.     {
  285.         return $this->hasRole(static::ROLE_SUPER_ADMIN);
  286.     }
  287.     /**
  288.      * {@inheritdoc}
  289.      */
  290.     public function removeRole($role)
  291.     {
  292.         if (false !== $key array_search(strtoupper($role), $this->rolestrue)) {
  293.             unset($this->roles[$key]);
  294.             $this->roles array_values($this->roles);
  295.         }
  296.         return $this;
  297.     }
  298.     /**
  299.      * {@inheritdoc}
  300.      */
  301.     public function setUsername($username)
  302.     {
  303.         $this->username $username;
  304.         return $this;
  305.     }
  306.     /**
  307.      * {@inheritdoc}
  308.      */
  309.     public function setUsernameCanonical($usernameCanonical)
  310.     {
  311.         $this->usernameCanonical $usernameCanonical;
  312.         return $this;
  313.     }
  314.     /**
  315.      * {@inheritdoc}
  316.      */
  317.     public function setSalt($salt)
  318.     {
  319.         $this->salt $salt;
  320.         return $this;
  321.     }
  322.     /**
  323.      * {@inheritdoc}
  324.      */
  325.     public function setEmail($email)
  326.     {
  327.         $this->email $email;
  328.         return $this;
  329.     }
  330.     /**
  331.      * {@inheritdoc}
  332.      */
  333.     public function setEmailCanonical($emailCanonical)
  334.     {
  335.         $this->emailCanonical $emailCanonical;
  336.         return $this;
  337.     }
  338.     /**
  339.      * {@inheritdoc}
  340.      */
  341.     public function setEnabled($boolean)
  342.     {
  343.         $this->enabled = (bool) $boolean;
  344.         return $this;
  345.     }
  346.     /**
  347.      * {@inheritdoc}
  348.      */
  349.     public function setPassword($password)
  350.     {
  351.         $this->password $password;
  352.         return $this;
  353.     }
  354.     /**
  355.      * {@inheritdoc}
  356.      */
  357.     public function setSuperAdmin($boolean)
  358.     {
  359.         if (true === $boolean) {
  360.             $this->addRole(static::ROLE_SUPER_ADMIN);
  361.         } else {
  362.             $this->removeRole(static::ROLE_SUPER_ADMIN);
  363.         }
  364.         return $this;
  365.     }
  366.     /**
  367.      * {@inheritdoc}
  368.      */
  369.     public function setPlainPassword($password)
  370.     {
  371.         $this->plainPassword $password;
  372.         return $this;
  373.     }
  374.     /**
  375.      * {@inheritdoc}
  376.      */
  377.     public function setLastLogin(\DateTime $time null)
  378.     {
  379.         $this->lastLogin $time;
  380.         return $this;
  381.     }
  382.     /**
  383.      * {@inheritdoc}
  384.      */
  385.     public function setConfirmationToken($confirmationToken)
  386.     {
  387.         $this->confirmationToken $confirmationToken;
  388.         return $this;
  389.     }
  390.     /**
  391.      * {@inheritdoc}
  392.      */
  393.     public function setPasswordRequestedAt(\DateTime $date null)
  394.     {
  395.         $this->passwordRequestedAt $date;
  396.         return $this;
  397.     }
  398.     /**
  399.      * Gets the timestamp that the user requested a password reset.
  400.      *
  401.      * @return null|\DateTime
  402.      */
  403.     public function getPasswordRequestedAt()
  404.     {
  405.         return $this->passwordRequestedAt;
  406.     }
  407.     /**
  408.      * {@inheritdoc}
  409.      */
  410.     public function isPasswordRequestNonExpired($ttl)
  411.     {
  412.         return $this->getPasswordRequestedAt() instanceof \DateTime &&
  413.                $this->getPasswordRequestedAt()->getTimestamp() + $ttl time();
  414.     }
  415.     /**
  416.      * {@inheritdoc}
  417.      */
  418.     public function setRoles(array $roles)
  419.     {
  420.         $this->roles = array();
  421.         foreach ($roles as $role) {
  422.             $this->addRole($role);
  423.         }
  424.         return $this;
  425.     }
  426.     /**
  427.      * {@inheritdoc}
  428.      */
  429.     public function getGroups()
  430.     {
  431.         return $this->groups ?: $this->groups = new ArrayCollection();
  432.     }
  433.     /**
  434.      * {@inheritdoc}
  435.      */
  436.     public function getGroupNames()
  437.     {
  438.         $names = array();
  439.         foreach ($this->getGroups() as $group) {
  440.             $names[] = $group->getName();
  441.         }
  442.         return $names;
  443.     }
  444.     /**
  445.      * {@inheritdoc}
  446.      */
  447.     public function hasGroup($name)
  448.     {
  449.         return in_array($name$this->getGroupNames());
  450.     }
  451.     /**
  452.      * {@inheritdoc}
  453.      */
  454.     public function addGroup(GroupInterface $group)
  455.     {
  456.         if (!$this->getGroups()->contains($group)) {
  457.             $this->getGroups()->add($group);
  458.         }
  459.         return $this;
  460.     }
  461.     /**
  462.      * {@inheritdoc}
  463.      */
  464.     public function removeGroup(GroupInterface $group)
  465.     {
  466.         if ($this->getGroups()->contains($group)) {
  467.             $this->getGroups()->removeElement($group);
  468.         }
  469.         return $this;
  470.     }
  471. }