src/Entity/User.php line 21

  1. <?php
  2. namespace App\Entity;
  3. use ApiPlatform\Core\Annotation\ApiResource;
  4. use App\Repository\UserRepository;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Doctrine\ORM\Mapping as ORM;
  8. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  9. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  10. use Symfony\Component\Security\Core\User\UserInterface;
  11. use Symfony\Component\Serializer\Annotation\Groups;
  12. #[ApiResource(
  13.     denormalizationContext: ['groups' => ['write']],
  14. )]
  15. #[ORM\Table(name'user')]
  16. #[ORM\Entity(repositoryClassUserRepository::class)]
  17. #[UniqueEntity(fields: ['username'], message'There is already an account with this username')]
  18. class User implements UserInterfacePasswordAuthenticatedUserInterface
  19. {
  20.     #[ORM\Id]
  21.     #[ORM\GeneratedValue]
  22.     #[ORM\Column(type'integer')]
  23.     private $id;
  24.     #[Groups("write")]
  25.     #[ORM\Column(type'string'length180uniquetrue)]
  26.     private ?string $username null;
  27.     #[Groups("write")]
  28.     #[ORM\Column(type'json')]
  29.     private array $roles = [];
  30.     #[Groups("write")]
  31.     #[ORM\Column(type'string')]
  32.     private ?string $password null;
  33.     #[Groups("write")]
  34.     #[ORM\Column(type'boolean'nullabletrue)]
  35.     private ?bool $isValid null;
  36.     #[ORM\Column(type'boolean')]
  37.     #[Groups("write")]
  38.     private bool $isVerified false;
  39.     #[ORM\ManyToMany(targetEntityRole::class, mappedBy'users')]
  40.     private Collection $storedRoles;
  41.     #[ORM\OneToMany(mappedBy'user'targetEntitySessionHistory::class, orphanRemovaltrue)]
  42.     private Collection $sessionHistories;
  43.     public function __construct()
  44.     {
  45.         $this->storedRoles = new ArrayCollection();
  46.         $this->isValid true;
  47.         $this->sessionHistories = new ArrayCollection();
  48.     }
  49.     public function __toString()
  50.     {
  51.         return $this->getUserIdentifier();
  52.     }
  53.     public function getId(): ?int
  54.     {
  55.         return $this->id;
  56.     }
  57.     /**
  58.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  59.      */
  60.     public function getUsername(): string
  61.     {
  62.         return (string) $this->username;
  63.     }
  64.     public function setUsername(string $username): self
  65.     {
  66.         $this->username $username;
  67.         return $this;
  68.     }
  69.     /**
  70.      * A visual identifier that represents this user.
  71.      *
  72.      * @see UserInterface
  73.      */
  74.     public function getUserIdentifier(): string
  75.     {
  76.         return (string) $this->username;
  77.     }
  78.     /**
  79.      * @see UserInterface
  80.      */
  81.     public function getRoles(): array
  82.     {
  83.         $roles $this->roles;
  84.         // guarantee every user at least has ROLE_USER
  85.         $roles[] = 'ROLE_USER';
  86.         foreach($this->getStoredRoles() as $singleRole){
  87.             $roles[] = $singleRole->getName();
  88.         }
  89.         return array_unique($roles);
  90.     }
  91.     public function setRoles(array $roles): self
  92.     {
  93.         $this->roles $roles;
  94.         return $this;
  95.     }
  96.     /**
  97.      * @see PasswordAuthenticatedUserInterface
  98.      */
  99.     public function getPassword(): string
  100.     {
  101.         return $this->password;
  102.     }
  103.     public function setPassword(string $password): self
  104.     {
  105.         $this->password $password;
  106.         return $this;
  107.     }
  108.     /**
  109.      * Returning a salt is only needed, if you are not using a modern
  110.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  111.      *
  112.      * @see UserInterface
  113.      */
  114.     public function getSalt(): ?string
  115.     {
  116.         return null;
  117.     }
  118.     /**
  119.      * @see UserInterface
  120.      */
  121.     public function eraseCredentials()
  122.     {
  123.         // If you store any temporary, sensitive data on the user, clear it here
  124.         // $this->plainPassword = null;
  125.     }
  126.     public function getIsValid(): ?bool
  127.     {
  128.         return $this->isValid;
  129.     }
  130.     public function setIsValid(?bool $isValid): self
  131.     {
  132.         $this->isValid $isValid;
  133.         return $this;
  134.     }
  135.     public function isVerified(): bool
  136.     {
  137.         return $this->isVerified;
  138.     }
  139.     public function setIsVerified(bool $isVerified): self
  140.     {
  141.         $this->isVerified $isVerified;
  142.         return $this;
  143.     }
  144.     /**
  145.      * @return Collection<int, Role>
  146.      */
  147.     public function getStoredRoles(): Collection
  148.     {
  149.         return $this->storedRoles;
  150.     }
  151.     public function addStoredRole(Role $storedRole): self
  152.     {
  153.         if (!$this->storedRoles->contains($storedRole)) {
  154.             $this->storedRoles->add($storedRole);
  155.             $storedRole->addUser($this);
  156.         }
  157.         return $this;
  158.     }
  159.     public function removeStoredRole(Role $storedRole): self
  160.     {
  161.         if ($this->storedRoles->removeElement($storedRole)) {
  162.             $storedRole->removeUser($this);
  163.         }
  164.         return $this;
  165.     }
  166.     /**
  167.      * @return Collection<int, SessionHistory>
  168.      */
  169.     public function getSessionHistories(): Collection
  170.     {
  171.         return $this->sessionHistories;
  172.     }
  173.     public function addSessionHistory(SessionHistory $sessionHistory): self
  174.     {
  175.         if (!$this->sessionHistories->contains($sessionHistory)) {
  176.             $this->sessionHistories->add($sessionHistory);
  177.             $sessionHistory->setUser($this);
  178.         }
  179.         return $this;
  180.     }
  181.     public function removeSessionHistory(SessionHistory $sessionHistory): self
  182.     {
  183.         if ($this->sessionHistories->removeElement($sessionHistory)) {
  184.             // set the owning side to null (unless already changed)
  185.             if ($sessionHistory->getUser() === $this) {
  186.                 $sessionHistory->setUser(null);
  187.             }
  188.         }
  189.         return $this;
  190.     }
  191. }