src/Entity/User.php line 27

  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\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;
  13. use Symfony\Component\HttpFoundation\File\File;
  14. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  15. use Scheb\TwoFactorBundle\Model\Totp\TotpConfiguration;
  16. use Scheb\TwoFactorBundle\Model\Totp\TotpConfigurationInterface;
  17. use Scheb\TwoFactorBundle\Model\Totp\TwoFactorInterface;
  21. use Symfony\Component\Validator\Constraints as Assert;
  24. #[ORM\Entity(repositoryClass: UserRepository::class)]
  25. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  26. #[Vich\Uploadable]
  27. class User implements UserInterface, PasswordAuthenticatedUserInterface
  28. {
  29.     #[ORM\Id]
  30.     #[ORM\GeneratedValue]
  31.     #[ORM\Column]
  32.     private ?int $id = null;
  34.     #[ORM\Column(length: 180, unique: true)]
  35.     private ?string $email = null;
  37.     #[ORM\Column]
  38.     private array $roles = [];
  40.     /**
  41.      * @var string The hashed password
  42.      */
  43.     #[ORM\Column(nullable: true)]
  44.     #[Assert\Length(min: 8, minMessage: "Le mot de passe doit faire au moins 8 caractères")]
  46.     private ?string $password = null;
  48.     #[ORM\Column(length: 100)]
  49.     private ?string $firstname = null;
  51.     #[ORM\Column(length: 100, nullable: true)]
  52.     private ?string $lastname = null;
  54.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  55.     private ?\DateTimeInterface $CreatedAt = null;
  57.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  58.     private ?\DateTimeInterface $UpdatedAt = null;
  60.     #[ORM\Column(nullable: true)]
  61.     private ?bool $Enable = null;
  63.     #[ORM\Column(length: 5, nullable: true)]
  64.     private ?string $language = null;
  67.     #[ORM\Column(nullable: true)]
  68.     private ?bool $isVerified = null;
  70.     #[ORM\ManyToOne(inversedBy: 'users')]
  71.     private ?LawOffice $LawOffice = null;
  74.     // NOTE: This is not a mapped field of entity metadata, just a simple property.
  76.     #[Vich\UploadableField(mapping: 'user_avatar', fileNameProperty: 'avatarName', size: 'avatarSize')]
  77.     private ?File $avatarFile = null;
  79.     #[ORM\Column(nullable: true)]
  80.     private ?string $avatarName = null;
  82.     #[ORM\Column(nullable: true)]
  83.     private ?int $avatarSize = null;
  85.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Client::class)]
  86.     private Collection $clients;
  88.     #[ORM\OneToMany(mappedBy: 'CreatedBy', targetEntity: TheCase::class)]
  89.     private Collection $theCases;
  91.     #[ORM\OneToMany(mappedBy: 'CreatedBy', targetEntity: Files::class)]
  92.     private Collection $files;
  94.     #[ORM\Column(nullable: true)]
  95.     private ?string $totpSecret;
  98.     public function __construct()
  99.     {
  100.         $this->clients = new ArrayCollection();
  101.         $this->theCases = new ArrayCollection();
  102.         $this->files = new ArrayCollection();
  103.     }
  105.     public function getId(): ?int
  106.     {
  107.         return $this->id;
  108.     }
  110.     public function getEmail(): ?string
  111.     {
  112.         return $this->email;
  113.     }
  115.     public function setEmail(string $email): self
  116.     {
  117.         $this->email = $email;
  119.         return $this;
  120.     }
  122.     /**
  123.      * A visual identifier that represents this user.
  124.      *
  125.      * @see UserInterface
  126.      */
  127.     public function getUserIdentifier(): string
  128.     {
  129.         return (string) $this->email;
  130.     }
  132.     /**
  133.      * @see UserInterface
  134.      */
  135.     public function getRoles(): array
  136.     {
  137.         $roles = $this->roles;
  138.         // guarantee every user at least has ROLE_USER
  139.         $roles[] = 'ROLE_USER';
  141.         return array_unique($roles);
  142.     }
  144.     public function setRoles(array $roles): self
  145.     {
  146.         $this->roles = $roles;
  148.         return $this;
  149.     }
  151.     /**
  152.      * @see PasswordAuthenticatedUserInterface
  153.      */
  154.     public function getPassword(): string
  155.     {
  156.         return $this->password;
  157.     }
  159.     public function setPassword(string $password): self
  160.     {
  161.         $this->password = $password;
  163.         return $this;
  164.     }
  166.     /**
  167.      * @see UserInterface
  168.      */
  169.     public function eraseCredentials()
  170.     {
  171.         // If you store any temporary, sensitive data on the user, clear it here
  172.         // $this->plainPassword = null;
  173.     }
  175.     public function getFirstname(): ?string
  176.     {
  177.         return $this->firstname;
  178.     }
  180.     public function setFirstname(string $firstname): self
  181.     {
  182.         $this->firstname = $firstname;
  184.         return $this;
  185.     }
  187.     public function getLastname(): ?string
  188.     {
  189.         return $this->lastname;
  190.     }
  192.     public function setLastname(?string $lastname): self
  193.     {
  194.         $this->lastname = $lastname;
  196.         return $this;
  197.     }
  199.     public function getCreatedAt(): ?\DateTimeInterface
  200.     {
  201.         return $this->CreatedAt;
  202.     }
  204.     public function setCreatedAt(?\DateTimeInterface $CreatedAt): self
  205.     {
  206.         $this->CreatedAt = $CreatedAt;
  208.         return $this;
  209.     }
  211.     public function getUpdatedAt(): ?\DateTimeInterface
  212.     {
  213.         return $this->UpdatedAt;
  214.     }
  216.     public function setUpdatedAt(?\DateTimeInterface $UpdatedAt): self
  217.     {
  218.         $this->UpdatedAt = $UpdatedAt;
  220.         return $this;
  221.     }
  223.     public function isEnable(): ?bool
  224.     {
  225.         return $this->Enable;
  226.     }
  228.     public function setEnable(?bool $Enable): self
  229.     {
  230.         $this->Enable = $Enable;
  232.         return $this;
  233.     }
  235.     public function getLanguage(): ?string
  236.     {
  237.         return $this->language;
  238.     }
  240.     public function setLanguage(?string $language): self
  241.     {
  242.         $this->language = $language;
  244.         return $this;
  245.     }
  247.     public function isIsVerified(): ?bool
  248.     {
  249.         return $this->isVerified;
  250.     }
  252.     public function setIsVerified(?bool $isVerified): self
  253.     {
  254.         $this->isVerified = $isVerified;
  256.         return $this;
  257.     }
  259.     public function isVerified(): bool
  260.     {
  261.         return $this->isVerified;
  262.     }
  264.     public function getLawOffice(): ?LawOffice
  265.     {
  266.         return $this->LawOffice;
  267.     }
  269.     public function setLawOffice(?LawOffice $LawOffice): self
  270.     {
  271.         $this->LawOffice = $LawOffice;
  273.         return $this;
  274.     }
  276.     /**
  277.      * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  278.      * of 'UploadedFile' is injected into this setter to trigger the update. If this
  279.      * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  280.      * must be able to accept an instance of 'File' as the bundle will inject one here
  281.      * during Doctrine hydration.
  282.      *
  283.      * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile|null $avatarFile
  284.      */
  285.     public function setAvatarFile(?File $avatarFile = null): void
  286.     {
  287.         $this->avatarFile = $avatarFile;
  289.         if (null !== $avatarFile) {
  290.             // It is required that at least one field changes if you are using doctrine
  291.             // otherwise the event listeners won't be called and the file is lost
  292.             $this->updatedAt = new \DateTimeImmutable();
  293.         }
  294.     }
  296.     public function getAvatarFile(): ?File
  297.     {
  298.         return $this->avatarFile;
  299.     }
  301.     public function setAvatarName(?string $avatarName): void
  302.     {
  303.         $this->avatarName = $avatarName;
  304.     }
  306.     public function getAvatarName(): ?string
  307.     {
  308.         return $this->avatarName;
  309.     }
  311.     public function setAvatarSize(?int $avatarSize): void
  312.     {
  313.         $this->avatarSize = $avatarSize;
  314.     }
  316.     public function getAvatarSize(): ?int
  317.     {
  318.         return $this->avatarSize;
  319.     }
  321.     /**
  322.      * @return Collection<int, Client>
  323.      */
  324.     public function getClients(): Collection
  325.     {
  326.         return $this->clients;
  327.     }
  329.     public function addClient(Client $client): self
  330.     {
  331.         if (!$this->clients->contains($client)) {
  332.             $this->clients->add($client);
  333.             $client->setCreatedBy($this);
  334.         }
  336.         return $this;
  337.     }
  339.     public function removeClient(Client $client): self
  340.     {
  341.         if ($this->clients->removeElement($client)) {
  342.             // set the owning side to null (unless already changed)
  343.             if ($client->getCreatedBy() === $this) {
  344.                 $client->setCreatedBy(null);
  345.             }
  346.         }
  348.         return $this;
  349.     }
  351.     /**
  352.      * @return Collection<int, TheCase>
  353.      */
  354.     public function getTheCases(): Collection
  355.     {
  356.         return $this->theCases;
  357.     }
  359.     public function addTheCase(TheCase $theCase): self
  360.     {
  361.         if (!$this->theCases->contains($theCase)) {
  362.             $this->theCases->add($theCase);
  363.             $theCase->setCreatedBy($this);
  364.         }
  366.         return $this;
  367.     }
  369.     public function removeTheCase(TheCase $theCase): self
  370.     {
  371.         if ($this->theCases->removeElement($theCase)) {
  372.             // set the owning side to null (unless already changed)
  373.             if ($theCase->getCreatedBy() === $this) {
  374.                 $theCase->setCreatedBy(null);
  375.             }
  376.         }
  378.         return $this;
  379.     }
  381.     /**
  382.      * @return Collection<int, Files>
  383.      */
  384.     public function getFiles(): Collection
  385.     {
  386.         return $this->files;
  387.     }
  389.     public function addFile(Files $file): self
  390.     {
  391.         if (!$this->files->contains($file)) {
  392.             $this->files->add($file);
  393.             $file->setCreatedBy($this);
  394.         }
  396.         return $this;
  397.     }
  399.     public function removeFile(Files $file): self
  400.     {
  401.         if ($this->files->removeElement($file)) {
  402.             // set the owning side to null (unless already changed)
  403.             if ($file->getCreatedBy() === $this) {
  404.                 $file->setCreatedBy(null);
  405.             }
  406.         }
  408.         return $this;
  409.     }
  411.     public function isTotpAuthenticationEnabled(): bool
  412.     {
  413.         return $this->totpSecret ? true : false;
  414.     }
  415.     public function getTotpAuthenticationUsername(): string
  416.     {
  417.         return $this->email;
  418.     }
  420.     public function getTotpAuthenticationConfiguration(): ?TotpConfigurationInterface
  421.     {
  422.         // You could persist the other configuration options in the user entity to make it individual per user.
  423.         return new TotpConfiguration($this->totpSecret, TotpConfiguration::ALGORITHM_SHA1, 20, 8);
  424.     }
  427. }