src/Entity/User.php line 15

  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Document;
  6. use App\Entity\Document\BlockCategory;
  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\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  14. #[ORM\Entity(repositoryClass: UserRepository::class)]
  15. class User implements UserInterface, PasswordAuthenticatedUserInterface
  16. {
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column]
  20.     private ?int $id = null;
  22.     #[ORM\Column(length: 180, unique: true)]
  23.     private ?string $email = null;
  25.     #[ORM\Column]
  26.     private array $roles = [];
  28.     /**
  29.      * @var string The hashed password
  30.      */
  31.     #[ORM\Column]
  32.     private ?string $password = null;
  34.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: DocxUploaded::class)]
  35.     private Collection $docxUploadeds;
  37.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Document::class)]
  38.     private Collection $documents;
  40.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Document::class)]
  41.     private Collection $docs;
  43.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: DocumentPermission::class, orphanRemoval: true)]
  44.     private Collection $documentPermissions;
  46.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: BlockCategory::class)]
  47.     private Collection $blockCategories;
  49.     #[ORM\Column(length: 255, nullable: true)]
  50.     private ?string $apikey = null;
  52.     public function __construct()
  53.     {
  54.         $this->docxUploadeds = new ArrayCollection();
  55.         $this->documents = new ArrayCollection();
  56.         $this->docs = new ArrayCollection();
  57.         $this->documentPermissions = new ArrayCollection();
  58.         $this->blockCategories = new ArrayCollection();
  59.     }
  61.     public function getId(): ?int
  62.     {
  63.         return $this->id;
  64.     }
  66.     public function getEmail(): ?string
  67.     {
  68.         return $this->email;
  69.     }
  71.     public function setEmail(string $email): self
  72.     {
  73.         $this->email = $email;
  75.         return $this;
  76.     }
  78.     /**
  79.      * A visual identifier that represents this user.
  80.      *
  81.      * @see UserInterface
  82.      */
  83.     public function getUserIdentifier(): string
  84.     {
  85.         return (string) $this->email;
  86.     }
  88.     /**
  89.      * @see UserInterface
  90.      */
  91.     public function getRoles(): array
  92.     {
  93.         $roles = $this->roles;
  94.         // guarantee every user at least has ROLE_USER
  95.         $roles[] = 'ROLE_USER';
  97.         return array_unique($roles);
  98.     }
  100.     public function setRoles(array $roles): self
  101.     {
  102.         $this->roles = $roles;
  104.         return $this;
  105.     }
  107.     /**
  108.      * @see PasswordAuthenticatedUserInterface
  109.      */
  110.     public function getPassword(): string
  111.     {
  112.         return $this->password;
  113.     }
  115.     public function setPassword(string $password): self
  116.     {
  117.         $this->password = $password;
  119.         return $this;
  120.     }
  122.     /**
  123.      * @see UserInterface
  124.      */
  125.     public function eraseCredentials()
  126.     {
  127.         // If you store any temporary, sensitive data on the user, clear it here
  128.         // $this->plainPassword = null;
  129.     }
  131.     /**
  132.      * @return Collection<int, DocxUploaded>
  133.      */
  134.     public function getDocxUploadeds(): Collection
  135.     {
  136.         return $this->docxUploadeds;
  137.     }
  139.     public function addDocxUploaded(DocxUploaded $docxUploaded): self
  140.     {
  141.         if (!$this->docxUploadeds->contains($docxUploaded)) {
  142.             $this->docxUploadeds->add($docxUploaded);
  143.             $docxUploaded->setOwner($this);
  144.         }
  146.         return $this;
  147.     }
  149.     public function removeDocxUploaded(DocxUploaded $docxUploaded): self
  150.     {
  151.         if ($this->docxUploadeds->removeElement($docxUploaded)) {
  152.             // set the owning side to null (unless already changed)
  153.             if ($docxUploaded->getOwner() === $this) {
  154.                 $docxUploaded->setOwner(null);
  155.             }
  156.         }
  158.         return $this;
  159.     }
  161.     /**
  162.      * @return Collection<int, Document>
  163.      */
  164.     public function getDocuments(): Collection
  165.     {
  166.         return $this->documents;
  167.     }
  169.     public function addDocument(Document $document): self
  170.     {
  171.         if (!$this->documents->contains($document)) {
  172.             $this->documents->add($document);
  173.             $document->setOwner($this);
  174.         }
  176.         return $this;
  177.     }
  179.     public function removeDocument(Document $document): self
  180.     {
  181.         if ($this->documents->removeElement($document)) {
  182.             // set the owning side to null (unless already changed)
  183.             if ($document->getOwner() === $this) {
  184.                 $document->setOwner(null);
  185.             }
  186.         }
  188.         return $this;
  189.     }
  191.     /**
  192.      * @return Collection<int, Document>
  193.      */
  194.     public function getDocs(): Collection
  195.     {
  196.         return $this->docs;
  197.     }
  199.     public function addDoc(Document $doc): self
  200.     {
  201.         if (!$this->docs->contains($doc)) {
  202.             $this->docs->add($doc);
  203.             $doc->setOwner($this);
  204.         }
  206.         return $this;
  207.     }
  209.     public function removeDoc(Document $doc): self
  210.     {
  211.         if ($this->docs->removeElement($doc)) {
  212.             // set the owning side to null (unless already changed)
  213.             if ($doc->getOwner() === $this) {
  214.                 $doc->setOwner(null);
  215.             }
  216.         }
  218.         return $this;
  219.     }
  221.     /**
  222.      * @return Collection<int, DocumentPermission>
  223.      */
  224.     public function getDocumentPermissions(): Collection
  225.     {
  226.         return $this->documentPermissions;
  227.     }
  229.     public function addDocumentPermission(DocumentPermission $documentPermission): self
  230.     {
  231.         if (!$this->documentPermissions->contains($documentPermission)) {
  232.             $this->documentPermissions->add($documentPermission);
  233.             $documentPermission->setUser($this);
  234.         }
  236.         return $this;
  237.     }
  239.     public function removeDocumentPermission(DocumentPermission $documentPermission): self
  240.     {
  241.         if ($this->documentPermissions->removeElement($documentPermission)) {
  242.             // set the owning side to null (unless already changed)
  243.             if ($documentPermission->getUser() === $this) {
  244.                 $documentPermission->setUser(null);
  245.             }
  246.         }
  248.         return $this;
  249.     }
  251.     /**
  252.      * @return Collection<int, BlockCategory>
  253.      */
  254.     public function getBlockCategories(): Collection
  255.     {
  256.         return $this->blockCategories;
  257.     }
  259.     public function addBlockCategory(BlockCategory $blockCategory): static
  260.     {
  261.         if (!$this->blockCategories->contains($blockCategory)) {
  262.             $this->blockCategories->add($blockCategory);
  263.             $blockCategory->setOwner($this);
  264.         }
  266.         return $this;
  267.     }
  269.     public function removeBlockCategory(BlockCategory $blockCategory): static
  270.     {
  271.         if ($this->blockCategories->removeElement($blockCategory)) {
  272.             // set the owning side to null (unless already changed)
  273.             if ($blockCategory->getOwner() === $this) {
  274.                 $blockCategory->setOwner(null);
  275.             }
  276.         }
  278.         return $this;
  279.     }
  281.     public function getApikey(): ?string
  282.     {
  283.         return $this->apikey;
  284.     }
  286.     public function setApikey(?string $apikey): static
  287.     {
  288.         $this->apikey = $apikey;
  290.         return $this;
  291.     }
  292. }