src/Entity/GHCandidato.php line 23

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\GHCandidatoRepository;
  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;
  10. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  11. use Symfony\Component\Validator\Constraints as Assert;
  13. #[ORM\Table(name: 'gh_candidato')]
  14. #[ORM\Entity(repositoryClass: GHCandidatoRepository::class)]
  15. #[UniqueEntity(
  16.     fields: ['numeroDocumento', 'vacante'],
  17.     errorPath: 'numeroDocumento',
  18.     message: 'Este numero de cedula ya esta registrado para la vacante.',
  19.     groups: ['Default'] // <- solo se activa en este grupo
  20. )]
  22. #[ORM\HasLifecycleCallbacks]
  23. class GHCandidato {
  25.     #[ORM\Id]
  26.     #[ORM\GeneratedValue]
  27.     #[ORM\Column]
  28.     private ?int $id = null;
  30.     #[ORM\Column(length: 255)]
  31.     private ?string $nombres = null;
  33.     #[ORM\Column(length: 255)]
  34.     #[Assert\Regex(
  35.                 pattern: '/^[0-9]*$/',
  36.                 message: 'Solo puede ingresar numeros',
  37.         )]
  38.     private ?string $numeroDocumento = null;
  40.     #[ORM\Column]
  41.     private ?int $proceso = null;
  43.     #[ORM\Column(length: 255)]
  44.     #[Assert\Email(
  45.                 message: 'la direccion {{ value }} no es valida',
  46.         )]
  47.     private ?string $correoElectronico = null;
  49.     #[ORM\Column(length: 255)]
  50.     #[Assert\Regex(
  51.                 pattern: '/^[0-9]*$/',
  52.                 message: 'Solo puede ingresar numeros',
  53.         )]
  54.     private ?string $celular = null;
  56.     #[ORM\Column(length: 255)]
  57.     private ?string $hojaVida = null;
  58.     #nullable
  59.     #[ORM\Column(length: 255, nullable:true)]
  60.     private ?string $comentario = null;
  62.     #[ORM\ManyToOne(inversedBy: 'candidato')]
  63.     private ?ParTipoDocumento $tipoDocumento = null;
  65.     #[ORM\ManyToOne(inversedBy: 'candidato')]
  66.     private ?ParTipoConvocatoria $tipoConvocatoria = null;
  68.     #[ORM\ManyToOne(inversedBy: 'candidato')]
  69.     private ?GHVacante $vacante = null;
  71.     #[ORM\ManyToOne(inversedBy: 'candidato')]
  72.     private ?ParFuenteReclutamiento $fuenteReclutamiento = null;
  74.     #[ORM\OneToMany(mappedBy: 'candidato', targetEntity: GHContratacion::class, cascade: ['remove'], orphanRemoval: true)]
  75.     private Collection $contratacion;
  77.     #[ORM\OneToMany(mappedBy: 'candidato', targetEntity: GHRevisionInicial::class, cascade: ['remove'], orphanRemoval: true)]
  78.     private Collection $revisionInicial;
  80.     #[ORM\OneToMany(mappedBy: 'candidato', targetEntity: GHExamenes::class, cascade: ['remove'], orphanRemoval: true)]
  81.     private Collection $examenes;
  83.     #[ORM\OneToMany(mappedBy: 'candidato', targetEntity: GHSolicitudDotacion::class)]
  84.     private Collection $solicitudDotacion;
  86.     #[ORM\OneToMany(mappedBy: 'candidato', targetEntity: GHCarnetizacion::class)]
  87.     private Collection $carnetizacion;
  89.     #[ORM\OneToMany(mappedBy: 'candidato', targetEntity: GHAfiliacionContratacion::class, cascade: ['remove'], orphanRemoval: true)]
  90.     private Collection $afiliacionContratacion;
  92.     #[ORM\OneToMany(mappedBy: 'candidato', targetEntity: GHContrato::class)]
  93.     private Collection $contrato;
  95.     #[ORM\OneToMany(mappedBy: 'candidato', targetEntity: GHPruebasPsicotecnicas::class, cascade: ['remove'], orphanRemoval: true)]
  96.     private Collection $pruebaPsicotecnica;
  98.     #[ORM\OneToMany(mappedBy: 'candidato', targetEntity: GHPruebasTecnicas::class)]
  99.     private Collection $pruebaTecnica;
  101.     #[ORM\OneToMany(mappedBy: 'candidato', targetEntity: GHVisitaDomiciliaria::class, cascade: ['remove'], orphanRemoval: true)]
  102.     private Collection $visitaDomiciliaria;
  104.     #[ORM\ManyToOne(inversedBy: 'GHCandidato')]
  105.     private ?ParEstado $estado = null;
  107.     #[ORM\Column]
  108.     private ?\DateTime $createAt = null;
  110.     #[ORM\Column]
  111.     private ?\DateTime $updateAt = null;
  113.     #[ORM\Column(length: 55)]
  114.     private ?string $createUser = null;
  116.     #[ORM\Column(length: 55)]
  117.     private ?string $updateUser = null;
  119.     #[ORM\OneToMany(mappedBy: 'candidato', targetEntity: GHEntrevista::class, cascade: ['remove'], orphanRemoval: true)]
  120.     private Collection $entrevista;
  122.     #[ORM\OneToMany(mappedBy: 'candidato', targetEntity: GHEntrevistaJefe::class, cascade: ['remove'], orphanRemoval: true)]
  123.     private Collection $entrevistaJefe;
  125.     #[ORM\Column(nullable: true)]
  126.     private ?int $ordenContratacion = null;
  128.     #[ORM\ManyToOne(inversedBy: 'candidato')]
  129.     private ?ParMotivoFinalizacion $motivoFinalizacion = null;
  131.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  132.     private ?string $observacionFinalizacion = null;
  134.     #[ORM\Column(length: 100, nullable: true)]
  135.     private ?string $estadoAnterior = null;
  137.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  138.     private ?\DateTimeInterface $fechaFinalizacion = null;
  140.     #[ORM\Column(length: 255, nullable: true)]
  141.     private ?string $estadoProceso = null;
  143.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  144.     private ?\DateTimeInterface $fechaOrdenContratacion = null;
  146.     public function __toString(): string
  147.     {
  148.         return $this->nombres; // Devuelve el nombre del candidato como el "texto" del objeto
  149.     }
  150.     public function __construct() {
  151.         $this->contratacion = new ArrayCollection();
  152.         $this->idVisita = new ArrayCollection();
  153.         $this->revisionInicial = new ArrayCollection();
  154.         $this->idExamenes = new ArrayCollection();
  155.         $this->solicitudDotacion = new ArrayCollection();
  156.         $this->carnetizacion = new ArrayCollection();
  157.         $this->afiliacionContratacion = new ArrayCollection();
  158.         $this->contrato = new ArrayCollection();
  159.         $this->pruebaPsicotecnica = new ArrayCollection();
  160.         $this->pruebaTecnica = new ArrayCollection();
  161.         $this->idVisitaDomiciliaria = new ArrayCollection();
  162.         $this->idExamen = new ArrayCollection();
  163.         $this->entrevista = new ArrayCollection();
  164.         $this->entrevistaJefe = new ArrayCollection();
  165.     }
  167.     public function getId(): ?int {
  168.         return $this->id;
  169.     }
  171.     public function getNombres(): ?string {
  172.         return $this->nombres;
  173.     }
  175.     public function getNumeroDocumento(): ?string {
  176.         return $this->numeroDocumento;
  177.     }
  179.     public function getProceso(): ?int {
  180.         return $this->proceso;
  181.     }
  183.     public function getCorreoElectronico(): ?string {
  184.         return $this->correoElectronico;
  185.     }
  187.     public function getCelular(): ?string {
  188.         return $this->celular;
  189.     }
  191.     public function getHojaVida(): ?string {
  192.         return $this->hojaVida;
  193.     }
  195.     public function getComentario(): ?string {
  196.         return $this->comentario;
  197.     }
  199.     public function setComentario(?string $comentario): void {
  200.         $this->comentario = $comentario;
  201.     }
  203.     public function setNombres(?string $nombres): void {
  204.         $this->nombres = $nombres;
  205.     }
  207.     public function setNumeroDocumento(?string $numeroDocumento): void {
  208.         $this->numeroDocumento = $numeroDocumento;
  209.     }
  211.     public function setProceso(?int $proceso): void {
  212.         $this->proceso = $proceso;
  213.     }
  215.     public function setCorreoElectronico(?string $correoElectronico): void {
  216.         $this->correoElectronico = $correoElectronico;
  217.     }
  219.     public function setCelular(?string $celular): void {
  220.         $this->celular = $celular;
  221.     }
  223.     public function setFuenteReclutamiento(?ParFuenteReclutamiento $fuenteReclutamiento): void {
  224.         $this->fuenteReclutamiento = $fuenteReclutamiento;
  225.     }
  227.     public function setHojaVida(?string $hojaVida): void {
  228.         $this->hojaVida = $hojaVida;
  229.     }
  231.     public function getTipoDocumento(): ?ParTipoDocumento {
  232.         return $this->tipoDocumento;
  233.     }
  235.     public function setTipoDocumento(?ParTipoDocumento $tipoDocumentoId): static {
  236.         $this->tipoDocumento = $tipoDocumentoId;
  238.         return $this;
  239.     }
  241.     public function getTipoConvocatoria(): ?ParTipoConvocatoria {
  242.         return $this->tipoConvocatoria;
  243.     }
  245.     public function setTipoConvocatoria(?ParTipoConvocatoria $tipoConvocatoria): static {
  246.         $this->tipoConvocatoria = $tipoConvocatoria;
  248.         return $this;
  249.     }
  251.     public function getVacante(): ?GHVacante {
  252.         return $this->vacante;
  253.     }
  255.     public function setVacante(?GHVacante $vacante): static {
  256.         $this->vacante = $vacante;
  258.         return $this;
  259.     }
  261.     public function getFuenteReclutamiento(): ?ParFuenteReclutamiento {
  262.         return $this->fuenteReclutamiento;
  263.     }
  265.     public function setFuenteReclutamientoId(?ParFuenteReclutamiento $fuenteReclutamientoId): static {
  266.         $this->fuenteReclutamientoId = $fuenteReclutamientoId;
  268.         return $this;
  269.     }
  271.     /**
  272.      * @return Collection<int, GHContratacion>
  273.      */
  274.     public function getContratacion(): Collection {
  275.         return $this->contratacion;
  276.     }
  278.     public function addContratacion(GHContratacion $contratacion): static {
  279.         if (!$this->contratacion->contains($contratacion)) {
  280.             $this->contratacion->add($contratacion);
  281.             $contratacion->setCandidato($this);
  282.         }
  284.         return $this;
  285.     }
  287.     public function removeContratacion(GHContratacion $contratacion): static {
  288.         if ($this->contratacion->removeElement($contratacion)) {
  289.             // set the owning side to null (unless already changed)
  290.             if ($contratacion->getCandidato() === $this) {
  291.                 $contratacion->setCandidato(null);
  292.             }
  293.         }
  295.         return $this;
  296.     }
  298.     /**
  299.      * @return Collection<int, GHRevisionInicial>
  300.      */
  301.     public function getRevisionInicial(): Collection {
  302.         return $this->revisionInicial;
  303.     }
  305.     public function addRevisionInicial(GHRevisionInicial $revisionInicial): static {
  306.         if (!$this->revisionInicial->contains($revisionInicial)) {
  307.             $this->revisionInicial->add($revisionInicial);
  308.             $revisionInicial->setCandidato($this);
  309.         }
  311.         return $this;
  312.     }
  314.     public function removeRevisionInicial(GHRevisionInicial $revisionInicial): static {
  315.         if ($this->revisionInicial->removeElement($revisionInicial)) {
  316.             // set the owning side to null (unless already changed)
  317.             if ($revisionInicial->getCandidato() === $this) {
  318.                 $revisionInicial->setCandidato(null);
  319.             }
  320.         }
  322.         return $this;
  323.     }
  325.     /**
  326.      * @return Collection<int, GHExamenes>
  327.      */
  328.     public function getExamenes(): Collection {
  329.         return $this->examenes;
  330.     }
  332.     public function addExamenes(GHExamenes $idExamene): static {
  333.         if (!$this->examenes->contains($idExamene)) {
  334.             $this->examenes->add($idExamene);
  335.             $idExamene->setCandidato($this);
  336.         }
  338.         return $this;
  339.     }
  341.     public function removeExamenes(GHExamenes $idExamene): static {
  342.         if ($this->examenes->removeElement($idExamene)) {
  343.             // set the owning side to null (unless already changed)
  344.             if ($idExamene->getCandidato() === $this) {
  345.                 $idExamene->setCandidato(null);
  346.             }
  347.         }
  349.         return $this;
  350.     }
  352.     /**
  353.      * @return Collection<int, GHSolicitudDotacion>
  354.      */
  355.     public function getSolicitudDotacion(): Collection {
  356.         return $this->solicitudDotacion;
  357.     }
  359.     public function addSolicitudDotacion(GHSolicitudDotacion $solicitudDotacion): static {
  360.         if (!$this->solicitudDotacion->contains($solicitudDotacion)) {
  361.             $this->solicitudDotacion->add($solicitudDotacion);
  362.             $solicitudDotacion->setCandidato($this);
  363.         }
  365.         return $this;
  366.     }
  368.     public function removeSolicitudDotacion(GHSolicitudDotacion $solicitudDotacion): static {
  369.         if ($this->solicitudDotacion->removeElement($solicitudDotacion)) {
  370.             // set the owning side to null (unless already changed)
  371.             if ($solicitudDotacion->getCandidato() === $this) {
  372.                 $solicitudDotacion->setCandidato(null);
  373.             }
  374.         }
  376.         return $this;
  377.     }
  379.     /**
  380.      * @return Collection<int, GHCarnetizacion>
  381.      */
  382.     public function getCarnetizacion(): Collection {
  383.         return $this->carnetizacion;
  384.     }
  386.     public function addCarnetizacion(GHCarnetizacion $carnetizacion): static {
  387.         if (!$this->carnetizacion->contains($carnetizacion)) {
  388.             $this->carnetizacion->add($carnetizacion);
  389.             $carnetizacion->setCandidato($this);
  390.         }
  392.         return $this;
  393.     }
  395.     public function removeCarnetizacion(GHCarnetizacion $carnetizacion): static {
  396.         if ($this->carnetizacion->removeElement($carnetizacion)) {
  397.             // set the owning side to null (unless already changed)
  398.             if ($carnetizacion->getCandidato() === $this) {
  399.                 $carnetizacion->setCandidato(null);
  400.             }
  401.         }
  403.         return $this;
  404.     }
  406.     /**
  407.      * @return Collection<int, GHAfiliacionContratacion>
  408.      */
  409.     public function getAfiliacionContratacion(): Collection {
  410.         return $this->afiliacionContratacion;
  411.     }
  413.     public function addAfiliacionContratacion(GHAfiliacionContratacion $afiliacionContratacion): static {
  414.         if (!$this->afiliacionContratacion->contains($afiliacionContratacion)) {
  415.             $this->afiliacionContratacion->add($afiliacionContratacion);
  416.             $afiliacionContratacion->setCandidato($this);
  417.         }
  419.         return $this;
  420.     }
  422.     public function removeAfiliacionContratacion(GHAfiliacionContratacion $afiliacionContratacion): static {
  423.         if ($this->afiliacionContratacion->removeElement($afiliacionContratacion)) {
  424.             // set the owning side to null (unless already changed)
  425.             if ($afiliacionContratacion->getCandidato() === $this) {
  426.                 $afiliacionContratacion->setCandidato(null);
  427.             }
  428.         }
  430.         return $this;
  431.     }
  433.     /**
  434.      * @return Collection<int, GHContrato>
  435.      */
  436.     public function getContrato(): Collection {
  437.         return $this->contrato;
  438.     }
  440.     public function addContrato(GHContrato $contrato): static {
  441.         if (!$this->contrato->contains($contrato)) {
  442.             $this->contrato->add($contrato);
  443.             $contrato->setCandidato($this);
  444.         }
  446.         return $this;
  447.     }
  449.     public function removeContrato(GHContrato $contrato): static {
  450.         if ($this->contrato->removeElement($contrato)) {
  451.             // set the owning side to null (unless already changed)
  452.             if ($contrato->getCandidato() === $this) {
  453.                 $contrato->setCandidato(null);
  454.             }
  455.         }
  457.         return $this;
  458.     }
  460.     /**
  461.      * @return Collection<int, GHPruebasPsicotecnicas>
  462.      */
  463.     public function getPruebaPsicotecnica(): Collection {
  464.         return $this->pruebaPsicotecnica;
  465.     }
  467.     public function addPruebaPsicotecnica(GHPruebasPsicotecnicas $pruebasPsicotecnica): static {
  468.         if (!$this->pruebaPsicotecnica->contains($pruebasPsicotecnica)) {
  469.             $this->pruebaPsicotecnica->add($pruebasPsicotecnica);
  470.             $pruebasPsicotecnica->setCandidato($this);
  471.         }
  473.         return $this;
  474.     }
  476.     public function removeIdPruebasPsicotecnica(GHPruebasPsicotecnicas $pruebaPsicotecnica): static {
  477.         if ($this->pruebaPsicotecnica->removeElement($pruebaPsicotecnica)) {
  478.             // set the owning side to null (unless already changed)
  479.             if ($pruebaPsicotecnica->getCandidato() === $this) {
  480.                 $pruebaPsicotecnica->setCandidato(null);
  481.             }
  482.         }
  484.         return $this;
  485.     }
  487.     /**
  488.      * @return Collection<int, GHPruebasTecnicas>
  489.      */
  490.     public function getPruebaTecnica(): Collection {
  491.         return $this->pruebaTecnica;
  492.     }
  494.     public function addPruebaTecnica(GHPruebasTecnicas $pruebaTecnica): static {
  495.         if (!$this->pruebaTecnica->contains($pruebaTecnica)) {
  496.             $this->pruebaTecnica->add($pruebaTecnica);
  497.             $pruebaTecnica->setCandidato($this);
  498.         }
  500.         return $this;
  501.     }
  503.     public function removePruebaTecnica(GHPruebasTecnicas $pruebaTecnica): static {
  504.         if ($this->pruebaTecnica->removeElement($pruebaTecnica)) {
  505.             // set the owning side to null (unless already changed)
  506.             if ($pruebaTecnica->getCandidato() === $this) {
  507.                 $pruebaTecnica->setCandidato(null);
  508.             }
  509.         }
  511.         return $this;
  512.     }
  514.     /**
  515.      * @return Collection<int, GHVisitaDomiciliaria>
  516.      */
  517.     public function getVisitaDomiciliaria(): Collection {
  518.         return $this->visitaDomiciliaria;
  519.     }
  521.     public function addVisitaDomiciliaria(GHVisitaDomiciliaria $idVisitaDomiciliarium): static {
  522.         if (!$this->visitaDomiciliaria->contains($idVisitaDomiciliarium)) {
  523.             $this->visitaDomiciliaria->add($idVisitaDomiciliarium);
  524.             $idVisitaDomiciliarium->setCandidato($this);
  525.         }
  527.         return $this;
  528.     }
  530.     public function removeVisitaDomiciliarium(GHVisitaDomiciliaria $idVisitaDomiciliarium): static {
  531.         if ($this->visitaDomiciliaria->removeElement($idVisitaDomiciliarium)) {
  532.             // set the owning side to null (unless already changed)
  533.             if ($idVisitaDomiciliarium->getCandidato() === $this) {
  534.                 $idVisitaDomiciliarium->setCandidato(null);
  535.             }
  536.         }
  538.         return $this;
  539.     }
  541.     public function getEstado(): ?ParEstado {
  542.         return $this->estado;
  543.     }
  545.     public function setEstado(?ParEstado $estado): static {
  546.         $this->estado = $estado;
  548.         return $this;
  549.     }
  551.     public function getCreateAt(): ?\DateTime {
  552.         return $this->createAt;
  553.     }
  555.     public function setCreateAt(\DateTime $createAt): static {
  556.         $this->createAt = $createAt;
  558.         return $this;
  559.     }
  561.     public function getUpdateAt(): ?\DateTime {
  562.         return $this->updateAt;
  563.     }
  565.     public function setUpdateAt(\DateTime $updateAt): static {
  566.         $this->updateAt = $updateAt;
  568.         return $this;
  569.     }
  571.     public function getCreateUser(): ?string {
  572.         return $this->createUser;
  573.     }
  575.     public function setCreateUser(string $createUser): static {
  576.         $this->createUser = $createUser;
  578.         return $this;
  579.     }
  581.     public function getUpdateUser(): ?string {
  582.         return $this->updateUser;
  583.     }
  585.     public function setUpdateUser(string $updateUser): static {
  586.         $this->updateUser = $updateUser;
  588.         return $this;
  589.     }
  591.     /**
  592.      * @return Collection<int, GHEntrevista>
  593.      */
  594.     public function getEntrevista(): Collection {
  595.         return $this->entrevista;
  596.     }
  598.     public function addEntrevistum(GHEntrevista $entrevistum): static {
  599.         if (!$this->entrevista->contains($entrevistum)) {
  600.             $this->entrevista->add($entrevistum);
  601.             $entrevistum->setCandidato($this);
  602.         }
  604.         return $this;
  605.     }
  607.     public function removeEntrevistum(GHEntrevista $entrevistum): static {
  608.         if ($this->entrevista->removeElement($entrevistum)) {
  609.             // set the owning side to null (unless already changed)
  610.             if ($entrevistum->getCandidato() === $this) {
  611.                 $entrevistum->setCandidato(null);
  612.             }
  613.         }
  615.         return $this;
  616.     }
  618.     /**
  619.      * @return Collection<int, GHEntrevistaJefe>
  620.      */
  621.     public function getEntrevistaJefe(): Collection {
  622.         return $this->entrevistaJefe;
  623.     }
  625.     public function addEntrevistaJefe(GHEntrevistaJefe $entrevistaJefe): static {
  626.         if (!$this->entrevistaJefe->contains($entrevistaJefe)) {
  627.             $this->entrevistaJefe->add($entrevistaJefe);
  628.             $entrevistaJefe->setCandidato($this);
  629.         }
  631.         return $this;
  632.     }
  634.     public function removeEntrevistaJefe(GHEntrevistaJefe $entrevistaJefe): static {
  635.         if ($this->entrevistaJefe->removeElement($entrevistaJefe)) {
  636.             // set the owning side to null (unless already changed)
  637.             if ($entrevistaJefe->getCandidato() === $this) {
  638.                 $entrevistaJefe->setCandidato(null);
  639.             }
  640.         }
  642.         return $this;
  643.     }
  645.     public function getOrdenContratacion(): ?int {
  646.         return $this->ordenContratacion;
  647.     }
  649.     public function setOrdenContratacion(?int $ordenContratacion): static {
  650.         $this->ordenContratacion = $ordenContratacion;
  652.         return $this;
  653.     }
  655.     public function getMotivoFinalizacion(): ?ParMotivoFinalizacion {
  656.         return $this->motivoFinalizacion;
  657.     }
  659.     public function setMotivoFinalizacion(?ParMotivoFinalizacion $motivoFinalizacion): static {
  660.         $this->motivoFinalizacion = $motivoFinalizacion;
  662.         return $this;
  663.     }
  665.     public function getObservacionFinalizacion(): ?string {
  666.         return $this->observacionFinalizacion;
  667.     }
  669.     public function setObservacionFinalizacion(?string $observacionFinalizacion): static {
  670.         $this->observacionFinalizacion = $observacionFinalizacion;
  672.         return $this;
  673.     }
  675.     public function getEstadoAnterior(): ?string {
  676.         return $this->estadoAnterior;
  677.     }
  679.     public function setEstadoAnterior(?string $estadoAnterior): static {
  680.         $this->estadoAnterior = $estadoAnterior;
  682.         return $this;
  683.     }
  685.     // #[ORM\PreUpdate]
  686.     // public function guardarEstadoAnterior(\Doctrine\ORM\Event\PreUpdateEventArgs $args): void {
  688.     //     try {
  689.     //         if($this->getEstado()->getId() == 6){
  690.     //             $this->fechaFinalizacion = new \DateTime('now');
  691.     //         }
  692.     //         $this->estadoAnterior = $args->getOldValue('estado') != null ? $args->getOldValue('estado')->getNombre() : null;
  693.     //     } catch (\Exception $e) {
  694.             
  695.     //     }
  696.         
  697.     // }
  699.     public function getFechaFinalizacion(): ?\DateTimeInterface {
  700.         return $this->fechaFinalizacion;
  701.     }
  703.     public function setFechaFinalizacion(?\DateTimeInterface $fechaFinalizacion): static {
  704.         $this->fechaFinalizacion = $fechaFinalizacion;
  706.         return $this;
  707.     }
  709.     public function getEstadoProceso(): ?string
  710.     {
  711.         return $this->estadoProceso;
  712.     }
  714.     public function setEstadoProceso(?string $estadoProceso): static
  715.     {
  716.         $this->estadoProceso = $estadoProceso;
  718.         return $this;
  719.     }
  721.     public function getFechaOrdenContratacion(): ?\DateTimeInterface
  722.     {
  723.         return $this->fechaOrdenContratacion;
  724.     }
  726.     public function setFechaOrdenContratacion(?\DateTimeInterface $fechaOrdenContratacion): static
  727.     {
  728.         $this->fechaOrdenContratacion = $fechaOrdenContratacion;
  730.         return $this;
  731.     }
  732. }