vendor/sylius/user/Model/User.php line 21

  1. <?php
  3. /*
  4.  * This file is part of the Sylius package.
  5.  *
  6.  * (c) Paweł Jędrzejewski
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. declare(strict_types=1);
  14. namespace Sylius\Component\User\Model;
  16. use Doctrine\Common\Collections\ArrayCollection;
  17. use Doctrine\Common\Collections\Collection;
  18. use Sylius\Component\Resource\Model\TimestampableTrait;
  19. use Sylius\Component\Resource\Model\ToggleableTrait;
  21. class User implements UserInterface, \Stringable
  22. {
  23.     use TimestampableTrait, ToggleableTrait;
  25.     /** @var mixed */
  26.     protected $id;
  28.     /** @var string|null */
  29.     protected $username;
  31.     /**
  32.      * Normalized representation of a username.
  33.      *
  34.      * @var string|null
  35.      */
  36.     protected $usernameCanonical;
  38.     /**
  39.      * Random data that is used as an additional input to a function that hashes a password.
  40.      *
  41.      * @var string
  42.      */
  43.     protected $salt;
  45.     /**
  46.      * Encrypted password. Must be persisted.
  47.      *
  48.      * @var string|null
  49.      */
  50.     protected $password;
  52.     /**
  53.      * Password before encryption. Used for model validation. Must not be persisted.
  54.      *
  55.      * @var string|null
  56.      */
  57.     protected $plainPassword;
  59.     /** @var \DateTimeInterface|null */
  60.     protected $lastLogin;
  62.     /**
  63.      * Random string sent to the user email address in order to verify it
  64.      *
  65.      * @var string|null
  66.      */
  67.     protected $emailVerificationToken;
  69.     /**
  70.      * Random string sent to the user email address in order to verify the password resetting request
  71.      *
  72.      * @var string|null
  73.      */
  74.     protected $passwordResetToken;
  76.     /** @var \DateTimeInterface|null */
  77.     protected $passwordRequestedAt;
  79.     /** @var \DateTimeInterface|null */
  80.     protected $verifiedAt;
  82.     /** @var bool */
  83.     protected $locked = false;
  85.     /** @var \DateTimeInterface|null */
  86.     protected $expiresAt;
  88.     /** @var \DateTimeInterface|null */
  89.     protected $credentialsExpireAt;
  91.     /**
  92.      * We need at least one role to be able to authenticate
  93.      *
  94.      * @var mixed[]
  95.      */
  96.     protected $roles = [UserInterface::DEFAULT_ROLE];
  98.     /**
  99.      * @var Collection|UserOAuthInterface[]
  100.      *
  101.      * @psalm-var Collection<array-key, UserOAuthInterface>
  102.      */
  103.     protected $oauthAccounts;
  105.     /** @var string|null */
  106.     protected $email;
  108.     /** @var string|null */
  109.     protected $emailCanonical;
  111.     /** @var string|null */
  112.     protected $encoderName;
  114.     public function __construct()
  115.     {
  116.         $this->salt = base_convert(bin2hex(random_bytes(20)), 16, 36);
  118.         /** @var ArrayCollection<array-key, UserOAuthInterface> $this->oauthAccounts */
  119.         $this->oauthAccounts = new ArrayCollection();
  121.         $this->createdAt = new \DateTime();
  123.         // Set here to overwrite default value from trait
  124.         $this->enabled = false;
  125.     }
  127.     /** @psalm-suppress RedundantCastGivenDocblockType */
  128.     public function __toString(): string
  129.     {
  130.         return (string) $this->getUsername();
  131.     }
  133.     public function getId()
  134.     {
  135.         return $this->id;
  136.     }
  138.     public function getEmail(): ?string
  139.     {
  140.         return $this->email;
  141.     }
  143.     public function setEmail(?string $email): void
  144.     {
  145.         $this->email = $email;
  146.     }
  148.     public function getEmailCanonical(): ?string
  149.     {
  150.         return $this->emailCanonical;
  151.     }
  153.     public function setEmailCanonical(?string $emailCanonical): void
  154.     {
  155.         $this->emailCanonical = $emailCanonical;
  156.     }
  158.     public function getUsername(): ?string
  159.     {
  160.         return $this->username;
  161.     }
  163.     public function setUsername(?string $username): void
  164.     {
  165.         $this->username = $username;
  166.     }
  168.     public function getUsernameCanonical(): ?string
  169.     {
  170.         return $this->usernameCanonical;
  171.     }
  173.     public function setUsernameCanonical(?string $usernameCanonical): void
  174.     {
  175.         $this->usernameCanonical = $usernameCanonical;
  176.     }
  178.     public function getUserIdentifier(): string
  179.     {
  180.         return (string) $this->usernameCanonical;
  181.     }
  183.     public function getSalt(): string
  184.     {
  185.         return $this->salt;
  186.     }
  188.     public function getPlainPassword(): ?string
  189.     {
  190.         return $this->plainPassword;
  191.     }
  193.     public function setPlainPassword(?string $plainPassword): void
  194.     {
  195.         $this->plainPassword = $plainPassword;
  196.     }
  198.     public function getPassword(): ?string
  199.     {
  200.         return $this->password;
  201.     }
  203.     public function setPassword(?string $encodedPassword): void
  204.     {
  205.         $this->password = $encodedPassword;
  206.     }
  208.     public function getExpiresAt(): ?\DateTimeInterface
  209.     {
  210.         return $this->expiresAt;
  211.     }
  213.     public function setExpiresAt(?\DateTimeInterface $date): void
  214.     {
  215.         $this->expiresAt = $date;
  216.     }
  218.     public function getCredentialsExpireAt(): ?\DateTimeInterface
  219.     {
  220.         return $this->credentialsExpireAt;
  221.     }
  223.     public function setCredentialsExpireAt(?\DateTimeInterface $date): void
  224.     {
  225.         $this->credentialsExpireAt = $date;
  226.     }
  228.     public function getLastLogin(): ?\DateTimeInterface
  229.     {
  230.         return $this->lastLogin;
  231.     }
  233.     public function setLastLogin(?\DateTimeInterface $time): void
  234.     {
  235.         $this->lastLogin = $time;
  236.     }
  238.     public function getEmailVerificationToken(): ?string
  239.     {
  240.         return $this->emailVerificationToken;
  241.     }
  243.     public function setEmailVerificationToken(?string $verificationToken): void
  244.     {
  245.         $this->emailVerificationToken = $verificationToken;
  246.     }
  248.     public function getPasswordResetToken(): ?string
  249.     {
  250.         return $this->passwordResetToken;
  251.     }
  253.     public function setPasswordResetToken(?string $passwordResetToken): void
  254.     {
  255.         $this->passwordResetToken = $passwordResetToken;
  256.     }
  258.     public function isCredentialsNonExpired(): bool
  259.     {
  260.         return !$this->hasExpired($this->credentialsExpireAt);
  261.     }
  263.     public function isAccountNonExpired(): bool
  264.     {
  265.         return !$this->hasExpired($this->expiresAt);
  266.     }
  268.     public function setLocked(bool $locked): void
  269.     {
  270.         $this->locked = $locked;
  271.     }
  273.     public function isAccountNonLocked(): bool
  274.     {
  275.         return !$this->locked;
  276.     }
  278.     public function hasRole(string $role): bool
  279.     {
  280.         return in_array(strtoupper($role), $this->getRoles(), true);
  281.     }
  283.     public function addRole(string $role): void
  284.     {
  285.         $role = strtoupper($role);
  286.         if (!in_array($role, $this->roles, true)) {
  287.             $this->roles[] = $role;
  288.         }
  289.     }
  291.     public function removeRole(string $role): void
  292.     {
  293.         if (false !== $key = array_search(strtoupper($role), $this->roles, true)) {
  294.             unset($this->roles[$key]);
  295.             $this->roles = array_values($this->roles);
  296.         }
  297.     }
  299.     public function getRoles(): array
  300.     {
  301.         return $this->roles;
  302.     }
  304.     public function isPasswordRequestNonExpired(\DateInterval $ttl): bool
  305.     {
  306.         if (null === $this->passwordRequestedAt) {
  307.             return false;
  308.         }
  310.         $threshold = new \DateTime();
  311.         $threshold->sub($ttl);
  313.         return $threshold <= $this->passwordRequestedAt;
  314.     }
  316.     public function getPasswordRequestedAt(): ?\DateTimeInterface
  317.     {
  318.         return $this->passwordRequestedAt;
  319.     }
  321.     public function setPasswordRequestedAt(?\DateTimeInterface $date): void
  322.     {
  323.         $this->passwordRequestedAt = $date;
  324.     }
  326.     public function isVerified(): bool
  327.     {
  328.         return null !== $this->verifiedAt;
  329.     }
  331.     public function getVerifiedAt(): ?\DateTimeInterface
  332.     {
  333.         return $this->verifiedAt;
  334.     }
  336.     public function setVerifiedAt(?\DateTimeInterface $verifiedAt): void
  337.     {
  338.         $this->verifiedAt = $verifiedAt;
  339.     }
  341.     public function eraseCredentials(): void
  342.     {
  343.         $this->plainPassword = null;
  344.     }
  346.     public function getOAuthAccounts(): Collection
  347.     {
  348.         return $this->oauthAccounts;
  349.     }
  351.     public function getOAuthAccount(string $provider): ?UserOAuthInterface
  352.     {
  353.         if ($this->oauthAccounts->isEmpty()) {
  354.             return null;
  355.         }
  357.         $filtered = $this->oauthAccounts->filter(function (UserOAuthInterface $oauth) use ($provider): bool {
  358.             return $provider === $oauth->getProvider();
  359.         });
  361.         if ($filtered->isEmpty()) {
  362.             return null;
  363.         }
  365.         return $filtered->current();
  366.     }
  368.     public function addOAuthAccount(UserOAuthInterface $oauth): void
  369.     {
  370.         if (!$this->oauthAccounts->contains($oauth)) {
  371.             $this->oauthAccounts->add($oauth);
  372.             $oauth->setUser($this);
  373.         }
  374.     }
  376.     public function getEncoderName(): ?string
  377.     {
  378.         return $this->encoderName;
  379.     }
  381.     public function setEncoderName(?string $encoderName): void
  382.     {
  383.         $this->encoderName = $encoderName;
  384.     }
  386.     /**
  387.      * The serialized data have to contain the fields used by the equals method and the username.
  388.      */
  389.     public function __serialize(): array
  390.     {
  391.         return [
  392.             $this->password,
  393.             $this->salt,
  394.             $this->usernameCanonical,
  395.             $this->username,
  396.             $this->locked,
  397.             $this->enabled,
  398.             $this->id,
  399.             $this->encoderName,
  400.         ];
  401.     }
  403.     /**
  404.      * @internal
  405.      *
  406.      * @deprecated since 1.11 and will be removed in Sylius 2.0, use \Sylius\Component\User\Model\User::__serialize() or \serialize($user) in PHP 8.1 instead
  407.      */
  408.     public function serialize(): string
  409.     {
  410.         return serialize($this->__serialize());
  411.     }
  413.     public function __unserialize(array $serialized): void
  414.     {
  415.         // add a few extra elements in the array to ensure that we have enough keys when unserializing
  416.         // older data which does not include all properties.
  417.         $serialized = array_merge($serialized, array_fill(0, 2, null));
  419.         [
  420.             $this->password,
  421.             $this->salt,
  422.             $this->usernameCanonical,
  423.             $this->username,
  424.             $this->locked,
  425.             $this->enabled,
  426.             $this->id,
  427.             $this->encoderName,
  428.         ] = $serialized;
  429.     }
  431.     /**
  432.      * @param string $serialized
  433.      *
  434.      * @internal
  435.      *
  436.      * @deprecated since 1.11 and will be removed in Sylius 2.0, use \Sylius\Component\User\Model\User::__unserialize() or \unserialize($serialized) in PHP 8.1 instead
  437.      */
  438.     public function unserialize($serialized): void
  439.     {
  440.         $this->__unserialize(unserialize($serialized));
  441.     }
  443.     protected function hasExpired(?\DateTimeInterface $date): bool
  444.     {
  445.         return null !== $date && new \DateTime() >= $date;
  446.     }
  447. }