src/Entity/Fraccionamiento.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\FraccionamientoRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. /**
  11.  * @ORM\Entity(repositoryClass=FraccionamientoRepository::class)
  12.  */
  13. class Fraccionamiento
  14. {
  15.     /**
  16.      * @ORM\Id
  17.      * @ORM\GeneratedValue
  18.      * @ORM\Column(type="integer")
  19.      */
  20.     private $id;
  22.     /**
  23.      * @ORM\ManyToMany(targetEntity=Factura::class, inversedBy="fraccionamientos")
  24.      */
  25.     private $facturas;
  27.     /**
  28.      * @ORM\ManyToMany(targetEntity=FacturaGenerica::class, inversedBy="fraccionamientos")
  29.      */
  30.     private $facturasGenericas;
  32.     /**
  33.      * @ORM\Column(type="integer", nullable=true)
  34.      */
  35.     private $plazos;
  37.     /**
  38.      * @ORM\Column(type="decimal", precision=10, scale=2, nullable=true)
  39.      */
  40.     private $importeTotal;
  42.     /**
  43.      * @ORM\OneToMany(targetEntity=Concepto::class, mappedBy="fraccionamiento")
  44.      */
  45.     private $otrosConceptos;
  47.     /**
  48.      * @ORM\ManyToOne(targetEntity=Cliente::class, inversedBy="fraccionamientos")
  49.      */
  50.     private $cliente;
  52.     /**
  53.      * @ORM\OneToMany(targetEntity=PagoFraccionamiento::class, mappedBy="fraccionamiento", orphanRemoval=true)
  54.      */
  55.     private $pagos;
  57.     /**
  58.      * @ORM\Column(type="datetime", nullable=true)
  59.      */
  60.     private $fechaCreacion;
  62.     /**
  63.      * @ORM\Column(type="string", length=255, nullable=true)
  64.      */
  65.     private $estado;
  67.     /**
  68.      * @ORM\Column(type="datetime", nullable=true)
  69.      */
  70.     private $fechaPago;
  72.     /**
  73.      * @ORM\Column(type="dateinterval", nullable=true)
  74.      */
  75.     private $periodo;
  77.     public function __construct()
  78.     {
  79.         $this->facturas = new ArrayCollection();
  80.         $this->facturasGenericas = new ArrayCollection();
  81.         $this->otrosConceptos = new ArrayCollection();
  82.         $this->pagos = new ArrayCollection();
  83.     }
  85.     public function getId(): ?int
  86.     {
  87.         return $this->id;
  88.     }
  90.     /**
  91.      * @return Collection<int, Factura>
  92.      */
  93.     public function getFacturas(): Collection
  94.     {
  95.         return $this->facturas;
  96.     }
  98.     public function addFactura(Factura $factura): self
  99.     {
  100.         if (!$this->facturas->contains($factura)) {
  101.             $this->facturas[] = $factura;
  102.         }
  104.         return $this;
  105.     }
  107.     public function removeFactura(Factura $factura): self
  108.     {
  109.         $this->facturas->removeElement($factura);
  111.         return $this;
  112.     }
  114.     /**
  115.      * @return Collection<int, FacturaGenerica>
  116.      */
  117.     public function getFacturasGenericas(): Collection
  118.     {
  119.         return $this->facturasGenericas;
  120.     }
  122.     public function addFacturasGenerica(FacturaGenerica $facturasGenerica): self
  123.     {
  124.         if (!$this->facturasGenericas->contains($facturasGenerica)) {
  125.             $this->facturasGenericas[] = $facturasGenerica;
  126.         }
  128.         return $this;
  129.     }
  131.     public function removeFacturasGenerica(FacturaGenerica $facturasGenerica): self
  132.     {
  133.         $this->facturasGenericas->removeElement($facturasGenerica);
  135.         return $this;
  136.     }
  138.     public function getPlazos(): ?int
  139.     {
  140.         return $this->plazos;
  141.     }
  143.     public function setPlazos(?int $plazos): self
  144.     {
  145.         $this->plazos = $plazos;
  147.         return $this;
  148.     }
  150.     public function getImporteTotal(): ?string
  151.     {
  152.         return $this->importeTotal;
  153.     }
  155.     public function setImporteTotal(?string $importeTotal): self
  156.     {
  157.         $this->importeTotal = $importeTotal;
  159.         return $this;
  160.     }
  162.     /**
  163.      * @return Collection<int, Concepto>
  164.      */
  165.     public function getOtrosConceptos(): Collection
  166.     {
  167.         return $this->otrosConceptos;
  168.     }
  170.     public function addOtrosConcepto(Concepto $otrosConcepto): self
  171.     {
  172.         if (!$this->otrosConceptos->contains($otrosConcepto)) {
  173.             $this->otrosConceptos[] = $otrosConcepto;
  174.             $otrosConcepto->setFraccionamiento($this);
  175.         }
  177.         return $this;
  178.     }
  180.     public function removeOtrosConcepto(Concepto $otrosConcepto): self
  181.     {
  182.         if ($this->otrosConceptos->removeElement($otrosConcepto)) {
  183.             // set the owning side to null (unless already changed)
  184.             if ($otrosConcepto->getFraccionamiento() === $this) {
  185.                 $otrosConcepto->setFraccionamiento(null);
  186.             }
  187.         }
  189.         return $this;
  190.     }
  192.     public function getCliente(): ?Cliente
  193.     {
  194.         return $this->cliente;
  195.     }
  197.     public function setCliente(?Cliente $cliente): self
  198.     {
  199.         $this->cliente = $cliente;
  201.         return $this;
  202.     }
  204.     /**
  205.      * @return Collection<int, PagoFraccionamiento>
  206.      */
  207.     public function getPagos(): Collection
  208.     {
  209.         return $this->pagos;
  210.     }
  212.     public function addPago(PagoFraccionamiento $pago): self
  213.     {
  214.         if (!$this->pagos->contains($pago)) {
  215.             $this->pagos[] = $pago;
  216.             $pago->setFraccionamiento($this);
  217.         }
  219.         return $this;
  220.     }
  222.     public function removePago(PagoFraccionamiento $pago): self
  223.     {
  224.         if ($this->pagos->removeElement($pago)) {
  225.             // set the owning side to null (unless already changed)
  226.             if ($pago->getFraccionamiento() === $this) {
  227.                 $pago->setFraccionamiento(null);
  228.             }
  229.         }
  231.         return $this;
  232.     }
  234.     public function getFechaCreacion(): ?\DateTimeInterface
  235.     {
  236.         return $this->fechaCreacion;
  237.     }
  239.     public function setFechaCreacion(?\DateTimeInterface $fechaCreacion): self
  240.     {
  241.         $this->fechaCreacion = $fechaCreacion;
  243.         return $this;
  244.     }
  246.     public function getEstado(): ?string
  247.     {
  248.         return $this->estado;
  249.     }
  251.     public function setEstado(?string $estado): self
  252.     {
  253.         $this->estado = $estado;
  255.         return $this;
  256.     }
  258.     public function getFechaPago(): ?\DateTimeInterface
  259.     {
  260.         return $this->fechaPago;
  261.     }
  263.     public function setFechaPago(?\DateTimeInterface $fechaPago): self
  264.     {
  265.         $this->fechaPago = $fechaPago;
  267.         return $this;
  268.     }
  270.     public function getPeriodo(): ?\DateInterval
  271.     {
  272.         return $this->periodo;
  273.     }
  275.     public function setPeriodo(?\DateInterval $periodo): self
  276.     {
  277.         $this->periodo = $periodo;
  279.         return $this;
  280.     }
  281. }