src/Domain/Entity/Entidad.php line 11

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 Symfony\Component\Uid\Uuid;
  11. class Entidad
  12. {
  13.     private ?Uuid $id = null;
  15.     private ?string $nombre = null;
  17.     private ?string $dni;
  19.     private ?string $codigo = null;
  21.     private ?DateTimeInterface $createdAt = null;
  23.     private ?DateTimeInterface $updatedAt = null;
  25.     private ?DateTimeInterface $deletedAt = null;
  27.     private Collection $expedientes;
  29.     private Collection $estados;
  31.     private Collection $metadataExpedientes;
  33.     private Collection $sonataUserUsers;
  35.     private Collection $calendarios;
  37.     private Collection $documentacions;
  39.     private Collection $intervinientes;
  41.     private Collection $sedes;
  43.     private Collection $metadataCustomRegistros;
  45.     private Collection $metadataExpedientesEnabled;
  47.     private Collection $metadataCustomRegistrosEnabled;
  49.     public function __construct()
  50.     {
  51.         $this->expedientes = new ArrayCollection();
  52.         $this->estados = new ArrayCollection();
  53.         $this->metadataExpedientes = new ArrayCollection();
  54.         $this->sonataUserUsers = new ArrayCollection();
  55.         $this->calendarios = new ArrayCollection();
  56.         $this->documentacions = new ArrayCollection();
  57.         $this->intervinientes = new ArrayCollection();
  58.         $this->sedes = new ArrayCollection();
  59.         $this->metadataCustomRegistros = new ArrayCollection();
  60.         $this->metadataExpedientesEnabled = new ArrayCollection();
  61.         $this->metadataCustomRegistrosEnabled = new ArrayCollection();
  62.     }
  64.     public function __toString(): string
  65.     {
  66.         return $this->getNombre()??'Entidad Sin Definir';
  67.     }
  69.     public function getCodigo(): ?string
  70.     {
  71.         return $this->codigo;
  72.     }
  74.     public function setCodigo(?string $codigo): static
  75.     {
  76.         $this->codigo = $codigo;
  78.         return $this;
  79.     }
  81.     public function getNombre(): ?string
  82.     {
  83.         return $this->nombre;
  84.     }
  86.     public function setNombre(?string $nombre): static
  87.     {
  88.         $this->nombre = $nombre;
  90.         return $this;
  91.     }
  93.     public function getCreatedAt(): ?\DateTimeInterface
  94.     {
  95.         return $this->createdAt;
  96.     }
  98.     public function setCreatedAt(\DateTimeInterface $createdAt): static
  99.     {
  100.         $this->createdAt = $createdAt;
  102.         return $this;
  103.     }
  105.     public function getUpdatedAt(): ?\DateTimeInterface
  106.     {
  107.         return $this->updatedAt;
  108.     }
  110.     public function setUpdatedAt(\DateTimeInterface $updatedAt): static
  111.     {
  112.         $this->updatedAt = $updatedAt;
  114.         return $this;
  115.     }
  117.     public function getDeletedAt(): ?\DateTimeInterface
  118.     {
  119.         return $this->deletedAt;
  120.     }
  122.     public function setDeletedAt(?\DateTimeInterface $deletedAt): static
  123.     {
  124.         $this->deletedAt = $deletedAt;
  126.         return $this;
  127.     }
  129.     public function getId(): ?Uuid
  130.     {
  131.         return $this->id;
  132.     }
  134.     /**
  135.      * @return Collection<int, Expediente>
  136.      */
  137.     public function getExpedientes(): Collection
  138.     {
  139.         return $this->expedientes;
  140.     }
  142.     public function addExpediente(Expediente $expediente): static
  143.     {
  144.         if (!$this->expedientes->contains($expediente)) {
  145.             $this->expedientes->add($expediente);
  146.             $expediente->setEntidad($this);
  147.         }
  149.         return $this;
  150.     }
  152.     public function removeExpediente(Expediente $expediente): static
  153.     {
  154.         if ($this->expedientes->removeElement($expediente)) {
  155.             // set the owning side to null (unless already changed)
  156.             if ($expediente->getEntidad() === $this) {
  157.                 $expediente->setEntidad(null);
  158.             }
  159.         }
  161.         return $this;
  162.     }
  164.     /**
  165.      * @return Collection<int, Estado>
  166.      */
  167.     public function getEstados(): Collection
  168.     {
  169.         return $this->estados;
  170.     }
  172.     public function addEstado(Estado $estado): static
  173.     {
  174.         if (!$this->estados->contains($estado)) {
  175.             $this->estados->add($estado);
  176.             $estado->setEntidad($this);
  177.         }
  179.         return $this;
  180.     }
  182.     public function removeEstado(Estado $estado): static
  183.     {
  184.         if ($this->estados->removeElement($estado)) {
  185.             // set the owning side to null (unless already changed)
  186.             if ($estado->getEntidad() === $this) {
  187.                 $estado->setEntidad(null);
  188.             }
  189.         }
  191.         return $this;
  192.     }
  194.     /**
  195.      * @return Collection<int, MetadataExpediente>
  196.      */
  197.     public function getMetadataExpedientes(): Collection
  198.     {
  199.         return $this->metadataExpedientes;
  200.     }
  202.     public function addMetadataExpediente(MetadataExpediente $metadataExpediente): static
  203.     {
  204.         if (!$this->metadataExpedientes->contains($metadataExpediente)) {
  205.             $this->metadataExpedientes->add($metadataExpediente);
  206.             $metadataExpediente->setEntidad($this);
  207.         }
  209.         return $this;
  210.     }
  212.     public function removeMetadataExpediente(MetadataExpediente $metadataExpediente): static
  213.     {
  214.         if ($this->metadataExpedientes->removeElement($metadataExpediente)) {
  215.             // set the owning side to null (unless already changed)
  216.             if ($metadataExpediente->getEntidad() === $this) {
  217.                 $metadataExpediente->setEntidad(null);
  218.             }
  219.         }
  221.         return $this;
  222.     }
  224.     /**
  225.      * @return Collection<int, SonataUserUser>
  226.      */
  227.     public function getSonataUserUsers(): Collection
  228.     {
  229.         return $this->sonataUserUsers;
  230.     }
  232.     public function addSonataUserUser(SonataUserUser $sonataUserUser): static
  233.     {
  234.         if (!$this->sonataUserUsers->contains($sonataUserUser)) {
  235.             $this->sonataUserUsers->add($sonataUserUser);
  236.             $sonataUserUser->setEntidad($this);
  237.         }
  239.         return $this;
  240.     }
  242.     public function removeSonataUserUser(SonataUserUser $sonataUserUser): static
  243.     {
  244.         if ($this->sonataUserUsers->removeElement($sonataUserUser)) {
  245.             // set the owning side to null (unless already changed)
  246.             if ($sonataUserUser->getEntidad() === $this) {
  247.                 $sonataUserUser->setEntidad(null);
  248.             }
  249.         }
  251.         return $this;
  252.     }
  254.     /**
  255.      * @return Collection<int, Calendario>
  256.      */
  257.     public function getCalendarios(): Collection
  258.     {
  259.         return $this->calendarios;
  260.     }
  262.     public function addCalendario(Calendario $calendario): static
  263.     {
  264.         if (!$this->calendarios->contains($calendario)) {
  265.             $this->calendarios->add($calendario);
  266.             $calendario->setEntidad($this);
  267.         }
  269.         return $this;
  270.     }
  272.     public function removeCalendario(Calendario $calendario): static
  273.     {
  274.         if ($this->calendarios->removeElement($calendario)) {
  275.             // set the owning side to null (unless already changed)
  276.             if ($calendario->getEntidad() === $this) {
  277.                 $calendario->setEntidad(null);
  278.             }
  279.         }
  281.         return $this;
  282.     }
  284.     /**
  285.      * @return Collection<int, Documentacion>
  286.      */
  287.     public function getDocumentacions(): Collection
  288.     {
  289.         return $this->documentacions;
  290.     }
  292.     public function addDocumentacion(Documentacion $documentacion): static
  293.     {
  294.         if (!$this->documentacions->contains($documentacion)) {
  295.             $this->documentacions->add($documentacion);
  296.             $documentacion->setEntidad($this);
  297.         }
  299.         return $this;
  300.     }
  302.     public function removeDocumentacion(Documentacion $documentacion): static
  303.     {
  304.         if ($this->documentacions->removeElement($documentacion)) {
  305.             // set the owning side to null (unless already changed)
  306.             if ($documentacion->getEntidad() === $this) {
  307.                 $documentacion->setEntidad(null);
  308.             }
  309.         }
  311.         return $this;
  312.     }
  314.     /**
  315.      * @return Collection<int, Interviniente>
  316.      */
  317.     public function getIntervinientes(): Collection
  318.     {
  319.         return $this->intervinientes;
  320.     }
  322.     public function addInterviniente(Interviniente $interviniente): static
  323.     {
  324.         if (!$this->intervinientes->contains($interviniente)) {
  325.             $this->intervinientes->add($interviniente);
  326.             $interviniente->setEntidad($this);
  327.         }
  329.         return $this;
  330.     }
  332.     public function removeInterviniente(Interviniente $interviniente): static
  333.     {
  334.         if ($this->intervinientes->removeElement($interviniente)) {
  335.             // set the owning side to null (unless already changed)
  336.             if ($interviniente->getEntidad() === $this) {
  337.                 $interviniente->setEntidad(null);
  338.             }
  339.         }
  341.         return $this;
  342.     }
  344.     /**
  345.      * @return Collection<int, Sede>
  346.      */
  347.     public function getSedes(): Collection
  348.     {
  349.         return $this->sedes;
  350.     }
  352.     public function addSede(Sede $sede): static
  353.     {
  354.         if (!$this->sedes->contains($sede)) {
  355.             $this->sedes->add($sede);
  356.             $sede->setEntidad($this);
  357.         }
  359.         return $this;
  360.     }
  362.     public function removeSede(Sede $sede): static
  363.     {
  364.         if ($this->sedes->removeElement($sede)) {
  365.             // set the owning side to null (unless already changed)
  366.             if ($sede->getEntidad() === $this) {
  367.                 $sede->setEntidad(null);
  368.             }
  369.         }
  371.         return $this;
  372.     }
  374.     /**
  375.      * @return Collection<int, MetadataCustomRegistro>
  376.      */
  377.     public function getMetadataCustomRegistros(): Collection
  378.     {
  379.         return $this->metadataCustomRegistros;
  380.     }
  382.     public function addMetadataCustomRegistro(MetadataCustomRegistro $metadataCustomRegistro): static
  383.     {
  384.         if (!$this->metadataCustomRegistros->contains($metadataCustomRegistro)) {
  385.             $this->metadataCustomRegistros->add($metadataCustomRegistro);
  386.             $metadataCustomRegistro->setEntidad($this);
  387.         }
  389.         return $this;
  390.     }
  392.     public function removeMetadataCustomRegistro(MetadataCustomRegistro $metadataCustomRegistro): static
  393.     {
  394.         if ($this->metadataCustomRegistros->removeElement($metadataCustomRegistro)) {
  395.             // set the owning side to null (unless already changed)
  396.             if ($metadataCustomRegistro->getEntidad() === $this) {
  397.                 $metadataCustomRegistro->setEntidad(null);
  398.             }
  399.         }
  401.         return $this;
  402.     }
  404.     /**
  405.      * @return Collection<int, MetadataExpediente>
  406.      */
  407.     public function getMetadataExpedientesEnabled(): Collection
  408.     {
  409.         return $this->metadataExpedientesEnabled;
  410.     }
  412.     public function addMetadataExpedientesEnabled(MetadataExpediente $metadataExpedientesEnabled): static
  413.     {
  414.         if (!$this->metadataExpedientesEnabled->contains($metadataExpedientesEnabled)) {
  415.             $this->metadataExpedientesEnabled->add($metadataExpedientesEnabled);
  416.         }
  418.         return $this;
  419.     }
  421.     public function removeMetadataExpedientesEnabled(MetadataExpediente $metadataExpedientesEnabled): static
  422.     {
  423.         $this->metadataExpedientesEnabled->removeElement($metadataExpedientesEnabled);
  425.         return $this;
  426.     }
  428.     /**
  429.      * @return Collection<int, MetadataCustomRegistro>
  430.      */
  431.     public function getMetadataCustomRegistrosEnabled(): Collection
  432.     {
  433.         return $this->metadataCustomRegistrosEnabled;
  434.     }
  436.     public function addMetadataCustomRegistrosEnabled(MetadataCustomRegistro $metadataCustomRegistrosEnabled): static
  437.     {
  438.         if (!$this->metadataCustomRegistrosEnabled->contains($metadataCustomRegistrosEnabled)) {
  439.             $this->metadataCustomRegistrosEnabled->add($metadataCustomRegistrosEnabled);
  440.         }
  442.         return $this;
  443.     }
  445.     public function removeMetadataCustomRegistrosEnabled(MetadataCustomRegistro $metadataCustomRegistrosEnabled): static
  446.     {
  447.         $this->metadataCustomRegistrosEnabled->removeElement($metadataCustomRegistrosEnabled);
  449.         return $this;
  450.     }
  452.     public function getDni()
  453.     {
  454.         return $this->dni;
  455.     }
  457.     public function setDni($dni): static
  458.     {
  459.         $this->dni = $dni;
  461.         return $this;
  462.     }
  463. }