src/Entity/Vente.php line 12

1. <?php
3. namespace App\Entity;
5. use App\Repository\VenteRepository;
6. use Doctrine\Common\Collections\ArrayCollection;
7. use Doctrine\Common\Collections\Collection;
8. use Doctrine\DBAL\Types\Types;
9. use Doctrine\ORM\Mapping as ORM;
11. #[ORM\Entity(repositoryClass: VenteRepository::class)]
12. class Vente
13. {
14.     #[ORM\Id]
15.     #[ORM\GeneratedValue]
16.     #[ORM\Column]
17.     private ?int $id = null;
19.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
20.     private ?\DateTimeInterface $dateVente = null;
22.     #[ORM\ManyToOne]
23.     #[ORM\JoinColumn(nullable: false)]
24.     private ?User $vendeur = null;
26.     #[ORM\OneToMany(mappedBy: 'vente', targetEntity: DetailsVente::class)]
27.     private Collection $detailsVentes;
29.     #[ORM\OneToMany(mappedBy: 'vente', targetEntity: Echeance::class)]
30.     private Collection $echeances;
32.     #[ORM\ManyToOne(inversedBy: 'ventes')]
33.     private ?Client $client = null;
35.     #[ORM\Column(length: 500, nullable: true)]
36.     private ?string $description = null;
38.     #[ORM\OneToMany(mappedBy: 'vente', targetEntity: Facture::class)]
39.     private Collection $factures;
41.     #[ORM\ManyToOne(inversedBy: 'ventes')]
42.     private ?Boutique $boutique = null;
44.     #[ORM\OneToMany(mappedBy: 'vente', targetEntity: Recette::class)]
45.     private Collection $recettes;
47.     public function __construct()
48.     {
49.         $this->dateVente = new \DateTime();
50.         $this->detailsVentes = new ArrayCollection();
51.         $this->echeances = new ArrayCollection();
52.         $this->factures = new ArrayCollection();
53.         $this->recettes = new ArrayCollection();
54.     }
56.     public function getId(): ?int
57.     {
58.         return $this->id;
59.     }
61.     public function getDateVente(): ?\DateTimeInterface
62.     {
63.         return $this->dateVente;
64.     }
66.     public function setDateVente(\DateTimeInterface $dateVente): static
67.     {
68.         $this->dateVente = $dateVente;
70.         return $this;
71.     }
73.     public function getVendeur(): ?User
74.     {
75.         return $this->vendeur;
76.     }
78.     public function setVendeur(?User $vendeur): static
79.     {
80.         $this->vendeur = $vendeur;
82.         return $this;
83.     }
85.     /**
86.      * @return Collection<int, DetailsVente>
87.      */
88.     public function getDetailsVentes(): Collection
89.     {
90.         return $this->detailsVentes;
91.     }
93.     public function addDetailsVente(DetailsVente $detailsVente): static
94.     {
95.         if (!$this->detailsVentes->contains($detailsVente)) {
96.             $this->detailsVentes->add($detailsVente);
97.             $detailsVente->setVente($this);
98.         }
100.         return $this;
101.     }
103.     public function removeDetailsVente(DetailsVente $detailsVente): static
104.     {
105.         if ($this->detailsVentes->removeElement($detailsVente)) {
106.             // set the owning side to null (unless already changed)
107.             if ($detailsVente->getVente() === $this) {
108.                 $detailsVente->setVente(null);
109.             }
110.         }
112.         return $this;
113.     }
115.     /**
116.      * @return Collection<int, Echeance>
117.      */
118.     public function getEcheances(): Collection
119.     {
120.         return $this->echeances;
121.     }
123.     public function addEcheance(Echeance $echeance): static
124.     {
125.         if (!$this->echeances->contains($echeance)) {
126.             $this->echeances->add($echeance);
127.             $echeance->setVente($this);
128.         }
130.         return $this;
131.     }
133.     public function removeEcheance(Echeance $echeance): static
134.     {
135.         if ($this->echeances->removeElement($echeance)) {
136.             // set the owning side to null (unless already changed)
137.             if ($echeance->getVente() === $this) {
138.                 $echeance->setVente(null);
139.             }
140.         }
142.         return $this;
143.     }
145.     public function getClient(): ?Client
146.     {
147.         return $this->client;
148.     }
150.     public function setClient(?Client $client): static
151.     {
152.         $this->client = $client;
154.         return $this;
155.     }
157.     public function getDescription(): ?string
158.     {
159.         return $this->description;
160.     }
162.     public function setDescription(?string $description): static
163.     {
164.         $this->description = $description;
166.         return $this;
167.     }
169.     /**
170.      * @return Collection<int, Facture>
171.      */
172.     public function getFactures(): Collection
173.     {
174.         return $this->factures;
175.     }
177.     public function addFacture(Facture $facture): static
178.     {
179.         if (!$this->factures->contains($facture)) {
180.             $this->factures->add($facture);
181.             $facture->setVente($this);
182.         }
184.         return $this;
185.     }
187.     public function removeFacture(Facture $facture): static
188.     {
189.         if ($this->factures->removeElement($facture)) {
190.             // set the owning side to null (unless already changed)
191.             if ($facture->getVente() === $this) {
192.                 $facture->setVente(null);
193.             }
194.         }
196.         return $this;
197.     }
199.     public function getBoutique(): ?Boutique
200.     {
201.         return $this->boutique;
202.     }
204.     public function setBoutique(?Boutique $boutique): static
205.     {
206.         $this->boutique = $boutique;
208.         return $this;
209.     }
211.     /**
212.      * @return Collection<int, Recette>
213.      */
214.     public function getRecettes(): Collection
215.     {
216.         return $this->recettes;
217.     }
219.     public function addRecette(Recette $recette): static
220.     {
221.         if (!$this->recettes->contains($recette)) {
222.             $this->recettes->add($recette);
223.             $recette->setVente($this);
224.         }
226.         return $this;
227.     }
229.     public function removeRecette(Recette $recette): static
230.     {
231.         if ($this->recettes->removeElement($recette)) {
232.             // set the owning side to null (unless already changed)
233.             if ($recette->getVente() === $this) {
234.                 $recette->setVente(null);
235.             }
236.         }
238.         return $this;
239.     }
240. }