src/Entity/JurProceso.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\JurProcesoRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: JurProcesoRepository::class)]
  12. class JurProceso {
  14.     #[ORM\Id]
  15.     #[ORM\GeneratedValue]
  16.     #[ORM\Column]
  17.     private ?int $id = null;
  19.     #[ORM\ManyToOne(inversedBy: 'proceso')]
  20.     private ?TerEmpresa $empresaFilial = null;
  22.     #[ORM\ManyToOne(inversedBy: 'proceso')]
  23.     private ?ParRama $rama = null;
  25.     #[ORM\Column(length: 255)]
  26.     private ?string $tipo = null;
  28.     #[ORM\Column(length: 255)]
  29.     private ?string $contraparte = null;
  31.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  32.     private ?\DateTimeInterface $fechaNotificacion = null;
  34.     #[ORM\Column(length: 255, nullable: true)]
  35.     private ?string $archivoNotificacion = null;
  37.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  38.     private ?\DateTimeInterface $fechaVencimiento = null;
  40.     #[ORM\Column(type: Types::TEXT)]
  41.     private ?string $motivo = null;
  43.     #[ORM\Column(type: Types::DECIMAL, precision: 11, scale: 2, nullable: true)]
  44.     private ?string $monto = null;
  46.     #[ORM\ManyToOne(inversedBy: 'procesoJuridico')]
  47.     private ?ParEstado $estado = null;
  49.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  50.     private ?\DateTimeInterface $createAt = null;
  52.     #[ORM\Column(length: 50)]
  53.     private ?string $createUser = null;
  55.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  56.     private ?\DateTimeInterface $updateAt = null;
  58.     #[ORM\Column(length: 50)]
  59.     private ?string $updateUser = null;
  61.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: JurRespuestaProceso::class)]
  62.     private Collection $respuestaProceso;
  64.     #[ORM\ManyToOne(inversedBy: 'procesoJuridico')]
  65.     private ?TerEmpresaCliente $empresaCliente = null;
  67.     #[ORM\ManyToOne(inversedBy: 'procesoJuridico')]
  68.     private ?TerAsociado $empresaAsociado = null;
  70.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: JurProcesoEvidencia::class)]
  71.     private Collection $procesoEvidencia;
  73.     #[ORM\ManyToOne(inversedBy: 'procesosJuridico')]
  74.     private ?TerSedeEmpresa $sede = null;
  76.     #[ORM\ManyToOne(inversedBy: 'proceso')]
  77.     private ?ParTipificacionJuridica $tipificacionJuridica = null;
  79.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'procesosAnteriores')]
  80.     private ?self $procesoAnterior = null;
  82.     #[ORM\OneToMany(mappedBy: 'procesoAnterior', targetEntity: self::class)]
  83.     private Collection $procesosAnteriores;
  85.     #[ORM\Column(nullable: true)]
  86.     private ?bool $vinculoProcesoAnterior = null;
  88.     #[ORM\Column(nullable: true)]
  89.     private ?bool $accionCorrectiva = null;
  91.     public function __toString(): string {
  92.         $rama = $this->getRama() != null ? $this->getRama()->getNombre() : "";
  93.         $fecNot = $this->getFechaNotificacion() != null ? $this->getFechaNotificacion()->format('Y-m-d') : "";
  94.         
  95.        // return "{$this->getId()} - {$rama} - {$fecNot}";
  96.         return $this->getTipo();
  97.     }
  99.     public function __construct() {
  100.         $this->respuestaProceso = new ArrayCollection();
  101.         $this->procesoEvidencia = new ArrayCollection();
  102.         $this->procesosAnteriores = new ArrayCollection();
  103.     }
  105.     public function getId(): ?int {
  106.         return $this->id;
  107.     }
  109.     public function getEmpresaFilial(): ?TerEmpresa {
  110.         return $this->empresaFilial;
  111.     }
  113.     public function setEmpresaFilial(?TerEmpresa $empresaFilial): static {
  114.         $this->empresaFilial = $empresaFilial;
  116.         return $this;
  117.     }
  119.     public function getRama(): ?ParRama {
  120.         return $this->rama;
  121.     }
  123.     public function setRama(?ParRama $rama): static {
  124.         $this->rama = $rama;
  126.         return $this;
  127.     }
  129.     public function getTipo(): ?string {
  130.         return $this->tipo;
  131.     }
  133.     public function setTipo(string $tipo): static {
  134.         $this->tipo = $tipo;
  136.         return $this;
  137.     }
  139.     public function getContraparte(): ?string {
  140.         return $this->contraparte;
  141.     }
  143.     public function setContraparte(string $contraparte): static {
  144.         $this->contraparte = $contraparte;
  146.         return $this;
  147.     }
  149.     public function getFechaNotificacion(): ?\DateTimeInterface {
  150.         return $this->fechaNotificacion;
  151.     }
  153.     public function setFechaNotificacion(\DateTimeInterface $fechaNotificacion): static {
  154.         $this->fechaNotificacion = $fechaNotificacion;
  156.         return $this;
  157.     }
  159.     public function getArchivoNotificacion(): ?string {
  160.         return $this->archivoNotificacion;
  161.     }
  163.     public function setArchivoNotificacion(string $archivoNotificacion): static {
  164.         $this->archivoNotificacion = $archivoNotificacion;
  166.         return $this;
  167.     }
  169.     public function getFechaVencimiento(): ?\DateTimeInterface {
  170.         return $this->fechaVencimiento;
  171.     }
  173.     public function setFechaVencimiento(\DateTimeInterface $fechaVencimiento): static {
  174.         $this->fechaVencimiento = $fechaVencimiento;
  176.         return $this;
  177.     }
  179.     public function getMotivo(): ?string {
  180.         return $this->motivo;
  181.     }
  183.     public function setMotivo(string $motivo): static {
  184.         $this->motivo = $motivo;
  186.         return $this;
  187.     }
  189.     public function getMonto(): ?string {
  190.         return $this->monto;
  191.     }
  193.     public function setMonto(string $monto): static {
  194.         $this->monto = $monto;
  196.         return $this;
  197.     }
  199.     public function getEstado(): ?ParEstado {
  200.         return $this->estado;
  201.     }
  203.     public function setEstado(?ParEstado $estado): static {
  204.         $this->estado = $estado;
  206.         return $this;
  207.     }
  209.     public function getCreateAt(): ?\DateTimeInterface {
  210.         return $this->createAt;
  211.     }
  213.     public function setCreateAt(\DateTimeInterface $createAt): static {
  214.         $this->createAt = $createAt;
  216.         return $this;
  217.     }
  219.     public function getCreateUser(): ?string {
  220.         return $this->createUser;
  221.     }
  223.     public function setCreateUser(string $createUser): static {
  224.         $this->createUser = $createUser;
  226.         return $this;
  227.     }
  229.     public function getUpdateAt(): ?\DateTimeInterface {
  230.         return $this->updateAt;
  231.     }
  233.     public function setUpdateAt(\DateTimeInterface $updateAt): static {
  234.         $this->updateAt = $updateAt;
  236.         return $this;
  237.     }
  239.     public function getUpdateUser(): ?string {
  240.         return $this->updateUser;
  241.     }
  243.     public function setUpdateUser(string $updateUser): static {
  244.         $this->updateUser = $updateUser;
  246.         return $this;
  247.     }
  249.     /**
  250.      * @return Collection<int, JurRespuestaProceso>
  251.      */
  252.     public function getRespuestaProceso(): Collection {
  253.         return $this->respuestaProceso;
  254.     }
  256.     public function addRespuestaProceso(JurRespuestaProceso $respuestaProceso): static {
  257.         if (!$this->respuestaProceso->contains($respuestaProceso)) {
  258.             $this->respuestaProceso->add($respuestaProceso);
  259.             $respuestaProceso->setProceso($this);
  260.         }
  262.         return $this;
  263.     }
  265.     public function removeRespuestaProceso(JurRespuestaProceso $respuestaProceso): static {
  266.         if ($this->respuestaProceso->removeElement($respuestaProceso)) {
  267.             // set the owning side to null (unless already changed)
  268.             if ($respuestaProceso->getProceso() === $this) {
  269.                 $respuestaProceso->setProceso(null);
  270.             }
  271.         }
  273.         return $this;
  274.     }
  276.     public function getEmpresaCliente(): ?TerEmpresaCliente {
  277.         return $this->empresaCliente;
  278.     }
  280.     public function setEmpresaCliente(?TerEmpresaCliente $empresaCliente): static {
  281.         $this->empresaCliente = $empresaCliente;
  283.         return $this;
  284.     }
  286.     public function getEmpresaAsociado(): ?TerAsociado {
  287.         return $this->empresaAsociado;
  288.     }
  290.     public function setEmpresaAsociado(?TerAsociado $empresaAsociado): static {
  291.         $this->empresaAsociado = $empresaAsociado;
  293.         return $this;
  294.     }
  296.     /**
  297.      * @return Collection<int, JurProcesoEvidencia>
  298.      */
  299.     public function getProcesoEvidencia(): Collection {
  300.         return $this->procesoEvidencia;
  301.     }
  303.     public function addProcesoEvidencium(JurProcesoEvidencia $procesoEvidencium): static {
  304.         if (!$this->procesoEvidencia->contains($procesoEvidencium)) {
  305.             $this->procesoEvidencia->add($procesoEvidencium);
  306.             $procesoEvidencium->setProceso($this);
  307.         }
  309.         return $this;
  310.     }
  312.     public function removeProcesoEvidencium(JurProcesoEvidencia $procesoEvidencium): static {
  313.         if ($this->procesoEvidencia->removeElement($procesoEvidencium)) {
  314.             // set the owning side to null (unless already changed)
  315.             if ($procesoEvidencium->getProceso() === $this) {
  316.                 $procesoEvidencium->setProceso(null);
  317.             }
  318.         }
  320.         return $this;
  321.     }
  323.     public function getSede(): ?TerSedeEmpresa {
  324.         return $this->sede;
  325.     }
  327.     public function setSede(?TerSedeEmpresa $sede): static {
  328.         $this->sede = $sede;
  330.         return $this;
  331.     }
  333.     public function getTipificacionJuridica(): ?ParTipificacionJuridica {
  334.         return $this->tipificacionJuridica;
  335.     }
  337.     public function setTipificacionJuridica(?ParTipificacionJuridica $tipificacionJuridica): static {
  338.         $this->tipificacionJuridica = $tipificacionJuridica;
  340.         return $this;
  341.     }
  343.     public function getProcesoAnterior(): ?self {
  344.         return $this->procesoAnterior;
  345.     }
  347.     public function setProcesoAnterior(?self $procesoAnterior): static {
  348.         $this->procesoAnterior = $procesoAnterior;
  350.         return $this;
  351.     }
  353.     /**
  354.      * @return Collection<int, self>
  355.      */
  356.     public function getProcesosAnteriores(): Collection {
  357.         return $this->procesosAnteriores;
  358.     }
  360.     public function addProcesosAnteriore(self $procesosAnteriore): static {
  361.         if (!$this->procesosAnteriores->contains($procesosAnteriore)) {
  362.             $this->procesosAnteriores->add($procesosAnteriore);
  363.             $procesosAnteriore->setProcesoAnterior($this);
  364.         }
  366.         return $this;
  367.     }
  369.     public function removeProcesosAnteriore(self $procesosAnteriore): static {
  370.         if ($this->procesosAnteriores->removeElement($procesosAnteriore)) {
  371.             // set the owning side to null (unless already changed)
  372.             if ($procesosAnteriore->getProcesoAnterior() === $this) {
  373.                 $procesosAnteriore->setProcesoAnterior(null);
  374.             }
  375.         }
  377.         return $this;
  378.     }
  380.     public function isVinculoProcesoAnterior(): ?bool {
  381.         return $this->vinculoProcesoAnterior;
  382.     }
  384.     public function setVinculoProcesoAnterior(?bool $vinculoProcesoAnterior): static {
  385.         $this->vinculoProcesoAnterior = $vinculoProcesoAnterior;
  387.         return $this;
  388.     }
  390.     public function isAccionCorrectiva(): ?bool
  391.     {
  392.         return $this->accionCorrectiva;
  393.     }
  395.     public function setAccionCorrectiva(?bool $accionCorrectiva): static
  396.     {
  397.         $this->accionCorrectiva = $accionCorrectiva;
  399.         return $this;
  400.     }
  401. }