src/Entity/User.php line 16

1. <?php
3. namespace App\Entity;
5. use App\Repository\UserRepository;
6. use Doctrine\Common\Collections\ArrayCollection;
7. use Doctrine\Common\Collections\Collection;
8. use Doctrine\ORM\Mapping as ORM;
9. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
11. use Symfony\Component\Security\Core\User\UserInterface;
12. use Symfony\Component\Validator\Constraints as Assert;
14. #[ORM\Entity(repositoryClass: UserRepository::class)]
15. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
16. class User implements UserInterface, PasswordAuthenticatedUserInterface
17. {
18.     #[ORM\Id]
19.     #[ORM\GeneratedValue]
20.     #[ORM\Column]
21.     private ?int $id = null;
23.     #[ORM\Column(length: 180, unique: true)]
24.     #[Assert\NotBlank(message: 'L\'email est obligatoire')]
25.     #[Assert\Email(message: 'L\'email {{ value }} n\'est pas valide')]
26.     private ?string $email = null;
28.     #[ORM\Column]
29.     private array $roles = [];
31.     /**
32.      * @var string The hashed password
33.      */
34.     #[ORM\Column]
35.     private ?string $password = null;
37.     #[ORM\Column(length: 50)]
38.     #[Assert\NotBlank(message: 'Le nom complet est obligatoire')]
39.     #[Assert\Length(min: 2, max: 50, minMessage: 'Le nom doit faire au moins {{ limit }} caractères', maxMessage: 'Le nom ne peut pas dépasser {{ limit }} caractères')]
40.     private ?string $fullName = null;
42.     #[ORM\Column]
43.     private ?\DateTimeImmutable $createdAt = null;
45.     
47.     #[ORM\OneToMany(mappedBy: 'utilisateur', targetEntity: EntreeStock::class)]
48.     private Collection $entreeStocks;
50.     #[ORM\OneToMany(mappedBy: 'utilisateur', targetEntity: SortieStock::class)]
51.     private Collection $sortieStocks;
53.     #[ORM\OneToMany(mappedBy: 'utilisateur', targetEntity: Produit::class)]
54.     private Collection $produits;
57.     #[ORM\Column(length: 255)]
58.     #[Assert\NotBlank(message: 'Le téléphone est obligatoire')]
59.     #[Assert\Length(min: 8, max: 20, minMessage: 'Le téléphone doit faire au moins {{ limit }} caractères', maxMessage: 'Le téléphone ne peut pas dépasser {{ limit }} caractères')]
60.     private ?string $telephone = null;
62.     #[ORM\Column(length: 255)]
63.     #[Assert\NotBlank(message: 'L\'adresse est obligatoire')]
64.     #[Assert\Length(min: 5, max: 255, minMessage: 'L\'adresse doit faire au moins {{ limit }} caractères', maxMessage: 'L\'adresse ne peut pas dépasser {{ limit }} caractères')]
65.     private ?string $adress = null;
67.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ActionLog::class)]
68.     private Collection $actionLogs;
70.     #[ORM\OneToMany(mappedBy: 'vendeur', targetEntity: Vente::class)]
71.     private Collection $ventes;
72.     public function __construct() {
73.         $this->createdAt= new \DateTimeImmutable();
74.         $this->entreeStocks = new ArrayCollection();
75.         $this->sortieStocks = new ArrayCollection();
76.         $this->produits = new ArrayCollection();
77.         $this->actionLogs = new ArrayCollection();
78.         $this->ventes = new ArrayCollection();
79.     }
81.     public function getId(): ?int
82.     {
83.         return $this->id;
84.     }
86.     public function getEmail(): ?string
87.     {
88.         return $this->email;
89.     }
91.     public function setEmail(string $email): static
92.     {
93.         $this->email = $email;
95.         return $this;
96.     }
98.     /**
99.      * A visual identifier that represents this user.
100.      *
101.      * @see UserInterface
102.      */
103.     public function getUserIdentifier(): string
104.     {
105.         return (string) $this->email;
106.     }
108.     /**
109.      * @see UserInterface
110.      */
111.     public function getRoles(): array
112.     {
113.        
115.         return array_unique($this->roles);
116.     }
118.     public function setRoles(array $roles): static
119.     {
120.         $this->roles = $roles;
122.         return $this;
123.     }
125.     /**
126.      * @see PasswordAuthenticatedUserInterface
127.      */
128.     public function getPassword(): string
129.     {
130.         return $this->password;
131.     }
133.     public function setPassword(string $password): static
134.     {
135.         $this->password = $password;
137.         return $this;
138.     }
140.     /**
141.      * @see UserInterface
142.      */
143.     public function eraseCredentials(): void
144.     {
145.         // If you store any temporary, sensitive data on the user, clear it here
146.         // $this->plainPassword = null;
147.     }
149.     public function getFullName(): ?string
150.     {
151.         return $this->fullName;
152.     }
154.     public function setFullName(string $fullName): static
155.     {
156.         $this->fullName = $fullName;
158.         return $this;
159.     }
161.     public function getCreatedAt(): ?\DateTimeImmutable
162.     {
163.         return $this->createdAt;
164.     }
166.     public function setCreatedAt(\DateTimeImmutable $createdAt): static
167.     {
168.         $this->createdAt = $createdAt;
170.         return $this;
171.     }
173.    
174.  
176.     /**
177.      * @return Collection<int, EntreeStock>
178.      */
179.     public function getEntreeStocks(): Collection
180.     {
181.         return $this->entreeStocks;
182.     }
184.     public function addEntreeStock(EntreeStock $entreeStock): static
185.     {
186.         if (!$this->entreeStocks->contains($entreeStock)) {
187.             $this->entreeStocks->add($entreeStock);
188.             $entreeStock->setUtilisateur($this);
189.         }
191.         return $this;
192.     }
194.     public function removeEntreeStock(EntreeStock $entreeStock): static
195.     {
196.         if ($this->entreeStocks->removeElement($entreeStock)) {
197.             // set the owning side to null (unless already changed)
198.             if ($entreeStock->getUtilisateur() === $this) {
199.                 $entreeStock->setUtilisateur(null);
200.             }
201.         }
203.         return $this;
204.     }
206.     /**
207.      * @return Collection<int, SortieStock>
208.      */
209.     public function getSortieStocks(): Collection
210.     {
211.         return $this->sortieStocks;
212.     }
214.     public function addSortieStock(SortieStock $sortieStock): static
215.     {
216.         if (!$this->sortieStocks->contains($sortieStock)) {
217.             $this->sortieStocks->add($sortieStock);
218.             $sortieStock->setUtilisateur($this);
219.         }
221.         return $this;
222.     }
224.     public function removeSortieStock(SortieStock $sortieStock): static
225.     {
226.         if ($this->sortieStocks->removeElement($sortieStock)) {
227.             // set the owning side to null (unless already changed)
228.             if ($sortieStock->getUtilisateur() === $this) {
229.                 $sortieStock->setUtilisateur(null);
230.             }
231.         }
233.         return $this;
234.     }
236.     /**
237.      * @return Collection<int, Produit>
238.      */
239.     public function getProduits(): Collection
240.     {
241.         return $this->produits;
242.     }
244.     public function addProduit(Produit $produit): static
245.     {
246.         if (!$this->produits->contains($produit)) {
247.             $this->produits->add($produit);
248.             $produit->setUtilisateur($this);
249.         }
251.         return $this;
252.     }
254.     public function removeProduit(Produit $produit): static
255.     {
256.         if ($this->produits->removeElement($produit)) {
257.             // set the owning side to null (unless already changed)
258.             if ($produit->getUtilisateur() === $this) {
259.                 $produit->setUtilisateur(null);
260.             }
261.         }
263.         return $this;
264.     }
266.   
267.     public function getTelephone(): ?string
268.     {
269.         return $this->telephone;
270.     }
272.     public function setTelephone(string $telephone): static
273.     {
274.         $this->telephone = $telephone;
276.         return $this;
277.     }
279.     public function getAdress(): ?string
280.     {
281.         return $this->adress;
282.     }
284.     public function setAdress(string $adress): static
285.     {
286.         $this->adress = $adress;
288.         return $this;
289.     }
291.     /**
292.      * @return Collection<int, ActionLog>
293.      */
294.     public function getActionLogs(): Collection
295.     {
296.         return $this->actionLogs;
297.     }
299.     public function addActionLog(ActionLog $actionLog): static
300.     {
301.         if (!$this->actionLogs->contains($actionLog)) {
302.             $this->actionLogs->add($actionLog);
303.             $actionLog->setUser($this);
304.         }
306.         return $this;
307.     }
309.     public function removeActionLog(ActionLog $actionLog): static
310.     {
311.         if ($this->actionLogs->removeElement($actionLog)) {
312.             // set the owning side to null (unless already changed)
313.             if ($actionLog->getUser() === $this) {
314.                 $actionLog->setUser(null);
315.             }
316.         }
318.         return $this;
319.     }
321.     /**
322.      * @return Collection<int, Vente>
323.      */
324.     public function getVentes(): Collection
325.     {
326.         return $this->ventes;
327.     }
329.     public function addVente(Vente $vente): static
330.     {
331.         if (!$this->ventes->contains($vente)) {
332.             $this->ventes->add($vente);
333.             $vente->setVendeur($this);
334.         }
336.         return $this;
337.     }
339.     public function removeVente(Vente $vente): static
340.     {
341.         if ($this->ventes->removeElement($vente)) {
342.             // set the owning side to null (unless already changed)
343.             if ($vente->getVendeur() === $this) {
344.                 $vente->setVendeur(null);
345.             }
346.         }
348.         return $this;
349.     }
350. }