src/Domain/Entity/Expediente.php line 15

Open in your IDE?
  1. <?php
  3. namespace App\Domain\Entity;
  5. use App\Domain\Enum\TipoProcedimientoTramiteEnum;
  6. use App\Shared\Domain\ApplicationCore\Interfaces\EntityInterface;
  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;
  13. use Symfony\Component\Validator\Constraints as Assert;
  15. class Expediente implements EntityInterface
  16. {
  17.     private ?Uuid $id = null;
  19.     private ?string $key = null;
  21.     private ?string $nombre = null;
  23.     /**
  24.      * @var string|null
  25.      * @Assert\NotBlank(message="not_blank", groups={"explicit_check"})
  26.      *
  27.      * FIX-260518-101: el constraint queda en el grupo "explicit_check"
  28.      * en lugar de Default, para que el flujo Sonata create no lo dispare
  29.      * antes del flush. postPersist (GenerateNumExpCommandHandler) genera
  30.      * el numero despues del persist. Quien necesite exigir el numero
  31.      * (API, console, batch) debe validar pasando explicitamente
  32.      * ['explicit_check'] al ValidatorInterface.
  33.      */
  34.     private ?string $numeroExpediente = null;
  36.     private ?string $descripcion = null;
  38.     private ?DateTimeInterface $createdAt = null;
  40.     private ?DateTimeInterface $updatedAt = null;
  42.     private ?DateTimeInterface $deletedAt = null;
  44.     private ?EstadoExpediente $estadoExpediente = null;
  46.     private ?ExpedienteCabecera $cabecera = null;
  48.     /**
  49.      * @var MetadataExpediente|null
  50.      * @Assert\NotBlank(message="not_blank")
  51.      */
  52.     private ?MetadataExpediente $metadata = null;
  54.     private ?SonataUserUser $creador = null;
  56.     private ?Entidad $entidad = null;
  58.     private ?DocumentacionRegistro $solicitud = null;
  60.     private Collection $tramites;
  62.     private Collection $minutas;
  64.     private Collection $responsables;
  66.     private Collection $registros;
  68.     private Collection $representacions;
  70.     public function __construct()
  71.     {
  72.         $this->tramites = new ArrayCollection();
  73.         $this->minutas = new ArrayCollection();
  74.         $this->responsables = new ArrayCollection();
  75.         $this->registros = new ArrayCollection();
  76.         $this->representacions = new ArrayCollection();
  77.     }
  79.     public function __toString(): string
  80.     {
  81.         return $this->getNumeroExpediente()??'X/0000/2024';
  82.     }
  84.     public function getKey(): ?string
  85.     {
  86.         return $this->key;
  87.     }
  89.     public function setKey(?string $key): static
  90.     {
  91.         $this->key = $key;
  93.         return $this;
  94.     }
  96.     public function getNumeroExpediente(): ?string
  97.     {
  98.         return $this->numeroExpediente;
  99.     }
  101.     public function setNumeroExpediente(?string $numeroExpediente): static
  102.     {
  103.         $this->numeroExpediente = $numeroExpediente;
  105.         return $this;
  106.     }
  108.     public function getNombre(): ?string
  109.     {
  110.         return $this->nombre;
  111.     }
  113.     public function setNombre(?string $nombre): static
  114.     {
  115.         $this->nombre = $nombre;
  117.         return $this;
  118.     }
  120.     public function getDescripcion(): ?string
  121.     {
  122.         return $this->descripcion;
  123.     }
  125.     public function setDescripcion(?string $descripcion): static
  126.     {
  127.         $this->descripcion = $descripcion;
  129.         return $this;
  130.     }
  132.     public function getCreatedAt(): ?\DateTimeInterface
  133.     {
  134.         return $this->createdAt;
  135.     }
  137.     public function setCreatedAt(\DateTimeInterface $createdAt): static
  138.     {
  139.         $this->createdAt = $createdAt;
  141.         return $this;
  142.     }
  144.     public function getUpdatedAt(): ?\DateTimeInterface
  145.     {
  146.         return $this->updatedAt;
  147.     }
  149.     public function setUpdatedAt(\DateTimeInterface $updatedAt): static
  150.     {
  151.         $this->updatedAt = $updatedAt;
  153.         return $this;
  154.     }
  156.     public function getDeletedAt(): ?\DateTimeInterface
  157.     {
  158.         return $this->deletedAt;
  159.     }
  161.     public function setDeletedAt(?\DateTimeInterface $deletedAt): static
  162.     {
  163.         $this->deletedAt = $deletedAt;
  165.         return $this;
  166.     }
  168.     public function getId(): ?Uuid
  169.     {
  170.         return $this->id;
  171.     }
  173.     /**
  174.      * @return Collection<int, Tramite>
  175.      */
  176.     public function getTramites(): Collection
  177.     {
  178.         return $this->tramites;
  179.     }
  181.     public function addTramite(Tramite $tramite): static
  182.     {
  183.         if (!$this->tramites->contains($tramite)) {
  184.             $this->tramites->add($tramite);
  185.             $tramite->setExpediente($this);
  186.         }
  188.         return $this;
  189.     }
  191.     public function removeTramite(Tramite $tramite): static
  192.     {
  193.         if ($this->tramites->removeElement($tramite)) {
  194.             // set the owning side to null (unless already changed)
  195.             if ($tramite->getExpediente() === $this) {
  196.                 $tramite->setExpediente(null);
  197.             }
  198.         }
  200.         return $this;
  201.     }
  203.     /**
  204.      * @return Collection<int, Minuta>
  205.      */
  206.     public function getMinutas(): Collection
  207.     {
  208.         return $this->minutas;
  209.     }
  211.     public function addMinuta(Minuta $minuta): static
  212.     {
  213.         if (!$this->minutas->contains($minuta)) {
  214.             $this->minutas->add($minuta);
  215.             $minuta->setExpediente($this);
  216.         }
  218.         return $this;
  219.     }
  221.     public function removeMinuta(Minuta $minuta): static
  222.     {
  223.         if ($this->minutas->removeElement($minuta)) {
  224.             // set the owning side to null (unless already changed)
  225.             if ($minuta->getExpediente() === $this) {
  226.                 $minuta->setExpediente(null);
  227.             }
  228.         }
  230.         return $this;
  231.     }
  233.     public function getEstadoExpediente(): ?EstadoExpediente
  234.     {
  235.         return $this->estadoExpediente;
  236.     }
  238.     public function setEstadoExpediente(?EstadoExpediente $estadoExpediente): static
  239.     {
  240.         $this->estadoExpediente = $estadoExpediente;
  242.         return $this;
  243.     }
  245.     public function getMetadata(): ?MetadataExpediente
  246.     {
  247.         return $this->metadata;
  248.     }
  250.     public function setMetadata(?MetadataExpediente $metadata): static
  251.     {
  252.         $this->metadata = $metadata;
  254.         return $this;
  255.     }
  257.     public function getCreador(): ?SonataUserUser
  258.     {
  259.         return $this->creador;
  260.     }
  262.     public function setCreador(?SonataUserUser $creador): static
  263.     {
  264.         $this->creador = $creador;
  266.         return $this;
  267.     }
  269.     public function getEntidad(): ?Entidad
  270.     {
  271.         return $this->entidad;
  272.     }
  274.     public function setEntidad(?Entidad $entidad): static
  275.     {
  276.         $this->entidad = $entidad;
  278.         return $this;
  279.     }
  281.     /**
  282.      * @return Collection<int, SonataUserUser>
  283.      */
  284.     public function getResponsables(): Collection
  285.     {
  286.         return $this->responsables;
  287.     }
  289.     public function addResponsable(SonataUserUser $responsable): static
  290.     {
  291.         if (!$this->responsables->contains($responsable)) {
  292.             $this->responsables->add($responsable);
  293.         }
  295.         return $this;
  296.     }
  298.     public function removeResponsable(SonataUserUser $responsable): static
  299.     {
  300.         $this->responsables->removeElement($responsable);
  302.         return $this;
  303.     }
  305.     public function getCabecera(): ?ExpedienteCabecera
  306.     {
  307.         return $this->cabecera;
  308.     }
  310.     public function setCabecera(?ExpedienteCabecera $cabecera): static
  311.     {
  312.         $this->cabecera = $cabecera;
  314.         return $this;
  315.     }
  317.     public function getTipo(): ?string
  318.     {
  319.         switch ($this->getTramites()?->last()->getProcedimiento())
  320.         {
  321.             case TipoProcedimientoTramiteEnum::PROCEDIMIENTO_EC:
  322.                  $return = 'EC';
  323.                 break;
  324.             case TipoProcedimientoTramiteEnum::PROCEDIMIENTO_M:
  325.                 $return = 'M';
  326.                 break;
  327.             case TipoProcedimientoTramiteEnum::PROCEDIMIENTO_C:
  328.                 $return = 'C';
  329.                 break;
  330.             case TipoProcedimientoTramiteEnum::PROCEDIMIENTO_A:
  331.                 $return = 'A';
  332.                 break;
  333.             default:
  334.                 $return = null;
  335.                 break;
  336.         }
  338.         return $return;
  339.     }
  341.     public function getEmpresa(): ?string
  342.     {
  343.         $data = json_decode($this->getCustom(), true);
  344.         switch ($data['entidad'])
  345.         {
  346.             case 'EMPRESA':
  347.             case '0':
  348.                 $tipo = 'E';
  349.                 break;
  350.             case 'SECTOR':
  351.             case '1':
  352.                 $tipo = 'S';
  353.                 break;
  354.             default:
  355.                 $tipo = '---';
  356.                 break;
  357.         }
  359.         return $tipo;
  360.     }
  362.     public function getEmpresaNombre(): ?string
  363.     {
  364.         $data = json_decode($this->getCustom(), true);
  365.         switch ($data['entidad'])
  366.         {
  367.             case 'EMPRESA':
  368.             case '0':
  369.                 $id = $data['empresa'];
  370.                 break;
  371.             case 'SECTOR':
  372.             case '1':
  373.                 $id = $data['sector'];
  374.                 break;
  375.             default:
  376.                 $id = null;
  377.                 break;
  378.         }
  380.         return $id;
  381.     }
  383.     /**
  384.      * @return Collection<int, DocumentacionRegistro>
  385.      */
  386.     public function getRegistros(): Collection
  387.     {
  388.         return $this->registros;
  389.     }
  391.     public function addRegistro(DocumentacionRegistro $registro): static
  392.     {
  393.         if (!$this->registros->contains($registro)) {
  394.             $this->registros->add($registro);
  395.             $registro->setExpediente($this);
  396.         }
  398.         return $this;
  399.     }
  401.     public function removeRegistro(DocumentacionRegistro $registro): static
  402.     {
  403.         if ($this->registros->removeElement($registro)) {
  404.             // set the owning side to null (unless already changed)
  405.             if ($registro->getExpediente() === $this) {
  406.                 $registro->setExpediente(null);
  407.             }
  408.         }
  410.         return $this;
  411.     }
  413.     public function getFase():?string
  414.     {
  415.         return $this->getEstadoExpediente()?->getSubestado();
  416.     }
  418.     public function getSubFase():?string
  419.     {
  420.         return $this->getTramites()?->last()->getNombre();
  421.     }
  423.     public function getSolicitud(): ?DocumentacionRegistro
  424.     {
  425.         return $this->solicitud;
  426.     }
  428.     public function setSolicitud(?DocumentacionRegistro $solicitud): static
  429.     {
  430.         $this->solicitud = $solicitud;
  432.         return $this;
  433.     }
  435.     public function getCustom():?string
  436.     {
  437.         return $this->getSolicitud()?->getCustom()->getForm();
  438.     }
  440.     /**
  441.      * @return Collection<int, Representacion>
  442.      */
  443.     public function getRepresentacions(): Collection
  444.     {
  445.         return $this->representacions;
  446.     }
  448.     public function addRepresentacion(Representacion $representacion): static
  449.     {
  450.         if (!$this->representacions->contains($representacion)) {
  451.             $this->representacions->add($representacion);
  452.             $representacion->setExpediente($this);
  453.         }
  455.         return $this;
  456.     }
  458.     public function removeRepresentacion(Representacion $representacion): static
  459.     {
  460.         if ($this->representacions->removeElement($representacion)) {
  461.             // set the owning side to null (unless already changed)
  462.             if ($representacion->getExpediente() === $this) {
  463.                 $representacion->setExpediente(null);
  464.             }
  465.         }
  467.         return $this;
  468.     }
  469. }