src/Entity/ParProceso.php line 11

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ParProcesoRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. #[ORM\Entity(repositoryClass: ParProcesoRepository::class)]
  11. class ParProceso
  12. {
  13.     #[ORM\Id]
  14.     #[ORM\GeneratedValue]
  15.     #[ORM\Column]
  16.     private ?int $id = null;
  18.     #[ORM\Column(length: 100)]
  19.     private ?string $nombre = null;
  21.     #[ORM\OneToMany(mappedBy: 'ParProceso', targetEntity: GHPerfilCargo::class)]
  22.     private Collection $idPerfilCargo;
  24. //    #[ORM\ManyToMany(targetEntity: GHPerfilCargo::class, mappedBy: 'relacionesInternas')]
  25. //    private Collection $perfilCargoRelaciones;
  27.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: ParSubproceso::class)]
  28.     private Collection $subproceso;
  30.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: GHGrupoTrabajo::class)]
  31.     private Collection $grupoTrabajo;
  33.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: GHNovedadNomina::class)]
  34.     private Collection $novedadNomina;
  36.     #[ORM\ManyToMany(targetEntity: JurNorma::class, mappedBy: 'procesos')]
  37.     private Collection $norma;
  39.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: ParMotivoJuridico::class)]
  40.     private Collection $motivoJuridico;
  42.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: RFSolicitudSuministro::class)]
  43.     private Collection $solicitudSuministro;
  45.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: RFTablaRetencion::class)]
  46.     private Collection $tablaRetencion;
  48.     #[ORM\ManyToMany(targetEntity: DocDocumento::class, inversedBy: 'proceso')]
  49.     private Collection $documentos;
  51.     #[ORM\Column(length: 100, nullable: true)]
  52.     private ?string $codigoRF = null;
  54.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: RFInventarioDocumentalFinanzas::class)]
  55.     private Collection $inventarioDocumentalFinanzas;
  57.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: RFFUID::class)]
  58.     private Collection $FUID;
  60.     #[ORM\Column(length: 255, nullable: true)]
  61.     private ?string $fuenteDatosRFFUID = null;
  63.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: RFCambioCustodiaDocumento::class)]
  64.     private Collection $cambioCustodiaDocumento;
  66.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: RFDisposicion::class)]
  67.     private Collection $disposicion;
  69.     #[ORM\ManyToMany(targetEntity: ParCargo::class, inversedBy: 'procesos')]
  70.     private Collection $cargos;
  72.     #[ORM\OneToMany(mappedBy: 'relacionInterna', targetEntity: GHPerfilCargoRelaciones::class)]
  73.     private Collection $perfilCargoRelacionesInternas;
  75.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: ParRecursosPerfil::class)]
  76.     private Collection $recursosPerfil;
  78.     #[ORM\ManyToMany(targetEntity: ParTipoDotacion::class, mappedBy: 'procesos')]
  79.     private Collection $tipoDotacion;
  81.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: ParInduccion::class)]
  82.     private Collection $induccion;
  84.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: GHInduccionProceso::class)]
  85.     private Collection $induccionProcesos;
  87.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: GHMatrizEntrenamientoProceso::class)]
  88.     private Collection $matrizEntrenamientoProceso;
  90.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: GHEntrenamientoProceso::class)]
  91.     private Collection $entrenamientoProcesos;
  93.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: SegControlIngreso::class)]
  94.     private Collection $controlIngreso;
  96.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: SegSolicitudCCTV::class)]
  97.     private Collection $solicitudCCTV;
  99.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: RFPrecintoSolicitud::class)]
  100.     private Collection $precintoSolicitud;
  102.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: RFPrecintoAsignacion::class)]
  103.     private Collection $precintoAsignado;
  105.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: RFSolicitudCompra::class)]
  106.     private Collection $solicitudCompras;
  108.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: RFOrdenCompra::class)]
  109.     private Collection $ordenCompra;
  111.     #[ORM\Column(nullable: true)]
  112.     private ?bool $activaTablaRetencion = null;
  114.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: SecMensaje::class)]
  115.     private Collection $mensajes;
  117.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: GHReentrenamiento::class)]
  118.     private Collection $reentrenamientos;
  120.     #[ORM\OneToMany(mappedBy: 'proceso', targetEntity: GHRegistroOpain::class)]
  121.     private Collection $registrosOpain;
  123.     #[ORM\OneToMany(mappedBy: 'procesoResponsable', targetEntity: ParSistemaInformatico::class)]
  124.     private Collection $sistemasInformaticos;
  126.     #[ORM\OneToMany(mappedBy: 'parProceso', targetEntity: GHReentrenamientoProceso::class)]
  127.     private Collection $gHReentrenamientoProcesos;
  130.     public function __construct()
  131.     {
  132.         $this->idPerfilCargo = new ArrayCollection();
  133.         $this->perfilCargoRelaciones = new ArrayCollection();
  134.         $this->subproceso = new ArrayCollection();
  135.         $this->grupoTrabajo = new ArrayCollection();
  136.         $this->novedadNomina = new ArrayCollection();
  137.         $this->norma = new ArrayCollection();
  138.         $this->motivoJuridico = new ArrayCollection();
  139.         $this->solicitudSuministro = new ArrayCollection();
  140.         $this->tablaRetencion = new ArrayCollection();
  141.         $this->documentos = new ArrayCollection();
  142.         $this->inventarioDocumentalFinanzas = new ArrayCollection();
  143.         $this->FUID = new ArrayCollection();
  144.         $this->cambioCustodiaDocumento = new ArrayCollection();
  145.         $this->disposicion = new ArrayCollection();
  146.         $this->cargos = new ArrayCollection();
  147. //        $this->perfilCargoRelacionesInternas = new ArrayCollection();
  148.         $this->recursosPerfil = new ArrayCollection();
  149.         $this->tipoDotacion = new ArrayCollection();
  150.         $this->induccion = new ArrayCollection();
  151.         $this->induccionProcesos = new ArrayCollection();
  152.         $this->matrizEntrenamientoProceso = new ArrayCollection();
  153.         $this->entrenamientoProcesos = new ArrayCollection();
  154.         $this->controlIngreso = new ArrayCollection();
  155.         $this->solicitudCCTV = new ArrayCollection();
  156.         $this->precintoSolicitud = new ArrayCollection();
  157.         $this->precintoAsignado = new ArrayCollection();
  158.         $this->solicitudCompras = new ArrayCollection();
  159.         $this->ordenCompra = new ArrayCollection();
  160.         $this->mensajes = new ArrayCollection();
  161.         $this->reentrenamientos = new ArrayCollection();
  162.         $this->registrosOpain = new ArrayCollection();
  163.         $this->sistemasInformaticos = new ArrayCollection();
  164.         $this->gHReentrenamientoProcesos = new ArrayCollection();
  165.    
  166.         
  167.     }
  168.     
  169.     public function __toString() {
  170.         return $this->getNombre();
  171.     }
  173.     public function getId(): ?int
  174.     {
  175.         return $this->id;
  176.     }
  178.     public function getNombre(): ?string
  179.     {
  180.         return $this->nombre;
  181.     }
  183.     public function setNombre(string $nombre): static
  184.     {
  185.         $this->nombre = $nombre;
  187.         return $this;
  188.     }
  190.     /**
  191.      * @return Collection<int, GHPerfilCargo>
  192.      */
  193.     public function getIdPerfilCargo(): Collection
  194.     {
  195.         return $this->idPerfilCargo;
  196.     }
  198.     public function addIdPerfilCargo(GHPerfilCargo $idPerfilCargo): static
  199.     {
  200.         if (!$this->idPerfilCargo->contains($idPerfilCargo)) {
  201.             $this->idPerfilCargo->add($idPerfilCargo);
  202.             $idPerfilCargo->setParProceso($this);
  203.         }
  205.         return $this;
  206.     }
  208.     public function removeIdPerfilCargo(GHPerfilCargo $idPerfilCargo): static
  209.     {
  210.         if ($this->idPerfilCargo->removeElement($idPerfilCargo)) {
  211.             // set the owning side to null (unless already changed)
  212.             if ($idPerfilCargo->getParProceso() === $this) {
  213.                 $idPerfilCargo->setParProceso(null);
  214.             }
  215.         }
  217.         return $this;
  218.     }
  220. //    /**
  221. //     * @return Collection<int, GHPerfilCargo>
  222. //     */
  223. //    public function getPerfilCargoRelaciones(): Collection
  224. //    {
  225. //        return $this->perfilCargoRelaciones;
  226. //    }
  227. //
  228. //    public function addPerfilCargoRelacione(GHPerfilCargo $perfilCargoRelacione): static
  229. //    {
  230. //        if (!$this->perfilCargoRelaciones->contains($perfilCargoRelacione)) {
  231. //            $this->perfilCargoRelaciones->add($perfilCargoRelacione);
  232. //            $perfilCargoRelacione->addRelacionesInterna($this);
  233. //        }
  234. //
  235. //        return $this;
  236. //    }
  237. //
  238. //    public function removePerfilCargoRelacione(GHPerfilCargo $perfilCargoRelacione): static
  239. //    {
  240. //        if ($this->perfilCargoRelaciones->removeElement($perfilCargoRelacione)) {
  241. //            $perfilCargoRelacione->removeRelacionesInterna($this);
  242. //        }
  243. //
  244. //        return $this;
  245. //    }
  247.     /**
  248.      * @return Collection<int, ParSubproceso>
  249.      */
  250.     public function getSubproceso(): Collection
  251.     {
  252.         return $this->subproceso;
  253.     }
  255.     public function addSubproceso(ParSubproceso $subproceso): static
  256.     {
  257.         if (!$this->subproceso->contains($subproceso)) {
  258.             $this->subproceso->add($subproceso);
  259.             $subproceso->setProceso($this);
  260.         }
  262.         return $this;
  263.     }
  265.     public function removeSubproceso(ParSubproceso $subproceso): static
  266.     {
  267.         if ($this->subproceso->removeElement($subproceso)) {
  268.             // set the owning side to null (unless already changed)
  269.             if ($subproceso->getProceso() === $this) {
  270.                 $subproceso->setProceso(null);
  271.             }
  272.         }
  274.         return $this;
  275.     }
  277.     /**
  278.      * @return Collection<int, GHGrupoTrabajo>
  279.      */
  280.     public function getGrupoTrabajo(): Collection
  281.     {
  282.         return $this->grupoTrabajo;
  283.     }
  285.     public function addGrupoTrabajo(GHGrupoTrabajo $grupoTrabajo): static
  286.     {
  287.         if (!$this->grupoTrabajo->contains($grupoTrabajo)) {
  288.             $this->grupoTrabajo->add($grupoTrabajo);
  289.             $grupoTrabajo->setProceso($this);
  290.         }
  292.         return $this;
  293.     }
  295.     public function removeGrupoTrabajo(GHGrupoTrabajo $grupoTrabajo): static
  296.     {
  297.         if ($this->grupoTrabajo->removeElement($grupoTrabajo)) {
  298.             // set the owning side to null (unless already changed)
  299.             if ($grupoTrabajo->getProceso() === $this) {
  300.                 $grupoTrabajo->setProceso(null);
  301.             }
  302.         }
  304.         return $this;
  305.     }
  307.     /**
  308.      * @return Collection<int, GHNovedadNomina>
  309.      */
  310.     public function getNovedadNomina(): Collection
  311.     {
  312.         return $this->novedadNomina;
  313.     }
  315.     public function addNovedadNomina(GHNovedadNomina $novedadNomina): static
  316.     {
  317.         if (!$this->novedadNomina->contains($novedadNomina)) {
  318.             $this->novedadNomina->add($novedadNomina);
  319.             $novedadNomina->setProceso($this);
  320.         }
  322.         return $this;
  323.     }
  325.     public function removeNovedadNomina(GHNovedadNomina $novedadNomina): static
  326.     {
  327.         if ($this->novedadNomina->removeElement($novedadNomina)) {
  328.             // set the owning side to null (unless already changed)
  329.             if ($novedadNomina->getProceso() === $this) {
  330.                 $novedadNomina->setProceso(null);
  331.             }
  332.         }
  334.         return $this;
  335.     }
  337.     /**
  338.      * @return Collection<int, JurNorma>
  339.      */
  340.     public function getNorma(): Collection
  341.     {
  342.         return $this->norma;
  343.     }
  345.     public function addNorma(JurNorma $norma): static
  346.     {
  347.         if (!$this->norma->contains($norma)) {
  348.             $this->norma->add($norma);
  349.             $norma->addProceso($this);
  350.         }
  352.         return $this;
  353.     }
  355.     public function removeNorma(JurNorma $norma): static
  356.     {
  357.         if ($this->norma->removeElement($norma)) {
  358.             $norma->removeProceso($this);
  359.         }
  361.         return $this;
  362.     }
  364.     /**
  365.      * @return Collection<int, ParMotivoJuridico>
  366.      */
  367.     public function getMotivoJuridico(): Collection
  368.     {
  369.         return $this->motivoJuridico;
  370.     }
  372.     public function addMotivoJuridico(ParMotivoJuridico $motivoJuridico): static
  373.     {
  374.         if (!$this->motivoJuridico->contains($motivoJuridico)) {
  375.             $this->motivoJuridico->add($motivoJuridico);
  376.             $motivoJuridico->setProceso($this);
  377.         }
  379.         return $this;
  380.     }
  382.     public function removeMotivoJuridico(ParMotivoJuridico $motivoJuridico): static
  383.     {
  384.         if ($this->motivoJuridico->removeElement($motivoJuridico)) {
  385.             // set the owning side to null (unless already changed)
  386.             if ($motivoJuridico->getProceso() === $this) {
  387.                 $motivoJuridico->setProceso(null);
  388.             }
  389.         }
  391.         return $this;
  392.     }
  394.     /**
  395.      * @return Collection<int, RFSolicitudSuministro>
  396.      */
  397.     public function getSolicitudSuministro(): Collection
  398.     {
  399.         return $this->solicitudSuministro;
  400.     }
  402.     public function addSolicitudSuministro(RFSolicitudSuministro $solicitudSuministro): static
  403.     {
  404.         if (!$this->solicitudSuministro->contains($solicitudSuministro)) {
  405.             $this->solicitudSuministro->add($solicitudSuministro);
  406.             $solicitudSuministro->setProceso($this);
  407.         }
  409.         return $this;
  410.     }
  412.     public function removeSolicitudSuministro(RFSolicitudSuministro $solicitudSuministro): static
  413.     {
  414.         if ($this->solicitudSuministro->removeElement($solicitudSuministro)) {
  415.             // set the owning side to null (unless already changed)
  416.             if ($solicitudSuministro->getProceso() === $this) {
  417.                 $solicitudSuministro->setProceso(null);
  418.             }
  419.         }
  421.         return $this;
  422.     }
  424.     /**
  425.      * @return Collection<int, RFTablaRetencion>
  426.      */
  427.     public function getTablaRetencion(): Collection
  428.     {
  429.         return $this->tablaRetencion;
  430.     }
  432.     public function addTablaRetencion(RFTablaRetencion $tablaRetencion): static
  433.     {
  434.         if (!$this->tablaRetencion->contains($tablaRetencion)) {
  435.             $this->tablaRetencion->add($tablaRetencion);
  436.             $tablaRetencion->setProceso($this);
  437.         }
  439.         return $this;
  440.     }
  442.     public function removeTablaRetencion(RFTablaRetencion $tablaRetencion): static
  443.     {
  444.         if ($this->tablaRetencion->removeElement($tablaRetencion)) {
  445.             // set the owning side to null (unless already changed)
  446.             if ($tablaRetencion->getProceso() === $this) {
  447.                 $tablaRetencion->setProceso(null);
  448.             }
  449.         }
  451.         return $this;
  452.     }
  454.     /**
  455.      * @return Collection<int, DocDocumento>
  456.      */
  457.     public function getDocumentos(): Collection
  458.     {
  459.         return $this->documentos;
  460.     }
  462.     public function addDocumento(DocDocumento $documento): static
  463.     {
  464.         if (!$this->documentos->contains($documento)) {
  465.             $this->documentos->add($documento);
  466.         }
  468.         return $this;
  469.     }
  471.     public function removeDocumento(DocDocumento $documento): static
  472.     {
  473.         $this->documentos->removeElement($documento);
  475.         return $this;
  476.     }
  478.     public function getCodigoRF(): ?string
  479.     {
  480.         return $this->codigoRF;
  481.     }
  483.     public function setCodigoRF(?string $codigoRF): static
  484.     {
  485.         $this->codigoRF = $codigoRF;
  487.         return $this;
  488.     }
  490.     /**
  491.      * @return Collection<int, RFInventarioDocumentalFinanzas>
  492.      */
  493.     public function getInventarioDocumentalFinanzas(): Collection
  494.     {
  495.         return $this->inventarioDocumentalFinanzas;
  496.     }
  498.     public function addInventarioDocumentalFinanza(RFInventarioDocumentalFinanzas $inventarioDocumentalFinanza): static
  499.     {
  500.         if (!$this->inventarioDocumentalFinanzas->contains($inventarioDocumentalFinanza)) {
  501.             $this->inventarioDocumentalFinanzas->add($inventarioDocumentalFinanza);
  502.             $inventarioDocumentalFinanza->setProceso($this);
  503.         }
  505.         return $this;
  506.     }
  508.     public function removeInventarioDocumentalFinanza(RFInventarioDocumentalFinanzas $inventarioDocumentalFinanza): static
  509.     {
  510.         if ($this->inventarioDocumentalFinanzas->removeElement($inventarioDocumentalFinanza)) {
  511.             // set the owning side to null (unless already changed)
  512.             if ($inventarioDocumentalFinanza->getProceso() === $this) {
  513.                 $inventarioDocumentalFinanza->setProceso(null);
  514.             }
  515.         }
  517.         return $this;
  518.     }
  520.     /**
  521.      * @return Collection<int, RFFUID>
  522.      */
  523.     public function getFUID(): Collection
  524.     {
  525.         return $this->FUID;
  526.     }
  528.     public function addFUID(RFFUID $fUID): static
  529.     {
  530.         if (!$this->FUID->contains($fUID)) {
  531.             $this->FUID->add($fUID);
  532.             $fUID->setProceso($this);
  533.         }
  535.         return $this;
  536.     }
  538.     public function removeFUID(RFFUID $fUID): static
  539.     {
  540.         if ($this->FUID->removeElement($fUID)) {
  541.             // set the owning side to null (unless already changed)
  542.             if ($fUID->getProceso() === $this) {
  543.                 $fUID->setProceso(null);
  544.             }
  545.         }
  547.         return $this;
  548.     }
  550.     public function getFuenteDatosRFFUID(): ?string
  551.     {
  552.         return $this->fuenteDatosRFFUID;
  553.     }
  555.     public function setFuenteDatosRFFUID(?string $fuenteDatosRFFUID): static
  556.     {
  557.         $this->fuenteDatosRFFUID = $fuenteDatosRFFUID;
  559.         return $this;
  560.     }
  562.     /**
  563.      * @return Collection<int, RFCambioCustodiaDocumento>
  564.      */
  565.     public function getCambioCustodiaDocumento(): Collection
  566.     {
  567.         return $this->cambioCustodiaDocumento;
  568.     }
  570.     public function addCambioCustodiaDocumento(RFCambioCustodiaDocumento $cambioCustodiaDocumento): static
  571.     {
  572.         if (!$this->cambioCustodiaDocumento->contains($cambioCustodiaDocumento)) {
  573.             $this->cambioCustodiaDocumento->add($cambioCustodiaDocumento);
  574.             $cambioCustodiaDocumento->setProceso($this);
  575.         }
  577.         return $this;
  578.     }
  580.     public function removeCambioCustodiaDocumento(RFCambioCustodiaDocumento $cambioCustodiaDocumento): static
  581.     {
  582.         if ($this->cambioCustodiaDocumento->removeElement($cambioCustodiaDocumento)) {
  583.             // set the owning side to null (unless already changed)
  584.             if ($cambioCustodiaDocumento->getProceso() === $this) {
  585.                 $cambioCustodiaDocumento->setProceso(null);
  586.             }
  587.         }
  589.         return $this;
  590.     }
  592.     /**
  593.      * @return Collection<int, RFDisposicion>
  594.      */
  595.     public function getDisposicion(): Collection
  596.     {
  597.         return $this->disposicion;
  598.     }
  600.     public function addDisposicion(RFDisposicion $disposicion): static
  601.     {
  602.         if (!$this->disposicion->contains($disposicion)) {
  603.             $this->disposicion->add($disposicion);
  604.             $disposicion->setProceso($this);
  605.         }
  607.         return $this;
  608.     }
  610.     public function removeDisposicion(RFDisposicion $disposicion): static
  611.     {
  612.         if ($this->disposicion->removeElement($disposicion)) {
  613.             // set the owning side to null (unless already changed)
  614.             if ($disposicion->getProceso() === $this) {
  615.                 $disposicion->setProceso(null);
  616.             }
  617.         }
  619.         return $this;
  620.     }
  622.     /**
  623.      * @return Collection<int, ParCargo>
  624.      */
  625.     public function getCargos(): Collection
  626.     {
  627.         return $this->cargos;
  628.     }
  630.     public function addCargo(ParCargo $cargo): static
  631.     {
  632.         if (!$this->cargos->contains($cargo)) {
  633.             $this->cargos->add($cargo);
  634.         }
  636.         return $this;
  637.     }
  639.     public function removeCargo(ParCargo $cargo): static
  640.     {
  641.         $this->cargos->removeElement($cargo);
  643.         return $this;
  644.     }
  646.     /**
  647.      * @return Collection<int, GHPerfilCargoRelaciones>
  648.      */
  649.     public function getPerfilCargoRelacionesInternas(): Collection
  650.     {
  651.         return $this->perfilCargoRelacionesInternas;
  652.     }
  654.     public function addPerfilCargoRelacionesInterna(GHPerfilCargoRelaciones $perfilCargoRelacionesInterna): static
  655.     {
  656.         if (!$this->perfilCargoRelacionesInternas->contains($perfilCargoRelacionesInterna)) {
  657.             $this->perfilCargoRelacionesInternas->add($perfilCargoRelacionesInterna);
  658.             $perfilCargoRelacionesInterna->setRelacionInterna($this);
  659.         }
  661.         return $this;
  662.     }
  664.     public function removePerfilCargoRelacionesInterna(GHPerfilCargoRelaciones $perfilCargoRelacionesInterna): static
  665.     {
  666.         if ($this->perfilCargoRelacionesInternas->removeElement($perfilCargoRelacionesInterna)) {
  667.             // set the owning side to null (unless already changed)
  668.             if ($perfilCargoRelacionesInterna->getRelacionInterna() === $this) {
  669.                 $perfilCargoRelacionesInterna->setRelacionInterna(null);
  670.             }
  671.         }
  673.         return $this;
  674.     }
  676.     /**
  677.      * @return Collection<int, ParRecursosPerfil>
  678.      */
  679.     public function getRecursosPerfil(): Collection
  680.     {
  681.         return $this->recursosPerfil;
  682.     }
  684.     public function addRecursosPerfil(ParRecursosPerfil $recursosPerfil): static
  685.     {
  686.         if (!$this->recursosPerfil->contains($recursosPerfil)) {
  687.             $this->recursosPerfil->add($recursosPerfil);
  688.             $recursosPerfil->setProceso($this);
  689.         }
  691.         return $this;
  692.     }
  694.     public function removeRecursosPerfil(ParRecursosPerfil $recursosPerfil): static
  695.     {
  696.         if ($this->recursosPerfil->removeElement($recursosPerfil)) {
  697.             // set the owning side to null (unless already changed)
  698.             if ($recursosPerfil->getProceso() === $this) {
  699.                 $recursosPerfil->setProceso(null);
  700.             }
  701.         }
  703.         return $this;
  704.     }
  706.     /**
  707.      * @return Collection<int, ParTipoDotacion>
  708.      */
  709.     public function getTipoDotacion(): Collection
  710.     {
  711.         return $this->tipoDotacion;
  712.     }
  714.     public function addTipoDotacion(ParTipoDotacion $tipoDotacion): static
  715.     {
  716.         if (!$this->tipoDotacion->contains($tipoDotacion)) {
  717.             $this->tipoDotacion->add($tipoDotacion);
  718.             $tipoDotacion->addProceso($this);
  719.         }
  721.         return $this;
  722.     }
  724.     public function removeTipoDotacion(ParTipoDotacion $tipoDotacion): static
  725.     {
  726.         if ($this->tipoDotacion->removeElement($tipoDotacion)) {
  727.             $tipoDotacion->removeProceso($this);
  728.         }
  730.         return $this;
  731.     }
  733.     /**
  734.      * @return Collection<int, ParInduccion>
  735.      */
  736.     public function getInduccion(): Collection
  737.     {
  738.         return $this->induccion;
  739.     }
  741.     public function addInduccion(ParInduccion $induccion): static
  742.     {
  743.         if (!$this->induccion->contains($induccion)) {
  744.             $this->induccion->add($induccion);
  745.             $induccion->setProceso($this);
  746.         }
  748.         return $this;
  749.     }
  751.     public function removeInduccion(ParInduccion $induccion): static
  752.     {
  753.         if ($this->induccion->removeElement($induccion)) {
  754.             // set the owning side to null (unless already changed)
  755.             if ($induccion->getProceso() === $this) {
  756.                 $induccion->setProceso(null);
  757.             }
  758.         }
  760.         return $this;
  761.     }
  763.     /**
  764.      * @return Collection<int, GHInduccionProceso>
  765.      */
  766.     public function getInduccionProcesos(): Collection
  767.     {
  768.         return $this->induccionProcesos;
  769.     }
  771.     public function addInduccionProceso(GHInduccionProceso $induccionProceso): static
  772.     {
  773.         if (!$this->induccionProcesos->contains($induccionProceso)) {
  774.             $this->induccionProcesos->add($induccionProceso);
  775.             $induccionProceso->setProceso($this);
  776.         }
  778.         return $this;
  779.     }
  781.     public function removeInduccionProceso(GHInduccionProceso $induccionProceso): static
  782.     {
  783.         if ($this->induccionProcesos->removeElement($induccionProceso)) {
  784.             // set the owning side to null (unless already changed)
  785.             if ($induccionProceso->getProceso() === $this) {
  786.                 $induccionProceso->setProceso(null);
  787.             }
  788.         }
  790.         return $this;
  791.     }
  793.     /**
  794.      * @return Collection<int, GHMatrizEntrenamientoProceso>
  795.      */
  796.     public function getMatrizEntrenamientoProceso(): Collection
  797.     {
  798.         return $this->matrizEntrenamientoProceso;
  799.     }
  801.     public function addMatrizEntrenamientoProceso(GHMatrizEntrenamientoProceso $matrizEntrenamientoProceso): static
  802.     {
  803.         if (!$this->matrizEntrenamientoProceso->contains($matrizEntrenamientoProceso)) {
  804.             $this->matrizEntrenamientoProceso->add($matrizEntrenamientoProceso);
  805.             $matrizEntrenamientoProceso->setProceso($this);
  806.         }
  808.         return $this;
  809.     }
  811.     public function removeMatrizEntrenamientoProceso(GHMatrizEntrenamientoProceso $matrizEntrenamientoProceso): static
  812.     {
  813.         if ($this->matrizEntrenamientoProceso->removeElement($matrizEntrenamientoProceso)) {
  814.             // set the owning side to null (unless already changed)
  815.             if ($matrizEntrenamientoProceso->getProceso() === $this) {
  816.                 $matrizEntrenamientoProceso->setProceso(null);
  817.             }
  818.         }
  820.         return $this;
  821.     }
  823.     /**
  824.      * @return Collection<int, GHEntrenamientoProceso>
  825.      */
  826.     public function getEntrenamientoProcesos(): Collection
  827.     {
  828.         return $this->entrenamientoProcesos;
  829.     }
  831.     public function addEntrenamientoProceso(GHEntrenamientoProceso $entrenamientoProceso): static
  832.     {
  833.         if (!$this->entrenamientoProcesos->contains($entrenamientoProceso)) {
  834.             $this->entrenamientoProcesos->add($entrenamientoProceso);
  835.             $entrenamientoProceso->setProceso($this);
  836.         }
  838.         return $this;
  839.     }
  841.     public function removeEntrenamientoProceso(GHEntrenamientoProceso $entrenamientoProceso): static
  842.     {
  843.         if ($this->entrenamientoProcesos->removeElement($entrenamientoProceso)) {
  844.             // set the owning side to null (unless already changed)
  845.             if ($entrenamientoProceso->getProceso() === $this) {
  846.                 $entrenamientoProceso->setProceso(null);
  847.             }
  848.         }
  850.         return $this;
  851.     }
  853.     /**
  854.      * @return Collection<int, SegControlIngreso>
  855.      */
  856.     public function getControlIngreso(): Collection
  857.     {
  858.         return $this->controlIngreso;
  859.     }
  861.     public function addControlIngreso(SegControlIngreso $controlIngreso): static
  862.     {
  863.         if (!$this->controlIngreso->contains($controlIngreso)) {
  864.             $this->controlIngreso->add($controlIngreso);
  865.             $controlIngreso->setProceso($this);
  866.         }
  868.         return $this;
  869.     }
  871.     public function removeControlIngreso(SegControlIngreso $controlIngreso): static
  872.     {
  873.         if ($this->controlIngreso->removeElement($controlIngreso)) {
  874.             // set the owning side to null (unless already changed)
  875.             if ($controlIngreso->getProceso() === $this) {
  876.                 $controlIngreso->setProceso(null);
  877.             }
  878.         }
  880.         return $this;
  881.     }
  883.     /**
  884.      * @return Collection<int, SegSolicitudCCTV>
  885.      */
  886.     public function getSolicitudCCTV(): Collection
  887.     {
  888.         return $this->solicitudCCTV;
  889.     }
  891.     public function addSolicitudCCTV(SegSolicitudCCTV $solicitudCCTV): static
  892.     {
  893.         if (!$this->solicitudCCTV->contains($solicitudCCTV)) {
  894.             $this->solicitudCCTV->add($solicitudCCTV);
  895.             $solicitudCCTV->setProceso($this);
  896.         }
  898.         return $this;
  899.     }
  901.     public function removeSolicitudCCTV(SegSolicitudCCTV $solicitudCCTV): static
  902.     {
  903.         if ($this->solicitudCCTV->removeElement($solicitudCCTV)) {
  904.             // set the owning side to null (unless already changed)
  905.             if ($solicitudCCTV->getProceso() === $this) {
  906.                 $solicitudCCTV->setProceso(null);
  907.             }
  908.         }
  910.         return $this;
  911.     }
  913.     /**
  914.      * @return Collection<int, RFPrecintoSolicitud>
  915.      */
  916.     public function getPrecintoSolicitud(): Collection
  917.     {
  918.         return $this->precintoSolicitud;
  919.     }
  921.     public function addPrecintoSolicitud(RFPrecintoSolicitud $precintoSolicitud): static
  922.     {
  923.         if (!$this->precintoSolicitud->contains($precintoSolicitud)) {
  924.             $this->precintoSolicitud->add($precintoSolicitud);
  925.             $precintoSolicitud->setProceso($this);
  926.         }
  928.         return $this;
  929.     }
  931.     public function removePrecintoSolicitud(RFPrecintoSolicitud $precintoSolicitud): static
  932.     {
  933.         if ($this->precintoSolicitud->removeElement($precintoSolicitud)) {
  934.             // set the owning side to null (unless already changed)
  935.             if ($precintoSolicitud->getProceso() === $this) {
  936.                 $precintoSolicitud->setProceso(null);
  937.             }
  938.         }
  940.         return $this;
  941.     }
  943.     /**
  944.      * @return Collection<int, RFPrecintoAsignacion>
  945.      */
  946.     public function getPrecintoAsignado(): Collection
  947.     {
  948.         return $this->precintoAsignado;
  949.     }
  951.     public function addPrecintoAsignado(RFPrecintoAsignacion $precintoAsignado): static
  952.     {
  953.         if (!$this->precintoAsignado->contains($precintoAsignado)) {
  954.             $this->precintoAsignado->add($precintoAsignado);
  955.             $precintoAsignado->setProceso($this);
  956.         }
  958.         return $this;
  959.     }
  961.     public function removePrecintoAsignado(RFPrecintoAsignacion $precintoAsignado): static
  962.     {
  963.         if ($this->precintoAsignado->removeElement($precintoAsignado)) {
  964.             // set the owning side to null (unless already changed)
  965.             if ($precintoAsignado->getProceso() === $this) {
  966.                 $precintoAsignado->setProceso(null);
  967.             }
  968.         }
  970.         return $this;
  971.     }
  973.     /**
  974.      * @return Collection<int, RFSolicitudCompra>
  975.      */
  976.     public function getSolicitudCompras(): Collection
  977.     {
  978.         return $this->solicitudCompras;
  979.     }
  981.     public function addSolicitudCompra(RFSolicitudCompra $solicitudCompra): static
  982.     {
  983.         if (!$this->solicitudCompras->contains($solicitudCompra)) {
  984.             $this->solicitudCompras->add($solicitudCompra);
  985.             $solicitudCompra->setProceso($this);
  986.         }
  988.         return $this;
  989.     }
  991.     public function removeSolicitudCompra(RFSolicitudCompra $solicitudCompra): static
  992.     {
  993.         if ($this->solicitudCompras->removeElement($solicitudCompra)) {
  994.             // set the owning side to null (unless already changed)
  995.             if ($solicitudCompra->getProceso() === $this) {
  996.                 $solicitudCompra->setProceso(null);
  997.             }
  998.         }
  1000.         return $this;
  1001.     }
  1003.     /**
  1004.      * @return Collection<int, RFOrdenCompra>
  1005.      */
  1006.     public function getOrdenCompra(): Collection
  1007.     {
  1008.         return $this->ordenCompra;
  1009.     }
  1011.     public function addOrdenCompra(RFOrdenCompra $ordenCompra): static
  1012.     {
  1013.         if (!$this->ordenCompra->contains($ordenCompra)) {
  1014.             $this->ordenCompra->add($ordenCompra);
  1015.             $ordenCompra->setProceso($this);
  1016.         }
  1018.         return $this;
  1019.     }
  1021.     public function removeOrdenCompra(RFOrdenCompra $ordenCompra): static
  1022.     {
  1023.         if ($this->ordenCompra->removeElement($ordenCompra)) {
  1024.             // set the owning side to null (unless already changed)
  1025.             if ($ordenCompra->getProceso() === $this) {
  1026.                 $ordenCompra->setProceso(null);
  1027.             }
  1028.         }
  1030.         return $this;
  1031.     }
  1033.     public function isActivaTablaRetencion(): ?bool
  1034.     {
  1035.         return $this->activaTablaRetencion;
  1036.     }
  1038.     public function setActivaTablaRetencion(?bool $activaTablaRetencion): static
  1039.     {
  1040.         $this->activaTablaRetencion = $activaTablaRetencion;
  1042.         return $this;
  1043.     }
  1045.     /**
  1046.      * @return Collection<int, SecMensaje>
  1047.      */
  1048.     public function getMensajes(): Collection
  1049.     {
  1050.         return $this->mensajes;
  1051.     }
  1053.     public function addMensaje(SecMensaje $mensaje): static
  1054.     {
  1055.         if (!$this->mensajes->contains($mensaje)) {
  1056.             $this->mensajes->add($mensaje);
  1057.             $mensaje->setProceso($this);
  1058.         }
  1060.         return $this;
  1061.     }
  1063.     public function removeMensaje(SecMensaje $mensaje): static
  1064.     {
  1065.         if ($this->mensajes->removeElement($mensaje)) {
  1066.             // set the owning side to null (unless already changed)
  1067.             if ($mensaje->getProceso() === $this) {
  1068.                 $mensaje->setProceso(null);
  1069.             }
  1070.         }
  1072.         return $this;
  1073.     }
  1075.     /**
  1076.      * @return Collection<int, GHReentrenamiento>
  1077.      */
  1078.     public function getReentrenamientos(): Collection
  1079.     {
  1080.         return $this->reentrenamientos;
  1081.     }
  1083.     public function addReentrenamiento(GHReentrenamiento $reentrenamiento): static
  1084.     {
  1085.         if (!$this->reentrenamientos->contains($reentrenamiento)) {
  1086.             $this->reentrenamientos->add($reentrenamiento);
  1087.             $reentrenamiento->setProceso($this);
  1088.         }
  1090.         return $this;
  1091.     }
  1093.     public function removeReentrenamiento(GHReentrenamiento $reentrenamiento): static
  1094.     {
  1095.         if ($this->reentrenamientos->removeElement($reentrenamiento)) {
  1096.             // set the owning side to null (unless already changed)
  1097.             if ($reentrenamiento->getProceso() === $this) {
  1098.                 $reentrenamiento->setProceso(null);
  1099.             }
  1100.         }
  1102.         return $this;
  1103.     }
  1105.     /**
  1106.      * @return Collection<int, GHRegistroOpain>
  1107.      */
  1108.     public function getRegistrosOpain(): Collection
  1109.     {
  1110.         return $this->registrosOpain;
  1111.     }
  1113.     public function addRegistrosOpain(GHRegistroOpain $registrosOpain): static
  1114.     {
  1115.         if (!$this->registrosOpain->contains($registrosOpain)) {
  1116.             $this->registrosOpain->add($registrosOpain);
  1117.             $registrosOpain->setProceso($this);
  1118.         }
  1120.         return $this;
  1121.     }
  1123.     public function removeRegistrosOpain(GHRegistroOpain $registrosOpain): static
  1124.     {
  1125.         if ($this->registrosOpain->removeElement($registrosOpain)) {
  1126.             // set the owning side to null (unless already changed)
  1127.             if ($registrosOpain->getProceso() === $this) {
  1128.                 $registrosOpain->setProceso(null);
  1129.             }
  1130.         }
  1132.         return $this;
  1133.     }
  1135.     /**
  1136.      * @return Collection<int, ParSistemaInformatico>
  1137.      */
  1138.     public function getSistemasInformaticos(): Collection
  1139.     {
  1140.         return $this->sistemasInformaticos;
  1141.     }
  1143.     public function addSistemasInformatico(ParSistemaInformatico $sistemasInformatico): static
  1144.     {
  1145.         if (!$this->sistemasInformaticos->contains($sistemasInformatico)) {
  1146.             $this->sistemasInformaticos->add($sistemasInformatico);
  1147.             $sistemasInformatico->setProcesoResponsable($this);
  1148.         }
  1150.         return $this;
  1151.     }
  1153.     public function removeSistemasInformatico(ParSistemaInformatico $sistemasInformatico): static
  1154.     {
  1155.         if ($this->sistemasInformaticos->removeElement($sistemasInformatico)) {
  1156.             // set the owning side to null (unless already changed)
  1157.             if ($sistemasInformatico->getProcesoResponsable() === $this) {
  1158.                 $sistemasInformatico->setProcesoResponsable(null);
  1159.             }
  1160.         }
  1162.         return $this;
  1163.     }
  1165.     /**
  1166.      * @return Collection<int, GHReentrenamientoProceso>
  1167.      */
  1168.     public function getGHReentrenamientoProcesos(): Collection
  1169.     {
  1170.         return $this->gHReentrenamientoProcesos;
  1171.     }
  1173.     public function addGHReentrenamientoProceso(GHReentrenamientoProceso $gHReentrenamientoProceso): static
  1174.     {
  1175.         if (!$this->gHReentrenamientoProcesos->contains($gHReentrenamientoProceso)) {
  1176.             $this->gHReentrenamientoProcesos->add($gHReentrenamientoProceso);
  1177.             $gHReentrenamientoProceso->setParProceso($this);
  1178.         }
  1180.         return $this;
  1181.     }
  1183.     public function removeGHReentrenamientoProceso(GHReentrenamientoProceso $gHReentrenamientoProceso): static
  1184.     {
  1185.         if ($this->gHReentrenamientoProcesos->removeElement($gHReentrenamientoProceso)) {
  1186.             // set the owning side to null (unless already changed)
  1187.             if ($gHReentrenamientoProceso->getParProceso() === $this) {
  1188.                 $gHReentrenamientoProceso->setParProceso(null);
  1189.             }
  1190.         }
  1192.         return $this;
  1193.     }
  1194.     
  1195. }