src/Entity/User.php line 25

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Core\Annotation\ApiFilter;
  6. use ApiPlatform\Core\Annotation\ApiResource;
  7. use App\Repository\UserRepository;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  14. use Symfony\Component\Serializer\Annotation\Groups;
  15. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\SearchFilter;
  17. #[ApiResource(
  18.     normalizationContext: ['groups' => ['read']],
  19.     denormalizationContext: ['groups' => ['write']],
  20. )]
  21. #[ApiFilter(SearchFilter::class, properties: ['username' => 'exact','googleId' => 'exact'])]
  22. #[ORM\Table(name: 'user')]
  23. #[ORM\Entity(repositoryClass: UserRepository::class)]
  24. #[UniqueEntity(fields: ['username'], message: 'There is already an account with this username')]
  25. class User implements UserInterface, PasswordAuthenticatedUserInterface
  26. {
  27.     #[ORM\Id]
  28.     #[ORM\GeneratedValue]
  29.     #[ORM\Column(type: 'integer')]
  30.     private $id;
  32.     #[Groups(["read","write"])]
  33.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  34.     private ?string $username = null;
  36.     #[Groups(["read","write"])]
  37.     #[ORM\Column(type: 'json')]
  38.     private array $roles = [];
  40.     #[Groups(["read","write"])]
  41.     #[ORM\Column(type: 'string')]
  42.     private ?string $password = "";
  44.     
  45.     #[ORM\Column(type: 'boolean', nullable: true)]
  46.     #[Groups(["read","write"])]
  47.     private ?bool $isValid = null;
  49.     #[ORM\Column(type: 'boolean')]
  50.     #[Groups(["read","write"])]
  51.     private bool $isVerified = false;
  53.     #[ORM\ManyToMany(targetEntity: Role::class, mappedBy: 'users')]
  54.     private Collection $storedRoles;
  55.     
  56.     #[Groups(["read","write"])]
  57.     #[ORM\Column(length: 255, nullable: true)]
  58.     private ?string $exponentPushToken = null;
  60.     #[Groups(["read","write"])]
  61.     #[ORM\Column(length: 255, nullable: true)]
  62.     private ?string $googleId = null;
  63.     #[Groups(["read","write"])]
  64.     #[ORM\Column(length: 255, nullable: true)]
  65.     private ?string $avatar = null;
  66.     #[Groups(["read","write"])]
  67.     #[ORM\Column(length: 255, nullable: true)]
  68.     private ?string $facebookId = null;
  70.     public function __construct()
  71.     {
  72.         $this->storedRoles = new ArrayCollection();
  73.         $this->isValid = true;
  74.     }
  77.     public function __toString()
  78.     {
  79.         return $this->getUserIdentifier();
  80.     }
  82.     public function getId(): ?int
  83.     {
  84.         return $this->id;
  85.     }
  87.     /**
  88.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  89.      */
  90.     public function getUsername(): string
  91.     {
  92.         return (string) $this->username;
  93.     }
  95.     public function setUsername(string $username): self
  96.     {
  97.         $this->username = $username;
  99.         return $this;
  100.     }
  102.     /**
  103.      * A visual identifier that represents this user.
  104.      *
  105.      * @see UserInterface
  106.      */
  107.     public function getUserIdentifier(): string
  108.     {
  109.         return (string) $this->username;
  110.     }
  112.     /**
  113.      * @see UserInterface
  114.      */
  115.     public function getRoles(): array
  116.     {
  117.         $roles = $this->roles;
  118.         // guarantee every user at least has ROLE_USER
  119.         $roles[] = 'ROLE_USER';
  121.         foreach($this->getStoredRoles() as $singleRole){
  122.             $roles[] = $singleRole->getName();
  123.         }
  125.         return array_unique($roles);
  126.     }
  128.     public function setRoles(array $roles): self
  129.     {
  130.         $this->roles = $roles;
  132.         return $this;
  133.     }
  135.     /**
  136.      * @see PasswordAuthenticatedUserInterface
  137.      */
  138.     public function getPassword(): string
  139.     {
  140.         return $this->password;
  141.     }
  143.     public function setPassword(string $password): self
  144.     {
  145.         $this->password = $password;
  147.         return $this;
  148.     }
  150.     /**
  151.      * Returning a salt is only needed, if you are not using a modern
  152.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  153.      *
  154.      * @see UserInterface
  155.      */
  156.     public function getSalt(): ?string
  157.     {
  158.         return null;
  159.     }
  161.     /**
  162.      * @see UserInterface
  163.      */
  164.     public function eraseCredentials()
  165.     {
  166.         // If you store any temporary, sensitive data on the user, clear it here
  167.         // $this->plainPassword = null;
  168.     }
  170.     public function getIsValid(): ?bool
  171.     {
  172.         return $this->isValid;
  173.     }
  175.     public function setIsValid(?bool $isValid): self
  176.     {
  177.         $this->isValid = $isValid;
  179.         return $this;
  180.     }
  182.     public function isVerified(): bool
  183.     {
  184.         return $this->isVerified;
  185.     }
  187.     public function setIsVerified(bool $isVerified): self
  188.     {
  189.         $this->isVerified = $isVerified;
  191.         return $this;
  192.     }
  194.     /**
  195.      * @return Collection<int, Role>
  196.      */
  197.     public function getStoredRoles(): Collection
  198.     {
  199.         return $this->storedRoles;
  200.     }
  202.     public function addStoredRole(Role $storedRole): self
  203.     {
  204.         if (!$this->storedRoles->contains($storedRole)) {
  205.             $this->storedRoles->add($storedRole);
  206.             $storedRole->addUser($this);
  207.         }
  209.         return $this;
  210.     }
  212.     public function removeStoredRole(Role $storedRole): self
  213.     {
  214.         if ($this->storedRoles->removeElement($storedRole)) {
  215.             $storedRole->removeUser($this);
  216.         }
  218.         return $this;
  219.     }
  221.     public function getExponentPushToken(): ?string
  222.     {
  223.         return $this->exponentPushToken;
  224.     }
  226.     public function setExponentPushToken(?string $exponentPushToken): self
  227.     {
  228.         $this->exponentPushToken = $exponentPushToken;
  230.         return $this;
  231.     }
  233.     public function getGoogleId(): ?string
  234.     {
  235.         return $this->googleId;
  236.     }
  238.     public function setGoogleId(?string $googleId): self
  239.     {
  240.         $this->googleId = $googleId;
  242.         return $this;
  243.     }
  245.     public function getAvatar(): ?string
  246.     {
  247.         return $this->avatar;
  248.     }
  250.     public function setAvatar(?string $avatar): self
  251.     {
  252.         $this->avatar = $avatar;
  254.         return $this;
  255.     }
  257.     public function getFacebookId(): ?string
  258.     {
  259.         return $this->facebookId;
  260.     }
  262.     public function setFacebookId(?string $facebookId): self
  263.     {
  264.         $this->facebookId = $facebookId;
  266.         return $this;
  267.     }
  268. }