src/Core/Model/User.php line 32

  1. <?php
  3. declare(strict_types=1);
  4. /**
  5.  * Copyright (c) 2019 TECLA Consulting Group oü.
  6.  * All rights reserved.
  7.  *
  8.  * This unpublished material is proprietary to TECLA Consulting Group oü.
  9.  * All rights reserved. The methods and
  10.  * techniques described herein are considered trade secrets
  11.  * and/or confidential. Reproduction or distribution, in whole
  12.  * or in part, is forbidden except by express written permission
  13.  * of TECLA Consulting Group oü.
  14.  *
  15.  * @author    Matúš Sýkorjak <matus@tecla.no>
  16.  * @copyright 2019 TECLA Consulting Group oü
  17.  */
  19. namespace App\Core\Model;
  21. use App\Contact\Model\ContactInterface;
  22. use App\Core\Model\Identity\UserIdInterface;
  23. use JetBrains\PhpStorm\Pure;
  24. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  25. use Symfony\Component\Validator\Constraints as Assert;
  27. #[UniqueEntity(
  28.     fields: 'username',
  29.     message: 'username.not_unique',
  30.     ignoreNull: false,
  31. )]
  32. class User implements UserInterface
  33. {
  34.     protected UserIdInterface $id;
  36.     protected \DateTimeImmutable $createdAt;
  38.     protected ?\DateTimeImmutable $updatedAt;
  40.     #[Assert\NotBlank(
  41.         message: 'username.blank',
  42.     )]
  43.     #[Assert\Email(
  44.         message: 'username.invalid',
  45.     )]
  46.     protected ?string $username;
  48.     protected ?string $password;
  50.     protected ?string $legacyPassword;
  52.     protected ?string $confirmationToken;
  54.     protected ?string $passwordResetToken;
  56.     #[Assert\Valid]
  57.     protected ?ContactInterface $contact;
  59.     protected ?ContactInterface $invitedBy;
  61.     #[Assert\NotBlank(
  62.         message: 'password.blank',
  63.     )]
  64.     #[Assert\Length(
  65.         min: 8,
  66.         minMessage: 'password.minimum_length',
  67.     )]
  68.     protected ?string $plainPassword = null;
  70.     #[Assert\NotNull(
  71.         message: 'locale.blank',
  72.     )]
  73.     protected ?string $locale;
  75.     protected ?\DateTimeImmutable $passwordResetTokenUpdatedAt;
  77.     public function __construct(UserIdInterface $id)
  78.     {
  79.         $this->id = $id;
  80.         $this->username = null;
  81.         $this->password = null;
  82.         $this->legacyPassword = null;
  83.         $this->confirmationToken = null;
  84.         $this->passwordResetToken = null;
  85.         $this->contact = null;
  86.         $this->invitedBy = null;
  87.         $this->locale = null;
  88.         $this->passwordResetTokenUpdatedAt = null;
  89.     }
  91.     public function getId(): UserIdInterface
  92.     {
  93.         return $this->id;
  94.     }
  96.     public function getCreatedAt(): \DateTimeImmutable
  97.     {
  98.         return $this->createdAt;
  99.     }
  101.     public function setCreatedAt(\DateTimeImmutable $createdAt): void
  102.     {
  103.         $this->createdAt = $createdAt;
  104.         $this->setUpdatedAt($createdAt);
  105.     }
  107.     public function getUpdatedAt(): \DateTimeImmutable
  108.     {
  109.         return $this->updatedAt;
  110.     }
  112.     public function setUpdatedAt(\DateTimeImmutable $updatedAt): void
  113.     {
  114.         $this->updatedAt = $updatedAt;
  115.     }
  117.     #[Pure]
  118.     public function getUsername(): ?string
  119.     {
  120.         return $this->getUserIdentifier();
  121.     }
  123.     public function setUsername(?string $username): void
  124.     {
  125.         $this->username = $username;
  126.     }
  128.     public function getUserIdentifier(): string
  129.     {
  130.         return $this->username ?? '';
  131.     }
  133.     /**
  134.      * Sets the username used to authenticate the user.
  135.      */
  136.     public function setUserIdentifier(string $userIdentifier): void
  137.     {
  138.         $this->username = $userIdentifier;
  139.     }
  141.     #[Pure]
  142.     public function getEmail(): string
  143.     {
  144.         return $this->getUserIdentifier();
  145.     }
  147.     /**
  148.      * Sets the e-mail.
  149.      */
  150.     public function setEmail(string $email): void
  151.     {
  152.         $this->setUserIdentifier($email);
  153.     }
  155.     public function getPassword(): ?string
  156.     {
  157.         return $this->password;
  158.     }
  160.     /**
  161.      * Sets the hashed password used to authenticate the user.
  162.      */
  163.     public function setPassword(string $password): void
  164.     {
  165.         $this->password = $password;
  166.     }
  168.     public function getLegacyPassword(): ?string
  169.     {
  170.         return $this->legacyPassword;
  171.     }
  173.     public function setLegacyPassword(?string $legacyPassword): void
  174.     {
  175.         $this->legacyPassword = $legacyPassword;
  176.     }
  178.     /**
  179.      * Gets the plain password.
  180.      *
  181.      * @return string
  182.      */
  183.     public function getPlainPassword(): ?string
  184.     {
  185.         return $this->plainPassword;
  186.     }
  188.     /**
  189.      * Sets the plain password.
  190.      */
  191.     public function setPlainPassword(string $plainPassword): void
  192.     {
  193.         $this->plainPassword = $plainPassword;
  194.     }
  196.     /**
  197.      * Gets the confirmation token.
  198.      */
  199.     public function getConfirmationToken(): ?string
  200.     {
  201.         return $this->confirmationToken;
  202.     }
  204.     /**
  205.      * Sets the confirmation token.
  206.      *
  207.      * @param string $confirmationToken
  208.      */
  209.     public function setConfirmationToken(?string $confirmationToken): void
  210.     {
  211.         $this->confirmationToken = $confirmationToken;
  212.     }
  214.     /**
  215.      * Returns the Contact.
  216.      */
  217.     public function getContact(): ?ContactInterface
  218.     {
  219.         return $this->contact;
  220.     }
  222.     /**
  223.      * Sets the Contact.
  224.      */
  225.     public function setContact(ContactInterface $contact): void
  226.     {
  227.         $this->contact = $contact;
  228.         $contact->setUser($this);
  229.     }
  231.     /**
  232.      * Returns the Contact what invited user.
  233.      */
  234.     public function getInvitedBy(): ?ContactInterface
  235.     {
  236.         return $this->invitedBy;
  237.     }
  239.     /**
  240.      * Sets the Contact what invited user.
  241.      */
  242.     public function setInvitedBy(ContactInterface $invitedBy): void
  243.     {
  244.         $this->invitedBy = $invitedBy;
  245.     }
  247.     /**
  248.      * Returns the roles granted to the user.
  249.      *
  250.      * @return string[] The user roles
  251.      */
  252.     public function getRoles(): array
  253.     {
  254.         return ['ROLE_USER'];
  255.     }
  257.     /**
  258.      * Returns the salt that was originally used to encode the password.
  259.      *
  260.      * @return string|null The salt
  261.      */
  262.     public function getSalt(): ?string
  263.     {
  264.         return 'salt';
  265.     }
  267.     /**
  268.      * Removes sensitive data from the user.
  269.      */
  270.     public function eraseCredentials()
  271.     {
  272.         $this->plainPassword = null;
  273.     }
  275.     public function getLocale(): ?string
  276.     {
  277.         return $this->locale;
  278.     }
  280.     public function setLocale(string $locale): void
  281.     {
  282.         $this->locale = $locale;
  283.     }
  285.     public function setPasswordResetToken(?string $passwordResetToken): void
  286.     {
  287.         $this->passwordResetToken = $passwordResetToken;
  289.         if (null === $passwordResetToken) {
  290.             $this->setPasswordResetTokenUpdatedAt(null);
  291.         } else {
  292.             $this->setPasswordResetTokenUpdatedAt(new \DateTimeImmutable());
  293.         }
  294.     }
  296.     public function getPasswordResetToken(): ?string
  297.     {
  298.         return $this->passwordResetToken;
  299.     }
  301.     public function getPasswordResetTokenUpdatedAt(): ?\DateTimeImmutable
  302.     {
  303.         return $this->passwordResetTokenUpdatedAt;
  304.     }
  306.     public function setPasswordResetTokenUpdatedAt(?\DateTimeImmutable $passwordResetTokenUpdatedAt): void
  307.     {
  308.         $this->passwordResetTokenUpdatedAt = $passwordResetTokenUpdatedAt;
  309.     }
  311.     public function __serialize(): array
  312.     {
  313.         return [
  314.             'id' => $this->id,
  315.             'username' => $this->username,
  316.             'password' => $this->password,
  317.             'legacyPassword' => $this->legacyPassword,
  318.         ];
  319.     }
  321.     public function __unserialize(array $data): void
  322.     {
  323.         $this->id = $data['id'];
  324.         $this->username = $data['username'];
  325.         $this->password = $data['password'];
  326.         $this->legacyPassword = $data['legacyPassword'];
  327.     }
  328. }