src/Entity/Users.php line 16

1. <?php
3. namespace App\Entity;
5. use App\Repository\UsersRepository;
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;
10. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
12. use Symfony\Component\Security\Core\User\UserInterface;
14. #[ORM\Entity(repositoryClass: UsersRepository::class)]
15. #[UniqueEntity(fields: ['username'], message: 'There is already an account with this username')]
16. class Users 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.     private ?string $username = null;
26.     #[ORM\Column]
27.     private array $roles = [];
29.     /**
30.      * @var string The hashed password
31.      */
32.     #[ORM\Column]
33.     private ?string $password = null;
35.     #[ORM\Column(length: 255, nullable: true)]
36.     private ?string $nom = null;
38.     #[ORM\Column(length: 255, nullable: true)]
39.     private ?string $prenom = null;
41.     #[ORM\Column]
42.     private ?bool $enable = false;
44.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
45.     private ?\DateTimeInterface $created = null;
47.     #[ORM\Column(length: 255, nullable: true)]
48.     private ?string $email = null;
50.     #[ORM\OneToMany(mappedBy: 'userCreated', targetEntity: HonoraireDetFixe::class)]
51.     private Collection $honoraireDetFixes;
53.     #[ORM\OneToMany(mappedBy: 'userCreated', targetEntity: TCnssA00::class)]
54.     private Collection $tCnssA00s;
56.     #[ORM\ManyToOne(targetEntity: self::class)]
57.     private ?self $userUpdated = null;
59.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
60.     private ?\DateTimeInterface $updated = null;
62.     #[ORM\OneToOne(cascade: ['persist', 'remove'])]
63.     private ?PDossier $dossierResponsable = null;
65.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: PNotification::class)]
66.     private Collection $notifications;
68.     public function __construct()
69.     {
70.         $this->honoraireDetFixes = new ArrayCollection();
71.         $this->tCnssA00s = new ArrayCollection();
72.         $this->notifications = new ArrayCollection();
73.     }
75.   
77.   
79.     // #[ORM\ManyToMany(targetEntity: PDossier::class, mappedBy: 'users')]
80.     // private Collection $dossiers;
82.     // public function __construct()
83.     // {
84.     //     $this->operations = new ArrayCollection();
85.     //     $this->dossiers = new ArrayCollection();
86.     // }
88.     public function getId(): ?int
89.     {
90.         return $this->id;
91.     }
93.     public function getUsername(): ?string
94.     {
95.         return $this->username;
96.     }
98.     public function setUsername(string $username): self
99.     {
100.         $this->username = $username;
102.         return $this;
103.     }
105.     /**
106.      * A visual identifier that represents this user.
107.      *
108.      * @see UserInterface
109.      */
110.     public function getUserIdentifier(): string
111.     {
112.         return (string) $this->username;
113.     }
115.     /**
116.      * @see UserInterface
117.      */
118.     public function getRoles(): array
119.     {
120.         $roles = $this->roles;
121.         // guarantee every user at least has ROLE_USER
122.         // $roles[] = 'ROLE_USER';
124.         return array_unique($roles);
125.     }
127.     public function setRoles(array $roles): self
128.     {
129.         $this->roles = $roles;
131.         return $this;
132.     }
134.     /**
135.      * @see PasswordAuthenticatedUserInterface
136.      */
137.     public function getPassword(): string
138.     {
139.         return $this->password;
140.     }
142.     public function setPassword(string $password): self
143.     {
144.         $this->password = $password;
146.         return $this;
147.     }
149.     /**
150.      * @see UserInterface
151.      */
152.     public function eraseCredentials()
153.     {
154.         // If you store any temporary, sensitive data on the user, clear it here
155.         // $this->plainPassword = null;
156.     }
158.     public function getNom(): ?string
159.     {
160.         return $this->nom;
161.     }
163.     public function setNom(?string $nom): self
164.     {
165.         $this->nom = $nom;
167.         return $this;
168.     }
170.     public function getPrenom(): ?string
171.     {
172.         return $this->prenom;
173.     }
175.     public function setPrenom(?string $prenom): self
176.     {
177.         $this->prenom = $prenom;
179.         return $this;
180.     }
182.     public function isEnable(): ?bool
183.     {
184.         return $this->enable;
185.     }
187.     public function setEnable(bool $enable): self
188.     {
189.         $this->enable = $enable;
191.         return $this;
192.     }
194.     public function getCreated(): ?\DateTimeInterface
195.     {
196.         return $this->created;
197.     }
199.     public function setCreated(?\DateTimeInterface $created): self
200.     {
201.         $this->created = $created;
203.         return $this;
204.     }
206.     public function getEmail(): ?string
207.     {
208.         return $this->email;
209.     }
211.     public function setEmail(?string $email): self
212.     {
213.         $this->email = $email;
215.         return $this;
216.     }
218.     /**
219.      * @return Collection<int, HonoraireDetFixe>
220.      */
221.     public function getHonoraireDetFixes(): Collection
222.     {
223.         return $this->honoraireDetFixes;
224.     }
226.     public function addHonoraireDetFix(HonoraireDetFixe $honoraireDetFix): static
227.     {
228.         if (!$this->honoraireDetFixes->contains($honoraireDetFix)) {
229.             $this->honoraireDetFixes->add($honoraireDetFix);
230.             $honoraireDetFix->setUserCreated($this);
231.         }
233.         return $this;
234.     }
236.     public function removeHonoraireDetFix(HonoraireDetFixe $honoraireDetFix): static
237.     {
238.         if ($this->honoraireDetFixes->removeElement($honoraireDetFix)) {
239.             // set the owning side to null (unless already changed)
240.             if ($honoraireDetFix->getUserCreated() === $this) {
241.                 $honoraireDetFix->setUserCreated(null);
242.             }
243.         }
245.         return $this;
246.     }
248.     /**
249.      * @return Collection<int, TCnssA00>
250.      */
251.     public function getTCnssA00s(): Collection
252.     {
253.         return $this->tCnssA00s;
254.     }
256.     public function addTCnssA00(TCnssA00 $tCnssA00): static
257.     {
258.         if (!$this->tCnssA00s->contains($tCnssA00)) {
259.             $this->tCnssA00s->add($tCnssA00);
260.             $tCnssA00->setUserCreated($this);
261.         }
263.         return $this;
264.     }
266.     public function removeTCnssA00(TCnssA00 $tCnssA00): static
267.     {
268.         if ($this->tCnssA00s->removeElement($tCnssA00)) {
269.             // set the owning side to null (unless already changed)
270.             if ($tCnssA00->getUserCreated() === $this) {
271.                 $tCnssA00->setUserCreated(null);
272.             }
273.         }
275.         return $this;
276.     }
278.     public function getUserUpdated(): ?self
279.     {
280.         return $this->userUpdated;
281.     }
283.     public function setUserUpdated(?self $userUpdated): static
284.     {
285.         $this->userUpdated = $userUpdated;
287.         return $this;
288.     }
290.     public function getUpdated(): ?\DateTimeInterface
291.     {
292.         return $this->updated;
293.     }
295.     public function setUpdated(?\DateTimeInterface $updated): static
296.     {
297.         $this->updated = $updated;
299.         return $this;
300.     }
302.     public function getDossierResponsable(): ?PDossier
303.     {
304.         return $this->dossierResponsable;
305.     }
307.     public function setDossierResponsable(?PDossier $dossierResponsable): static
308.     {
309.         $this->dossierResponsable = $dossierResponsable;
311.         return $this;
312.     }
314.     /**
315.      * @return Collection<int, PNotification>
316.      */
317.     public function getNotifications(): Collection
318.     {
319.         return $this->notifications;
320.     }
322.     public function addNotification(PNotification $notification): static
323.     {
324.         if (!$this->notifications->contains($notification)) {
325.             $this->notifications->add($notification);
326.             $notification->setUser($this);
327.         }
329.         return $this;
330.     }
332.     public function removeNotification(PNotification $notification): static
333.     {
334.         if ($this->notifications->removeElement($notification)) {
335.             // set the owning side to null (unless already changed)
336.             if ($notification->getUser() === $this) {
337.                 $notification->setUser(null);
338.             }
339.         }
341.         return $this;
342.     }
344.    
345. }