src/Entity/User.php line 32

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.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 App\Entity;
  14. use Doctrine\ORM\Mapping as ORM;
  15. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  16. use Symfony\Component\Security\Core\User\UserInterface;
  17. use Symfony\Component\Validator\Constraints as Assert;
  19. /**
  20.  * @ORM\Entity(repositoryClass="App\Repository\UserRepository")
  21.  * @ORM\Table(name="symfony_demo_user")
  22.  *
  23.  * Defines the properties of the User entity to represent the application users.
  24.  * See https://symfony.com/doc/current/doctrine.html#creating-an-entity-class
  25.  *
  26.  * Tip: if you have an existing database, you can generate these entity class automatically.
  27.  * See https://symfony.com/doc/current/doctrine/reverse_engineering.html
  28.  *
  29.  * @author Ryan Weaver <weaverryan@gmail.com>
  30.  * @author Javier Eguiluz <javier.eguiluz@gmail.com>
  31.  */
  32. class User implements UserInterface, PasswordAuthenticatedUserInterface
  33. {
  34.     /**
  35.      * @ORM\Id
  36.      * @ORM\GeneratedValue
  37.      * @ORM\Column(type="integer")
  38.      */
  39.     private ?int $id = null;
  41.     /**
  42.      * @ORM\Column(type="string")
  43.      */
  44.     #[Assert\NotBlank]
  45.     private ?string $fullName = null;
  47.     /**
  48.      * @ORM\Column(type="string", unique=true)
  49.      */
  50.     #[
  51.         Assert\NotBlank,
  52.         Assert\Length(min: 2, max: 50)
  53.     ]
  54.     private ?string $username = null;
  56.     /**
  57.      * @ORM\Column(type="string", unique=true)
  58.      */
  59.     #[Assert\Email]
  60.     private ?string $email = null;
  62.     /**
  63.      * @ORM\Column(type="string")
  64.      */
  65.     private ?string $password = null;
  67.     /**
  68.      * @ORM\Column(type="json")
  69.      */
  70.     private array $roles = [];
  72.     public function getId(): ?int
  73.     {
  74.         return $this->id;
  75.     }
  77.     public function setFullName(string $fullName): void
  78.     {
  79.         $this->fullName = $fullName;
  80.     }
  82.     public function getFullName(): ?string
  83.     {
  84.         return $this->fullName;
  85.     }
  87.     public function getUserIdentifier(): string
  88.     {
  89.         return $this->username;
  90.     }
  92.     public function getUsername(): string
  93.     {
  94.         return $this->getUserIdentifier();
  95.     }
  97.     public function setUsername(string $username): void
  98.     {
  99.         $this->username = $username;
  100.     }
  102.     public function getEmail(): ?string
  103.     {
  104.         return $this->email;
  105.     }
  107.     public function setEmail(string $email): void
  108.     {
  109.         $this->email = $email;
  110.     }
  112.     public function getPassword(): ?string
  113.     {
  114.         return $this->password;
  115.     }
  117.     public function setPassword(string $password): void
  118.     {
  119.         $this->password = $password;
  120.     }
  122.     /**
  123.      * Returns the roles or permissions granted to the user for security.
  124.      */
  125.     public function getRoles(): array
  126.     {
  127.         $roles = $this->roles;
  129.         // guarantees that a user always has at least one role for security
  130.         if (empty($roles)) {
  131.             $roles[] = 'ROLE_USER';
  132.         }
  134.         return array_unique($roles);
  135.     }
  137.     public function setRoles(array $roles): void
  138.     {
  139.         $this->roles = $roles;
  140.     }
  142.     /**
  143.      * Returns the salt that was originally used to encode the password.
  144.      *
  145.      * {@inheritdoc}
  146.      */
  147.     public function getSalt(): ?string
  148.     {
  149.         // We're using bcrypt in security.yaml to encode the password, so
  150.         // the salt value is built-in and you don't have to generate one
  151.         // See https://en.wikipedia.org/wiki/Bcrypt
  153.         return null;
  154.     }
  156.     /**
  157.      * Removes sensitive data from the user.
  158.      *
  159.      * {@inheritdoc}
  160.      */
  161.     public function eraseCredentials(): void
  162.     {
  163.         // if you had a plainPassword property, you'd nullify it here
  164.         // $this->plainPassword = null;
  165.     }
  167.     public function __serialize(): array
  168.     {
  169.         // add $this->salt too if you don't use Bcrypt or Argon2i
  170.         return [$this->id, $this->username, $this->password];
  171.     }
  173.     public function __unserialize(array $data): void
  174.     {
  175.         // add $this->salt too if you don't use Bcrypt or Argon2i
  176.         [$this->id, $this->username, $this->password] = $data;
  177.     }
  178. }