src/Entity/User.php line 14

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\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
10. use Symfony\Component\Security\Core\User\UserInterface;
12. #[ORM\Entity(repositoryClass: UserRepository::class)]
13. #[ORM\Table(name: '`user`')]
14. class User implements UserInterface, PasswordAuthenticatedUserInterface
15. {
16.     #[ORM\Id]
17.     #[ORM\GeneratedValue]
18.     #[ORM\Column]
19.     private ?int $id = null;
21.     #[ORM\Column(length: 180, unique: true)]
22.     private ?string $email = null;
24.     #[ORM\Column]
25.     private array $roles = [];
27.     #[ORM\Column]
28.     private ?string $password = null;
30.     #[ORM\Column(length: 10)]
31.     private string $lang = 'fr';
33.     #[ORM\Column(length: 255)]
34.     private ?string $nom = null;
36.     #[ORM\Column(length: 255)]
37.     private ?string $prenom = null;
39.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserProject::class, cascade: ['persist', 'remove'])]
40.     private Collection $userProjects;
42.     public function __construct()
43.     {
44.         $this->userProjects = new ArrayCollection();
45.     }
47.     public function getId(): ?int
48.     {
49.         return $this->id;
50.     }
52.     public function getEmail(): ?string
53.     {
54.         return $this->email;
55.     }
57.     public function setEmail(string $email): static
58.     {
59.         $this->email = $email;
61.         return $this;
62.     }
64.     /**
65.      * A visual identifier that represents this user.
66.      *
67.      * @see UserInterface
68.      */
69.     public function getUserIdentifier(): string
70.     {
71.         return (string) $this->email;
72.     }
74.     /**
75.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
76.      */
77.     public function getUsername(): string
78.     {
79.         return (string) $this->email;
80.     }
82.     /**
83.      * @see UserInterface
84.      */
85.     public function getRoles(): array
86.     {
87.         $roles = $this->roles;
88.         // guarantee every user at least has ROLE_USER
89.         $roles[] = 'ROLE_USER';
91.         return array_unique($roles);
92.     }
94.     public function setRoles(array $roles): static
95.     {
96.         $this->roles = $roles;
98.         return $this;
99.     }
101.     /**
102.      * @see PasswordAuthenticatedUserInterface
103.      */
104.     public function getPassword(): string
105.     {
106.         return $this->password;
107.     }
109.     public function setPassword(string $password): static
110.     {
111.         $this->password = $password;
113.         return $this;
114.     }
116.     /**
117.      * Returning a salt is only needed, if you are not using a modern
118.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
119.      *
120.      * @see UserInterface
121.      */
122.     public function getSalt(): ?string
123.     {
124.         return null;
125.     }
127.     /**
128.      * @see UserInterface
129.      */
130.     public function eraseCredentials(): void
131.     {
132.         // If you store any temporary, sensitive data on the user, clear it here
133.         // $this->plainPassword = null;
134.     }
136.     public function setLang(string $lang): static
137.     {
138.         $this->lang = $lang;
140.         return $this;
141.     }
143.     public function getLang(): string
144.     {
145.         return $this->lang;
146.     }
148.     public function getUserProjects(): Collection
149.     {
150.         return $this->userProjects;
151.     }
153.     public function addProject(Project $project, array $role): self
154.     {
155.         foreach ($this->userProjects as $userProject) {
156.             if ($userProject->getProject() === $project) {
157.                 return $this;
158.             }
159.         }
161.         $userProject = new UserProject($this, $project, $role);
162.         $this->userProjects->add($userProject);
164.         return $this;
165.     }
167.     public function removeProject(Project $project): self
168.     {
169.         foreach ($this->userProjects as $userProject) {
170.             if ($userProject->getProject() === $project) {
171.                 $this->userProjects->removeElement($userProject);
172.             }
173.         }
175.         return $this;
176.     }
178.     public function __toString(): string
179.     {
180.         return $this->getUserIdentifier();
181.     }
183.     public function addUserProject(UserProject $userProject): static
184.     {
185.         if (!$this->userProjects->contains($userProject)) {
186.             $this->userProjects->add($userProject);
187.             $userProject->setUser($this);
188.         }
190.         return $this;
191.     }
193.     public function removeUserProject(UserProject $userProject): static
194.     {
195.         if ($this->userProjects->removeElement($userProject)) {
196.             // set the owning side to null (unless already changed)
197.             if ($userProject->getUser() === $this) {
198.                 $userProject->setUser(null);
199.             }
200.         }
202.         return $this;
203.     }
205.     public function getNom(): ?string
206.     {
207.         return $this->nom;
208.     }
210.     public function setNom(string $nom): static
211.     {
212.         $this->nom = $nom;
214.         return $this;
215.     }
217.     public function getPrenom(): ?string
218.     {
219.         return $this->prenom;
220.     }
222.     public function setPrenom(string $prenom): static
223.     {
224.         $this->prenom = $prenom;
226.         return $this;
227.     }
228. }