src/Domain/Entity/SonataUserUser.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Domain\Entity;
  5. use DateTimeInterface;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Sonata\UserBundle\Entity\BaseUser;
  11. use Symfony\Component\Uid\Uuid;
  13. class SonataUserUser extends BaseUser
  14. {
  15.     protected $id;
  17.     private Collection $expedientesCreador;
  19.     private Collection $expedientesResponsable;
  21.     private Collection $metadataExpedientesResponsable;
  23.     private Collection $tramitesResponsable;
  25.     private Collection $metadataTramitesResponsable;
  27.     private ?Entidad $entidad = null;
  29.     private ?Sede $sedeResponsable = null;
  31.     private ?DateTimeInterface $deletedAt;
  33.     private Collection $documentacionRegistros;
  35.     public function __construct()
  36.     {
  37.         $this->expedientesCreador = new ArrayCollection();
  38.         $this->metadataExpedientesResponsable = new ArrayCollection();
  39.         $this->tramitesResponsable = new ArrayCollection();
  40.         $this->metadataTramitesResponsable = new ArrayCollection();
  41.         $this->expedientesResponsable = new ArrayCollection();
  42.         $this->documentacionRegistros = new ArrayCollection();
  43.     }
  45.     public function getId(): ?Uuid
  46.     {
  47.         return $this->id;
  48.     }
  50.     /**
  51.      * @return Collection<int, Expediente>
  52.      */
  53.     public function getExpedientesCreador(): Collection
  54.     {
  55.         return $this->expedientesCreador;
  56.     }
  58.     public function addExpedientesCreador(Expediente $expedientesCreador): static
  59.     {
  60.         if (!$this->expedientesCreador->contains($expedientesCreador)) {
  61.             $this->expedientesCreador->add($expedientesCreador);
  62.             $expedientesCreador->setCreador($this);
  63.         }
  65.         return $this;
  66.     }
  68.     public function removeExpedientesCreador(Expediente $expedientesCreador): static
  69.     {
  70.         if ($this->expedientesCreador->removeElement($expedientesCreador)) {
  71.             // set the owning side to null (unless already changed)
  72.             if ($expedientesCreador->getCreador() === $this) {
  73.                 $expedientesCreador->setCreador(null);
  74.             }
  75.         }
  77.         return $this;
  78.     }
  80.     /**
  81.      * @return Collection<int, MetadataExpediente>
  82.      */
  83.     public function getMetadataExpedientesResponsable(): Collection
  84.     {
  85.         return $this->metadataExpedientesResponsable;
  86.     }
  88.     public function addMetadataExpedientesResponsable(MetadataExpediente $metadataExpedientesResponsable): static
  89.     {
  90.         if (!$this->metadataExpedientesResponsable->contains($metadataExpedientesResponsable)) {
  91.             $this->metadataExpedientesResponsable->add($metadataExpedientesResponsable);
  92.             $metadataExpedientesResponsable->addResponsable($this);
  93.         }
  95.         return $this;
  96.     }
  98.     public function removeMetadataExpedientesResponsable(MetadataExpediente $metadataExpedientesResponsable): static
  99.     {
  100.         if ($this->metadataExpedientesResponsable->removeElement($metadataExpedientesResponsable)) {
  101.             $metadataExpedientesResponsable->removeResponsable($this);
  102.         }
  104.         return $this;
  105.     }
  107.     /**
  108.      * @return Collection<int, Tramite>
  109.      */
  110.     public function getTramitesResponsable(): Collection
  111.     {
  112.         return $this->tramitesResponsable;
  113.     }
  115.     public function addTramitesResponsable(Tramite $tramitesResponsable): static
  116.     {
  117.         if (!$this->tramitesResponsable->contains($tramitesResponsable)) {
  118.             $this->tramitesResponsable->add($tramitesResponsable);
  119.             $tramitesResponsable->addResponsable($this);
  120.         }
  122.         return $this;
  123.     }
  125.     public function removeTramitesResponsable(Tramite $tramitesResponsable): static
  126.     {
  127.         if ($this->tramitesResponsable->removeElement($tramitesResponsable)) {
  128.             $tramitesResponsable->removeResponsable($this);
  129.         }
  131.         return $this;
  132.     }
  134.     /**
  135.      * @return Collection<int, MetadataTramite>
  136.      */
  137.     public function getMetadataTramitesResponsable(): Collection
  138.     {
  139.         return $this->metadataTramitesResponsable;
  140.     }
  142.     public function addMetadataTramitesResponsable(MetadataTramite $metadataTramitesResponsable): static
  143.     {
  144.         if (!$this->metadataTramitesResponsable->contains($metadataTramitesResponsable)) {
  145.             $this->metadataTramitesResponsable->add($metadataTramitesResponsable);
  146.             $metadataTramitesResponsable->addResponsable($this);
  147.         }
  149.         return $this;
  150.     }
  152.     public function removeMetadataTramitesResponsable(MetadataTramite $metadataTramitesResponsable): static
  153.     {
  154.         if ($this->metadataTramitesResponsable->removeElement($metadataTramitesResponsable)) {
  155.             $metadataTramitesResponsable->removeResponsable($this);
  156.         }
  158.         return $this;
  159.     }
  161.     /**
  162.      * @return Collection<int, Expediente>
  163.      */
  164.     public function getExpedientesResponsable(): Collection
  165.     {
  166.         return $this->expedientesResponsable;
  167.     }
  169.     public function addExpedientesResponsable(Expediente $expedientesResponsable): static
  170.     {
  171.         if (!$this->expedientesResponsable->contains($expedientesResponsable)) {
  172.             $this->expedientesResponsable->add($expedientesResponsable);
  173.             $expedientesResponsable->addResponsable($this);
  174.         }
  176.         return $this;
  177.     }
  179.     public function removeExpedientesResponsable(Expediente $expedientesResponsable): static
  180.     {
  181.         if ($this->expedientesResponsable->removeElement($expedientesResponsable)) {
  182.             $expedientesResponsable->removeResponsable($this);
  183.         }
  185.         return $this;
  186.     }
  188.     public function getEntidad(): ?Entidad
  189.     {
  190.         return $this->entidad;
  191.     }
  193.     public function setEntidad(?Entidad $entidad): static
  194.     {
  195.         $this->entidad = $entidad;
  197.         return $this;
  198.     }
  200.     public function getDeletedAt(): ?\DateTimeInterface
  201.     {
  202.         return $this->deletedAt;
  203.     }
  205.     public function setDeletedAt(?\DateTimeInterface $deletedAt): static
  206.     {
  207.         $this->deletedAt = $deletedAt;
  209.         return $this;
  210.     }
  212.     public function getSedeResponsable(): ?Sede
  213.     {
  214.         return $this->sedeResponsable;
  215.     }
  217.     public function setSedeResponsable(?Sede $sedeResponsable): static
  218.     {
  219.         // unset the owning side of the relation if necessary
  220.         if ($sedeResponsable === null && $this->sedeResponsable !== null) {
  221.             $this->sedeResponsable->setResponsable(null);
  222.         }
  224.         // set the owning side of the relation if necessary
  225.         if ($sedeResponsable !== null && $sedeResponsable->getResponsable() !== $this) {
  226.             $sedeResponsable->setResponsable($this);
  227.         }
  229.         $this->sedeResponsable = $sedeResponsable;
  231.         return $this;
  232.     }
  234.     /**
  235.      * @return Collection<int, DocumentacionRegistro>
  236.      */
  237.     public function getDocumentacionRegistros(): Collection
  238.     {
  239.         return $this->documentacionRegistros;
  240.     }
  242.     public function addDocumentacionRegistro(DocumentacionRegistro $documentacionRegistro): static
  243.     {
  244.         if (!$this->documentacionRegistros->contains($documentacionRegistro)) {
  245.             $this->documentacionRegistros->add($documentacionRegistro);
  246.             $documentacionRegistro->setUser($this);
  247.         }
  249.         return $this;
  250.     }
  252.     public function removeDocumentacionRegistro(DocumentacionRegistro $documentacionRegistro): static
  253.     {
  254.         if ($this->documentacionRegistros->removeElement($documentacionRegistro)) {
  255.             // set the owning side to null (unless already changed)
  256.             if ($documentacionRegistro->getUser() === $this) {
  257.                 $documentacionRegistro->setUser(null);
  258.             }
  259.         }
  261.         return $this;
  262.     }
  263. }