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\Column(length: 50, nullable: true)]
39.     private ?string $type = null;
41.     #[ORM\OneToMany(mappedBy: 'vente', targetEntity: Facture::class)]
42.     private Collection $factures;
44.     #[ORM\ManyToOne(inversedBy: 'ventes')]
45.     private ?Boutique $boutique = null;
47.     #[ORM\OneToMany(mappedBy: 'vente', targetEntity: Recette::class)]
48.     private Collection $recettes;
50.     public function __construct()
51.     {
52.         $this->dateVente = new \DateTime();
53.         $this->detailsVentes = new ArrayCollection();
54.         $this->echeances = new ArrayCollection();
55.         $this->factures = new ArrayCollection();
56.         $this->recettes = new ArrayCollection();
57.     }
59.     public function getId(): ?int
60.     {
61.         return $this->id;
62.     }
64.     public function getDateVente(): ?\DateTimeInterface
65.     {
66.         return $this->dateVente;
67.     }
69.     public function setDateVente(\DateTimeInterface $dateVente): static
70.     {
71.         $this->dateVente = $dateVente;
73.         return $this;
74.     }
76.     public function getVendeur(): ?User
77.     {
78.         return $this->vendeur;
79.     }
81.     public function setVendeur(?User $vendeur): static
82.     {
83.         $this->vendeur = $vendeur;
85.         return $this;
86.     }
88.     /**
89.      * @return Collection<int, DetailsVente>
90.      */
91.     public function getDetailsVentes(): Collection
92.     {
93.         return $this->detailsVentes;
94.     }
96.     public function addDetailsVente(DetailsVente $detailsVente): static
97.     {
98.         if (!$this->detailsVentes->contains($detailsVente)) {
99.             $this->detailsVentes->add($detailsVente);
100.             $detailsVente->setVente($this);
101.         }
103.         return $this;
104.     }
106.     public function removeDetailsVente(DetailsVente $detailsVente): static
107.     {
108.         if ($this->detailsVentes->removeElement($detailsVente)) {
109.             // set the owning side to null (unless already changed)
110.             if ($detailsVente->getVente() === $this) {
111.                 $detailsVente->setVente(null);
112.             }
113.         }
115.         return $this;
116.     }
118.     /**
119.      * @return Collection<int, Echeance>
120.      */
121.     public function getEcheances(): Collection
122.     {
123.         return $this->echeances;
124.     }
126.     public function addEcheance(Echeance $echeance): static
127.     {
128.         if (!$this->echeances->contains($echeance)) {
129.             $this->echeances->add($echeance);
130.             $echeance->setVente($this);
131.         }
133.         return $this;
134.     }
136.     public function removeEcheance(Echeance $echeance): static
137.     {
138.         if ($this->echeances->removeElement($echeance)) {
139.             // set the owning side to null (unless already changed)
140.             if ($echeance->getVente() === $this) {
141.                 $echeance->setVente(null);
142.             }
143.         }
145.         return $this;
146.     }
148.     public function getClient(): ?Client
149.     {
150.         return $this->client;
151.     }
153.     public function setClient(?Client $client): static
154.     {
155.         $this->client = $client;
157.         return $this;
158.     }
160.     public function getDescription(): ?string
161.     {
162.         return $this->description;
163.     }
165.     public function setDescription(?string $description): static
166.     {
167.         $this->description = $description;
169.         return $this;
170.     }
172.     public function getType(): ?string
173.     {
174.         return $this->type;
175.     }
177.     public function setType(?string $type): static
178.     {
179.         $this->type = $type;
181.         return $this;
182.     }
184.     /**
185.      * @return Collection<int, Facture>
186.      */
187.     public function getFactures(): Collection
188.     {
189.         return $this->factures;
190.     }
192.     public function addFacture(Facture $facture): static
193.     {
194.         if (!$this->factures->contains($facture)) {
195.             $this->factures->add($facture);
196.             $facture->setVente($this);
197.         }
199.         return $this;
200.     }
202.     public function removeFacture(Facture $facture): static
203.     {
204.         if ($this->factures->removeElement($facture)) {
205.             // set the owning side to null (unless already changed)
206.             if ($facture->getVente() === $this) {
207.                 $facture->setVente(null);
208.             }
209.         }
211.         return $this;
212.     }
214.     public function getBoutique(): ?Boutique
215.     {
216.         return $this->boutique;
217.     }
219.     public function setBoutique(?Boutique $boutique): static
220.     {
221.         $this->boutique = $boutique;
223.         return $this;
224.     }
226.     /**
227.      * @return Collection<int, Recette>
228.      */
229.     public function getRecettes(): Collection
230.     {
231.         return $this->recettes;
232.     }
234.     public function addRecette(Recette $recette): static
235.     {
236.         if (!$this->recettes->contains($recette)) {
237.             $this->recettes->add($recette);
238.             $recette->setVente($this);
239.         }
241.         return $this;
242.     }
244.     public function removeRecette(Recette $recette): static
245.     {
246.         if ($this->recettes->removeElement($recette)) {
247.             // set the owning side to null (unless already changed)
248.             if ($recette->getVente() === $this) {
249.                 $recette->setVente(null);
250.             }
251.         }
253.         return $this;
254.     }
255. }