src/Entity/User.php line 17

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. #[ORM\Table(name: '`user`')]
16. #[UniqueEntity(fields: ['email'], message: "Cet email est déjà utilisé")]
17. class User implements UserInterface, PasswordAuthenticatedUserInterface
18. {
19.     #[ORM\Id]
20.     #[ORM\GeneratedValue]
21.     #[ORM\Column]
22.     private ?int $id = null;
24.     #[ORM\Column(length: 180, unique: true)]
25.     #[Assert\Email]
26.     #[Assert\Length(max: 180)]
27.     private ?string $email = null;
29.     #[ORM\Column]
30.     private array $roles = [];
32.     /**
33.      * @var string The hashed password
34.      */
35.     #[ORM\Column]
36.     private ?string $password = null;
38.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserAccess::class, orphanRemoval: true)]
39.     private Collection $accesses;
41.     public function __construct()
42.     {
43.         $this->accesses = new ArrayCollection();
44.     }
46.     /**
47.      * @param object $entity Resource to access
48.      * @param string[] $requiredRoles Should have at least one of these roles. Ex: "role1" OR "role2"
49.      *
50.      * @return bool
51.      */
52.     public function canAccessResource(object $entity, array $requiredRoles): bool
53.     {
54.         $fn = function(UserAccess $access) use ($entity, $requiredRoles) {
55.             if (!in_array($access->getRole(), $requiredRoles)) {
56.                 return false;
57.             }
59.             return ($access->getType() === UserAccess::TYPE_MAGASIN && $access->getMagasin() === $entity)
60.                 || ($access->getType() === UserAccess::TYPE_GROUPEMENT && $access->getGroupement() === $entity)
61.             ;
62.         };
64.         return $this->getAccesses()
65.             ->filter($fn)
66.             ->count() > 0;
67.     }
69.     public function getDefaultGroupement(): ?Groupement
70.     {
71.         foreach ($this->getAccesses() as $access) {
72.             if ($access->getType() === UserAccess::TYPE_GROUPEMENT && $access->getRole() === UserAccess::ROLE_ADMIN) {
73.                 return $access->getGroupement();
74.             }
75.         }
77.         return null;
78.     }
80.     public function getDefaultProject(): ?Project
81.     {
82.         foreach ($this->getAccesses() as $access) {
83.             if ($access->getType() === UserAccess::TYPE_MAGASIN && $access->getRole() === UserAccess::ROLE_ADMIN) {
84.                 return $access->getMagasin()?->getProject();
85.             }
86.         }
88.         return null;
89.     }
91.     public function getId(): ?int
92.     {
93.         return $this->id;
94.     }
96.     public function getEmail(): ?string
97.     {
98.         return $this->email;
99.     }
101.     public function setEmail(string $email): static
102.     {
103.         $this->email = $email;
105.         return $this;
106.     }
108.     /**
109.      * A visual identifier that represents this user.
110.      *
111.      * @see UserInterface
112.      */
113.     public function getUserIdentifier(): string
114.     {
115.         return (string) $this->email;
116.     }
118.     /**
119.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
120.      */
121.     public function getUsername(): string
122.     {
123.         return (string) $this->email;
124.     }
126.     /**
127.      * @see UserInterface
128.      */
129.     public function getRoles(): array
130.     {
131.         $roles = $this->roles;
132.         // guarantee every user at least has ROLE_USER
133.         $roles[] = 'ROLE_USER';
135.         return array_unique($roles);
136.     }
138.     public function setRoles(array $roles): static
139.     {
140.         $this->roles = $roles;
142.         return $this;
143.     }
145.     /**
146.      * @see PasswordAuthenticatedUserInterface
147.      */
148.     public function getPassword(): string
149.     {
150.         return $this->password;
151.     }
153.     public function setPassword(string $password): static
154.     {
155.         $this->password = $password;
157.         return $this;
158.     }
160.     /**
161.      * Returning a salt is only needed, if you are not using a modern
162.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
163.      *
164.      * @see UserInterface
165.      */
166.     public function getSalt(): ?string
167.     {
168.         return null;
169.     }
171.     /**
172.      * @see UserInterface
173.      */
174.     public function eraseCredentials(): void
175.     {
176.         // If you store any temporary, sensitive data on the user, clear it here
177.         // $this->plainPassword = null;
178.     }
180.     /**
181.      * @return Collection<int, UserAccess>
182.      */
183.     public function getAccesses(): Collection
184.     {
185.         return $this->accesses;
186.     }
188.     public function addAccess(UserAccess $access): static
189.     {
190.         if (!$this->accesses->contains($access)) {
191.             $this->accesses->add($access);
192.             $access->setUser($this);
193.         }
195.         return $this;
196.     }
198.     public function removeAccess(UserAccess $access): static
199.     {
200.         if ($this->accesses->removeElement($access)) {
201.             // set the owning side to null (unless already changed)
202.             if ($access->getUser() === $this) {
203.                 $access->setUser(null);
204.             }
205.         }
207.         return $this;
208.     }
209. }