src/Domain/Entity/Expediente.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Domain\Entity;
  5. use App\Shared\Domain\ApplicationCore\Interfaces\EntityInterface;
  6. use DateTimeInterface;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Component\Uid\Uuid;
  12. use Symfony\Component\Validator\Constraints as Assert;
  14. class Expediente implements EntityInterface
  15. {
  16.     private ?Uuid $id = null;
  18.     private ?string $key = null;
  20.     private ?string $nombre = null;
  22.     /**
  23.      * @var string|null
  24.      * @Assert\NotBlank(message="not_blank")
  25.      */
  26.     private ?string $numeroExpediente = null;
  28.     private ?string $descripcion = null;
  30.     private ?DateTimeInterface $createdAt = null;
  32.     private ?DateTimeInterface $updatedAt = null;
  34.     private ?DateTimeInterface $deletedAt = null;
  36.     private ?EstadoExpediente $estadoExpediente = null;
  38.     private ?ExpedienteCabecera $cabecera = null;
  40.     /**
  41.      * @var MetadataExpediente|null
  42.      * @Assert\NotBlank(message="not_blank")
  43.      */
  44.     private ?MetadataExpediente $metadata = null;
  46.     private ?SonataUserUser $creador = null;
  48.     private ?Entidad $entidad = null;
  50.     private ?DocumentacionRegistro $solicitud = null;
  52.     private Collection $tramites;
  54.     private Collection $minutas;
  56.     private Collection $responsables;
  58.     private Collection $registros;
  60.     public function __construct()
  61.     {
  62.         $this->tramites = new ArrayCollection();
  63.         $this->minutas = new ArrayCollection();
  64.         $this->responsables = new ArrayCollection();
  65.         $this->registros = new ArrayCollection();
  66.     }
  68.     public function __toString(): string
  69.     {
  70.         return $this->getNumeroExpediente()??'X/0000/2024';
  71.     }
  73.     public function getKey(): ?string
  74.     {
  75.         return $this->key;
  76.     }
  78.     public function setKey(?string $key): static
  79.     {
  80.         $this->key = $key;
  82.         return $this;
  83.     }
  85.     public function getNumeroExpediente(): ?string
  86.     {
  87.         return $this->numeroExpediente;
  88.     }
  90.     public function setNumeroExpediente(?string $numeroExpediente): static
  91.     {
  92.         $this->numeroExpediente = $numeroExpediente;
  94.         return $this;
  95.     }
  97.     public function getNombre(): ?string
  98.     {
  99.         return $this->nombre;
  100.     }
  102.     public function setNombre(?string $nombre): static
  103.     {
  104.         $this->nombre = $nombre;
  106.         return $this;
  107.     }
  109.     public function getDescripcion(): ?string
  110.     {
  111.         return $this->descripcion;
  112.     }
  114.     public function setDescripcion(?string $descripcion): static
  115.     {
  116.         $this->descripcion = $descripcion;
  118.         return $this;
  119.     }
  121.     public function getCreatedAt(): ?\DateTimeInterface
  122.     {
  123.         return $this->createdAt;
  124.     }
  126.     public function setCreatedAt(\DateTimeInterface $createdAt): static
  127.     {
  128.         $this->createdAt = $createdAt;
  130.         return $this;
  131.     }
  133.     public function getUpdatedAt(): ?\DateTimeInterface
  134.     {
  135.         return $this->updatedAt;
  136.     }
  138.     public function setUpdatedAt(\DateTimeInterface $updatedAt): static
  139.     {
  140.         $this->updatedAt = $updatedAt;
  142.         return $this;
  143.     }
  145.     public function getDeletedAt(): ?\DateTimeInterface
  146.     {
  147.         return $this->deletedAt;
  148.     }
  150.     public function setDeletedAt(?\DateTimeInterface $deletedAt): static
  151.     {
  152.         $this->deletedAt = $deletedAt;
  154.         return $this;
  155.     }
  157.     public function getId(): ?Uuid
  158.     {
  159.         return $this->id;
  160.     }
  162.     /**
  163.      * @return Collection<int, Tramite>
  164.      */
  165.     public function getTramites(): Collection
  166.     {
  167.         return $this->tramites;
  168.     }
  170.     public function addTramite(Tramite $tramite): static
  171.     {
  172.         if (!$this->tramites->contains($tramite)) {
  173.             $this->tramites->add($tramite);
  174.             $tramite->setExpediente($this);
  175.         }
  177.         return $this;
  178.     }
  180.     public function removeTramite(Tramite $tramite): static
  181.     {
  182.         if ($this->tramites->removeElement($tramite)) {
  183.             // set the owning side to null (unless already changed)
  184.             if ($tramite->getExpediente() === $this) {
  185.                 $tramite->setExpediente(null);
  186.             }
  187.         }
  189.         return $this;
  190.     }
  192.     /**
  193.      * @return Collection<int, Minuta>
  194.      */
  195.     public function getMinutas(): Collection
  196.     {
  197.         return $this->minutas;
  198.     }
  200.     public function addMinuta(Minuta $minuta): static
  201.     {
  202.         if (!$this->minutas->contains($minuta)) {
  203.             $this->minutas->add($minuta);
  204.             $minuta->setExpediente($this);
  205.         }
  207.         return $this;
  208.     }
  210.     public function removeMinuta(Minuta $minuta): static
  211.     {
  212.         if ($this->minutas->removeElement($minuta)) {
  213.             // set the owning side to null (unless already changed)
  214.             if ($minuta->getExpediente() === $this) {
  215.                 $minuta->setExpediente(null);
  216.             }
  217.         }
  219.         return $this;
  220.     }
  222.     public function getEstadoExpediente(): ?EstadoExpediente
  223.     {
  224.         return $this->estadoExpediente;
  225.     }
  227.     public function setEstadoExpediente(?EstadoExpediente $estadoExpediente): static
  228.     {
  229.         $this->estadoExpediente = $estadoExpediente;
  231.         return $this;
  232.     }
  234.     public function getMetadata(): ?MetadataExpediente
  235.     {
  236.         return $this->metadata;
  237.     }
  239.     public function setMetadata(?MetadataExpediente $metadata): static
  240.     {
  241.         $this->metadata = $metadata;
  243.         return $this;
  244.     }
  246.     public function getCreador(): ?SonataUserUser
  247.     {
  248.         return $this->creador;
  249.     }
  251.     public function setCreador(?SonataUserUser $creador): static
  252.     {
  253.         $this->creador = $creador;
  255.         return $this;
  256.     }
  258.     public function getEntidad(): ?Entidad
  259.     {
  260.         return $this->entidad;
  261.     }
  263.     public function setEntidad(?Entidad $entidad): static
  264.     {
  265.         $this->entidad = $entidad;
  267.         return $this;
  268.     }
  270.     /**
  271.      * @return Collection<int, SonataUserUser>
  272.      */
  273.     public function getResponsables(): Collection
  274.     {
  275.         return $this->responsables;
  276.     }
  278.     public function addResponsable(SonataUserUser $responsable): static
  279.     {
  280.         if (!$this->responsables->contains($responsable)) {
  281.             $this->responsables->add($responsable);
  282.         }
  284.         return $this;
  285.     }
  287.     public function removeResponsable(SonataUserUser $responsable): static
  288.     {
  289.         $this->responsables->removeElement($responsable);
  291.         return $this;
  292.     }
  294.     public function getCabecera(): ?ExpedienteCabecera
  295.     {
  296.         return $this->cabecera;
  297.     }
  299.     public function setCabecera(?ExpedienteCabecera $cabecera): static
  300.     {
  301.         $this->cabecera = $cabecera;
  303.         return $this;
  304.     }
  306.     public function getTipo(): ?string
  307.     {
  308.         $data = json_decode($this->getCustom(), true);
  310.         switch ($data['procedimiento'])
  311.         {
  312.             case 'CM':
  313.             case '0':
  314.                  $return = 'EC';
  315.                 break;
  316.             case 'ARBITRAJE':
  317.             case '1':
  318.                 $return = 'A';
  319.                 break;
  320.             default:
  321.                 $return = null;
  322.                 break;
  323.         }
  325.         return $return;
  326.         return 'EC / C/ M / A';
  327.     }
  329.     public function getEmpresa(): ?string
  330.     {
  331.         $data = json_decode($this->getCustom(), true);
  332.         switch ($data['entidad'])
  333.         {
  334.             case 'EMPRESA':
  335.             case '0':
  336.                 $tipo = 'E';
  337.                 break;
  338.             case 'SECTOR':
  339.             case '1':
  340.                 $tipo = 'S';
  341.                 break;
  342.             default:
  343.                 $tipo = '---';
  344.                 break;
  345.         }
  347.         return $tipo;
  348.     }
  350.     public function getEmpresaNombre(): ?string
  351.     {
  352.         $data = json_decode($this->getCustom(), true);
  353.         switch ($data['entidad'])
  354.         {
  355.             case 'EMPRESA':
  356.             case '0':
  357.                 $id = $data['empresa'];
  358.                 break;
  359.             case 'SECTOR':
  360.             case '1':
  361.                 $id = $data['sector'];
  362.                 break;
  363.             default:
  364.                 $id = null;
  365.                 break;
  366.         }
  368.         return $id;
  369.     }
  371.     /**
  372.      * @return Collection<int, DocumentacionRegistro>
  373.      */
  374.     public function getRegistros(): Collection
  375.     {
  376.         return $this->registros;
  377.     }
  379.     public function addRegistro(DocumentacionRegistro $registro): static
  380.     {
  381.         if (!$this->registros->contains($registro)) {
  382.             $this->registros->add($registro);
  383.             $registro->setExpediente($this);
  384.         }
  386.         return $this;
  387.     }
  389.     public function removeRegistro(DocumentacionRegistro $registro): static
  390.     {
  391.         if ($this->registros->removeElement($registro)) {
  392.             // set the owning side to null (unless already changed)
  393.             if ($registro->getExpediente() === $this) {
  394.                 $registro->setExpediente(null);
  395.             }
  396.         }
  398.         return $this;
  399.     }
  401.     public function getFase():?string
  402.     {
  403.         return $this->getEstadoExpediente()?->getSubestado();
  404.     }
  406.     public function getSolicitud(): ?DocumentacionRegistro
  407.     {
  408.         return $this->solicitud;
  409.     }
  411.     public function setSolicitud(?DocumentacionRegistro $solicitud): static
  412.     {
  413.         $this->solicitud = $solicitud;
  415.         return $this;
  416.     }
  418.     public function getCustom():?string
  419.     {
  420.         return $this->getSolicitud()?->getCustom()->getForm();
  421.     }
  422. }