src/Entity/User.php line 34

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Abstract\Persona;
  6. use App\Entity\GroupTicket\PublicConnection;
  7. use App\Entity\GroupTicket\School;
  8. use App\Entity\GroupTicket\Teacher;
  9. use App\Entity\GroupTicket\TransportCompany;
  10. use App\Entity\Security\UserRole;
  11. use App\Repository\UserRepository;
  12. use Doctrine\Common\Collections\ArrayCollection;
  13. use Doctrine\Common\Collections\Collection;
  14. use Doctrine\DBAL\Types\Types;
  15. use Doctrine\ORM\Mapping as ORM;
  16. use Scheb\TwoFactorBundle\Model\Email\TwoFactorInterface;
  17. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  18. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  19. use Symfony\Component\Security\Core\User\UserInterface;
  20. use Symfony\Component\Validator\Constraints as Assert;
  22. #[ORM\Entity(repositoryClass: UserRepository::class)]
  24. #[ORM\Table('user')]
  25. #[ORM\InheritanceType('SINGLE_TABLE')]
  26. #[ORM\DiscriminatorColumn(name: 'type', type: 'string')]
  27. #[ORM\DiscriminatorMap([
  28. 'admin' => Admin::class,
  29. 'teacher' => Teacher::class,
  30. 'transport' => TransportCompany::class,
  31. 'school' => School::class])
  32. ]
  33. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email', entityClass: User::class)]
  34. abstract class User extends Persona implements UserInterface, PasswordAuthenticatedUserInterface, TwoFactorInterface
  35. {
  36. #[ORM\Column(length: 180, unique: true)]
  37. #[Assert\NotBlank]
  38. #[Assert\Email]
  39. protected ?string $email = null;
  41. #[ORM\Column]
  42. private ?string $password = null;
  44. #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  45. private ?\DateTimeInterface $passwordChangedAt = null;
  47. #[ORM\Column(type: 'boolean')]
  48. private bool $isVerified = false;
  50. #[ORM\Column(length: 20, nullable: true)]
  51. private ?string $authCode = null;
  53. #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  54. private ?\DateTimeInterface $validatedAt = null;
  56. #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  57. private ?\DateTimeInterface $loginValidStart = null;
  59. #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  60. private ?\DateTimeInterface $loginValidEnd = null;
  62. #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  63. private ?\DateTimeInterface $lastLogin = null;
  65. #[ORM\ManyToMany(targetEntity: UserRole::class, inversedBy: 'users')]
  66. private Collection $userRoles;
  68. #[ORM\Column(type: Types::JSON, nullable: false)]
  69. private array $roles = [];
  71. #[ORM\ManyToOne(inversedBy: 'users')]
  72. private ?Tu $tu = null;
  74. #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Institution::class)]
  75. private Collection $institutions;
  77. #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Seller::class)]
  78. private Collection $sellers;
  80. #[ORM\ManyToMany(targetEntity: PublicConnection::class, inversedBy: 'users')]
  81. private Collection $groupTicketPublicConnection;
  83. #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserPasswordHistory::class, cascade: ['persist', 'remove'])]
  84. private Collection $passwordHistory;
  86. public function __construct()
  87. {
  88. $this->userRoles = new ArrayCollection();
  89. $this->institutions = new ArrayCollection();
  90. $this->sellers = new ArrayCollection();
  91. $this->groupTicketPublicConnection = new ArrayCollection();
  92. $this->passwordHistory = new ArrayCollection();
  93. }
  95. /**
  96. * A visual identifier that represents this user.
  97. *
  98. * @see UserInterface
  99. */
  100. public function getUserIdentifier(): string
  101. {
  102. return (string) $this->email;
  103. }
  105. /**
  106. * @deprecated since Symfony 5.3, use getUserIdentifier instead
  107. */
  108. public function getUsername(): string
  109. {
  110. return (string) $this->email;
  111. }
  113. public function getRoles(): array
  114. {
  115. $roles = $this->roles;
  117. if (!in_array('ROLE_USER', $roles, true)) {
  118. $roles[] = 'ROLE_USER';
  119. }
  121. return array_unique($roles);
  122. }
  124. public function setRoles(array $roles): self
  125. {
  126. $this->roles = $roles;
  128. return $this;
  129. }
  131. public function hasRole($role): bool
  132. {
  133. return in_array($role, $this->getRoles()) || $this->hasUserRole($role);
  134. }
  136. /**
  137. * @param string|UserRole $role
  138. * @return bool
  139. */
  140. public function hasUserRole(UserRole|string $role): bool
  141. {
  142. if ($role instanceof UserRole) {
  143. return $this->userRoles->contains($role);
  144. }
  146. if (is_string($role)) {
  147. foreach ($this->userRoles as $userRole) {
  148. if ($userRole->getIdentifier() === $role) {
  149. return true;
  150. }
  151. }
  152. }
  154. return false;
  155. }
  157. /**
  158. * @see PasswordAuthenticatedUserInterface
  159. */
  160. public function getPassword(): string
  161. {
  162. return $this->password;
  163. }
  165. public function setPassword(string $password): self
  166. {
  167. $this->password = $password;
  168. return $this;
  169. }
  171. public function getPasswordChangedAt(): ?\DateTimeInterface
  172. {
  173. return $this->passwordChangedAt;
  174. }
  176. public function setPasswordChangedAt(?\DateTimeInterface $passwordChangedAt): static
  177. {
  178. $this->passwordChangedAt = $passwordChangedAt;
  179. return $this;
  180. }
  182. /**
  183. * Returning a salt is only needed, if you are not using a modern
  184. * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  185. *
  186. * @see UserInterface
  187. */
  188. public function getSalt(): ?string
  189. {
  190. return null;
  191. }
  193. /**
  194. * @see UserInterface
  195. */
  196. public function eraseCredentials()
  197. {
  198. // If you store any temporary, sensitive data on the user, clear it here
  199. // $this->plainPassword = null;
  200. }
  202. public function isVerified(): bool
  203. {
  204. return $this->isVerified;
  205. }
  207. public function setIsVerified(bool $isVerified): self
  208. {
  209. $this->isVerified = $isVerified;
  211. return $this;
  212. }
  214. public function getAuthCode(): ?string
  215. {
  216. return $this->authCode;
  217. }
  219. public function setAuthCode(?string $authCode): static
  220. {
  221. $this->authCode = $authCode;
  223. return $this;
  224. }
  226. public function isEmailAuthEnabled(): bool
  227. {
  228. if (in_array('ROLE_TEACHER', $this->roles)) {
  229. return false;
  230. }
  231. return true;
  232. }
  234. public function getEmailAuthRecipient(): string
  235. {
  236. return $this->email;
  237. }
  239. public function getEmailAuthCode(): string
  240. {
  241. if (null === $this->authCode) {
  242. throw new \LogicException('The email authentication code was not set');
  243. }
  245. return $this->authCode;
  246. }
  248. public function setEmailAuthCode(string $authCode): void
  249. {
  250. $this->authCode = $authCode;
  251. }
  253. public function getFullName(): string
  254. {
  255. return $this->getName();
  256. }
  258. public function getValidatedAt(): ?\DateTimeInterface
  259. {
  260. return $this->validatedAt;
  261. }
  263. public function setValidatedAt(?\DateTimeInterface $validatedAt): static
  264. {
  265. $this->validatedAt = $validatedAt;
  267. return $this;
  268. }
  270. public function getLoginValidStart(): ?\DateTimeInterface
  271. {
  272. return $this->loginValidStart;
  273. }
  275. public function setLoginValidStart(?\DateTimeInterface $loginValidStart): static
  276. {
  277. $this->loginValidStart = $loginValidStart;
  279. return $this;
  280. }
  282. public function getLoginValidEnd(): ?\DateTimeInterface
  283. {
  284. return $this->loginValidEnd;
  285. }
  287. public function setLoginValidEnd(?\DateTimeInterface $loginValidEnd): static
  288. {
  289. $this->loginValidEnd = $loginValidEnd;
  291. return $this;
  292. }
  294. public function getLastLogin(): ?\DateTimeInterface
  295. {
  296. return $this->lastLogin;
  297. }
  299. public function setLastLogin(?\DateTimeInterface $lastLogin): static
  300. {
  301. $this->lastLogin = $lastLogin;
  303. return $this;
  304. }
  306. public function isExpired(): bool
  307. {
  308. $currentDate = new \DateTime();
  309. $validStart = $this->getLoginValidStart();
  310. $validEnd = $this->getLoginValidEnd();
  312. if ($validStart !== null && $validEnd !== null) {
  313. if ($currentDate < $validStart || $currentDate > $validEnd) {
  314. return true;
  315. }
  316. } elseif ($validStart !== null && $currentDate < $validStart) {
  317. return true;
  318. } elseif ($validEnd !== null && $currentDate > $validEnd) {
  319. return true;
  320. }
  322. return false;
  323. }
  325. public function updateEmailForDelete(): void
  326. {
  327. if(!empty($this->email)){
  328. $this->email = time().'-'.$this->email;
  329. }
  330. }
  332. public function addUserRole(UserRole $role): self
  333. {
  334. if (!$this->userRoles->contains($role)) {
  335. $this->userRoles->add($role);
  336. if(in_array($role->getIdentifier(), $this->roles) === false){
  337. $this->roles[] = $role->getIdentifier();
  338. }
  339. }
  341. return $this;
  342. }
  344. public function removeUserRole(UserRole $role): self
  345. {
  346. if ($this->userRoles->contains($role)) {
  347. $this->userRoles->removeElement($role);
  348. $this->roles = array_filter($this->roles, fn($r) => $r !== $role->getIdentifier());
  349. }
  351. return $this;
  352. }
  354. public function clearUserRoles(): self
  355. {
  356. $this->userRoles->clear();
  357. $this->roles = [];
  359. return $this;
  360. }
  362. public function getUserRoles(): Collection
  363. {
  364. return $this->userRoles;
  365. }
  367. public function getTu(): ?Tu
  368. {
  369. return $this->tu;
  370. }
  372. public function setTu(?Tu $tu): static
  373. {
  374. $this->tu = $tu;
  376. return $this;
  377. }
  379. /**
  380. * @return Collection<int, Institution>
  381. */
  382. public function getInstitutions(): Collection
  383. {
  384. return $this->institutions;
  385. }
  387. public function addInstitution(Institution $institution): static
  388. {
  389. if (!$this->institutions->contains($institution)) {
  390. $this->institutions->add($institution);
  391. $institution->setCreatedBy($this);
  392. }
  394. return $this;
  395. }
  397. public function removeInstitution(Institution $institution): static
  398. {
  399. if ($this->institutions->removeElement($institution)) {
  400. // set the owning side to null (unless already changed)
  401. if ($institution->getCreatedBy() === $this) {
  402. $institution->setCreatedBy(null);
  403. }
  404. }
  406. return $this;
  407. }
  409. /**
  410. * @return Collection<int, Seller>
  411. */
  412. public function getSellers(): Collection
  413. {
  414. return $this->sellers;
  415. }
  417. public function addSeller(Seller $seller): static
  418. {
  419. if (!$this->sellers->contains($seller)) {
  420. $this->sellers->add($seller);
  421. $seller->setCreatedBy($this);
  422. }
  424. return $this;
  425. }
  427. public function removeSeller(Seller $seller): static
  428. {
  429. if ($this->sellers->removeElement($seller)) {
  430. // set the owning side to null (unless already changed)
  431. if ($seller->getCreatedBy() === $this) {
  432. $seller->setCreatedBy(null);
  433. }
  434. }
  436. return $this;
  437. }
  439. /**
  440. * @return Collection<int, PublicConnection>
  441. */
  442. public function getGroupTicketPublicConnection(): Collection
  443. {
  444. return $this->groupTicketPublicConnection;
  445. }
  447. public function addGroupTicketPublicConnection(PublicConnection $groupTicketPublicConnection): static
  448. {
  449. if (!$this->groupTicketPublicConnection->contains($groupTicketPublicConnection)) {
  450. $this->groupTicketPublicConnection->add($groupTicketPublicConnection);
  451. }
  453. return $this;
  454. }
  456. public function removeGroupTicketPublicConnection(PublicConnection $groupTicketPublicConnection): static
  457. {
  458. $this->groupTicketPublicConnection->removeElement($groupTicketPublicConnection);
  460. return $this;
  461. }
  463. public function getPasswordHistory(): Collection
  464. {
  465. return $this->passwordHistory;
  466. }
  468. public function addPasswordHistory(UserPasswordHistory $entry): static
  469. {
  470. if (!$this->passwordHistory->contains($entry)) {
  471. $this->passwordHistory->add($entry);
  472. $entry->setUser($this);
  473. }
  474. return $this;
  475. }
  477. public function clearPasswordHistory(): static
  478. {
  479. foreach ($this->passwordHistory as $entry) {
  480. $this->passwordHistory->removeElement($entry);
  481. }
  482. return $this;
  483. }
  485. }