src/Domain/Entity/MetadataExpediente.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Domain\Entity;
  5. use App\Shared\Domain\ApplicationCore\Interfaces\EntityInterface;
  6. use DateTime;
  7. use DateTimeInterface;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\DBAL\Types\Types;
  11. use Doctrine\ORM\Mapping as ORM;
  12. use Symfony\Component\Uid\Uuid;
  14. class MetadataExpediente implements EntityInterface
  15. {
  16.     private ?string $key = null;
  18.     private ?string $nombre = null;
  20.     private ?string $descripcion = null;
  22.     private ?DateTimeInterface $createdAt = null;
  24.     private ?DateTimeInterface $updatedAt = null;
  26.     private ?Uuid $id = null;
  28.     private ?Entidad $entidad = null;
  30.     private Collection $expedientes;
  32.     private Collection $metadataTramites ;
  34.     private Collection $responsables;
  36.     private ?EstadoExpediente $estadoInicial = null;
  38.     private ?EstadoExpediente $estadoFinal = null;
  40.     private Collection $estadoDisponibles;
  42.     private ?DateTimeInterface $deletedAt = null;
  44.     private Collection $estados;
  46.     private ?MetadataExpedienteCabecera $metadataCabecera = null;
  48.     private Collection $entidades;
  50.     public function __construct()
  51.     {
  52.         $this->metadataCabecera = new MetadataExpedienteCabecera();
  53.         $this->expedientes = new ArrayCollection();
  54.         $this->metadataTramites = new ArrayCollection();
  55.         $this->responsables = new ArrayCollection();
  56.         $this->estadoDisponibles = new ArrayCollection();
  57.         $this->estados = new ArrayCollection();
  58.         $this->entidades = new ArrayCollection();
  59.     }
  61.     public function __toString(): string
  62.     {
  63.         return $this->getNombre()??$this->getKey()??'';
  64.     }
  66.     public function getKey(): ?string
  67.     {
  68.         return $this->key;
  69.     }
  71.     public function setKey(string $key): static
  72.     {
  73.         $this->key = $key;
  75.         return $this;
  76.     }
  78.     public function getCreatedAt(): ?DateTimeInterface
  79.     {
  80.         return $this->createdAt;
  81.     }
  83.     public function setCreatedAt(?DateTimeInterface $createdAt): static
  84.     {
  85.         $this->createdAt = $createdAt;
  87.         return $this;
  88.     }
  90.     public function getUpdatedAt(): ?DateTimeInterface
  91.     {
  92.         return $this->updatedAt;
  93.     }
  95.     public function setUpdatedAt(?DateTimeInterface $updatedAt): static
  96.     {
  97.         $this->updatedAt = $updatedAt;
  99.         return $this;
  100.     }
  102.     public function getId(): ?Uuid
  103.     {
  104.         return $this->id;
  105.     }
  107.     /**
  108.      * @return Collection<int, Expediente>
  109.      */
  110.     public function getExpedientes(): Collection
  111.     {
  112.         return $this->expedientes;
  113.     }
  115.     public function addExpediente(Expediente $expediente): static
  116.     {
  117.         if (!$this->expedientes->contains($expediente)) {
  118.             $this->expedientes->add($expediente);
  119.             $expediente->setMetadata($this);
  120.         }
  122.         return $this;
  123.     }
  125.     public function removeExpediente(Expediente $expediente): static
  126.     {
  127.         if ($this->expedientes->removeElement($expediente)) {
  128.             // set the owning side to null (unless already changed)
  129.             if ($expediente->getMetadata() === $this) {
  130.                 $expediente->setMetadata(null);
  131.             }
  132.         }
  134.         return $this;
  135.     }
  137.     /**
  138.      * @return Collection<int, MetadataTramite>
  139.      */
  140.     public function getMetadataTramites(): Collection
  141.     {
  142.         return $this->metadataTramites;
  143.     }
  145.     public function addMetadataTramite(MetadataTramite $metadataTramite): static
  146.     {
  147.         if (!$this->metadataTramites->contains($metadataTramite)) {
  148.             $this->metadataTramites->add($metadataTramite);
  149.             $metadataTramite->setMetadataExpediente($this);
  150.         }
  152.         return $this;
  153.     }
  155.     public function removeMetadataTramite(MetadataTramite $metadataTramite): static
  156.     {
  157.         if ($this->metadataTramites->removeElement($metadataTramite)) {
  158.             // set the owning side to null (unless already changed)
  159.             if ($metadataTramite->getMetadataExpediente() === $this) {
  160.                 $metadataTramite->setMetadataExpediente(null);
  161.             }
  162.         }
  164.         return $this;
  165.     }
  167.     public function getNombre(): ?string
  168.     {
  169.         return $this->nombre;
  170.     }
  172.     public function setNombre(?string $nombre): static
  173.     {
  174.         $this->nombre = $nombre;
  176.         return $this;
  177.     }
  179.     public function getDescripcion(): ?string
  180.     {
  181.         return $this->descripcion;
  182.     }
  184.     public function setDescripcion(?string $descripcion): static
  185.     {
  186.         $this->descripcion = $descripcion;
  188.         return $this;
  189.     }
  191.     /**
  192.      * @return Collection<int, SonataUserUser>
  193.      */
  194.     public function getResponsables(): Collection
  195.     {
  196.         return $this->responsables;
  197.     }
  199.     public function addResponsable(SonataUserUser $responsable): static
  200.     {
  201.         if (!$this->responsables->contains($responsable)) {
  202.             $this->responsables->add($responsable);
  203.         }
  205.         return $this;
  206.     }
  208.     public function removeResponsable(SonataUserUser $responsable): static
  209.     {
  210.         $this->responsables->removeElement($responsable);
  212.         return $this;
  213.     }
  215.     public function getEstadoInicial(): ?EstadoExpediente
  216.     {
  217.         return $this->estadoInicial;
  218.     }
  220.     public function setEstadoInicial(?EstadoExpediente $estadoInicial): static
  221.     {
  222.         $this->estadoInicial = $estadoInicial;
  224.         return $this;
  225.     }
  227.     public function getEstadoFinal(): ?EstadoExpediente
  228.     {
  229.         return $this->estadoFinal;
  230.     }
  232.     public function setEstadoFinal(?EstadoExpediente $estadoFinal): static
  233.     {
  234.         $this->estadoFinal = $estadoFinal;
  236.         return $this;
  237.     }
  239.     /**
  240.      * @return Collection<int, EstadoExpediente>
  241.      */
  242.     public function getEstadoDisponibles(): Collection
  243.     {
  244.         return $this->estadoDisponibles;
  245.     }
  247.     public function addEstadoDisponible(EstadoExpediente $estadoDisponible): static
  248.     {
  249.         if (!$this->estadoDisponibles->contains($estadoDisponible)) {
  250.             $this->estadoDisponibles->add($estadoDisponible);
  251.         }
  253.         return $this;
  254.     }
  256.     public function removeEstadoDisponible(EstadoExpediente $estadoDisponible): static
  257.     {
  258.         $this->estadoDisponibles->removeElement($estadoDisponible);
  260.         return $this;
  261.     }
  263.     public function getDeletedAt(): ?DateTimeInterface
  264.     {
  265.         return $this->deletedAt;
  266.     }
  268.     public function setDeletedAt(?DateTimeInterface $deletedAt): static
  269.     {
  270.         $this->deletedAt = $deletedAt;
  272.         return $this;
  273.     }
  275.     /**
  276.      * @return Collection<int, Estado>
  277.      */
  278.     public function getEstados(): Collection
  279.     {
  280.         return $this->estados;
  281.     }
  283.     public function addEstado(Estado $estado): static
  284.     {
  285.         if (!$this->estados->contains($estado)) {
  286.             $this->estados->add($estado);
  287.         }
  289.         return $this;
  290.     }
  292.     public function removeEstado(Estado $estado): static
  293.     {
  294.         $this->estados->removeElement($estado);
  296.         return $this;
  297.     }
  299.     public function getEntidad(): ?Entidad
  300.     {
  301.         return $this->entidad;
  302.     }
  304.     public function setEntidad(?Entidad $entidad): static
  305.     {
  306.         $this->entidad = $entidad;
  308.         return $this;
  309.     }
  311.     public function getMetadataCabecera(): ?MetadataExpedienteCabecera
  312.     {
  313.         return $this->metadataCabecera;
  314.     }
  316.     public function setMetadataCabecera(?MetadataExpedienteCabecera $metadataCabecera): static
  317.     {
  318.         $this->metadataCabecera = $metadataCabecera;
  320.         return $this;
  321.     }
  323.     /**
  324.      * @return Collection<int, Entidad>
  325.      */
  326.     public function getEntidades(): Collection
  327.     {
  328.         return $this->entidades;
  329.     }
  331.     public function addEntidade(Entidad $entidade): static
  332.     {
  333.         if (!$this->entidades->contains($entidade)) {
  334.             $this->entidades->add($entidade);
  335.             $entidade->addMetadataExpedientesEnabled($this);
  336.         }
  338.         return $this;
  339.     }
  341.     public function removeEntidade(Entidad $entidade): static
  342.     {
  343.         if ($this->entidades->removeElement($entidade)) {
  344.             $entidade->removeMetadataExpedientesEnabled($this);
  345.         }
  347.         return $this;
  348.     }
  349. }