src/Domain/Entity/Entidad.php line 10

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 Symfony\Component\Uid\Uuid;
  10. class Entidad
  11. {
  12.     private ?Uuid $id = null;
  14.     private ?string $nombre = null;
  16.     private ?string $dni;
  18.     private ?string $codigo = null;
  20.     private ?DateTimeInterface $createdAt = null;
  22.     private ?DateTimeInterface $updatedAt = null;
  24.     private ?DateTimeInterface $deletedAt = null;
  26.     private Collection $expedientes;
  28.     private Collection $estados;
  30.     private Collection $metadataExpedientes;
  32.     private Collection $sonataUserUsers;
  34.     private Collection $calendarios;
  36.     private Collection $documentacions;
  38.     private Collection $intervinientes;
  40.     private Collection $sedes;
  42.     private Collection $metadataCustomRegistros;
  44.     private Collection $metadataExpedientesEnabled;
  46.     private Collection $metadataCustomRegistrosEnabled;
  48.     public function __construct()
  49.     {
  50.         $this->expedientes = new ArrayCollection();
  51.         $this->estados = new ArrayCollection();
  52.         $this->metadataExpedientes = new ArrayCollection();
  53.         $this->sonataUserUsers = new ArrayCollection();
  54.         $this->calendarios = new ArrayCollection();
  55.         $this->documentacions = new ArrayCollection();
  56.         $this->intervinientes = new ArrayCollection();
  57.         $this->sedes = new ArrayCollection();
  58.         $this->metadataCustomRegistros = new ArrayCollection();
  59.         $this->metadataExpedientesEnabled = new ArrayCollection();
  60.         $this->metadataCustomRegistrosEnabled = new ArrayCollection();
  61.     }
  63.     public function __toString(): string
  64.     {
  65.         return $this->getNombre()??'Entidad Sin Definir';
  66.     }
  68.     public function getCodigo(): ?string
  69.     {
  70.         return $this->codigo;
  71.     }
  73.     public function setCodigo(?string $codigo): static
  74.     {
  75.         $this->codigo = $codigo;
  77.         return $this;
  78.     }
  80.     public function getNombre(): ?string
  81.     {
  82.         return $this->nombre;
  83.     }
  85.     public function setNombre(?string $nombre): static
  86.     {
  87.         $this->nombre = $nombre;
  89.         return $this;
  90.     }
  92.     public function getCreatedAt(): ?\DateTimeInterface
  93.     {
  94.         return $this->createdAt;
  95.     }
  97.     public function setCreatedAt(\DateTimeInterface $createdAt): static
  98.     {
  99.         $this->createdAt = $createdAt;
  101.         return $this;
  102.     }
  104.     public function getUpdatedAt(): ?\DateTimeInterface
  105.     {
  106.         return $this->updatedAt;
  107.     }
  109.     public function setUpdatedAt(\DateTimeInterface $updatedAt): static
  110.     {
  111.         $this->updatedAt = $updatedAt;
  113.         return $this;
  114.     }
  116.     public function getDeletedAt(): ?\DateTimeInterface
  117.     {
  118.         return $this->deletedAt;
  119.     }
  121.     public function setDeletedAt(?\DateTimeInterface $deletedAt): static
  122.     {
  123.         $this->deletedAt = $deletedAt;
  125.         return $this;
  126.     }
  128.     public function getId(): ?Uuid
  129.     {
  130.         return $this->id;
  131.     }
  133.     /**
  134.      * @return Collection<int, Expediente>
  135.      */
  136.     public function getExpedientes(): Collection
  137.     {
  138.         return $this->expedientes;
  139.     }
  141.     public function addExpediente(Expediente $expediente): static
  142.     {
  143.         if (!$this->expedientes->contains($expediente)) {
  144.             $this->expedientes->add($expediente);
  145.             $expediente->setEntidad($this);
  146.         }
  148.         return $this;
  149.     }
  151.     public function removeExpediente(Expediente $expediente): static
  152.     {
  153.         if ($this->expedientes->removeElement($expediente)) {
  154.             // set the owning side to null (unless already changed)
  155.             if ($expediente->getEntidad() === $this) {
  156.                 $expediente->setEntidad(null);
  157.             }
  158.         }
  160.         return $this;
  161.     }
  163.     /**
  164.      * @return Collection<int, Estado>
  165.      */
  166.     public function getEstados(): Collection
  167.     {
  168.         return $this->estados;
  169.     }
  171.     public function addEstado(Estado $estado): static
  172.     {
  173.         if (!$this->estados->contains($estado)) {
  174.             $this->estados->add($estado);
  175.             $estado->setEntidad($this);
  176.         }
  178.         return $this;
  179.     }
  181.     public function removeEstado(Estado $estado): static
  182.     {
  183.         if ($this->estados->removeElement($estado)) {
  184.             // set the owning side to null (unless already changed)
  185.             if ($estado->getEntidad() === $this) {
  186.                 $estado->setEntidad(null);
  187.             }
  188.         }
  190.         return $this;
  191.     }
  193.     /**
  194.      * @return Collection<int, MetadataExpediente>
  195.      */
  196.     public function getMetadataExpedientes(): Collection
  197.     {
  198.         return $this->metadataExpedientes;
  199.     }
  201.     public function addMetadataExpediente(MetadataExpediente $metadataExpediente): static
  202.     {
  203.         if (!$this->metadataExpedientes->contains($metadataExpediente)) {
  204.             $this->metadataExpedientes->add($metadataExpediente);
  205.             $metadataExpediente->setEntidad($this);
  206.         }
  208.         return $this;
  209.     }
  211.     public function removeMetadataExpediente(MetadataExpediente $metadataExpediente): static
  212.     {
  213.         if ($this->metadataExpedientes->removeElement($metadataExpediente)) {
  214.             // set the owning side to null (unless already changed)
  215.             if ($metadataExpediente->getEntidad() === $this) {
  216.                 $metadataExpediente->setEntidad(null);
  217.             }
  218.         }
  220.         return $this;
  221.     }
  223.     /**
  224.      * @return Collection<int, SonataUserUser>
  225.      */
  226.     public function getSonataUserUsers(): Collection
  227.     {
  228.         return $this->sonataUserUsers;
  229.     }
  231.     public function addSonataUserUser(SonataUserUser $sonataUserUser): static
  232.     {
  233.         if (!$this->sonataUserUsers->contains($sonataUserUser)) {
  234.             $this->sonataUserUsers->add($sonataUserUser);
  235.             $sonataUserUser->setEntidad($this);
  236.         }
  238.         return $this;
  239.     }
  241.     public function removeSonataUserUser(SonataUserUser $sonataUserUser): static
  242.     {
  243.         if ($this->sonataUserUsers->removeElement($sonataUserUser)) {
  244.             // set the owning side to null (unless already changed)
  245.             if ($sonataUserUser->getEntidad() === $this) {
  246.                 $sonataUserUser->setEntidad(null);
  247.             }
  248.         }
  250.         return $this;
  251.     }
  253.     /**
  254.      * @return Collection<int, Calendario>
  255.      */
  256.     public function getCalendarios(): Collection
  257.     {
  258.         return $this->calendarios;
  259.     }
  261.     public function addCalendario(Calendario $calendario): static
  262.     {
  263.         if (!$this->calendarios->contains($calendario)) {
  264.             $this->calendarios->add($calendario);
  265.             $calendario->setEntidad($this);
  266.         }
  268.         return $this;
  269.     }
  271.     public function removeCalendario(Calendario $calendario): static
  272.     {
  273.         if ($this->calendarios->removeElement($calendario)) {
  274.             // set the owning side to null (unless already changed)
  275.             if ($calendario->getEntidad() === $this) {
  276.                 $calendario->setEntidad(null);
  277.             }
  278.         }
  280.         return $this;
  281.     }
  283.     /**
  284.      * @return Collection<int, Documentacion>
  285.      */
  286.     public function getDocumentacions(): Collection
  287.     {
  288.         return $this->documentacions;
  289.     }
  291.     public function addDocumentacion(Documentacion $documentacion): static
  292.     {
  293.         if (!$this->documentacions->contains($documentacion)) {
  294.             $this->documentacions->add($documentacion);
  295.             $documentacion->setEntidad($this);
  296.         }
  298.         return $this;
  299.     }
  301.     public function removeDocumentacion(Documentacion $documentacion): static
  302.     {
  303.         if ($this->documentacions->removeElement($documentacion)) {
  304.             // set the owning side to null (unless already changed)
  305.             if ($documentacion->getEntidad() === $this) {
  306.                 $documentacion->setEntidad(null);
  307.             }
  308.         }
  310.         return $this;
  311.     }
  313.     /**
  314.      * @return Collection<int, Interviniente>
  315.      */
  316.     public function getIntervinientes(): Collection
  317.     {
  318.         return $this->intervinientes;
  319.     }
  321.     public function addInterviniente(Interviniente $interviniente): static
  322.     {
  323.         if (!$this->intervinientes->contains($interviniente)) {
  324.             $this->intervinientes->add($interviniente);
  325.             $interviniente->setEntidad($this);
  326.         }
  328.         return $this;
  329.     }
  331.     public function removeInterviniente(Interviniente $interviniente): static
  332.     {
  333.         if ($this->intervinientes->removeElement($interviniente)) {
  334.             // set the owning side to null (unless already changed)
  335.             if ($interviniente->getEntidad() === $this) {
  336.                 $interviniente->setEntidad(null);
  337.             }
  338.         }
  340.         return $this;
  341.     }
  343.     /**
  344.      * @return Collection<int, Sede>
  345.      */
  346.     public function getSedes(): Collection
  347.     {
  348.         return $this->sedes;
  349.     }
  351.     public function addSede(Sede $sede): static
  352.     {
  353.         if (!$this->sedes->contains($sede)) {
  354.             $this->sedes->add($sede);
  355.             $sede->setEntidad($this);
  356.         }
  358.         return $this;
  359.     }
  361.     public function removeSede(Sede $sede): static
  362.     {
  363.         if ($this->sedes->removeElement($sede)) {
  364.             // set the owning side to null (unless already changed)
  365.             if ($sede->getEntidad() === $this) {
  366.                 $sede->setEntidad(null);
  367.             }
  368.         }
  370.         return $this;
  371.     }
  373.     /**
  374.      * @return Collection<int, MetadataCustomRegistro>
  375.      */
  376.     public function getMetadataCustomRegistros(): Collection
  377.     {
  378.         return $this->metadataCustomRegistros;
  379.     }
  381.     public function addMetadataCustomRegistro(MetadataCustomRegistro $metadataCustomRegistro): static
  382.     {
  383.         if (!$this->metadataCustomRegistros->contains($metadataCustomRegistro)) {
  384.             $this->metadataCustomRegistros->add($metadataCustomRegistro);
  385.             $metadataCustomRegistro->setEntidad($this);
  386.         }
  388.         return $this;
  389.     }
  391.     public function removeMetadataCustomRegistro(MetadataCustomRegistro $metadataCustomRegistro): static
  392.     {
  393.         if ($this->metadataCustomRegistros->removeElement($metadataCustomRegistro)) {
  394.             // set the owning side to null (unless already changed)
  395.             if ($metadataCustomRegistro->getEntidad() === $this) {
  396.                 $metadataCustomRegistro->setEntidad(null);
  397.             }
  398.         }
  400.         return $this;
  401.     }
  403.     /**
  404.      * @return Collection<int, MetadataExpediente>
  405.      */
  406.     public function getMetadataExpedientesEnabled(): Collection
  407.     {
  408.         return $this->metadataExpedientesEnabled;
  409.     }
  411.     public function addMetadataExpedientesEnabled(MetadataExpediente $metadataExpedientesEnabled): static
  412.     {
  413.         if (!$this->metadataExpedientesEnabled->contains($metadataExpedientesEnabled)) {
  414.             $this->metadataExpedientesEnabled->add($metadataExpedientesEnabled);
  415.         }
  417.         return $this;
  418.     }
  420.     public function removeMetadataExpedientesEnabled(MetadataExpediente $metadataExpedientesEnabled): static
  421.     {
  422.         $this->metadataExpedientesEnabled->removeElement($metadataExpedientesEnabled);
  424.         return $this;
  425.     }
  427.     /**
  428.      * @return Collection<int, MetadataCustomRegistro>
  429.      */
  430.     public function getMetadataCustomRegistrosEnabled(): Collection
  431.     {
  432.         return $this->metadataCustomRegistrosEnabled;
  433.     }
  435.     public function addMetadataCustomRegistrosEnabled(MetadataCustomRegistro $metadataCustomRegistrosEnabled): static
  436.     {
  437.         if (!$this->metadataCustomRegistrosEnabled->contains($metadataCustomRegistrosEnabled)) {
  438.             $this->metadataCustomRegistrosEnabled->add($metadataCustomRegistrosEnabled);
  439.         }
  441.         return $this;
  442.     }
  444.     public function removeMetadataCustomRegistrosEnabled(MetadataCustomRegistro $metadataCustomRegistrosEnabled): static
  445.     {
  446.         $this->metadataCustomRegistrosEnabled->removeElement($metadataCustomRegistrosEnabled);
  448.         return $this;
  449.     }
  451.     public function getDni()
  452.     {
  453.         return $this->dni;
  454.     }
  456.     public function setDni($dni): static
  457.     {
  458.         $this->dni = $dni;
  460.         return $this;
  461.     }
  462. }