src/Entity/User.php line 21

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. /**
  18.  * @ORM\Entity(repositoryClass=UserRepository::class)
  19.  * @UniqueEntity(fields={"email"}, message="Cette adresse email est déjà utilisé")
  20.  */
  21. class User implements UserInterface, PasswordAuthenticatedUserInterface
  22. {
  23.     public const ROLE_SUPER_ADMIN = 'ROLE_SUPER_ADMIN';
  24.     public const ROLE_ADMIN = 'ROLE_ADMIN';
  25.     public const ROLE_DIRECTEUR = 'ROLE_DIRECTEUR';
  26.     public const ROLE_CHEF_REDACTEUR = 'ROLE_CHEF_REDACTEUR';
  27.     public const ROLE_ADJOINT_REDACTEUR = 'ROLE_ADJOINT_REDACTEUR';
  28.     public const ROLE_CHEF_RUBRIQUE = 'ROLE_CHEF_RUBRIQUE';
  29.     public const ROLE_REDACTEUR = 'ROLE_REDACTEUR';
  30.     public const ROLE_USER = 'ROLE_USER';
  32.     /**
  33.      * @ORM\Id
  34.      * @ORM\GeneratedValue
  35.      * @ORM\Column(type="integer")
  36.      */
  37.     private $id;
  39.     /**
  40.      * @ORM\Column(type="string", length=180, unique=true)
  41.      * @Assert\NotBlank()
  42.      * @Assert\Email()
  43.      */
  44.     private $email;
  46.     /**
  47.      * @ORM\Column(type="json")
  48.      */
  49.     private $roles = [];
  51.     /**
  52.      * @var string The hashed password
  53.      * @ORM\Column(type="string")
  54.      * @Assert\NotBlank(message="Veuillez entrer un mot de passe")
  55.      * @Assert\Length(min="8", minMessage="Le mot de passe doit faire au moins 8 caratères")
  56.      */
  57.     private $password;
  59.     /**
  60.      * @Assert\EqualTo(propertyPath="password", message="Les mots de passes ne correspondent pas")
  61.      */
  62.     private $passwordConfirm;
  64.     /**
  65.      * @ORM\OneToMany(targetEntity=BlogPostLike::class, mappedBy="user")
  66.      */
  67.     private $blogPostLikes;
  69.     /**
  70.      * @ORM\Column(type="datetime", nullable=true)
  71.      */
  72.     private $createdAt;
  74.     /**
  75.      * @ORM\Column(type="boolean", options={"default": false}, nullable=true)
  76.      */
  77.     private $isItmConnect;
  79.     /**
  80.      * @ORM\Column(type="text", nullable=true)
  81.      */
  82.     private $refreshToken;
  84.     /**
  85.      * @ORM\ManyToMany(targetEntity="BlogPostCategory", inversedBy="users")
  86.      * @ORM\JoinColumn(nullable=true,onDelete="SET NULL")
  87.      * )
  88.      */
  89.     private $blogPostCategories;
  91.     /**
  92.      * @ORM\OneToMany(targetEntity=UserNotificationEntry::class, mappedBy="user", orphanRemoval=true)
  93.      */
  94.     private $userNotificationEntries;
  96.     /**
  97.      * @ORM\ManyToMany(targetEntity=Preference::class)
  98.      */
  99.     private $preference;
  101.     /**
  102.      * @ORM\OneToMany(targetEntity=Contributor::class, mappedBy="user")
  103.      */
  104.     private $contributors;
  106.     /**
  107.      * @ORM\Column(type="string", length=255, nullable=true)
  108.      */
  109.     private $tokenFirebase;
  111.     /**
  112.      * @ORM\Column(type="boolean", nullable=true)
  113.      */
  114.     private $acceptCgu;
  116.     /**
  117.      * @ORM\Column(type="uuid", unique=true, nullable=true)
  118.      */
  119.     private ?Uuid $uuid = null;
  121.     /**
  122.      * @ORM\OneToMany(mappedBy="user", targetEntity=OAuth2UserConsent::class, orphanRemoval=true)
  123.      */
  124.     private Collection $oAuth2UserConsents;
  126.     /**
  127.      * @ORM\OneToMany(targetEntity=BlogPost::class, mappedBy="author")
  128.      */
  129.     private $blogPosts;
  131.     /**
  132.      * @ORM\ManyToMany(targetEntity=Criteria1Item::class)
  133.      */
  134.     private $criteria1Items;
  136.     /**
  137.      * @ORM\ManyToMany(targetEntity=Criteria2Item::class)
  138.      */
  139.     private $criteria2Items;
  141.     /**
  142.      * @ORM\ManyToMany(targetEntity=Criteria3Item::class)
  143.      */
  144.     private $criteria3Items;
  146.     /**
  147.      * @ORM\ManyToMany(targetEntity=Criteria4Item::class)
  148.      */
  149.     private $criteria4Items;
  151.     /**
  152.      * @ORM\ManyToMany(targetEntity=Criteria5Item::class)
  153.      */
  154.     private $criteria5Items;
  156.     /**
  157.      * @ORM\Column(type="datetime", nullable=true)
  158.      */
  159.     private $firebaseTokenGeneratedAt;
  161.     /**
  162.      * @ORM\OneToMany(targetEntity=Scoring::class, mappedBy="user", orphanRemoval=true)
  163.      */
  164.     private $scorings;
  165.     /**
  166.      * @ORM\ManyToMany(targetEntity=Instance::class, inversedBy="users")
  167.      */
  168.     private Collection $instances;
  170.     /**
  171.      * @ORM\Column(type="boolean", options={"default": false})
  172.      */
  173.     private bool $allowSelfEdit = false;
  175.     /**
  176.      * @ORM\Column(type="boolean", options={"default": false})
  177.      */
  178.     private bool $anonymizationEnabled = false;
  180.     /**
  181.      * @ORM\Column(type="string", length=512, nullable=true)
  182.      */
  183.     private ?string $firstName = null;
  185.     /**
  186.      * @ORM\Column(type="string", length=512, nullable=true)
  187.      */
  188.     private ?string $lastName = null;
  190.     /**
  191.      * @ORM\Column(type="string", length=512, nullable=true)
  192.      */
  193.     private ?string $entityCode = null;
  195.     /**
  196.      * @ORM\Column(type="string", length=512, nullable=true)
  197.      * @Assert\Email(message="Veuillez saisir un email professionnel valide")
  198.      */
  199.     private ?string $proEmail = null;
  201.     /**
  202.      * @ORM\Column(type="string", length=512, nullable=true)
  203.      * @Assert\Regex(
  204.      *     pattern="/^\d*$/",
  205.      *     message="Le téléphone professionnel doit contenir uniquement des chiffres."
  206.      * )
  207.      */
  208.     private ?string $proPhone = null;
  210.     /**
  211.      * @ORM\Column(type="string", length=255, nullable=true)
  212.      */
  213.     private ?string $photoPath = null;
  215.     /**
  216.      * @ORM\Column(type="boolean", options={"default": 0})
  217.      */
  218.     private bool $acceptPrivacy = false;
  220.     /**
  221.      * @ORM\Column(type="datetime_immutable", nullable=true)
  222.      */
  223.     private ?DateTimeImmutable $acceptPrivacyAt = null;
  225.     /**
  226.      * @ORM\Column(type="string", length=32, nullable=true)
  227.      */
  228.     private ?string $acceptPrivacyVersion = null;
  230.     /**
  231.      * @ORM\Column(type="boolean", options={"default": 0})
  232.      */
  233.     private bool $privacyChecked = false;
  235.     public function __construct()
  236.     {
  237.         $this->blogPostLikes = new ArrayCollection();
  238.         $this->createdAt = new \DateTime();
  239.         $this->blogPostCategories = new ArrayCollection();
  240.         $this->userNotificationEntries = new ArrayCollection();
  241.         $this->preference = new ArrayCollection();
  242.         $this->contributors = new ArrayCollection();
  243.         $this->oAuth2UserConsents = new ArrayCollection();
  244.         $this->blogPosts = new ArrayCollection();
  245.         $this->criteria1Items = new ArrayCollection();
  246.         $this->criteria2Items = new ArrayCollection();
  247.         $this->criteria3Items = new ArrayCollection();
  248.         $this->criteria4Items = new ArrayCollection();
  249.         $this->criteria5Items = new ArrayCollection();
  250.         $this->scorings = new ArrayCollection();
  251.         $this->instances = new ArrayCollection();
  252.     }
  254.     /**
  255.      * @return int|null
  256.      */
  257.     public function getId(): ?int
  258.     {
  259.         return $this->id;
  260.     }
  262.     /**
  263.      * @return string|null
  264.      */
  265.     public function getEmail(): ?string
  266.     {
  267.         return $this->email;
  268.     }
  270.     /**
  271.      * @param string $email
  272.      * @return $this
  273.      */
  274.     public function setEmail(string $email): self
  275.     {
  276.         $this->email = $email;
  278.         return $this;
  279.     }
  281.     public function getCreatedAt(): ?\DateTimeInterface
  282.     {
  283.         return $this->createdAt;
  284.     }
  286.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  287.     {
  288.         $this->createdAt = $createdAt;
  290.         return $this;
  291.     }
  293.     /**
  294.      * A visual identifier that represents this user.
  295.      *
  296.      * @see UserInterface
  297.      */
  298.     public function getUserIdentifier(): string
  299.     {
  300.         return (string) $this->email;
  301.     }
  303.     /**
  304.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  305.      */
  306.     public function getUsername(): string
  307.     {
  308.         return (string) $this->email;
  309.     }
  311.     public function __toString(): string
  312.     {
  313.         return (string) $this->email;
  314.     }
  316.     /**
  317.      * @see UserInterface
  318.      */
  319.     public function getRoles(): array
  320.     {
  321.         $roles = $this->roles;
  322.         // guarantee every user at least has ROLE_USER
  323.         $roles[] = User::ROLE_USER;
  325.         return array_unique($roles);
  326.     }
  328.     public function getRolesList(): string
  329.     {
  330.         return implode(", ", $this->roles);
  331.     }
  333.     public function getRolesString(): string
  334.     {
  335.         $roleString = "[";
  337.         foreach ($this->roles as $key => $role) {
  338.             $roleString .= '"' . $role . '"';
  339.             if ($key < count($this->roles) - 1)
  340.                 $roleString .= ',';
  341.         }
  343.         $roleString .= "]";
  345.         return $roleString;
  346.     }
  348.     public function hasRole(string $role): bool
  349.     {
  350.         return in_array($role, $this->getRoles());
  351.     }
  353.     /**
  354.      * @param array $roles
  355.      * @return $this
  356.      */
  357.     public function setRoles(array $roles): self
  358.     {
  359.         $this->roles = $roles;
  361.         return $this;
  362.     }
  364.     public function getPasswordConfirm(): ?string
  365.     {
  366.         return $this->passwordConfirm;
  367.     }
  369.     public function setPasswordConfirm(string $passwordConfirm): self
  370.     {
  371.         $this->passwordConfirm = $passwordConfirm;
  373.         return $this;
  374.     }
  376.     /**
  377.      * @see PasswordAuthenticatedUserInterface
  378.      */
  379.     public function getPassword(): ?string
  380.     {
  381.         return $this->password;
  382.     }
  384.     public function setPassword(string $password): self
  385.     {
  386.         $this->password = $password;
  388.         return $this;
  389.     }
  391.     /**
  392.      * Returning a salt is only needed, if you are not using a modern
  393.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  394.      *
  395.      * @see UserInterface
  396.      */
  397.     public function getSalt(): ?string
  398.     {
  399.         return null;
  400.     }
  402.     /**
  403.      * @see UserInterface
  404.      */
  405.     public function eraseCredentials()
  406.     {
  407.         // If you store any temporary, sensitive data on the user, clear it here
  408.         // $this->plainPassword = null;
  409.     }
  411.     /**
  412.      * @return Collection|BlogPostLike[]
  413.      */
  414.     public function getBlogPostLikes(): Collection
  415.     {
  416.         return $this->blogPostLikes;
  417.     }
  419.     public function addBlogPostLike(BlogPostLike $blogPostLike): self
  420.     {
  421.         if (!$this->blogPostLikes->contains($blogPostLike)) {
  422.             $this->blogPostLikes[] = $blogPostLike;
  423.             $blogPostLike->setUser($this);
  424.         }
  426.         return $this;
  427.     }
  429.     public function removeBlogPostLike(BlogPostLike $blogPostLike): self
  430.     {
  431.         if ($this->blogPostLikes->removeElement($blogPostLike)) {
  432.             // set the owning side to null (unless already changed)
  433.             if ($blogPostLike->getUser() === $this) {
  434.                 $blogPostLike->setUser(null);
  435.             }
  436.         }
  438.         return $this;
  439.     }
  441.     /**
  442.      * @return Collection|BlogPostCategory[]
  443.      */
  444.     public function getBlogPostCategories(): Collection
  445.     {
  446.         return $this->blogPostCategories;
  447.     }
  449.     public function addBlogPostCategory(BlogPostCategory $blogPostCategory): self
  450.     {
  451.         if (!$this->blogPostCategories->contains($blogPostCategory)) {
  452.             $this->blogPostCategories[] = $blogPostCategory;
  453.             $blogPostCategory->addUser($this);
  454.         }
  456.         return $this;
  457.     }
  459.     public function removeBlogPostCategory(BlogPostCategory $rubrique): self
  460.     {
  461.         $this->blogPostCategories->removeElement($rubrique);
  463.         return $this;
  464.     }
  466.     /**
  467.      * @return Collection<int, UserNotificationEntry>
  468.      */
  469.     public function getUserNotificationEntries(): Collection
  470.     {
  471.         return $this->userNotificationEntries;
  472.     }
  474.     public function addUserNotificationEntry(UserNotificationEntry $userNotificationEntry): self
  475.     {
  476.         if (!$this->userNotificationEntries->contains($userNotificationEntry)) {
  477.             $this->userNotificationEntries[] = $userNotificationEntry;
  478.             $userNotificationEntry->setUser($this);
  479.         }
  481.         return $this;
  482.     }
  484.     public function removeUserNotificationEntry(UserNotificationEntry $userNotificationEntry): self
  485.     {
  486.         if ($this->userNotificationEntries->removeElement($userNotificationEntry)) {
  487.             // set the owning side to null (unless already changed)
  488.             if ($userNotificationEntry->getUser() === $this) {
  489.                 $userNotificationEntry->setUser(null);
  490.             }
  491.         }
  493.         return $this;
  494.     }
  496.     public function isItmConnect(): ?bool
  497.     {
  498.         return $this->isItmConnect;
  499.     }
  501.     public function getIsItmConnect(): bool
  502.     {
  503.         return $this->isItmConnect;
  504.     }
  506.     public function setIsItmConnect(bool $ItmConnect): self
  507.     {
  508.         $this->isItmConnect = $ItmConnect;
  510.         return $this;
  511.     }
  513.     /**
  514.      * @return Collection<int, Preference>
  515.      */
  516.     public function getPreference(): Collection
  517.     {
  518.         return $this->preference;
  519.     }
  521.     public function getPreferenceString(): string
  522.     {
  523.         $preferences = $this->preference;
  524.         $preferenceString = "";
  525.         if (count($preferences) > 0) {
  526.             for ($i = 0; $i < count($preferences); $i++) {
  527.                 if ($i == count($preferences) - 1) {
  528.                     $preferenceString = $preferenceString . "" . $preferences[$i]->getId();
  529.                 } else {
  530.                     $preferenceString = $preferenceString . "" . $preferences[$i]->getId() . ",";
  531.                 }
  532.             }
  533.         }
  534.         return $preferenceString;
  535.     }
  537.     public function addPreference(Preference $preference): self
  538.     {
  539.         if (!$this->preference->contains($preference)) {
  540.             $this->preference[] = $preference;
  541.         }
  543.         return $this;
  544.     }
  546.     public function removePreference(Preference $preference): self
  547.     {
  548.         $this->preference->removeElement($preference);
  550.         return $this;
  551.     }
  553.     public function getRefreshToken(): ?string
  554.     {
  555.         return $this->refreshToken;
  556.     }
  558.     public function setRefreshToken(string $refreshToken): self
  559.     {
  560.         $this->refreshToken = $refreshToken;
  562.         return $this;
  563.     }
  565.     /**
  566.      * @return Collection<int, Contributor>
  567.      */
  568.     public function getContributors(): Collection
  569.     {
  570.         return $this->contributors;
  571.     }
  573.     public function addContributor(Contributor $contributor): self
  574.     {
  575.         if (!$this->contributors->contains($contributor)) {
  576.             $this->contributors[] = $contributor;
  577.             $contributor->setUser($this);
  578.         }
  580.         return $this;
  581.     }
  583.     public function removeContributor(Contributor $contributor): self
  584.     {
  585.         if ($this->contributors->removeElement($contributor)) {
  586.             // set the owning side to null (unless already changed)
  587.             if ($contributor->getUser() === $this) {
  588.                 $contributor->setUser(null);
  589.             }
  590.         }
  592.         return $this;
  593.     }
  595.     public function getTokenFirebase(): ?string
  596.     {
  597.         return $this->tokenFirebase;
  598.     }
  600.     public function setTokenFirebase(?string $tokenFirebase): self
  601.     {
  602.         $this->tokenFirebase = $tokenFirebase;
  604.         return $this;
  605.     }
  607.     public function isAcceptCgu(): ?bool
  608.     {
  609.         return $this->acceptCgu;
  610.     }
  612.     public function setAcceptCgu(?bool $acceptCgu): self
  613.     {
  614.         $this->acceptCgu = $acceptCgu;
  616.         return $this;
  617.     }
  619.     public function getUuid(): ?Uuid
  620.     {
  621.         return $this->uuid;
  622.     }
  624.     public function setUuid(Uuid $uuid): self
  625.     {
  626.         $this->uuid = $uuid;
  628.         return $this;
  629.     }
  631.     /**
  632.      * @return Collection<int, OAuth2UserConsent>
  633.      */
  634.     public function getOAuth2UserConsents(): Collection
  635.     {
  636.         return $this->oAuth2UserConsents;
  637.     }
  639.     public function addOAuth2UserConsent(OAuth2UserConsent $oAuth2UserConsent): self
  640.     {
  641.         if (!$this->oAuth2UserConsents->contains($oAuth2UserConsent)) {
  642.             $this->oAuth2UserConsents->add($oAuth2UserConsent);
  643.             $oAuth2UserConsent->setUser($this);
  644.         }
  646.         return $this;
  647.     }
  649.     public function removeOAuth2UserConsent(OAuth2UserConsent $oAuth2UserConsent): self
  650.     {
  651.         if ($this->oAuth2UserConsents->removeElement($oAuth2UserConsent)) {
  652.             // set the owning side to null (unless already changed)
  653.             if ($oAuth2UserConsent->getUser() === $this) {
  654.                 $oAuth2UserConsent->setUser(null);
  655.             }
  656.         }
  658.         return $this;
  659.     }
  661.     public function canAccessBO(): bool
  662.     {
  663.         return
  664.             $this->hasRole(User::ROLE_SUPER_ADMIN) ||
  665.             $this->hasRole(User::ROLE_ADMIN) ||
  666.             $this->hasRole(User::ROLE_DIRECTEUR) ||
  667.             $this->hasRole(User::ROLE_CHEF_REDACTEUR) ||
  668.             $this->hasRole(User::ROLE_ADJOINT_REDACTEUR) ||
  669.             $this->hasRole(User::ROLE_CHEF_RUBRIQUE) ||
  670.             $this->hasRole(User::ROLE_REDACTEUR);
  671.     }
  673.     /**
  674.      * @return Collection<int, BlogPost>
  675.      */
  676.     public function getBlogPosts(): Collection
  677.     {
  678.         return $this->blogPosts;
  679.     }
  681.     public function addBlogPost(BlogPost $blogPost): self
  682.     {
  683.         if (!$this->blogPosts->contains($blogPost)) {
  684.             $this->blogPosts[] = $blogPost;
  685.             $blogPost->setAuthor($this);
  686.         }
  688.         return $this;
  689.     }
  691.     public function removeBlogPost(BlogPost $blogPost): self
  692.     {
  693.         if ($this->blogPosts->removeElement($blogPost)) {
  694.             // set the owning side to null (unless already changed)
  695.             if ($blogPost->getAuthor() === $this) {
  696.                 $blogPost->setAuthor(null);
  697.             }
  698.         }
  700.         return $this;
  701.     }
  703.     /**
  704.      * @return Collection<int, Criteria1Item>
  705.      */
  706.     public function getCriteria1Items(): Collection
  707.     {
  708.         return $this->criteria1Items;
  709.     }
  711.     public function getCriteria1ItemsList(): string
  712.     {
  713.         return implode(", ", $this->criteria1Items->toArray());
  714.     }
  716.     public function getCriteria1ItemsString(): string
  717.     {
  718.         $string = "[";
  720.         foreach ($this->criteria1Items as $key => $criteria) {
  721.             $string .= '"' . $criteria . '"';
  722.             if ($key < count($this->criteria1Items) - 1)
  723.                 $string .= ',';
  724.         }
  726.         $string .= "]";
  728.         return $string;
  729.     }
  731.     public function addCriteria1Item(Criteria1Item $criteria1Item): self
  732.     {
  733.         if (!$this->criteria1Items->contains($criteria1Item)) {
  734.             $this->criteria1Items[] = $criteria1Item;
  735.         }
  737.         return $this;
  738.     }
  740.     /**
  741.      * @return Collection<int, Criteria2Item>
  742.      */
  743.     public function getCriteria2Items(): Collection
  744.     {
  745.         return $this->criteria2Items;
  746.     }
  748.     public function getCriteria2ItemsList(): string
  749.     {
  750.         return implode(", ", $this->criteria2Items->toArray());
  751.     }
  753.     public function getCriteria2ItemsString(): string
  754.     {
  755.         $string = "[";
  757.         foreach ($this->criteria2Items as $key => $criteria) {
  758.             $string .= '"' . $criteria . '"';
  759.             if ($key < count($this->criteria2Items) - 1)
  760.                 $string .= ',';
  761.         }
  763.         $string .= "]";
  765.         return $string;
  766.     }
  768.     public function addCriteria2Item(Criteria2Item $criteria2Item): self
  769.     {
  770.         if (!$this->criteria2Items->contains($criteria2Item)) {
  771.             $this->criteria2Items[] = $criteria2Item;
  772.         }
  774.         return $this;
  775.     }
  777.     /**
  778.      * @return Collection<int, Criteria3Item>
  779.      */
  780.     public function getCriteria3Items(): Collection
  781.     {
  782.         return $this->criteria3Items;
  783.     }
  785.     public function getCriteria3ItemsList(): string
  786.     {
  787.         return implode(", ", $this->criteria3Items->toArray());
  788.     }
  790.     public function getCriteria3ItemsString(): string
  791.     {
  792.         $string = "[";
  794.         foreach ($this->criteria3Items as $key => $criteria) {
  795.             $string .= '"' . $criteria . '"';
  796.             if ($key < count($this->criteria3Items) - 1)
  797.                 $string .= ',';
  798.         }
  800.         $string .= "]";
  802.         return $string;
  803.     }
  805.     public function addCriteria3Item(Criteria3Item $criteria3Item): self
  806.     {
  807.         if (!$this->criteria3Items->contains($criteria3Item)) {
  808.             $this->criteria3Items[] = $criteria3Item;
  809.         }
  811.         return $this;
  812.     }
  813.     /**
  814.      * @return Collection<int, Criteria4Item>
  815.      */
  816.     public function getCriteria4Items(): Collection
  817.     {
  818.         return $this->criteria4Items;
  819.     }
  821.     public function getCriteria4ItemsList(): string
  822.     {
  823.         return implode(", ", $this->criteria4Items->toArray());
  824.     }
  826.     public function getCriteria4ItemsString(): string
  827.     {
  828.         $string = "[";
  830.         foreach ($this->criteria4Items as $key => $criteria) {
  831.             $string .= '"' . $criteria . '"';
  832.             if ($key < count($this->criteria4Items) - 1)
  833.                 $string .= ',';
  834.         }
  836.         $string .= "]";
  838.         return $string;
  839.     }
  841.     public function addCriteria4Item(Criteria4Item $criteria4Item): self
  842.     {
  843.         if (!$this->criteria4Items->contains($criteria4Item)) {
  844.             $this->criteria4Items[] = $criteria4Item;
  845.         }
  847.         return $this;
  848.     }
  849.     /**
  850.      * @return Collection<int, Criteria5Item>
  851.      */
  852.     public function getCriteria5Items(): Collection
  853.     {
  854.         return $this->criteria5Items;
  855.     }
  857.     public function getCriteria5ItemsList(): string
  858.     {
  859.         return implode(", ", $this->criteria5Items->toArray());
  860.     }
  862.     public function getCriteria5ItemsString(): string
  863.     {
  864.         $string = "[";
  866.         foreach ($this->criteria5Items as $key => $criteria) {
  867.             $string .= '"' . $criteria . '"';
  868.             if ($key < count($this->criteria5Items) - 1)
  869.                 $string .= ',';
  870.         }
  872.         $string .= "]";
  874.         return $string;
  875.     }
  877.     // AVANT (bug) : public function addCriteria5Item(Criteria4Item $criteria5Item): self
  878.     public function addCriteria5Item(Criteria5Item $criteria5Item): self
  879.     {
  880.         if (!$this->criteria5Items->contains($criteria5Item)) {
  881.             $this->criteria5Items[] = $criteria5Item;
  882.         }
  883.         return $this;
  884.     }
  886.     public function getTokenFirebaseGeneratedAt(): ?\DateTimeInterface
  887.     {
  888.         return $this->firebaseTokenGeneratedAt;
  889.     }
  891.     public function setTokenFirebaseGeneratedAt(?\DateTimeInterface $firebaseTokenGeneratedAt): self
  892.     {
  893.         $this->firebaseTokenGeneratedAt = $firebaseTokenGeneratedAt;
  895.         return $this;
  896.     }
  898.     /**
  899.      * @return Collection<int, Scoring>
  900.      */
  901.     public function getScorings(): Collection
  902.     {
  903.         return $this->scorings;
  904.     }
  906.     public function addScoring(Scoring $scoring): self
  907.     {
  908.         if (!$this->scorings->contains($scoring)) {
  909.             $this->scorings[] = $scoring;
  910.             $scoring->setUser($this);
  911.         }
  913.         return $this;
  914.     }
  916.     public function removeScoring(Scoring $scoring): self
  917.     {
  918.         if ($this->scorings->removeElement($scoring)) {
  919.             if ($scoring->getUser() === $this) {
  920.                 $scoring->setUser(null);
  921.             }
  922.         }
  924.         return $this;
  925.     }
  926.     /**
  927.      * @return Collection<int, Instance>
  928.      */
  929.     public function getInstances(): Collection
  930.     {
  931.         return $this->instances;
  932.     }
  934.     public function getInstancesList(): string
  935.     {
  936.         return implode(", ", $this->instances->toArray());
  937.     }
  939.     public function getInstancesString(): string
  940.     {
  941.         $string = "[";
  942.         foreach ($this->instances as $key => $instance) {
  943.             $string .= '"' . $instance->getName() . '"';
  944.             if ($key < count($this->instances) - 1) {
  945.                 $string .= ',';
  946.             }
  947.         }
  948.         $string .= "]";
  949.         return $string;
  950.     }
  952.     public function addInstance(Instance $instance): self
  953.     {
  954.         if (!$this->instances->contains($instance)) {
  955.             $this->instances[] = $instance;
  956.         }
  957.         return $this;
  958.     }
  960.     public function removeInstance(Instance $instance): self
  961.     {
  962.         $this->instances->removeElement($instance);
  963.         return $this;
  964.     }
  966.     public function hasInstance(Instance $instance): bool
  967.     {
  968.         return $this->instances->contains($instance);
  969.     }
  971.     /**
  972.      * @return bool
  973.      */
  974.     public function isAllowSelfEdit(): bool
  975.     {
  976.         return (bool) $this->allowSelfEdit;
  977.     }
  979.     /**
  980.      * @param bool $allowSelfEdit 
  981.      * @return self
  982.      */
  983.     public function setAllowSelfEdit(bool $allowSelfEdit): self
  984.     {
  985.         $this->allowSelfEdit = $allowSelfEdit;
  986.         return $this;
  987.     }
  989.     /**
  990.      * @return bool
  991.      */
  992.     public function isAnonymizationEnabled(): bool
  993.     {
  994.         return $this->anonymizationEnabled;
  995.     }
  997.     /**
  998.      * @param bool $anonymizationEnabled 
  999.      * @return self
  1000.      */
  1001.     public function setAnonymizationEnabled(bool $anonymizationEnabled): self
  1002.     {
  1003.         $this->anonymizationEnabled = $anonymizationEnabled;
  1004.         return $this;
  1005.     }
  1007.     /**
  1008.      * @return 
  1009.      */
  1010.     public function getFirstName(): ?string
  1011.     {
  1012.         return $this->firstName;
  1013.     }
  1015.     /**
  1016.      * @param  $firstName 
  1017.      * @return self
  1018.      */
  1019.     public function setFirstName(?string $firstName): self
  1020.     {
  1021.         $this->firstName = $firstName;
  1022.         return $this;
  1023.     }
  1025.     /**
  1026.      * @return 
  1027.      */
  1028.     public function getLastName(): ?string
  1029.     {
  1030.         return $this->lastName;
  1031.     }
  1033.     /**
  1034.      * @param  $lastName 
  1035.      * @return self
  1036.      */
  1037.     public function setLastName(?string $lastName): self
  1038.     {
  1039.         $this->lastName = $lastName;
  1040.         return $this;
  1041.     }
  1043.     /**
  1044.      * @return 
  1045.      */
  1046.     public function getEntityCode(): ?string
  1047.     {
  1048.         return $this->entityCode;
  1049.     }
  1051.     /**
  1052.      * @param  $entityCode 
  1053.      * @return self
  1054.      */
  1055.     public function setEntityCode(?string $entityCode): self
  1056.     {
  1057.         $this->entityCode = $entityCode;
  1058.         return $this;
  1059.     }
  1061.     /**
  1062.      * @return 
  1063.      */
  1064.     public function getPhotoPath(): ?string
  1065.     {
  1066.         return $this->photoPath;
  1067.     }
  1069.     /**
  1070.      * @param  $photoPath 
  1071.      * @return self
  1072.      */
  1073.     public function setPhotoPath(?string $photoPath): self
  1074.     {
  1075.         $this->photoPath = $photoPath;
  1076.         return $this;
  1077.     }
  1079.     /**
  1080.      * @return 
  1081.      */
  1082.     public function getProEmail(): ?string
  1083.     {
  1084.         return $this->proEmail;
  1085.     }
  1087.     /**
  1088.      * @param  $proEmail 
  1089.      * @return self
  1090.      */
  1091.     public function setProEmail(?string $proEmail): self
  1092.     {
  1093.         $this->proEmail = $proEmail;
  1094.         return $this;
  1095.     }
  1097.     /**
  1098.      * @return 
  1099.      */
  1100.     public function getProPhone(): ?string
  1101.     {
  1102.         return $this->proPhone;
  1103.     }
  1105.     /**
  1106.      * @param  $proPhone 
  1107.      * @return self
  1108.      */
  1109.     public function setProPhone(?string $proPhone): self
  1110.     {
  1111.         $this->proPhone = $proPhone;
  1112.         return $this;
  1113.     }
  1115.     public function isAcceptPrivacy(): bool
  1116.     {
  1117.         return $this->acceptPrivacy;
  1118.     }
  1120.     public function setAcceptPrivacy(bool $acceptPrivacy): self
  1121.     {
  1122.         $this->acceptPrivacy = $acceptPrivacy;
  1123.         return $this;
  1124.     }
  1126.     public function getAcceptPrivacyAt(): ?DateTimeImmutable
  1127.     {
  1128.         return $this->acceptPrivacyAt;
  1129.     }
  1131.     public function setAcceptPrivacyAt(?DateTimeImmutable $acceptPrivacyAt): self
  1132.     {
  1133.         $this->acceptPrivacyAt = $acceptPrivacyAt;
  1134.         return $this;
  1135.     }
  1137.     public function getAcceptPrivacyVersion(): ?string
  1138.     {
  1139.         return $this->acceptPrivacyVersion;
  1140.     }
  1142.     public function setAcceptPrivacyVersion(?string $acceptPrivacyVersion): self
  1143.     {
  1144.         $this->acceptPrivacyVersion = $acceptPrivacyVersion;
  1145.         return $this;
  1146.     }
  1148.     public function isPrivacyChecked(): bool
  1149.     {
  1150.         return $this->privacyChecked;
  1151.     }
  1153.     public function setPrivacyChecked(bool $value): self
  1154.     {
  1155.         $this->privacyChecked = $value;
  1156.         return $this;
  1157.     }
  1159.     #[Assert\Callback(groups: ['identity'])]
  1160.     public function validateIdentity(ExecutionContextInterface $context): void
  1161.     {
  1162.         // Si l’admin coche "Autoriser l’utilisateur à compléter/modifier ses infos"
  1163.         // => on n'impose pas les champs d’identité côté back-office.
  1164.         if ($this->isAllowSelfEdit() || $this->isAnonymizationEnabled()) {
  1165.             return;
  1166.         }
  1168.         // Sinon : ces champs deviennent obligatoires côté admin
  1169.         $lastName = trim((string) $this->getLastName());
  1170.         $firstName = trim((string) $this->getFirstName());
  1171.         $entity = trim((string) $this->getEntityCode());
  1173.         if ($lastName === '') {
  1174.             $context->buildViolation('Le nom est obligatoire.')
  1175.                 ->atPath('lastName')
  1176.                 ->addViolation();
  1177.         }
  1178.         if ($firstName === '') {
  1179.             $context->buildViolation('Le prénom est obligatoire.')
  1180.                 ->atPath('firstName')
  1181.                 ->addViolation();
  1182.         }
  1183.         if ($entity === '') {
  1184.             $context->buildViolation('L’entité / code entité est obligatoire.')
  1185.                 ->atPath('entityCode')
  1186.                 ->addViolation();
  1187.         }
  1188.     }
  1190.     // Criteria 1
  1191.     public function removeCriteria1Item(Criteria1Item $criteria1Item): self
  1192.     {
  1193.         $this->criteria1Items->removeElement($criteria1Item);
  1194.         return $this;
  1195.     }
  1197.     // Criteria 2
  1198.     public function removeCriteria2Item(Criteria2Item $criteria2Item): self
  1199.     {
  1200.         $this->criteria2Items->removeElement($criteria2Item);
  1201.         return $this;
  1202.     }
  1204.     // Criteria 3
  1205.     public function removeCriteria3Item(Criteria3Item $criteria3Item): self
  1206.     {
  1207.         $this->criteria3Items->removeElement($criteria3Item);
  1208.         return $this;
  1209.     }
  1211.     // Criteria 4
  1212.     public function removeCriteria4Item(Criteria4Item $criteria4Item): self
  1213.     {
  1214.         $this->criteria4Items->removeElement($criteria4Item);
  1215.         return $this;
  1216.     }
  1218.     // Criteria 5
  1219.     public function removeCriteria5Item(Criteria5Item $criteria5Item): self
  1220.     {
  1221.         $this->criteria5Items->removeElement($criteria5Item);
  1222.         return $this;
  1223.     }
  1226. }