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, inversedBy: '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.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: AiRequest::class)]
  71.     private Collection $aiRequests;
  73.     public function __construct()
  74.     {
  75.         $this->storedRoles = new ArrayCollection();
  76.         $this->isValid = true;
  77.         $this->aiRequests = new ArrayCollection();
  78.     }
  81.     public function __toString()
  82.     {
  83.         return $this->getUserIdentifier();
  84.     }
  86.     public function getId(): ?int
  87.     {
  88.         return $this->id;
  89.     }
  91.     /**
  92.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  93.      */
  94.     public function getUsername(): string
  95.     {
  96.         return (string) $this->username;
  97.     }
  99.     public function setUsername(string $username): self
  100.     {
  101.         $this->username = $username;
  103.         return $this;
  104.     }
  106.     /**
  107.      * A visual identifier that represents this user.
  108.      *
  109.      * @see UserInterface
  110.      */
  111.     public function getUserIdentifier(): string
  112.     {
  113.         return (string) $this->username;
  114.     }
  116.     /**
  117.      * @see UserInterface
  118.      */
  119.     public function getRoles(): array
  120.     {
  121.         $roles = $this->roles;
  122.         // guarantee every user at least has ROLE_USER
  123.         $roles[] = 'ROLE_USER';
  125.         foreach($this->getStoredRoles() as $singleRole){
  126.             $roles[] = $singleRole->getName();
  127.         }
  129.         return array_unique($roles);
  130.     }
  132.     public function setRoles(array $roles): self
  133.     {
  134.         $this->roles = $roles;
  136.         return $this;
  137.     }
  139.     /**
  140.      * @see PasswordAuthenticatedUserInterface
  141.      */
  142.     public function getPassword(): string
  143.     {
  144.         return $this->password;
  145.     }
  147.     public function setPassword(string $password): self
  148.     {
  149.         $this->password = $password;
  151.         return $this;
  152.     }
  154.     /**
  155.      * Returning a salt is only needed, if you are not using a modern
  156.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  157.      *
  158.      * @see UserInterface
  159.      */
  160.     public function getSalt(): ?string
  161.     {
  162.         return null;
  163.     }
  165.     /**
  166.      * @see UserInterface
  167.      */
  168.     public function eraseCredentials()
  169.     {
  170.         // If you store any temporary, sensitive data on the user, clear it here
  171.         // $this->plainPassword = null;
  172.     }
  174.     public function getIsValid(): ?bool
  175.     {
  176.         return $this->isValid;
  177.     }
  179.     public function setIsValid(?bool $isValid): self
  180.     {
  181.         $this->isValid = $isValid;
  183.         return $this;
  184.     }
  186.     public function isVerified(): bool
  187.     {
  188.         return $this->isVerified;
  189.     }
  191.     public function setIsVerified(bool $isVerified): self
  192.     {
  193.         $this->isVerified = $isVerified;
  195.         return $this;
  196.     }
  198.     /**
  199.      * @return Collection<int, Role>
  200.      */
  201.     public function getStoredRoles(): Collection
  202.     {
  203.         return $this->storedRoles;
  204.     }
  206.     public function addStoredRole(Role $storedRole): self
  207.     {
  208.         if (!$this->storedRoles->contains($storedRole)) {
  209.             $this->storedRoles->add($storedRole);
  210.             $storedRole->addUser($this);
  211.         }
  213.         return $this;
  214.     }
  216.     public function removeStoredRole(Role $storedRole): self
  217.     {
  218.         if ($this->storedRoles->removeElement($storedRole)) {
  219.             $storedRole->removeUser($this);
  220.         }
  222.         return $this;
  223.     }
  225.     public function getExponentPushToken(): ?string
  226.     {
  227.         return $this->exponentPushToken;
  228.     }
  230.     public function setExponentPushToken(?string $exponentPushToken): self
  231.     {
  232.         $this->exponentPushToken = $exponentPushToken;
  234.         return $this;
  235.     }
  237.     public function getGoogleId(): ?string
  238.     {
  239.         return $this->googleId;
  240.     }
  242.     public function setGoogleId(?string $googleId): self
  243.     {
  244.         $this->googleId = $googleId;
  246.         return $this;
  247.     }
  249.     public function getAvatar(): ?string
  250.     {
  251.         return $this->avatar;
  252.     }
  254.     public function setAvatar(?string $avatar): self
  255.     {
  256.         $this->avatar = $avatar;
  258.         return $this;
  259.     }
  261.     public function getFacebookId(): ?string
  262.     {
  263.         return $this->facebookId;
  264.     }
  266.     public function setFacebookId(?string $facebookId): self
  267.     {
  268.         $this->facebookId = $facebookId;
  270.         return $this;
  271.     }
  273.     /**
  274.      * @return Collection<int, AiRequest>
  275.      */
  276.     public function getAiRequests(): Collection
  277.     {
  278.         return $this->aiRequests;
  279.     }
  281.     public function addAiRequest(AiRequest $aiRequest): static
  282.     {
  283.         if (!$this->aiRequests->contains($aiRequest)) {
  284.             $this->aiRequests->add($aiRequest);
  285.             $aiRequest->setUser($this);
  286.         }
  288.         return $this;
  289.     }
  291.     public function removeAiRequest(AiRequest $aiRequest): static
  292.     {
  293.         if ($this->aiRequests->removeElement($aiRequest)) {
  294.             // set the owning side to null (unless already changed)
  295.             if ($aiRequest->getUser() === $this) {
  296.                 $aiRequest->setUser(null);
  297.             }
  298.         }
  300.         return $this;
  301.     }
  302. }