src/Entity/Account.php line 26

  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\AccountBlock;
  6. use ApiPlatform\Metadata\Get;
  7. use ApiPlatform\Metadata\Post;
  8. use Doctrine\DBAL\Types\Types;
  9. use Symfony\Component\Uid\Ulid;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use App\Entity\CompletedDialogue;
  12. use ApiPlatform\Metadata\ApiResource;
  13. use App\Repository\AccountRepository;
  14. use Doctrine\Common\Collections\Collection;
  15. use Symfony\Bridge\Doctrine\Types\UlidType;
  16. use Doctrine\Common\Collections\ArrayCollection;
  17. use Symfony\Component\Serializer\Annotation\Groups;
  18. use Symfony\Component\Validator\Constraints as Assert;
  19. use Symfony\Component\Security\Core\User\UserInterface;
  20. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  21. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  24. #[ORM\Entity(repositoryClass: AccountRepository::class)]
  25. #[UniqueEntity('email')]
  26. class Account implements UserInterface, PasswordAuthenticatedUserInterface
  27. {
  28.     #[ORM\Id]
  29.     #[ORM\GeneratedValue]
  30.     #[ORM\Column]
  31.     private ?int $id = null;
  33.     #[Assert\NotBlank]
  34.     #[Assert\Email]
  35.     #[ORM\Column(length: 180, unique: true)]
  36.     private ?string $email = null;
  38.     #[ORM\Column(type: 'json')]
  39.     private array $roles = [];
  41.     #[ORM\Column]
  42.     private ?\DateTimeImmutable $createdAt = null;
  44.     #[ORM\Column]
  45.     private ?bool $active = null;
  47.     #[ORM\Column(length: 255, nullable: true)]
  48.     private ?string $diocese = null;
  50.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  51.     private ?\DateTimeInterface $nextDialogue = null;
  53.     #[ORM\Column(type: UlidType::NAME, unique: true, nullable: true)]
  54.     private ?Ulid $hash = null;
  56.     #[ORM\Column(nullable: true)]
  57.     private ?\DateTimeImmutable $hashedAt = null;
  59.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: CompletedDialogue::class)]
  60.     private Collection $completedDialogues;
  62.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: AccountBlock::class)]
  63.     private Collection $accountBlocks;
  65.     /**
  66.      * @var string The hashed password
  67.      */
  68.     #[ORM\Column]
  69.     private ?string $password = null;
  71.     private ?string $plainPassword = null;
  73.     public function __construct()
  74.     {
  75.         $this->completedDialogues = new ArrayCollection();
  76.         $this->accountBlocks = new ArrayCollection();
  77.     }
  79.     public function getId(): ?int
  80.     {
  81.         return $this->id;
  82.     }
  84.     public function getEmail(): ?string
  85.     {
  86.         return $this->email;
  87.     }
  89.     public function setEmail(string $email): self
  90.     {
  91.         $this->email = $email;
  93.         return $this;
  94.     }
  96.     /**
  97.      * A visual identifier that represents this user..
  98.      *
  99.      * @see UserInterface
  100.      */
  101.     public function getUserIdentifier(): string
  102.     {
  103.         return (string) $this->email;
  104.     }
  106.     /**
  107.      * @see UserInterface
  108.      */
  109.     public function getRoles(): array
  110.     {
  111.         $roles = $this->roles;
  112.         // guarantee every user at least has ROLE_USER
  113.         $roles[] = 'ROLE_USER';
  115.         return array_unique($roles);
  116.     }
  118.     public function setRoles(array $roles): self
  119.     {
  120.         $this->roles = $roles;
  122.         return $this;
  123.     }
  125.     /**
  126.      * @see PasswordAuthenticatedUserInterface
  127.      */
  128.     public function getPassword(): string
  129.     {
  130.         return $this->password;
  131.     }
  133.     public function setPassword(string $password): self
  134.     {
  135.         $this->password = $password;
  137.         return $this;
  138.     }
  140.     public function getPlainPassword(): ?string
  141.     {
  142.         return $this->plainPassword;
  143.     }
  145.     public function setPlainPassword(?string $plainPassword): self
  146.     {
  147.         $this->plainPassword = $plainPassword;
  149.         return $this;
  150.     }
  152.     /**
  153.      * @see UserInterface
  154.      */
  155.     public function eraseCredentials()
  156.     {
  157.         // If you store any temporary, sensitive data on the user, clear it here
  158.         // $this->plainPassword = null;
  159.     }
  161.     public function getCreatedAt(): ?\DateTimeImmutable
  162.     {
  163.         return $this->createdAt;
  164.     }
  166.     public function setCreatedAt(\DateTimeImmutable $createdAt): self
  167.     {
  168.         $this->createdAt = $createdAt;
  170.         return $this;
  171.     }
  173.     public function isActive(): ?bool
  174.     {
  175.         return $this->active;
  176.     }
  178.     public function setActive(bool $active): self
  179.     {
  180.         $this->active = $active;
  182.         return $this;
  183.     }
  185.     public function getDiocese(): ?string
  186.     {
  187.         return $this->diocese;
  188.     }
  190.     public function setDiocese(?string $diocese): self
  191.     {
  192.         $this->diocese = $diocese;
  194.         return $this;
  195.     }
  197.     public function getNextDialogue(): ?\DateTimeInterface
  198.     {
  199.         return $this->nextDialogue;
  200.     }
  202.     public function setNextDialogue(?\DateTimeInterface $nextDialogue): self
  203.     {
  204.         $this->nextDialogue = $nextDialogue;
  206.         return $this;
  207.     }
  209.     public function getHash(): ?Ulid
  210.     {
  211.         return $this->hash;
  212.     }
  214.     public function setHash(?Ulid $hash): self
  215.     {
  216.         $this->hash = $hash;
  218.         return $this;
  219.     }
  221.     public function getHashedAt(): ?\DateTimeImmutable
  222.     {
  223.         return $this->hashedAt;
  224.     }
  226.     public function setHashedAt(?\DateTimeImmutable $hashedAt): static
  227.     {
  228.         $this->hashedAt = $hashedAt;
  230.         return $this;
  231.     }
  233.     /**
  234.      * @return Collection<int, CompletedDialogue>
  235.      */
  236.     public function getCompletedDialogues(): Collection
  237.     {
  238.         return $this->completedDialogues;
  239.     }
  241.     public function addCompletedDialogue(CompletedDialogue $completedDialogue): self
  242.     {
  243.         if (!$this->completedDialogues->contains($completedDialogue)) {
  244.             $this->completedDialogues->add($completedDialogue);
  245.             $completedDialogue->setAccount($this);
  246.         }
  248.         return $this;
  249.     }
  251.     public function removeCompletedDialogue(CompletedDialogue $completedDialogue): self
  252.     {
  253.         if ($this->completedDialogues->removeElement($completedDialogue)) {
  254.             // set the owning side to null (unless already changed)
  255.             if ($completedDialogue->getAccount() === $this) {
  256.                 $completedDialogue->setAccount(null);
  257.             }
  258.         }
  260.         return $this;
  261.     }
  263.     /**
  264.      * @return Collection<int, AccountBlock>
  265.      */
  266.     public function getAccountBlocks(): Collection
  267.     {
  268.         return $this->accountBlocks;
  269.     }
  271.     public function addAccountBlock(AccountBlock $accountBlock): self
  272.     {
  273.         if (!$this->accountBlocks->contains($accountBlock)) {
  274.             $this->accountBlocks->add($accountBlock);
  275.             $accountBlock->setAccount($this);
  276.         }
  278.         return $this;
  279.     }
  281.     public function removeAccountBlock(AccountBlock $accountBlock): self
  282.     {
  283.         if ($this->accountBlocks->removeElement($accountBlock)) {
  284.             // set the owning side to null (unless already changed)
  285.             if ($accountBlock->getAccount() === $this) {
  286.                 $accountBlock->setAccount(null);
  287.             }
  288.         }
  290.         return $this;
  291.     }
  292. }