src/Entity/User.php line 25

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use DateTimeImmutable;
  6. use Doctrine\ORM\Mapping as ORM;
  7. use App\Repository\UserRepository;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\Common\Collections\ArrayCollection;
  10. use Symfony\Component\Uid\Uuid;
  11. use Symfony\Component\Validator\Constraints as Assert;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  13. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  14. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  15. use App\Entity\Instance;
  16. use Symfony\Component\Validator\Context\ExecutionContextInterface;
  17. use League\OAuth2\Server\Entities\UserEntityInterface;
  18. use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
  20. /**
  21.  * @ORM\Entity(repositoryClass=UserRepository::class)
  22.  * @UniqueEntity(fields={"email"}, message="Cette adresse email est déjà utilisé")
  23.  * @ORM\HasLifecycleCallbacks
  24.  */
  25. class User implements UserInterface, PasswordAuthenticatedUserInterface, UserEntityInterface
  26. {
  27.     public const ROLE_SUPER_ADMIN = 'ROLE_SUPER_ADMIN';
  28.     public const ROLE_ADMIN = 'ROLE_ADMIN';
  29.     public const ROLE_DIRECTEUR = 'ROLE_DIRECTEUR';
  30.     public const ROLE_CHEF_REDACTEUR = 'ROLE_CHEF_REDACTEUR';
  31.     public const ROLE_ADJOINT_REDACTEUR = 'ROLE_ADJOINT_REDACTEUR';
  32.     public const ROLE_CHEF_RUBRIQUE = 'ROLE_CHEF_RUBRIQUE';
  33.     public const ROLE_REDACTEUR = 'ROLE_REDACTEUR';
  34.     public const ROLE_USER = 'ROLE_USER';
  36.     /**
  37.      * @ORM\Id
  38.      * @ORM\GeneratedValue
  39.      * @ORM\Column(type="integer")
  40.      */
  41.     private $id;
  43.     /**
  44.      * @ORM\Column(type="string", length=180, unique=true)
  45.      * @Assert\NotBlank()
  46.      * @Assert\Email()
  47.      */
  48.     private $email;
  50.     /**
  51.      * @ORM\Column(type="json")
  52.      */
  53.     private $roles = [];
  55.     /**
  56.      * @var string The hashed password
  57.      * @ORM\Column(type="string")
  58.      * @Assert\NotBlank(message="Veuillez entrer un mot de passe")
  59.      * @Assert\Length(min="8", minMessage="Le mot de passe doit faire au moins 8 caratères")
  60.      */
  61.     private $password;
  63.     /**
  64.      * @Assert\EqualTo(propertyPath="password", message="Les mots de passes ne correspondent pas")
  65.      */
  66.     private $passwordConfirm;
  68.     /**
  69.      * @ORM\OneToMany(targetEntity=BlogPostLike::class, mappedBy="user")
  70.      */
  71.     private $blogPostLikes;
  73.     /**
  74.      * @ORM\Column(type="datetime", nullable=true)
  75.      */
  76.     private $createdAt;
  78.     /**
  79.      * @ORM\Column(type="datetime", nullable=true)
  80.      */
  81.     private ?\DateTimeInterface $updatedAt = null;
  83.     /**
  84.      * @ORM\Column(type="boolean", options={"default": false}, nullable=true)
  85.      */
  86.     private $isItmConnect;
  88.     /**
  89.      * @ORM\Column(type="text", nullable=true)
  90.      */
  91.     private $refreshToken;
  93.     /**
  94.      * @ORM\ManyToMany(targetEntity="BlogPostCategory", inversedBy="users")
  95.      * @ORM\JoinColumn(nullable=true,onDelete="SET NULL")
  96.      * )
  97.      */
  98.     private $blogPostCategories;
  100.     /**
  101.      * @ORM\OneToMany(targetEntity=UserNotificationEntry::class, mappedBy="user", orphanRemoval=true)
  102.      */
  103.     private $userNotificationEntries;
  105.     /**
  106.      * @ORM\ManyToMany(targetEntity=Preference::class)
  107.      */
  108.     private $preference;
  110.     /**
  111.      * @ORM\OneToMany(targetEntity=Contributor::class, mappedBy="user")
  112.      */
  113.     private $contributors;
  115.     /**
  116.      * @ORM\Column(type="string", length=255, nullable=true)
  117.      */
  118.     private $tokenFirebase;
  120.     /**
  121.      * @ORM\Column(type="boolean", nullable=true)
  122.      */
  123.     private $acceptCgu;
  125.     /**
  126.      * @ORM\Column(type="uuid", unique=true, nullable=true)
  127.      */
  128.     private ?Uuid $uuid = null;
  130.     /**
  131.      * @ORM\OneToMany(mappedBy="user", targetEntity=OAuth2UserConsent::class, orphanRemoval=true)
  132.      */
  133.     private Collection $oAuth2UserConsents;
  135.     /**
  136.      * @ORM\OneToMany(targetEntity=BlogPost::class, mappedBy="author")
  137.      */
  138.     private $blogPosts;
  140.     /**
  141.      * @ORM\ManyToMany(targetEntity=Criteria1Item::class)
  142.      */
  143.     private $criteria1Items;
  145.     /**
  146.      * @ORM\ManyToMany(targetEntity=Criteria2Item::class)
  147.      */
  148.     private $criteria2Items;
  150.     /**
  151.      * @ORM\ManyToMany(targetEntity=Criteria3Item::class)
  152.      */
  153.     private $criteria3Items;
  155.     /**
  156.      * @ORM\ManyToMany(targetEntity=Criteria4Item::class)
  157.      */
  158.     private $criteria4Items;
  160.     /**
  161.      * @ORM\ManyToMany(targetEntity=Criteria5Item::class)
  162.      */
  163.     private $criteria5Items;
  165.     /**
  166.      * @ORM\Column(type="datetime", nullable=true)
  167.      */
  168.     private $firebaseTokenGeneratedAt;
  170.     /**
  171.      * @ORM\OneToMany(targetEntity=Scoring::class, mappedBy="user", orphanRemoval=true)
  172.      */
  173.     private $scorings;
  174.     /**
  175.      * @ORM\ManyToMany(targetEntity=Instance::class, inversedBy="users")
  176.      */
  177.     private Collection $instances;
  179.     /**
  180.      * @ORM\Column(type="boolean", options={"default": false})
  181.      */
  182.     private bool $allowSelfEdit = false;
  184.     /**
  185.      * @ORM\Column(type="boolean", options={"default": false})
  186.      */
  187.     private bool $anonymizationEnabled = false;
  189.     /**
  190.      * Indique si l'utilisateur a confirmé la popup d'anonymisation
  191.      * @ORM\Column(type="boolean", options={"default": false})
  192.      */
  193.     private bool $isAnonymisationConfirmed = false;
  194.     /**
  195.      * Retourne vrai si l'utilisateur a confirmé la popup d'anonymisation
  196.      */
  197.     public function isAnonymisationConfirmed(): bool
  198.     {
  199.         return $this->isAnonymisationConfirmed;
  200.     }
  202.     /**
  203.      * Définit la confirmation d'anonymisation
  204.      */
  205.     public function setAnonymisationConfirmed(bool $confirmed): self
  206.     {
  207.         $this->isAnonymisationConfirmed = $confirmed;
  208.         return $this;
  209.     }
  211.     /**
  212.      * @ORM\Column(type="string", length=512, nullable=true)
  213.      */
  214.     private ?string $firstName = null;
  216.     /**
  217.      * @ORM\Column(type="string", length=512, nullable=true)
  218.      */
  219.     private ?string $lastName = null;
  221.     /**
  222.      * @ORM\Column(type="string", length=512, nullable=true)
  223.      */
  224.     private ?string $entityCode = null;
  226.     /**
  227.      * @ORM\Column(type="string", length=512, nullable=true)
  228.      * @Assert\Email(message="Veuillez saisir un email professionnel valide")
  229.      */
  230.     private ?string $proEmail = null;
  232.     /**
  233.      * @ORM\Column(type="string", length=512, nullable=true)
  234.      * @Assert\Regex(
  235.      *     pattern="/^\d*$/",
  236.      *     message="Le téléphone professionnel doit contenir uniquement des chiffres."
  237.      * )
  238.      */
  239.     private ?string $proPhone = null;
  241.     /**
  242.      * @ORM\Column(type="string", length=255, nullable=true)
  243.      */
  244.     private ?string $photoPath = null;
  246.     /**
  247.      * @ORM\Column(type="boolean", options={"default": 0})
  248.      */
  249.     private bool $acceptPrivacy = false;
  251.     /**
  252.      * @ORM\Column(type="datetime_immutable", nullable=true)
  253.      */
  254.     private ?DateTimeImmutable $acceptPrivacyAt = null;
  256.     /**
  257.      * @ORM\Column(type="string", length=32, nullable=true)
  258.      */
  259.     private ?string $acceptPrivacyVersion = null;
  261.     /**
  262.      * @ORM\Column(type="boolean", options={"default": 0})
  263.      */
  264.     private bool $privacyChecked = false;
  266.     public function __construct()
  267.     {
  268.         $this->blogPostLikes = new ArrayCollection();
  269.         $this->createdAt = new \DateTime();
  270.         $this->blogPostCategories = new ArrayCollection();
  271.         $this->userNotificationEntries = new ArrayCollection();
  272.         $this->preference = new ArrayCollection();
  273.         $this->contributors = new ArrayCollection();
  274.         $this->oAuth2UserConsents = new ArrayCollection();
  275.         $this->blogPosts = new ArrayCollection();
  276.         $this->criteria1Items = new ArrayCollection();
  277.         $this->criteria2Items = new ArrayCollection();
  278.         $this->criteria3Items = new ArrayCollection();
  279.         $this->criteria4Items = new ArrayCollection();
  280.         $this->criteria5Items = new ArrayCollection();
  281.         $this->scorings = new ArrayCollection();
  282.         $this->instances = new ArrayCollection();
  283.         // Init updatedAt with the same value as createdAt at creation time
  284.         $this->updatedAt = $this->createdAt;
  285.     }
  287.     /**
  288.      * @return int|null
  289.      */
  290.     public function getId(): ?int
  291.     {
  292.         return $this->id;
  293.     }
  295.     /**
  296.      * @return string|null
  297.      */
  298.     public function getEmail(): ?string
  299.     {
  300.         return $this->email;
  301.     }
  303.     /**
  304.      * @param string $email
  305.      * @return $this
  306.      */
  307.     public function setEmail(string $email): self
  308.     {
  309.         $this->email = $email;
  311.         return $this;
  312.     }
  314.     public function getCreatedAt(): ?\DateTimeInterface
  315.     {
  316.         return $this->createdAt;
  317.     }
  319.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  320.     {
  321.         $this->createdAt = $createdAt;
  322.         // Keep updatedAt in sync initially if it's not set yet
  323.         if ($this->updatedAt === null) {
  324.             $this->updatedAt = $createdAt;
  325.         }
  326.         return $this;
  327.     }
  329.     public function getUpdatedAt(): ?\DateTimeInterface
  330.     {
  331.         return $this->updatedAt;
  332.     }
  334.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  335.     {
  336.         $this->updatedAt = $updatedAt;
  337.         return $this;
  338.     }
  340.     /**
  341.      * Met à jour automatiquement la date de modification avant insert
  342.      * @ORM\PrePersist
  343.      */
  344.     public function onPrePersist(): void
  345.     {
  346.         $now = new \DateTime();
  347.         if ($this->createdAt === null) {
  348.             $this->createdAt = $now;
  349.         }
  350.         $this->updatedAt = $this->createdAt ?? $now;
  351.     }
  353.     /**
  354.      * Met à jour automatiquement la date de modification avant update
  355.      * @ORM\PreUpdate
  356.      */
  357.     public function onPreUpdate(): void
  358.     {
  359.         $this->updatedAt = new \DateTime();
  360.     }
  362.     /**
  363.      * A visual identifier that represents this user.
  364.      *
  365.      * @see UserInterface
  366.      */
  367.     public function getUserIdentifier(): string
  368.     {
  369.         return (string) $this->email;
  370.     }
  372.     /**
  373.      * Required by UserEntityInterface for OAuth2 server
  374.      *
  375.      * @see UserEntityInterface
  376.      */
  377.     public function getIdentifier(): ?string
  378.     {
  379.         return (string) $this->id;
  380.     }
  382.     /**
  383.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  384.      */
  385.     public function getUsername(): string
  386.     {
  387.         return (string) $this->email;
  388.     }
  390.     public function __toString(): string
  391.     {
  392.         return (string) $this->email;
  393.     }
  395.     /**
  396.      * @see UserInterface
  397.      */
  398.     public function getRoles(): array
  399.     {
  400.         $roles = $this->roles;
  401.         // guarantee every user at least has ROLE_USER
  402.         $roles[] = User::ROLE_USER;
  404.         return array_unique($roles);
  405.     }
  407.     public function getRolesList(): string
  408.     {
  409.         return implode(", ", $this->roles);
  410.     }
  412.     public function getRolesString(): string
  413.     {
  414.         $roleString = "[";
  416.         foreach ($this->roles as $key => $role) {
  417.             $roleString .= '"' . $role . '"';
  418.             if ($key < count($this->roles) - 1)
  419.                 $roleString .= ',';
  420.         }
  422.         $roleString .= "]";
  424.         return $roleString;
  425.     }
  427.     public function hasRole(string $role): bool
  428.     {
  429.         return in_array($role, $this->getRoles());
  430.     }
  432.     /**
  433.      * @param array $roles
  434.      * @return $this
  435.      */
  436.     public function setRoles(array $roles): self
  437.     {
  438.         $this->roles = $roles;
  440.         return $this;
  441.     }
  443.     public function getPasswordConfirm(): ?string
  444.     {
  445.         return $this->passwordConfirm;
  446.     }
  448.     public function setPasswordConfirm(string $passwordConfirm): self
  449.     {
  450.         $this->passwordConfirm = $passwordConfirm;
  452.         return $this;
  453.     }
  455.     /**
  456.      * @see PasswordAuthenticatedUserInterface
  457.      */
  458.     public function getPassword(): ?string
  459.     {
  460.         return $this->password;
  461.     }
  463.     public function setPassword(string $password): self
  464.     {
  465.         $this->password = $password;
  467.         return $this;
  468.     }
  470.     /**
  471.      * Returning a salt is only needed, if you are not using a modern
  472.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  473.      *
  474.      * @see UserInterface
  475.      */
  476.     public function getSalt(): ?string
  477.     {
  478.         return null;
  479.     }
  481.     /**
  482.      * @see UserInterface
  483.      */
  484.     public function eraseCredentials()
  485.     {
  486.         // If you store any temporary, sensitive data on the user, clear it here
  487.         // $this->plainPassword = null;
  488.     }
  490.     /**
  491.      * @return Collection|BlogPostLike[]
  492.      */
  493.     public function getBlogPostLikes(): Collection
  494.     {
  495.         return $this->blogPostLikes;
  496.     }
  498.     public function addBlogPostLike(BlogPostLike $blogPostLike): self
  499.     {
  500.         if (!$this->blogPostLikes->contains($blogPostLike)) {
  501.             $this->blogPostLikes[] = $blogPostLike;
  502.             $blogPostLike->setUser($this);
  503.         }
  505.         return $this;
  506.     }
  508.     public function removeBlogPostLike(BlogPostLike $blogPostLike): self
  509.     {
  510.         if ($this->blogPostLikes->removeElement($blogPostLike)) {
  511.             // set the owning side to null (unless already changed)
  512.             if ($blogPostLike->getUser() === $this) {
  513.                 $blogPostLike->setUser(null);
  514.             }
  515.         }
  517.         return $this;
  518.     }
  520.     /**
  521.      * @return Collection|BlogPostCategory[]
  522.      */
  523.     public function getBlogPostCategories(): Collection
  524.     {
  525.         return $this->blogPostCategories;
  526.     }
  528.     public function addBlogPostCategory(BlogPostCategory $blogPostCategory): self
  529.     {
  530.         if (!$this->blogPostCategories->contains($blogPostCategory)) {
  531.             $this->blogPostCategories[] = $blogPostCategory;
  532.             $blogPostCategory->addUser($this);
  533.         }
  535.         return $this;
  536.     }
  538.     public function removeBlogPostCategory(BlogPostCategory $rubrique): self
  539.     {
  540.         $this->blogPostCategories->removeElement($rubrique);
  542.         return $this;
  543.     }
  545.     /**
  546.      * @return Collection<int, UserNotificationEntry>
  547.      */
  548.     public function getUserNotificationEntries(): Collection
  549.     {
  550.         return $this->userNotificationEntries;
  551.     }
  553.     public function addUserNotificationEntry(UserNotificationEntry $userNotificationEntry): self
  554.     {
  555.         if (!$this->userNotificationEntries->contains($userNotificationEntry)) {
  556.             $this->userNotificationEntries[] = $userNotificationEntry;
  557.             $userNotificationEntry->setUser($this);
  558.         }
  560.         return $this;
  561.     }
  563.     public function removeUserNotificationEntry(UserNotificationEntry $userNotificationEntry): self
  564.     {
  565.         if ($this->userNotificationEntries->removeElement($userNotificationEntry)) {
  566.             // set the owning side to null (unless already changed)
  567.             if ($userNotificationEntry->getUser() === $this) {
  568.                 $userNotificationEntry->setUser(null);
  569.             }
  570.         }
  572.         return $this;
  573.     }
  575.     public function isItmConnect(): ?bool
  576.     {
  577.         return $this->isItmConnect;
  578.     }
  580.     public function getIsItmConnect(): bool
  581.     {
  582.         return $this->isItmConnect;
  583.     }
  585.     public function setIsItmConnect(bool $ItmConnect): self
  586.     {
  587.         $this->isItmConnect = $ItmConnect;
  589.         return $this;
  590.     }
  592.     /**
  593.      * @return Collection<int, Preference>
  594.      */
  595.     public function getPreference(): Collection
  596.     {
  597.         return $this->preference;
  598.     }
  600.     public function getPreferenceString(): string
  601.     {
  602.         $preferences = $this->preference;
  603.         $preferenceString = "";
  604.         if (count($preferences) > 0) {
  605.             for ($i = 0; $i < count($preferences); $i++) {
  606.                 if ($i == count($preferences) - 1) {
  607.                     $preferenceString = $preferenceString . "" . $preferences[$i]->getId();
  608.                 } else {
  609.                     $preferenceString = $preferenceString . "" . $preferences[$i]->getId() . ",";
  610.                 }
  611.             }
  612.         }
  613.         return $preferenceString;
  614.     }
  616.     public function addPreference(Preference $preference): self
  617.     {
  618.         if (!$this->preference->contains($preference)) {
  619.             $this->preference[] = $preference;
  620.         }
  622.         return $this;
  623.     }
  625.     public function removePreference(Preference $preference): self
  626.     {
  627.         $this->preference->removeElement($preference);
  629.         return $this;
  630.     }
  632.     public function getRefreshToken(): ?string
  633.     {
  634.         return $this->refreshToken;
  635.     }
  637.     public function setRefreshToken(string $refreshToken): self
  638.     {
  639.         $this->refreshToken = $refreshToken;
  641.         return $this;
  642.     }
  644.     /**
  645.      * @return Collection<int, Contributor>
  646.      */
  647.     public function getContributors(): Collection
  648.     {
  649.         return $this->contributors;
  650.     }
  652.     public function addContributor(Contributor $contributor): self
  653.     {
  654.         if (!$this->contributors->contains($contributor)) {
  655.             $this->contributors[] = $contributor;
  656.             $contributor->setUser($this);
  657.         }
  659.         return $this;
  660.     }
  662.     public function removeContributor(Contributor $contributor): self
  663.     {
  664.         if ($this->contributors->removeElement($contributor)) {
  665.             // set the owning side to null (unless already changed)
  666.             if ($contributor->getUser() === $this) {
  667.                 $contributor->setUser(null);
  668.             }
  669.         }
  671.         return $this;
  672.     }
  674.     public function getTokenFirebase(): ?string
  675.     {
  676.         return $this->tokenFirebase;
  677.     }
  679.     public function setTokenFirebase(?string $tokenFirebase): self
  680.     {
  681.         $this->tokenFirebase = $tokenFirebase;
  683.         return $this;
  684.     }
  686.     public function isAcceptCgu(): ?bool
  687.     {
  688.         return $this->acceptCgu;
  689.     }
  691.     public function setAcceptCgu(?bool $acceptCgu): self
  692.     {
  693.         $this->acceptCgu = $acceptCgu;
  695.         return $this;
  696.     }
  698.     public function getUuid(): ?Uuid
  699.     {
  700.         return $this->uuid;
  701.     }
  703.     public function setUuid(Uuid $uuid): self
  704.     {
  705.         $this->uuid = $uuid;
  707.         return $this;
  708.     }
  710.     /**
  711.      * @return Collection<int, OAuth2UserConsent>
  712.      */
  713.     public function getOAuth2UserConsents(): Collection
  714.     {
  715.         return $this->oAuth2UserConsents;
  716.     }
  718.     public function addOAuth2UserConsent(OAuth2UserConsent $oAuth2UserConsent): self
  719.     {
  720.         if (!$this->oAuth2UserConsents->contains($oAuth2UserConsent)) {
  721.             $this->oAuth2UserConsents->add($oAuth2UserConsent);
  722.             $oAuth2UserConsent->setUser($this);
  723.         }
  725.         return $this;
  726.     }
  728.     public function removeOAuth2UserConsent(OAuth2UserConsent $oAuth2UserConsent): self
  729.     {
  730.         if ($this->oAuth2UserConsents->removeElement($oAuth2UserConsent)) {
  731.             // set the owning side to null (unless already changed)
  732.             if ($oAuth2UserConsent->getUser() === $this) {
  733.                 $oAuth2UserConsent->setUser(null);
  734.             }
  735.         }
  737.         return $this;
  738.     }
  740.     public function canAccessBO(?AuthorizationCheckerInterface $authChecker = null): bool
  741.     {
  742.         // Canonical check via voter (préférable depuis BoAccessVoter)
  743.         if ($authChecker !== null) {
  744.             return $authChecker->isGranted('BO_ACCESS');
  745.         }
  747.         // Fallback legacy : tout rôle autre que ROLE_USER
  748.         // Préférer is_granted('BO_ACCESS') ou canAccessBO($authChecker) pour un check complet
  749.         if ($this->hasRole(self::ROLE_SUPER_ADMIN)) {
  750.             return true;
  751.         }
  752.         foreach ($this->getRoles() as $role) {
  753.             if ($role !== self::ROLE_USER) {
  754.                 return true;
  755.             }
  756.         }
  757.         return false;
  758.     }
  760.     /**
  761.      * @return Collection<int, BlogPost>
  762.      */
  763.     public function getBlogPosts(): Collection
  764.     {
  765.         return $this->blogPosts;
  766.     }
  768.     public function addBlogPost(BlogPost $blogPost): self
  769.     {
  770.         if (!$this->blogPosts->contains($blogPost)) {
  771.             $this->blogPosts[] = $blogPost;
  772.             $blogPost->setAuthor($this);
  773.         }
  775.         return $this;
  776.     }
  778.     public function removeBlogPost(BlogPost $blogPost): self
  779.     {
  780.         if ($this->blogPosts->removeElement($blogPost)) {
  781.             // set the owning side to null (unless already changed)
  782.             if ($blogPost->getAuthor() === $this) {
  783.                 $blogPost->setAuthor(null);
  784.             }
  785.         }
  787.         return $this;
  788.     }
  790.     /**
  791.      * @return Collection<int, Criteria1Item>
  792.      */
  793.     public function getCriteria1Items(): Collection
  794.     {
  795.         return $this->criteria1Items;
  796.     }
  798.     public function getCriteria1ItemsList(): string
  799.     {
  800.         return implode(", ", $this->criteria1Items->toArray());
  801.     }
  803.     public function getCriteria1ItemsString(): string
  804.     {
  805.         $string = "[";
  807.         foreach ($this->criteria1Items as $key => $criteria) {
  808.             $string .= '"' . $criteria . '"';
  809.             if ($key < count($this->criteria1Items) - 1)
  810.                 $string .= ',';
  811.         }
  813.         $string .= "]";
  815.         return $string;
  816.     }
  818.     public function addCriteria1Item(Criteria1Item $criteria1Item): self
  819.     {
  820.         if (!$this->criteria1Items->contains($criteria1Item)) {
  821.             $this->criteria1Items[] = $criteria1Item;
  822.         }
  824.         return $this;
  825.     }
  827.     /**
  828.      * @return Collection<int, Criteria2Item>
  829.      */
  830.     public function getCriteria2Items(): Collection
  831.     {
  832.         return $this->criteria2Items;
  833.     }
  835.     public function getCriteria2ItemsList(): string
  836.     {
  837.         return implode(", ", $this->criteria2Items->toArray());
  838.     }
  840.     public function getCriteria2ItemsString(): string
  841.     {
  842.         $string = "[";
  844.         foreach ($this->criteria2Items as $key => $criteria) {
  845.             $string .= '"' . $criteria . '"';
  846.             if ($key < count($this->criteria2Items) - 1)
  847.                 $string .= ',';
  848.         }
  850.         $string .= "]";
  852.         return $string;
  853.     }
  855.     public function addCriteria2Item(Criteria2Item $criteria2Item): self
  856.     {
  857.         if (!$this->criteria2Items->contains($criteria2Item)) {
  858.             $this->criteria2Items[] = $criteria2Item;
  859.         }
  861.         return $this;
  862.     }
  864.     /**
  865.      * @return Collection<int, Criteria3Item>
  866.      */
  867.     public function getCriteria3Items(): Collection
  868.     {
  869.         return $this->criteria3Items;
  870.     }
  872.     public function getCriteria3ItemsList(): string
  873.     {
  874.         return implode(", ", $this->criteria3Items->toArray());
  875.     }
  877.     public function getCriteria3ItemsString(): string
  878.     {
  879.         $string = "[";
  881.         foreach ($this->criteria3Items as $key => $criteria) {
  882.             $string .= '"' . $criteria . '"';
  883.             if ($key < count($this->criteria3Items) - 1)
  884.                 $string .= ',';
  885.         }
  887.         $string .= "]";
  889.         return $string;
  890.     }
  892.     public function addCriteria3Item(Criteria3Item $criteria3Item): self
  893.     {
  894.         if (!$this->criteria3Items->contains($criteria3Item)) {
  895.             $this->criteria3Items[] = $criteria3Item;
  896.         }
  898.         return $this;
  899.     }
  900.     /**
  901.      * @return Collection<int, Criteria4Item>
  902.      */
  903.     public function getCriteria4Items(): Collection
  904.     {
  905.         return $this->criteria4Items;
  906.     }
  908.     public function getCriteria4ItemsList(): string
  909.     {
  910.         return implode(", ", $this->criteria4Items->toArray());
  911.     }
  913.     public function getCriteria4ItemsString(): string
  914.     {
  915.         $string = "[";
  917.         foreach ($this->criteria4Items as $key => $criteria) {
  918.             $string .= '"' . $criteria . '"';
  919.             if ($key < count($this->criteria4Items) - 1)
  920.                 $string .= ',';
  921.         }
  923.         $string .= "]";
  925.         return $string;
  926.     }
  928.     public function addCriteria4Item(Criteria4Item $criteria4Item): self
  929.     {
  930.         if (!$this->criteria4Items->contains($criteria4Item)) {
  931.             $this->criteria4Items[] = $criteria4Item;
  932.         }
  934.         return $this;
  935.     }
  936.     /**
  937.      * @return Collection<int, Criteria5Item>
  938.      */
  939.     public function getCriteria5Items(): Collection
  940.     {
  941.         return $this->criteria5Items;
  942.     }
  944.     public function getCriteria5ItemsList(): string
  945.     {
  946.         return implode(", ", $this->criteria5Items->toArray());
  947.     }
  949.     public function getCriteria5ItemsString(): string
  950.     {
  951.         $string = "[";
  953.         foreach ($this->criteria5Items as $key => $criteria) {
  954.             $string .= '"' . $criteria . '"';
  955.             if ($key < count($this->criteria5Items) - 1)
  956.                 $string .= ',';
  957.         }
  959.         $string .= "]";
  961.         return $string;
  962.     }
  964.     // AVANT (bug) : public function addCriteria5Item(Criteria4Item $criteria5Item): self
  965.     public function addCriteria5Item(Criteria5Item $criteria5Item): self
  966.     {
  967.         if (!$this->criteria5Items->contains($criteria5Item)) {
  968.             $this->criteria5Items[] = $criteria5Item;
  969.         }
  970.         return $this;
  971.     }
  973.     public function getTokenFirebaseGeneratedAt(): ?\DateTimeInterface
  974.     {
  975.         return $this->firebaseTokenGeneratedAt;
  976.     }
  978.     public function setTokenFirebaseGeneratedAt(?\DateTimeInterface $firebaseTokenGeneratedAt): self
  979.     {
  980.         $this->firebaseTokenGeneratedAt = $firebaseTokenGeneratedAt;
  982.         return $this;
  983.     }
  985.     /**
  986.      * @return Collection<int, Scoring>
  987.      */
  988.     public function getScorings(): Collection
  989.     {
  990.         return $this->scorings;
  991.     }
  993.     public function addScoring(Scoring $scoring): self
  994.     {
  995.         if (!$this->scorings->contains($scoring)) {
  996.             $this->scorings[] = $scoring;
  997.             $scoring->setUser($this);
  998.         }
  1000.         return $this;
  1001.     }
  1003.     public function removeScoring(Scoring $scoring): self
  1004.     {
  1005.         if ($this->scorings->removeElement($scoring)) {
  1006.             if ($scoring->getUser() === $this) {
  1007.                 $scoring->setUser(null);
  1008.             }
  1009.         }
  1011.         return $this;
  1012.     }
  1013.     /**
  1014.      * @return Collection<int, Instance>
  1015.      */
  1016.     public function getInstances(): Collection
  1017.     {
  1018.         return $this->instances;
  1019.     }
  1021.     public function getInstancesList(): string
  1022.     {
  1023.         return implode(", ", $this->instances->toArray());
  1024.     }
  1026.     public function getInstancesString(): string
  1027.     {
  1028.         $string = "[";
  1029.         foreach ($this->instances as $key => $instance) {
  1030.             $string .= '"' . $instance->getName() . '"';
  1031.             if ($key < count($this->instances) - 1) {
  1032.                 $string .= ',';
  1033.             }
  1034.         }
  1035.         $string .= "]";
  1036.         return $string;
  1037.     }
  1039.     public function addInstance(Instance $instance): self
  1040.     {
  1041.         if (!$this->instances->contains($instance)) {
  1042.             $this->instances[] = $instance;
  1043.         }
  1044.         return $this;
  1045.     }
  1047.     public function removeInstance(Instance $instance): self
  1048.     {
  1049.         $this->instances->removeElement($instance);
  1050.         return $this;
  1051.     }
  1053.     public function hasInstance(Instance $instance): bool
  1054.     {
  1055.         return $this->instances->contains($instance);
  1056.     }
  1058.     /**
  1059.      * @return bool
  1060.      */
  1061.     public function isAllowSelfEdit(): bool
  1062.     {
  1063.         return (bool) $this->allowSelfEdit;
  1064.     }
  1066.     /**
  1067.      * @param bool $allowSelfEdit 
  1068.      * @return self
  1069.      */
  1070.     public function setAllowSelfEdit(bool $allowSelfEdit): self
  1071.     {
  1072.         $this->allowSelfEdit = $allowSelfEdit;
  1073.         return $this;
  1074.     }
  1076.     /**
  1077.      * @return bool
  1078.      */
  1079.     public function isAnonymizationEnabled(): bool
  1080.     {
  1081.         return $this->anonymizationEnabled;
  1082.     }
  1084.     /**
  1085.      * @param bool $anonymizationEnabled 
  1086.      * @return self
  1087.      */
  1088.     public function setAnonymizationEnabled(bool $anonymizationEnabled): self
  1089.     {
  1090.         $this->anonymizationEnabled = $anonymizationEnabled;
  1091.         return $this;
  1092.     }
  1094.     /**
  1095.      * @return 
  1096.      */
  1097.     public function getFirstName(): ?string
  1098.     {
  1099.         return $this->firstName;
  1100.     }
  1102.     /**
  1103.      * @param  $firstName 
  1104.      * @return self
  1105.      */
  1106.     public function setFirstName(?string $firstName): self
  1107.     {
  1108.         $this->firstName = $firstName;
  1109.         return $this;
  1110.     }
  1112.     /**
  1113.      * @return 
  1114.      */
  1115.     public function getLastName(): ?string
  1116.     {
  1117.         return $this->lastName;
  1118.     }
  1120.     /**
  1121.      * @param  $lastName 
  1122.      * @return self
  1123.      */
  1124.     public function setLastName(?string $lastName): self
  1125.     {
  1126.         $this->lastName = $lastName;
  1127.         return $this;
  1128.     }
  1130.     /**
  1131.      * @return 
  1132.      */
  1133.     public function getEntityCode(): ?string
  1134.     {
  1135.         return $this->entityCode;
  1136.     }
  1138.     /**
  1139.      * @param  $entityCode 
  1140.      * @return self
  1141.      */
  1142.     public function setEntityCode(?string $entityCode): self
  1143.     {
  1144.         $this->entityCode = $entityCode;
  1145.         return $this;
  1146.     }
  1148.     /**
  1149.      * @return 
  1150.      */
  1151.     public function getPhotoPath(): ?string
  1152.     {
  1153.         return $this->photoPath;
  1154.     }
  1156.     /**
  1157.      * @param  $photoPath 
  1158.      * @return self
  1159.      */
  1160.     public function setPhotoPath(?string $photoPath): self
  1161.     {
  1162.         $this->photoPath = $photoPath;
  1163.         return $this;
  1164.     }
  1166.     /**
  1167.      * @return 
  1168.      */
  1169.     public function getProEmail(): ?string
  1170.     {
  1171.         return $this->proEmail;
  1172.     }
  1174.     /**
  1175.      * @param  $proEmail 
  1176.      * @return self
  1177.      */
  1178.     public function setProEmail(?string $proEmail): self
  1179.     {
  1180.         $this->proEmail = $proEmail;
  1181.         return $this;
  1182.     }
  1184.     /**
  1185.      * @return 
  1186.      */
  1187.     public function getProPhone(): ?string
  1188.     {
  1189.         return $this->proPhone;
  1190.     }
  1192.     /**
  1193.      * @param  $proPhone 
  1194.      * @return self
  1195.      */
  1196.     public function setProPhone(?string $proPhone): self
  1197.     {
  1198.         $this->proPhone = $proPhone;
  1199.         return $this;
  1200.     }
  1202.     public function isAcceptPrivacy(): bool
  1203.     {
  1204.         return $this->acceptPrivacy;
  1205.     }
  1207.     public function setAcceptPrivacy(bool $acceptPrivacy): self
  1208.     {
  1209.         $this->acceptPrivacy = $acceptPrivacy;
  1210.         return $this;
  1211.     }
  1213.     public function getAcceptPrivacyAt(): ?DateTimeImmutable
  1214.     {
  1215.         return $this->acceptPrivacyAt;
  1216.     }
  1218.     public function setAcceptPrivacyAt(?DateTimeImmutable $acceptPrivacyAt): self
  1219.     {
  1220.         $this->acceptPrivacyAt = $acceptPrivacyAt;
  1221.         return $this;
  1222.     }
  1224.     public function getAcceptPrivacyVersion(): ?string
  1225.     {
  1226.         return $this->acceptPrivacyVersion;
  1227.     }
  1229.     public function setAcceptPrivacyVersion(?string $acceptPrivacyVersion): self
  1230.     {
  1231.         $this->acceptPrivacyVersion = $acceptPrivacyVersion;
  1232.         return $this;
  1233.     }
  1235.     public function isPrivacyChecked(): bool
  1236.     {
  1237.         return $this->privacyChecked;
  1238.     }
  1240.     public function setPrivacyChecked(bool $value): self
  1241.     {
  1242.         $this->privacyChecked = $value;
  1243.         return $this;
  1244.     }
  1246.     #[Assert\Callback(groups: ['identity'])]
  1247.     public function validateIdentity(ExecutionContextInterface $context): void
  1248.     {
  1249.         // Si l’admin coche "Autoriser l’utilisateur à compléter/modifier ses infos"
  1250.         // => on n'impose pas les champs d’identité côté back-office.
  1251.         if ($this->isAllowSelfEdit() || $this->isAnonymizationEnabled()) {
  1252.             return;
  1253.         }
  1255.         // Sinon : ces champs deviennent obligatoires côté admin
  1256.         $lastName = trim((string) $this->getLastName());
  1257.         $firstName = trim((string) $this->getFirstName());
  1258.         $entity = trim((string) $this->getEntityCode());
  1260.         if ($lastName === '') {
  1261.             $context->buildViolation('Le nom est obligatoire.')
  1262.                 ->atPath('lastName')
  1263.                 ->addViolation();
  1264.         }
  1265.         if ($firstName === '') {
  1266.             $context->buildViolation('Le prénom est obligatoire.')
  1267.                 ->atPath('firstName')
  1268.                 ->addViolation();
  1269.         }
  1270.         if ($entity === '') {
  1271.             $context->buildViolation('L’entité / code entité est obligatoire.')
  1272.                 ->atPath('entityCode')
  1273.                 ->addViolation();
  1274.         }
  1275.     }
  1277.     // Criteria 1
  1278.     public function removeCriteria1Item(Criteria1Item $criteria1Item): self
  1279.     {
  1280.         $this->criteria1Items->removeElement($criteria1Item);
  1281.         return $this;
  1282.     }
  1284.     // Criteria 2
  1285.     public function removeCriteria2Item(Criteria2Item $criteria2Item): self
  1286.     {
  1287.         $this->criteria2Items->removeElement($criteria2Item);
  1288.         return $this;
  1289.     }
  1291.     // Criteria 3
  1292.     public function removeCriteria3Item(Criteria3Item $criteria3Item): self
  1293.     {
  1294.         $this->criteria3Items->removeElement($criteria3Item);
  1295.         return $this;
  1296.     }
  1298.     // Criteria 4
  1299.     public function removeCriteria4Item(Criteria4Item $criteria4Item): self
  1300.     {
  1301.         $this->criteria4Items->removeElement($criteria4Item);
  1302.         return $this;
  1303.     }
  1305.     // Criteria 5
  1306.     public function removeCriteria5Item(Criteria5Item $criteria5Item): self
  1307.     {
  1308.         $this->criteria5Items->removeElement($criteria5Item);
  1309.         return $this;
  1310.     }
  1313. }