vendor/friendsofsymfony/user-bundle/src/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|null
  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 string[]
  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. /**
  130. * @param list<mixed> $data
  131. */
  132. public function __unserialize(array $data): void
  133. {
  134. if (13 === count($data)) {
  135. // Unserializing a User object from 1.3.x
  136. unset($data[4], $data[5], $data[6], $data[9], $data[10]);
  137. $data = array_values($data);
  138. } elseif (11 === count($data)) {
  139. // Unserializing a User from a dev version somewhere between 2.0-alpha3 and 2.0-beta1
  140. unset($data[4], $data[7], $data[8]);
  141. $data = array_values($data);
  142. }
  144. [
  145. $this->password,
  146. $this->salt,
  147. $this->usernameCanonical,
  148. $this->username,
  149. $this->enabled,
  150. $this->id,
  151. $this->email,
  152. $this->emailCanonical
  153. ] = $data;
  154. }
  156. /**
  157. * @internal
  158. */
  159. final public function serialize()
  160. {
  161. return serialize($this->__serialize());
  162. }
  164. /**
  165. * @internal
  166. */
  167. final public function unserialize($serialized)
  168. {
  169. $this->__unserialize(unserialize($serialized));
  170. }
  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. * @return void
  188. */
  189. public function eraseCredentials()
  190. {
  191. $this->plainPassword = null;
  192. }
  194. public function getId()
  195. {
  196. return $this->id;
  197. }
  199. public function getUserIdentifier(): string
  200. {
  201. return $this->username;
  202. }
  204. /**
  205. * @return string
  206. */
  207. public function getUsername()
  208. {
  209. return $this->username;
  210. }
  212. public function getUsernameCanonical()
  213. {
  214. return $this->usernameCanonical;
  215. }
  217. public function getSalt(): ?string
  218. {
  219. return $this->salt;
  220. }
  222. public function getEmail()
  223. {
  224. return $this->email;
  225. }
  227. public function getEmailCanonical()
  228. {
  229. return $this->emailCanonical;
  230. }
  232. public function getPassword(): ?string
  233. {
  234. return $this->password;
  235. }
  237. public function getPlainPassword()
  238. {
  239. return $this->plainPassword;
  240. }
  242. /**
  243. * Gets the last login time.
  244. *
  245. * @return \DateTime|null
  246. */
  247. public function getLastLogin()
  248. {
  249. return $this->lastLogin;
  250. }
  252. public function getConfirmationToken()
  253. {
  254. return $this->confirmationToken;
  255. }
  257. public function getRoles(): array
  258. {
  259. $roles = $this->roles;
  261. // we need to make sure to have at least one role
  262. $roles[] = static::ROLE_DEFAULT;
  264. return array_values(array_unique($roles));
  265. }
  267. public function hasRole($role)
  268. {
  269. return in_array(strtoupper($role), $this->getRoles(), true);
  270. }
  272. public function isEnabled()
  273. {
  274. return $this->enabled;
  275. }
  277. public function isSuperAdmin()
  278. {
  279. return $this->hasRole(static::ROLE_SUPER_ADMIN);
  280. }
  282. public function removeRole($role)
  283. {
  284. if (false !== $key = array_search(strtoupper($role), $this->roles, true)) {
  285. unset($this->roles[$key]);
  286. $this->roles = array_values($this->roles);
  287. }
  289. return $this;
  290. }
  292. public function setUsername($username)
  293. {
  294. $this->username = $username;
  296. return $this;
  297. }
  299. public function setUsernameCanonical($usernameCanonical)
  300. {
  301. $this->usernameCanonical = $usernameCanonical;
  303. return $this;
  304. }
  306. public function setSalt($salt)
  307. {
  308. $this->salt = $salt;
  310. return $this;
  311. }
  313. public function setEmail($email)
  314. {
  315. $this->email = $email;
  317. return $this;
  318. }
  320. public function setEmailCanonical($emailCanonical)
  321. {
  322. $this->emailCanonical = $emailCanonical;
  324. return $this;
  325. }
  327. public function setEnabled($boolean)
  328. {
  329. $this->enabled = (bool) $boolean;
  331. return $this;
  332. }
  334. public function setPassword($password)
  335. {
  336. $this->password = $password;
  338. return $this;
  339. }
  341. public function setSuperAdmin($boolean)
  342. {
  343. if (true === $boolean) {
  344. $this->addRole(static::ROLE_SUPER_ADMIN);
  345. } else {
  346. $this->removeRole(static::ROLE_SUPER_ADMIN);
  347. }
  349. return $this;
  350. }
  352. public function setPlainPassword($password)
  353. {
  354. $this->plainPassword = $password;
  356. return $this;
  357. }
  359. public function setLastLogin(?\DateTime $time = null)
  360. {
  361. $this->lastLogin = $time;
  363. return $this;
  364. }
  366. public function setConfirmationToken($confirmationToken)
  367. {
  368. $this->confirmationToken = $confirmationToken;
  370. return $this;
  371. }
  373. public function setPasswordRequestedAt(?\DateTime $date = null)
  374. {
  375. $this->passwordRequestedAt = $date;
  377. return $this;
  378. }
  380. /**
  381. * Gets the timestamp that the user requested a password reset.
  382. *
  383. * @return \DateTime|null
  384. */
  385. public function getPasswordRequestedAt()
  386. {
  387. return $this->passwordRequestedAt;
  388. }
  390. public function isPasswordRequestNonExpired($ttl)
  391. {
  392. return $this->getPasswordRequestedAt() instanceof \DateTime
  393. && $this->getPasswordRequestedAt()->getTimestamp() + $ttl > time();
  394. }
  396. public function setRoles(array $roles)
  397. {
  398. $this->roles = [];
  400. foreach ($roles as $role) {
  401. $this->addRole($role);
  402. }
  404. return $this;
  405. }
  407. public function isEqualTo(BaseUserInterface $user): bool
  408. {
  409. if (!$user instanceof self) {
  410. return false;
  411. }
  413. if ($this->password !== $user->getPassword()) {
  414. return false;
  415. }
  417. if ($this->salt !== $user->getSalt()) {
  418. return false;
  419. }
  421. if ($this->username !== $user->getUsername()) {
  422. return false;
  423. }
  425. return true;
  426. }
  427. }