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")
  26.      */
  27.     private ?string $numeroExpediente = null;
  29.     private ?string $descripcion = null;
  31.     private ?DateTimeInterface $createdAt = null;
  33.     private ?DateTimeInterface $updatedAt = null;
  35.     private ?DateTimeInterface $deletedAt = null;
  37.     private ?EstadoExpediente $estadoExpediente = null;
  39.     private ?ExpedienteCabecera $cabecera = null;
  41.     /**
  42.      * @var MetadataExpediente|null
  43.      * @Assert\NotBlank(message="not_blank")
  44.      */
  45.     private ?MetadataExpediente $metadata = null;
  47.     private ?SonataUserUser $creador = null;
  49.     private ?Entidad $entidad = null;
  51.     private ?DocumentacionRegistro $solicitud = null;
  53.     private Collection $tramites;
  55.     private Collection $minutas;
  57.     private Collection $responsables;
  59.     private Collection $registros;
  61.     private Collection $representacions;
  63.     public function __construct()
  64.     {
  65.         $this->tramites = new ArrayCollection();
  66.         $this->minutas = new ArrayCollection();
  67.         $this->responsables = new ArrayCollection();
  68.         $this->registros = new ArrayCollection();
  69.         $this->representacions = new ArrayCollection();
  70.     }
  72.     public function __toString(): string
  73.     {
  74.         return $this->getNumeroExpediente()??'X/0000/2024';
  75.     }
  77.     public function getKey(): ?string
  78.     {
  79.         return $this->key;
  80.     }
  82.     public function setKey(?string $key): static
  83.     {
  84.         $this->key = $key;
  86.         return $this;
  87.     }
  89.     public function getNumeroExpediente(): ?string
  90.     {
  91.         return $this->numeroExpediente;
  92.     }
  94.     public function setNumeroExpediente(?string $numeroExpediente): static
  95.     {
  96.         $this->numeroExpediente = $numeroExpediente;
  98.         return $this;
  99.     }
  101.     public function getNombre(): ?string
  102.     {
  103.         return $this->nombre;
  104.     }
  106.     public function setNombre(?string $nombre): static
  107.     {
  108.         $this->nombre = $nombre;
  110.         return $this;
  111.     }
  113.     public function getDescripcion(): ?string
  114.     {
  115.         return $this->descripcion;
  116.     }
  118.     public function setDescripcion(?string $descripcion): static
  119.     {
  120.         $this->descripcion = $descripcion;
  122.         return $this;
  123.     }
  125.     public function getCreatedAt(): ?\DateTimeInterface
  126.     {
  127.         return $this->createdAt;
  128.     }
  130.     public function setCreatedAt(\DateTimeInterface $createdAt): static
  131.     {
  132.         $this->createdAt = $createdAt;
  134.         return $this;
  135.     }
  137.     public function getUpdatedAt(): ?\DateTimeInterface
  138.     {
  139.         return $this->updatedAt;
  140.     }
  142.     public function setUpdatedAt(\DateTimeInterface $updatedAt): static
  143.     {
  144.         $this->updatedAt = $updatedAt;
  146.         return $this;
  147.     }
  149.     public function getDeletedAt(): ?\DateTimeInterface
  150.     {
  151.         return $this->deletedAt;
  152.     }
  154.     public function setDeletedAt(?\DateTimeInterface $deletedAt): static
  155.     {
  156.         $this->deletedAt = $deletedAt;
  158.         return $this;
  159.     }
  161.     public function getId(): ?Uuid
  162.     {
  163.         return $this->id;
  164.     }
  166.     /**
  167.      * @return Collection<int, Tramite>
  168.      */
  169.     public function getTramites(): Collection
  170.     {
  171.         return $this->tramites;
  172.     }
  174.     public function addTramite(Tramite $tramite): static
  175.     {
  176.         if (!$this->tramites->contains($tramite)) {
  177.             $this->tramites->add($tramite);
  178.             $tramite->setExpediente($this);
  179.         }
  181.         return $this;
  182.     }
  184.     public function removeTramite(Tramite $tramite): static
  185.     {
  186.         if ($this->tramites->removeElement($tramite)) {
  187.             // set the owning side to null (unless already changed)
  188.             if ($tramite->getExpediente() === $this) {
  189.                 $tramite->setExpediente(null);
  190.             }
  191.         }
  193.         return $this;
  194.     }
  196.     /**
  197.      * @return Collection<int, Minuta>
  198.      */
  199.     public function getMinutas(): Collection
  200.     {
  201.         return $this->minutas;
  202.     }
  204.     public function addMinuta(Minuta $minuta): static
  205.     {
  206.         if (!$this->minutas->contains($minuta)) {
  207.             $this->minutas->add($minuta);
  208.             $minuta->setExpediente($this);
  209.         }
  211.         return $this;
  212.     }
  214.     public function removeMinuta(Minuta $minuta): static
  215.     {
  216.         if ($this->minutas->removeElement($minuta)) {
  217.             // set the owning side to null (unless already changed)
  218.             if ($minuta->getExpediente() === $this) {
  219.                 $minuta->setExpediente(null);
  220.             }
  221.         }
  223.         return $this;
  224.     }
  226.     public function getEstadoExpediente(): ?EstadoExpediente
  227.     {
  228.         return $this->estadoExpediente;
  229.     }
  231.     public function setEstadoExpediente(?EstadoExpediente $estadoExpediente): static
  232.     {
  233.         $this->estadoExpediente = $estadoExpediente;
  235.         return $this;
  236.     }
  238.     public function getMetadata(): ?MetadataExpediente
  239.     {
  240.         return $this->metadata;
  241.     }
  243.     public function setMetadata(?MetadataExpediente $metadata): static
  244.     {
  245.         $this->metadata = $metadata;
  247.         return $this;
  248.     }
  250.     public function getCreador(): ?SonataUserUser
  251.     {
  252.         return $this->creador;
  253.     }
  255.     public function setCreador(?SonataUserUser $creador): static
  256.     {
  257.         $this->creador = $creador;
  259.         return $this;
  260.     }
  262.     public function getEntidad(): ?Entidad
  263.     {
  264.         return $this->entidad;
  265.     }
  267.     public function setEntidad(?Entidad $entidad): static
  268.     {
  269.         $this->entidad = $entidad;
  271.         return $this;
  272.     }
  274.     /**
  275.      * @return Collection<int, SonataUserUser>
  276.      */
  277.     public function getResponsables(): Collection
  278.     {
  279.         return $this->responsables;
  280.     }
  282.     public function addResponsable(SonataUserUser $responsable): static
  283.     {
  284.         if (!$this->responsables->contains($responsable)) {
  285.             $this->responsables->add($responsable);
  286.         }
  288.         return $this;
  289.     }
  291.     public function removeResponsable(SonataUserUser $responsable): static
  292.     {
  293.         $this->responsables->removeElement($responsable);
  295.         return $this;
  296.     }
  298.     public function getCabecera(): ?ExpedienteCabecera
  299.     {
  300.         return $this->cabecera;
  301.     }
  303.     public function setCabecera(?ExpedienteCabecera $cabecera): static
  304.     {
  305.         $this->cabecera = $cabecera;
  307.         return $this;
  308.     }
  310.     public function getTipo(): ?string
  311.     {
  312.         switch ($this->getTramites()?->last()->getProcedimiento())
  313.         {
  314.             case TipoProcedimientoTramiteEnum::PROCEDIMIENTO_EC:
  315.                  $return = 'EC';
  316.                 break;
  317.             case TipoProcedimientoTramiteEnum::PROCEDIMIENTO_M:
  318.                 $return = 'M';
  319.                 break;
  320.             case TipoProcedimientoTramiteEnum::PROCEDIMIENTO_C:
  321.                 $return = 'C';
  322.                 break;
  323.             case TipoProcedimientoTramiteEnum::PROCEDIMIENTO_A:
  324.                 $return = 'A';
  325.                 break;
  326.             default:
  327.                 $return = null;
  328.                 break;
  329.         }
  331.         return $return;
  332.     }
  334.     public function getEmpresa(): ?string
  335.     {
  336.         $data = json_decode($this->getCustom(), true);
  337.         switch ($data['entidad'])
  338.         {
  339.             case 'EMPRESA':
  340.             case '0':
  341.                 $tipo = 'E';
  342.                 break;
  343.             case 'SECTOR':
  344.             case '1':
  345.                 $tipo = 'S';
  346.                 break;
  347.             default:
  348.                 $tipo = '---';
  349.                 break;
  350.         }
  352.         return $tipo;
  353.     }
  355.     public function getEmpresaNombre(): ?string
  356.     {
  357.         $data = json_decode($this->getCustom(), true);
  358.         switch ($data['entidad'])
  359.         {
  360.             case 'EMPRESA':
  361.             case '0':
  362.                 $id = $data['empresa'];
  363.                 break;
  364.             case 'SECTOR':
  365.             case '1':
  366.                 $id = $data['sector'];
  367.                 break;
  368.             default:
  369.                 $id = null;
  370.                 break;
  371.         }
  373.         return $id;
  374.     }
  376.     /**
  377.      * @return Collection<int, DocumentacionRegistro>
  378.      */
  379.     public function getRegistros(): Collection
  380.     {
  381.         return $this->registros;
  382.     }
  384.     public function addRegistro(DocumentacionRegistro $registro): static
  385.     {
  386.         if (!$this->registros->contains($registro)) {
  387.             $this->registros->add($registro);
  388.             $registro->setExpediente($this);
  389.         }
  391.         return $this;
  392.     }
  394.     public function removeRegistro(DocumentacionRegistro $registro): static
  395.     {
  396.         if ($this->registros->removeElement($registro)) {
  397.             // set the owning side to null (unless already changed)
  398.             if ($registro->getExpediente() === $this) {
  399.                 $registro->setExpediente(null);
  400.             }
  401.         }
  403.         return $this;
  404.     }
  406.     public function getFase():?string
  407.     {
  408.         return $this->getEstadoExpediente()?->getSubestado();
  409.     }
  411.     public function getSubFase():?string
  412.     {
  413.         return $this->getTramites()?->last()->getNombre();
  414.     }
  416.     public function getSolicitud(): ?DocumentacionRegistro
  417.     {
  418.         return $this->solicitud;
  419.     }
  421.     public function setSolicitud(?DocumentacionRegistro $solicitud): static
  422.     {
  423.         $this->solicitud = $solicitud;
  425.         return $this;
  426.     }
  428.     public function getCustom():?string
  429.     {
  430.         return $this->getSolicitud()?->getCustom()->getForm();
  431.     }
  433.     /**
  434.      * @return Collection<int, Representacion>
  435.      */
  436.     public function getRepresentacions(): Collection
  437.     {
  438.         return $this->representacions;
  439.     }
  441.     public function addRepresentacion(Representacion $representacion): static
  442.     {
  443.         if (!$this->representacions->contains($representacion)) {
  444.             $this->representacions->add($representacion);
  445.             $representacion->setExpediente($this);
  446.         }
  448.         return $this;
  449.     }
  451.     public function removeRepresentacion(Representacion $representacion): static
  452.     {
  453.         if ($this->representacions->removeElement($representacion)) {
  454.             // set the owning side to null (unless already changed)
  455.             if ($representacion->getExpediente() === $this) {
  456.                 $representacion->setExpediente(null);
  457.             }
  458.         }
  460.         return $this;
  461.     }
  462. }