src/Entity/Admin.php

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\AdminRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. #[ORM\Table(name: '`admin`')]
  11. #[ORM\Entity(repositoryClass: AdminRepository::class)]
  12. class Admin extends User
  13. {
  14.     #[ORM\Id]
  15.     #[ORM\GeneratedValue]
  16.     #[ORM\Column(type: 'integer')]
  17.     private $id;
  19.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: Empresa::class)]
  20.     private $empresas;
  22.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: SolicitarEmpresa::class)]
  23.     private $solicitarEmpresas;
  25.     // #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: Cargo::class)]
  26.     // private $cargos;
  28.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: Prestador::class)]
  29.     private $prestadors;
  31.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: SubBeneficio::class)]
  32.     private $subBeneficios;
  34.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: Beneficio::class)]
  35.     private $beneficios;
  37.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: Proveedor::class)]
  38.     private $proveedors;
  40.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: FacturaDeCompra::class)]
  41.     private $facturaDeCompras;
  43.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: CompraStock::class)]
  44.     private $compraStocks;
  46.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: EmpleadoBeneficio::class)]
  47.     private $empleadoBeneficios;
  49.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: Concepto::class)]
  50.     private $conceptos;
  52.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: MediosDePago::class)]
  53.     private $mediosDePagos;
  55.     #[ORM\OneToMany(mappedBy: 'adminPagoManual', targetEntity: Boleta::class)]
  56.     private $boleta;
  58.     #[ORM\OneToMany(mappedBy: 'adminEdito', targetEntity: EscalaSalarial::class)]
  59.     private $escalaSalarials;
  61.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: MotivoLiquidacionEmpleado::class)]
  62.     private $motivoLiquidacionEmpleado;
  64.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: AcuerdoDePago::class)]
  65.     private $acuerdoDePagos;
  67.     #[ORM\OneToMany(mappedBy: 'AdminCargo', targetEntity: PagosAcuerdo::class)]
  68.     private $pagosAcuerdos;
  70.     #[ORM\OneToMany(mappedBy: 'adminAprobo', targetEntity: InformarPago::class)]
  71.     private $informarPagos;
  73.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: ItemDenuncia::class)]
  74.     private $itemDenuncias;
  76.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: Denuncia::class)]
  77.     private $denuncias;
  79.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: PagosBanco::class)]
  80.     private $pagosBancos;
  82.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: CertificadoDeDeuda::class)]
  83.     private Collection $certificado;
  85.     #[ORM\OneToMany(mappedBy: 'adminCargo', targetEntity: EmpleadoRecibo::class)]
  86.     private Collection $empleadoRecibos;
  88.     public function __construct()
  89.     {
  90.         $this->empresas = new ArrayCollection();
  91.         $this->solicitarEmpresas = new ArrayCollection();
  92.         $this->prestadors = new ArrayCollection();
  93.         $this->subBeneficios = new ArrayCollection();
  94.         $this->beneficios = new ArrayCollection();
  95.         $this->proveedors = new ArrayCollection();
  96.         $this->facturaDeCompras = new ArrayCollection();
  97.         $this->compraStocks = new ArrayCollection();
  98.         $this->empleadoBeneficios = new ArrayCollection();
  99.         $this->conceptos = new ArrayCollection();
  100.         $this->mediosDePagos = new ArrayCollection();
  101.         $this->boleta = new ArrayCollection();
  102.         $this->escalaSalarials = new ArrayCollection();
  103.         $this->motivoLiquidacionEmpleado = new ArrayCollection();
  104.         $this->acuerdoDePagos = new ArrayCollection();
  105.         $this->acuerdoDePagos = new ArrayCollection();
  106.         $this->pagosAcuerdos = new ArrayCollection();
  107.         $this->informarPagos = new ArrayCollection();
  108.         $this->itemDenuncias = new ArrayCollection();
  109.         $this->denuncias = new ArrayCollection();
  110.         $this->pagosBancos = new ArrayCollection();
  111.         $this->certificado = new ArrayCollection();
  112.         $this->empleadoRecibos = new ArrayCollection();
  113.     }
  115.     /**
  116.      * @return Collection<int, Empresa>
  117.      */
  118.     public function getEmpresas(): Collection
  119.     {
  120.         return $this->empresas;
  121.     }
  123.     public function addEmpresa(Empresa $empresa): self
  124.     {
  125.         if (!$this->empresas->contains($empresa)) {
  126.             $this->empresas[] = $empresa;
  127.             $empresa->setAdminCargo($this);
  128.         }
  130.         return $this;
  131.     }
  133.     public function removeEmpresa(Empresa $empresa): self
  134.     {
  135.         if ($this->empresas->removeElement($empresa)) {
  136.             // set the owning side to null (unless already changed)
  137.             if ($empresa->getAdminCargo() === $this) {
  138.                 $empresa->setAdminCargo(null);
  139.             }
  140.         }
  142.         return $this;
  143.     }
  145.        /**
  146.      * @return Collection<int, SolicitarEmpresa>
  147.      */
  148.     public function getSolicitarEmpresas(): Collection
  149.     {
  150.         return $this->solicitarEmpresas;
  151.     }
  153.     public function addSolicitarEmpresa(SolicitarEmpresa $solicitarEmpresa): self
  154.     {
  155.         if (!$this->solicitarEmpresas->contains($solicitarEmpresa)) {
  156.             $this->solicitarEmpresas[] = $solicitarEmpresa;
  157.             $solicitarEmpresa->setAdmin($this);
  158.         }
  160.         return $this;
  161.     }
  163.     public function removeSolicitarEmpresa(SolicitarEmpresa $solicitarEmpresa): self
  164.     {
  165.         if ($this->solicitarEmpresas->removeElement($solicitarEmpresa)) {
  166.             // set the owning side to null (unless already changed)
  167.             if ($solicitarEmpresa->getAdmin() === $this) {
  168.                 $solicitarEmpresa->setAdmin(null);
  169.             }
  170.         }
  172.         return $this;
  173.     }
  175.     /**
  176.      * @return Collection<int, Prestador>
  177.      */
  178.     public function getPrestadors(): Collection
  179.     {
  180.         return $this->prestadors;
  181.     }
  183.     public function addPrestador(Prestador $prestador): self
  184.     {
  185.         if (!$this->prestadors->contains($prestador)) {
  186.             $this->prestadors[] = $prestador;
  187.             $prestador->setAdminCargo($this);
  188.         }
  190.         return $this;
  191.     }
  193.     public function removePrestador(Prestador $prestador): self
  194.     {
  195.         if ($this->prestadors->removeElement($prestador)) {
  196.             // set the owning side to null (unless already changed)
  197.             if ($prestador->getAdminCargo() === $this) {
  198.                 $prestador->setAdminCargo(null);
  199.             }
  200.         }
  202.         return $this;
  203.     }
  205.     /**
  206.      * @return Collection<int, SubBeneficio>
  207.      */
  208.     public function getSubBeneficios(): Collection
  209.     {
  210.         return $this->subBeneficios;
  211.     }
  213.     public function addSubBeneficio(SubBeneficio $subBeneficio): self
  214.     {
  215.         if (!$this->subBeneficios->contains($subBeneficio)) {
  216.             $this->subBeneficios[] = $subBeneficio;
  217.             $subBeneficio->setAdminCargo($this);
  218.         }
  220.         return $this;
  221.     }
  223.     public function removeSubBeneficio(SubBeneficio $subBeneficio): self
  224.     {
  225.         if ($this->subBeneficios->removeElement($subBeneficio)) {
  226.             // set the owning side to null (unless already changed)
  227.             if ($subBeneficio->getAdminCargo() === $this) {
  228.                 $subBeneficio->setAdminCargo(null);
  229.             }
  230.         }
  232.         return $this;
  233.     }
  235.     /**
  236.      * @return Collection<int, Beneficio>
  237.      */
  238.     public function getBeneficios(): Collection
  239.     {
  240.         return $this->beneficios;
  241.     }
  243.     public function addBeneficio(Beneficio $beneficio): self
  244.     {
  245.         if (!$this->beneficios->contains($beneficio)) {
  246.             $this->beneficios[] = $beneficio;
  247.             $beneficio->setAdminCargo($this);
  248.         }
  250.         return $this;
  251.     }
  253.     public function removeBeneficio(Beneficio $beneficio): self
  254.     {
  255.         if ($this->beneficios->removeElement($beneficio)) {
  256.             // set the owning side to null (unless already changed)
  257.             if ($beneficio->getAdminCargo() === $this) {
  258.                 $beneficio->setAdminCargo(null);
  259.             }
  260.         }
  262.         return $this;
  263.     }
  265.     /**
  266.      * @return Collection<int, Proveedor>
  267.      */
  268.     public function getProveedors(): Collection
  269.     {
  270.         return $this->proveedors;
  271.     }
  273.     public function addProveedor(Proveedor $proveedor): self
  274.     {
  275.         if (!$this->proveedors->contains($proveedor)) {
  276.             $this->proveedors[] = $proveedor;
  277.             $proveedor->setAdminCargo($this);
  278.         }
  280.         return $this;
  281.     }
  283.     public function removeProveedor(Proveedor $proveedor): self
  284.     {
  285.         if ($this->proveedors->removeElement($proveedor)) {
  286.             // set the owning side to null (unless already changed)
  287.             if ($proveedor->getAdminCargo() === $this) {
  288.                 $proveedor->setAdminCargo(null);
  289.             }
  290.         }
  292.         return $this;
  293.     }
  295.     /**
  296.      * @return Collection<int, FacturaDeCompra>
  297.      */
  298.     public function getFacturaDeCompras(): Collection
  299.     {
  300.         return $this->facturaDeCompras;
  301.     }
  303.     public function addFacturaDeCompra(FacturaDeCompra $facturaDeCompra): self
  304.     {
  305.         if (!$this->facturaDeCompras->contains($facturaDeCompra)) {
  306.             $this->facturaDeCompras[] = $facturaDeCompra;
  307.             $facturaDeCompra->setAdminCargo($this);
  308.         }
  310.         return $this;
  311.     }
  313.     public function removeFacturaDeCompra(FacturaDeCompra $facturaDeCompra): self
  314.     {
  315.         if ($this->facturaDeCompras->removeElement($facturaDeCompra)) {
  316.             // set the owning side to null (unless already changed)
  317.             if ($facturaDeCompra->getAdminCargo() === $this) {
  318.                 $facturaDeCompra->setAdminCargo(null);
  319.             }
  320.         }
  322.         return $this;
  323.     }
  325.     /**
  326.      * @return Collection<int, CompraStock>
  327.      */
  328.     public function getCompraStocks(): Collection
  329.     {
  330.         return $this->compraStocks;
  331.     }
  333.     public function addCompraStock(CompraStock $compraStock): self
  334.     {
  335.         if (!$this->compraStocks->contains($compraStock)) {
  336.             $this->compraStocks[] = $compraStock;
  337.             $compraStock->setAdminCargo($this);
  338.         }
  340.         return $this;
  341.     }
  343.     public function removeCompraStock(CompraStock $compraStock): self
  344.     {
  345.         if ($this->compraStocks->removeElement($compraStock)) {
  346.             // set the owning side to null (unless already changed)
  347.             if ($compraStock->getAdminCargo() === $this) {
  348.                 $compraStock->setAdminCargo(null);
  349.             }
  350.         }
  352.         return $this;
  353.     }
  355.     /**
  356.      * @return Collection<int, EmpleadoBeneficio>
  357.      */
  358.     public function getEmpleadoBeneficios(): Collection
  359.     {
  360.         return $this->empleadoBeneficios;
  361.     }
  363.     public function addEmpleadoBeneficio(EmpleadoBeneficio $empleadoBeneficio): self
  364.     {
  365.         if (!$this->empleadoBeneficios->contains($empleadoBeneficio)) {
  366.             $this->empleadoBeneficios[] = $empleadoBeneficio;
  367.             $empleadoBeneficio->setAdminCargo($this);
  368.         }
  370.         return $this;
  371.     }
  373.     public function removeEmpleadoBeneficio(EmpleadoBeneficio $empleadoBeneficio): self
  374.     {
  375.         if ($this->empleadoBeneficios->removeElement($empleadoBeneficio)) {
  376.             // set the owning side to null (unless already changed)
  377.             if ($empleadoBeneficio->getAdminCargo() === $this) {
  378.                 $empleadoBeneficio->setAdminCargo(null);
  379.             }
  380.         }
  382.         return $this;
  383.     }
  385.     /**
  386.      * @return Collection<int, Concepto>
  387.      */
  388.     public function getConceptos(): Collection
  389.     {
  390.         return $this->conceptos;
  391.     }
  393.     public function addConcepto(Concepto $concepto): self
  394.     {
  395.         if (!$this->conceptos->contains($concepto)) {
  396.             $this->conceptos[] = $concepto;
  397.             $concepto->setAdminCargo($this);
  398.         }
  400.         return $this;
  401.     }
  403.     public function removeConcepto(Concepto $concepto): self
  404.     {
  405.         if ($this->conceptos->removeElement($concepto)) {
  406.             // set the owning side to null (unless already changed)
  407.             if ($concepto->getAdminCargo() === $this) {
  408.                 $concepto->setAdminCargo(null);
  409.             }
  410.         }
  412.         return $this;
  413.     }
  415.     /**
  416.      * @return Collection<int, MediosDePago>
  417.      */
  418.     public function getMediosDePagos(): Collection
  419.     {
  420.         return $this->mediosDePagos;
  421.     }
  423.     public function addMediosDePago(MediosDePago $mediosDePago): self
  424.     {
  425.         if (!$this->mediosDePagos->contains($mediosDePago)) {
  426.             $this->mediosDePagos[] = $mediosDePago;
  427.             $mediosDePago->setAdminCargo($this);
  428.         }
  430.         return $this;
  431.     }
  433.     public function removeMediosDePago(MediosDePago $mediosDePago): self
  434.     {
  435.         if ($this->mediosDePagos->removeElement($mediosDePago)) {
  436.             // set the owning side to null (unless already changed)
  437.             if ($mediosDePago->getAdminCargo() === $this) {
  438.                 $mediosDePago->setAdminCargo(null);
  439.             }
  440.         }
  442.         return $this;
  443.     }
  445.     /**
  446.      * @return Collection<int, Boleta>
  447.      */
  448.     public function getBoleta(): Collection
  449.     {
  450.         return $this->boleta;
  451.     }
  453.     public function addBoleta(Boleta $boleta): self
  454.     {
  455.         if (!$this->boleta->contains($boleta)) {
  456.             $this->boleta[] = $boleta;
  457.             $boleta->setAdminPagoManual($this);
  458.         }
  460.         return $this;
  461.     }
  463.     public function removeBoleta(Boleta $boleta): self
  464.     {
  465.         if ($this->boleta->removeElement($boleta)) {
  466.             // set the owning side to null (unless already changed)
  467.             if ($boleta->getAdminPagoManual() === $this) {
  468.                 $boleta->setAdminPagoManual(null);
  469.             }
  470.         }
  472.         return $this;
  473.     }
  475.     /**
  476.      * @return Collection<int, EscalaSalarial>
  477.      */
  478.     public function getEscalaSalarials(): Collection
  479.     {
  480.         return $this->escalaSalarials;
  481.     }
  483.     public function addEscalaSalarial(EscalaSalarial $escalaSalarial): self
  484.     {
  485.         if (!$this->escalaSalarials->contains($escalaSalarial)) {
  486.             $this->escalaSalarials[] = $escalaSalarial;
  487.             $escalaSalarial->setAdminEdito($this);
  488.         }
  490.         return $this;
  491.     }
  493.     public function removeEscalaSalarial(EscalaSalarial $escalaSalarial): self
  494.     {
  495.         if ($this->escalaSalarials->removeElement($escalaSalarial)) {
  496.             // set the owning side to null (unless already changed)
  497.             if ($escalaSalarial->getAdminEdito() === $this) {
  498.                 $escalaSalarial->setAdminEdito(null);
  499.             }
  500.         }
  502.         return $this;
  503.     }
  505.     /**
  506.      * @return Collection<int, MotivoLiquidacionEmpleado>
  507.      */
  508.     public function getMotivoLiquidacionEmpleado(): Collection
  509.     {
  510.         return $this->motivoLiquidacionEmpleado;
  511.     }
  513.     public function addMotivoLiquidacionEmpleado(MotivoLiquidacionEmpleado $motivoLiquidacionEmpleado): self
  514.     {
  515.         if (!$this->motivoLiquidacionEmpleado->contains($motivoLiquidacionEmpleado)) {
  516.             $this->motivoLiquidacionEmpleado[] = $motivoLiquidacionEmpleado;
  517.             $motivoLiquidacionEmpleado->setAdminCargo($this);
  518.         }
  520.         return $this;
  521.     }
  523.     public function removeMotivoLiquidacionEmpleado(MotivoLiquidacionEmpleado $motivoLiquidacionEmpleado): self
  524.     {
  525.         if ($this->motivoLiquidacionEmpleado->removeElement($motivoLiquidacionEmpleado)) {
  526.             // set the owning side to null (unless already changed)
  527.             if ($motivoLiquidacionEmpleado->getAdminCargo() === $this) {
  528.                 $motivoLiquidacionEmpleado->setAdminCargo(null);
  529.             }
  530.         }
  532.         return $this;
  533.     }
  535.     /**
  536.      * @return Collection<int, AcuerdoDePago>
  537.      */
  538.     public function getAcuerdoDePagos(): Collection
  539.     {
  540.         return $this->acuerdoDePagos;
  541.     }
  543.     public function addAcuerdoDePago(AcuerdoDePago $acuerdoDePago): self
  544.     {
  545.         if (!$this->acuerdoDePagos->contains($acuerdoDePago)) {
  546.             $this->acuerdoDePagos[] = $acuerdoDePago;
  547.             $acuerdoDePago->setAdminCargo($this);
  548.         }
  550.         return $this;
  551.     }
  553.     public function removeAcuerdoDePago(AcuerdoDePago $acuerdoDePago): self
  554.     {
  555.         if ($this->acuerdoDePagos->removeElement($acuerdoDePago)) {
  556.             // set the owning side to null (unless already changed)
  557.             if ($acuerdoDePago->getAdminCargo() === $this) {
  558.                 $acuerdoDePago->setAdminCargo(null);
  559.             }
  560.         }
  562.         return $this;
  563.     }
  565.   
  567.     /**
  568.      * @return Collection<int, PagosAcuerdo>
  569.      */
  570.     public function getPagosAcuerdos(): Collection
  571.     {
  572.         return $this->pagosAcuerdos;
  573.     }
  575.     public function addPagosAcuerdo(PagosAcuerdo $pagosAcuerdo): self
  576.     {
  577.         if (!$this->pagosAcuerdos->contains($pagosAcuerdo)) {
  578.             $this->pagosAcuerdos[] = $pagosAcuerdo;
  579.             $pagosAcuerdo->setAdminCargo($this);
  580.         }
  582.         return $this;
  583.     }
  585.     public function removePagosAcuerdo(PagosAcuerdo $pagosAcuerdo): self
  586.     {
  587.         if ($this->pagosAcuerdos->removeElement($pagosAcuerdo)) {
  588.             // set the owning side to null (unless already changed)
  589.             if ($pagosAcuerdo->getAdminCargo() === $this) {
  590.                 $pagosAcuerdo->setAdminCargo(null);
  591.             }
  592.         }
  594.         return $this;
  595.     }
  597.     /**
  598.      * @return Collection<int, InformarPago>
  599.      */
  600.     public function getInformarPagos(): Collection
  601.     {
  602.         return $this->informarPagos;
  603.     }
  605.     public function addInformarPago(InformarPago $informarPago): self
  606.     {
  607.         if (!$this->informarPagos->contains($informarPago)) {
  608.             $this->informarPagos[] = $informarPago;
  609.             $informarPago->setAdminAprobo($this);
  610.         }
  612.         return $this;
  613.     }
  615.     public function removeInformarPago(InformarPago $informarPago): self
  616.     {
  617.         if ($this->informarPagos->removeElement($informarPago)) {
  618.             // set the owning side to null (unless already changed)
  619.             if ($informarPago->getAdminAprobo() === $this) {
  620.                 $informarPago->setAdminAprobo(null);
  621.             }
  622.         }
  624.         return $this;
  625.     }
  627.     /**
  628.      * @return Collection<int, ItemDenuncia>
  629.      */
  630.     public function getItemDenuncias(): Collection
  631.     {
  632.         return $this->itemDenuncias;
  633.     }
  635.     public function addItemDenuncia(ItemDenuncia $itemDenuncia): self
  636.     {
  637.         if (!$this->itemDenuncias->contains($itemDenuncia)) {
  638.             $this->itemDenuncias[] = $itemDenuncia;
  639.             $itemDenuncia->setAdminCargo($this);
  640.         }
  642.         return $this;
  643.     }
  645.     public function removeItemDenuncia(ItemDenuncia $itemDenuncia): self
  646.     {
  647.         if ($this->itemDenuncias->removeElement($itemDenuncia)) {
  648.             // set the owning side to null (unless already changed)
  649.             if ($itemDenuncia->getAdminCargo() === $this) {
  650.                 $itemDenuncia->setAdminCargo(null);
  651.             }
  652.         }
  654.         return $this;
  655.     }
  657.     /**
  658.      * @return Collection<int, Denuncia>
  659.      */
  660.     public function getDenuncias(): Collection
  661.     {
  662.         return $this->denuncias;
  663.     }
  665.     public function addDenuncia(Denuncia $denuncia): self
  666.     {
  667.         if (!$this->denuncias->contains($denuncia)) {
  668.             $this->denuncias[] = $denuncia;
  669.             $denuncia->setAdminCargo($this);
  670.         }
  672.         return $this;
  673.     }
  675.     public function removeDenuncia(Denuncia $denuncia): self
  676.     {
  677.         if ($this->denuncias->removeElement($denuncia)) {
  678.             // set the owning side to null (unless already changed)
  679.             if ($denuncia->getAdminCargo() === $this) {
  680.                 $denuncia->setAdminCargo(null);
  681.             }
  682.         }
  684.         return $this;
  685.     }
  686.     
  687.     /**
  688.      * @return Collection<int, PagosBanco>
  689.      */
  690.     public function getPagosBancos(): Collection
  691.     {
  692.         return $this->pagosBancos;
  693.     }
  695.     public function addPagosBanco(PagosBanco $pagosBanco): self
  696.     {
  697.         if (!$this->pagosBancos->contains($pagosBanco)) {
  698.             $this->pagosBancos[] = $pagosBanco;
  699.             $pagosBanco->setAdminCargo($this);
  700.         }
  702.         return $this;
  703.     }
  705.     public function removePagosBanco(PagosBanco $pagosBanco): self
  706.     {
  707.         if ($this->pagosBancos->removeElement($pagosBanco)) {
  708.             // set the owning side to null (unless already changed)
  709.             if ($pagosBanco->getAdminCargo() === $this) {
  710.                 $pagosBanco->setAdminCargo(null);
  711.             }
  712.         }
  714.         return $this;
  715.     }
  717.     /**
  718.      * @return Collection<int, CertificadoDeDeuda>
  719.      */
  720.     public function getCertificado(): Collection
  721.     {
  722.         return $this->certificado;
  723.     }
  725.     public function addCertificado(CertificadoDeDeuda $certificado): self
  726.     {
  727.         if (!$this->certificado->contains($certificado)) {
  728.             $this->certificado->add($certificado);
  729.             $certificado->setAdminCargo($this);
  730.         }
  732.         return $this;
  733.     }
  735.     public function removeCertificado(CertificadoDeDeuda $certificado): self
  736.     {
  737.         if ($this->certificado->removeElement($certificado)) {
  738.             // set the owning side to null (unless already changed)
  739.             if ($certificado->getAdminCargo() === $this) {
  740.                 $certificado->setAdminCargo(null);
  741.             }
  742.         }
  744.         return $this;
  745.     }
  747.     /**
  748.      * @return Collection<int, EmpleadoRecibo>
  749.      */
  750.     public function getEmpleadoRecibos(): Collection
  751.     {
  752.         return $this->empleadoRecibos;
  753.     }
  755.     public function addEmpleadoRecibo(EmpleadoRecibo $empleadoRecibo): self
  756.     {
  757.         if (!$this->empleadoRecibos->contains($empleadoRecibo)) {
  758.             $this->empleadoRecibos->add($empleadoRecibo);
  759.             $empleadoRecibo->setAdminCargo($this);
  760.         }
  762.         return $this;
  763.     }
  765.     public function removeEmpleadoRecibo(EmpleadoRecibo $empleadoRecibo): self
  766.     {
  767.         if ($this->empleadoRecibos->removeElement($empleadoRecibo)) {
  768.             // set the owning side to null (unless already changed)
  769.             if ($empleadoRecibo->getAdminCargo() === $this) {
  770.                 $empleadoRecibo->setAdminCargo(null);
  771.             }
  772.         }
  774.         return $this;
  775.     }
  777. }