src/Entity/EnteteFacture.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\EnteteFactureRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. /**
  11.  * @ORM\Entity(repositoryClass=EnteteFactureRepository::class)
  12.  */
  13. class EnteteFacture
  14. {
  15.     /**
  16.      * @ORM\Id
  17.      * @ORM\GeneratedValue
  18.      * @ORM\Column(type="integer")
  19.      */
  20.     private $id;
  22.     /**
  23.      * @ORM\Column(type="string", length=255)
  24.      */
  25.     private $numerofacture;
  27.     /**
  28.      * @ORM\Column(type="date", nullable=true)
  29.      */
  30.     private $datefacture;
  32.     /**
  33.      * @ORM\Column(type="date", nullable=true)
  34.      */
  35.     private $dateecheance;
  37.     /**
  38.      * @ORM\Column(type="string", length=255, nullable=true)
  39.      */
  40.     private $reference;
  42.     /**
  43.      * @ORM\Column(type="string", length=255, nullable=true)
  44.      */
  45.     private $statut;
  47.     /**
  48.      * @ORM\Column(type="datetime_immutable", nullable=true)
  49.      */
  50.     private $created_at;
  52.     /**
  53.      * @ORM\Column(type="datetime_immutable", nullable=true)
  54.      */
  55.     private $updated_at;
  57.     /**
  58.      * @ORM\OneToMany(targetEntity=Inscrit::class, mappedBy="entetefacture")
  59.      */
  60.     private $inscrits;
  62.     /**
  63.      * @ORM\OneToMany(targetEntity=LigneFacture::class, mappedBy="entetefacture",cascade={"persist"})
  64.      */
  65.     private $ligneFactures;
  67.     /**
  68.      * @ORM\Column(type="string", length=255, nullable=true)
  69.      */
  70.     private $typeclient;
  72.     /**
  73.      * @ORM\Column(type="string", length=255, nullable=true)
  74.      */
  75.     private $statutreglement;
  77.     /**
  78.      * @ORM\OneToMany(targetEntity=ReglementFactureInscrit::class, mappedBy="entetefacture")
  79.      */
  80.     private $enteteReglementFactureInscrits;
  82.     /**
  83.      * @ORM\Column(type="string", length=255, nullable=true)
  84.      */
  85.     private $payeur;
  87.     /**
  88.      * @ORM\ManyToOne(targetEntity=Site::class, inversedBy="enteteFactures")
  89.      */
  90.     private $site;
  92.     /**
  93.      * @ORM\OneToMany(targetEntity=LigneFacturePrint::class, mappedBy="enteteFacture")
  94.      */
  95.     private $ligneFacturePrints;
  97.     /**
  98.      * @ORM\ManyToOne(targetEntity=Tier::class)
  99.      */
  100.     private $tier;
  102.     /**
  103.      * @ORM\ManyToOne(targetEntity=Entreprise::class, inversedBy="enteteFactures")
  104.      */
  105.     private $entreprise;
  107.     /**
  108.      * @ORM\ManyToOne(targetEntity=Organisme::class, inversedBy="enteteFactures")
  109.      */
  110.     private $organisme;
  112.     /**
  113.      * @ORM\OneToMany(targetEntity=EcheanceInscrit::class, mappedBy="enteteFacture")
  114.      */
  115.     private $echeanceInscrits;
  117.     /**
  118.      * @ORM\Column(type="float", nullable=true)
  119.      */
  120.     private $montant;
  122.     /**
  123.      * @ORM\Column(type="float", nullable=true)
  124.      */
  125.     private $montantRegle;
  127.     /**
  128.      * @ORM\Column(type="float", nullable=true)
  129.      */
  130.     private $resteAregler;
  132.     /**
  133.      * @ORM\OneToMany(targetEntity=ReglementEcheance::class, mappedBy="enteteFacture")
  134.      */
  135.     private $reglementEcheances;
  137.     public function __construct()
  138.     {
  139.         $this->inscrits = new ArrayCollection();
  140.         $this->ligneFactures = new ArrayCollection();
  141.         $this->enteteReglementFactureInscrits = new ArrayCollection();
  142.         $this->ligneFacturePrints = new ArrayCollection();
  143.         $this->echeanceInscrits = new ArrayCollection();
  144.         $this->reglementEcheances = new ArrayCollection();
  145.     }
  147.     public function getId(): ?int
  148.     {
  149.         return $this->id;
  150.     }
  152.     public function getNumerofacture(): ?string
  153.     {
  154.         return $this->numerofacture;
  155.     }
  157.     public function setNumerofacture(string $numerofacture): self
  158.     {
  159.         $this->numerofacture = $numerofacture;
  161.         return $this;
  162.     }
  164.     public function getDatefacture(): ?\DateTimeInterface
  165.     {
  166.         return $this->datefacture;
  167.     }
  169.     public function setDatefacture(?\DateTimeInterface $datefacture): self
  170.     {
  171.         $this->datefacture = $datefacture;
  173.         return $this;
  174.     }
  176.     public function getDateecheance(): ?\DateTimeInterface
  177.     {
  178.         return $this->dateecheance;
  179.     }
  181.     public function setDateecheance(?\DateTimeInterface $dateecheance): self
  182.     {
  183.         $this->dateecheance = $dateecheance;
  185.         return $this;
  186.     }
  189.     public function getReference(): ?string
  190.     {
  191.         return $this->reference;
  192.     }
  194.     public function setReference(?string $reference): self
  195.     {
  196.         $this->reference = $reference;
  198.         return $this;
  199.     }
  201.     public function getStatut(): ?string
  202.     {
  203.         return $this->statut;
  204.     }
  206.     public function setStatut(?string $statut): self
  207.     {
  208.         $this->statut = $statut;
  210.         return $this;
  211.     }
  213.     public function getCreatedAt(): ?\DateTimeImmutable
  214.     {
  215.         return $this->created_at;
  216.     }
  218.     public function setCreatedAt(?\DateTimeImmutable $created_at): self
  219.     {
  220.         $this->created_at = $created_at;
  222.         return $this;
  223.     }
  225.     public function getUpdatedAt(): ?\DateTimeImmutable
  226.     {
  227.         return $this->updated_at;
  228.     }
  230.     public function setUpdatedAt(?\DateTimeImmutable $updated_at): self
  231.     {
  232.         $this->updated_at = $updated_at;
  234.         return $this;
  235.     }
  237.     /**
  238.      * @return Collection<int, Inscrit>
  239.      */
  240.     public function getInscrits(): Collection
  241.     {
  242.         return $this->inscrits;
  243.     }
  245.     public function addInscrit(Inscrit $inscrit): self
  246.     {
  247.         if (!$this->inscrits->contains($inscrit)) {
  248.             $this->inscrits[] = $inscrit;
  249.             $inscrit->setEntetefacture($this);
  250.         }
  252.         return $this;
  253.     }
  255.     public function removeInscrit(Inscrit $inscrit): self
  256.     {
  257.         if ($this->inscrits->removeElement($inscrit)) {
  258.             // set the owning side to null (unless already changed)
  259.             if ($inscrit->getEntetefacture() === $this) {
  260.                 $inscrit->setEntetefacture(null);
  261.             }
  262.         }
  264.         return $this;
  265.     }
  267.     /**
  268.      * @return Collection<int, LigneFacture>
  269.      */
  270.     public function getLigneFactures(): Collection
  271.     {
  272.         return $this->ligneFactures;
  273.     }
  275.     public function addLigneFacture(LigneFacture $ligneFacture): self
  276.     {
  277.         if (!$this->ligneFactures->contains($ligneFacture)) {
  278.             $this->ligneFactures[] = $ligneFacture;
  279.             $ligneFacture->setEntetefacture($this);
  280.         }
  282.         return $this;
  283.     }
  285.     public function removeLigneFacture(LigneFacture $ligneFacture): self
  286.     {
  287.         if ($this->ligneFactures->removeElement($ligneFacture)) {
  288.             // set the owning side to null (unless already changed)
  289.             if ($ligneFacture->getEntetefacture() === $this) {
  290.                 $ligneFacture->setEntetefacture(null);
  291.             }
  292.         }
  294.         return $this;
  295.     }
  297.     public function getTypeclient(): ?string
  298.     {
  299.         return $this->typeclient;
  300.     }
  302.     public function setTypeclient(?string $typeclient): self
  303.     {
  304.         $this->typeclient = $typeclient;
  306.         return $this;
  307.     }
  309.     public function getStatutreglement(): ?string
  310.     {
  311.         return $this->statutreglement;
  312.     }
  314.     public function setStatutreglement(?string $statutreglement): self
  315.     {
  316.         $this->statutreglement = $statutreglement;
  318.         return $this;
  319.     }
  321.     /**
  322.      * @return Collection<int, ReglementFactureInscrit>
  323.      */
  324.     public function getEnteteReglementFactureInscrits(): Collection
  325.     {
  326.         return $this->enteteReglementFactureInscrits;
  327.     }
  329.     public function addEnteteReglementFactureInscrit(ReglementFactureInscrit $enteteReglementFactureInscrit): self
  330.     {
  331.         if (!$this->enteteReglementFactureInscrits->contains($enteteReglementFactureInscrit)) {
  332.             $this->enteteReglementFactureInscrits[] = $enteteReglementFactureInscrit;
  333.             $enteteReglementFactureInscrit->setEntetefacture($this);
  334.         }
  336.         return $this;
  337.     }
  339.     public function removeEnteteReglementFactureInscrit(ReglementFactureInscrit $enteteReglementFactureInscrit): self
  340.     {
  341.         if ($this->enteteReglementFactureInscrits->removeElement($enteteReglementFactureInscrit)) {
  342.             // set the owning side to null (unless already changed)
  343.             if ($enteteReglementFactureInscrit->getEntetefacture() === $this) {
  344.                 $enteteReglementFactureInscrit->setEntetefacture(null);
  345.             }
  346.         }
  348.         return $this;
  349.     }
  351.     public function getPayeur(): ?string
  352.     {
  353.         return $this->payeur;
  354.     }
  356.     public function setPayeur(?string $payeur): self
  357.     {
  358.         $this->payeur = $payeur;
  360.         return $this;
  361.     }
  363.     public function getSite(): ?Site
  364.     {
  365.         return $this->site;
  366.     }
  368.     public function setSite(?Site $site): self
  369.     {
  370.         $this->site = $site;
  372.         return $this;
  373.     }
  375.     /**
  376.      * @return Collection<int, LigneFacturePrint>
  377.      */
  378.     public function getLigneFacturePrints(): Collection
  379.     {
  380.         return $this->ligneFacturePrints;
  381.     }
  383.     public function addLigneFacturePrint(LigneFacturePrint $ligneFacturePrint): self
  384.     {
  385.         if (!$this->ligneFacturePrints->contains($ligneFacturePrint)) {
  386.             $this->ligneFacturePrints[] = $ligneFacturePrint;
  387.             $ligneFacturePrint->setEnteteFacture($this);
  388.         }
  390.         return $this;
  391.     }
  393.     public function removeLigneFacturePrint(LigneFacturePrint $ligneFacturePrint): self
  394.     {
  395.         if ($this->ligneFacturePrints->removeElement($ligneFacturePrint)) {
  396.             // set the owning side to null (unless already changed)
  397.             if ($ligneFacturePrint->getEnteteFacture() === $this) {
  398.                 $ligneFacturePrint->setEnteteFacture(null);
  399.             }
  400.         }
  402.         return $this;
  403.     }
  405.     public function getTier(): ?Tier
  406.     {
  407.         return $this->tier;
  408.     }
  410.     public function setTier(?Tier $tier): self
  411.     {
  412.         $this->tier = $tier;
  414.         return $this;
  415.     }
  417.     public function getEntreprise(): ?Entreprise
  418.     {
  419.         return $this->entreprise;
  420.     }
  422.     public function setEntreprise(?Entreprise $entreprise): self
  423.     {
  424.         $this->entreprise = $entreprise;
  426.         return $this;
  427.     }
  429.     public function getOrganisme(): ?Organisme
  430.     {
  431.         return $this->organisme;
  432.     }
  434.     public function setOrganisme(?Organisme $organisme): self
  435.     {
  436.         $this->organisme = $organisme;
  438.         return $this;
  439.     }
  441.     /**
  442.      * @return Collection<int, EcheanceInscrit>
  443.      */
  444.     public function getEcheanceInscrits(): Collection
  445.     {
  446.         return $this->echeanceInscrits;
  447.     }
  449.     public function addEcheanceInscrit(EcheanceInscrit $echeanceInscrit): self
  450.     {
  451.         if (!$this->echeanceInscrits->contains($echeanceInscrit)) {
  452.             $this->echeanceInscrits[] = $echeanceInscrit;
  453.             $echeanceInscrit->setEnteteFacture($this);
  454.         }
  456.         return $this;
  457.     }
  459.     public function removeEcheanceInscrit(EcheanceInscrit $echeanceInscrit): self
  460.     {
  461.         if ($this->echeanceInscrits->removeElement($echeanceInscrit)) {
  462.             // set the owning side to null (unless already changed)
  463.             if ($echeanceInscrit->getEnteteFacture() === $this) {
  464.                 $echeanceInscrit->setEnteteFacture(null);
  465.             }
  466.         }
  468.         return $this;
  469.     }
  471.     public function getMontant(): ?float
  472.     {
  473.         return $this->montant;
  474.     }
  476.     public function setMontant(?float $montant): self
  477.     {
  478.         $this->montant = $montant;
  480.         return $this;
  481.     }
  483.     public function getMontantRegle(): ?float
  484.     {
  485.         return $this->montantRegle;
  486.     }
  488.     public function setMontantRegle(?float $montantRegle): self
  489.     {
  490.         $this->montantRegle = $montantRegle;
  492.         return $this;
  493.     }
  495.     public function getResteAregler(): ?float
  496.     {
  497.         return $this->resteAregler;
  498.     }
  500.     public function setResteAregler(?float $resteAregler): self
  501.     {
  502.         $this->resteAregler = $resteAregler;
  504.         return $this;
  505.     }
  507.     /**
  508.      * @return Collection<int, ReglementEcheance>
  509.      */
  510.     public function getReglementEcheances(): Collection
  511.     {
  512.         return $this->reglementEcheances;
  513.     }
  515.     public function addReglementEcheance(ReglementEcheance $reglementEcheance): self
  516.     {
  517.         if (!$this->reglementEcheances->contains($reglementEcheance)) {
  518.             $this->reglementEcheances[] = $reglementEcheance;
  519.             $reglementEcheance->setEnteteFacture($this);
  520.         }
  522.         return $this;
  523.     }
  525.     public function removeReglementEcheance(ReglementEcheance $reglementEcheance): self
  526.     {
  527.         if ($this->reglementEcheances->removeElement($reglementEcheance)) {
  528.             // set the owning side to null (unless already changed)
  529.             if ($reglementEcheance->getEnteteFacture() === $this) {
  530.                 $reglementEcheance->setEnteteFacture(null);
  531.             }
  532.         }
  534.         return $this;
  535.     }
  536. }