src/Entity/User.php line 23

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. /**
  19.  * @ORM\Entity(repositoryClass=UserRepository::class)
  20.  * @UniqueEntity(fields={"email"}, message="Cette adresse email est déjà utilisé")
  21.  * @ORM\HasLifecycleCallbacks
  22.  */
  23. class User implements UserInterface, PasswordAuthenticatedUserInterface, UserEntityInterface
  24. {
  25.     public const ROLE_SUPER_ADMIN = 'ROLE_SUPER_ADMIN';
  26.     public const ROLE_ADMIN = 'ROLE_ADMIN';
  27.     public const ROLE_DIRECTEUR = 'ROLE_DIRECTEUR';
  28.     public const ROLE_CHEF_REDACTEUR = 'ROLE_CHEF_REDACTEUR';
  29.     public const ROLE_ADJOINT_REDACTEUR = 'ROLE_ADJOINT_REDACTEUR';
  30.     public const ROLE_CHEF_RUBRIQUE = 'ROLE_CHEF_RUBRIQUE';
  31.     public const ROLE_REDACTEUR = 'ROLE_REDACTEUR';
  32.     public const ROLE_USER = 'ROLE_USER';
  34.     /**
  35.      * @ORM\Id
  36.      * @ORM\GeneratedValue
  37.      * @ORM\Column(type="integer")
  38.      */
  39.     private $id;
  41.     /**
  42.      * @ORM\Column(type="string", length=180, unique=true)
  43.      * @Assert\NotBlank()
  44.      * @Assert\Email()
  45.      */
  46.     private $email;
  48.     /**
  49.      * @ORM\Column(type="json")
  50.      */
  51.     private $roles = [];
  53.     /**
  54.      * @var string The hashed password
  55.      * @ORM\Column(type="string")
  56.      * @Assert\NotBlank(message="Veuillez entrer un mot de passe")
  57.      * @Assert\Length(min="8", minMessage="Le mot de passe doit faire au moins 8 caratères")
  58.      */
  59.     private $password;
  61.     /**
  62.      * @Assert\EqualTo(propertyPath="password", message="Les mots de passes ne correspondent pas")
  63.      */
  64.     private $passwordConfirm;
  66.     /**
  67.      * @ORM\OneToMany(targetEntity=BlogPostLike::class, mappedBy="user")
  68.      */
  69.     private $blogPostLikes;
  71.     /**
  72.      * @ORM\Column(type="datetime", nullable=true)
  73.      */
  74.     private $createdAt;
  76.     /**
  77.      * @ORM\Column(type="datetime", nullable=true)
  78.      */
  79.     private ?\DateTimeInterface $updatedAt = null;
  81.     /**
  82.      * @ORM\Column(type="boolean", options={"default": false}, nullable=true)
  83.      */
  84.     private $isItmConnect;
  86.     /**
  87.      * @ORM\Column(type="text", nullable=true)
  88.      */
  89.     private $refreshToken;
  91.     /**
  92.      * @ORM\ManyToMany(targetEntity="BlogPostCategory", inversedBy="users")
  93.      * @ORM\JoinColumn(nullable=true,onDelete="SET NULL")
  94.      * )
  95.      */
  96.     private $blogPostCategories;
  98.     /**
  99.      * @ORM\OneToMany(targetEntity=UserNotificationEntry::class, mappedBy="user", orphanRemoval=true)
  100.      */
  101.     private $userNotificationEntries;
  103.     /**
  104.      * @ORM\ManyToMany(targetEntity=Preference::class)
  105.      */
  106.     private $preference;
  108.     /**
  109.      * @ORM\OneToMany(targetEntity=Contributor::class, mappedBy="user")
  110.      */
  111.     private $contributors;
  113.     /**
  114.      * @ORM\Column(type="string", length=255, nullable=true)
  115.      */
  116.     private $tokenFirebase;
  118.     /**
  119.      * @ORM\Column(type="boolean", nullable=true)
  120.      */
  121.     private $acceptCgu;
  123.     /**
  124.      * @ORM\Column(type="uuid", unique=true, nullable=true)
  125.      */
  126.     private ?Uuid $uuid = null;
  128.     /**
  129.      * @ORM\OneToMany(mappedBy="user", targetEntity=OAuth2UserConsent::class, orphanRemoval=true)
  130.      */
  131.     private Collection $oAuth2UserConsents;
  133.     /**
  134.      * @ORM\OneToMany(targetEntity=BlogPost::class, mappedBy="author")
  135.      */
  136.     private $blogPosts;
  138.     /**
  139.      * @ORM\ManyToMany(targetEntity=Criteria1Item::class)
  140.      */
  141.     private $criteria1Items;
  143.     /**
  144.      * @ORM\ManyToMany(targetEntity=Criteria2Item::class)
  145.      */
  146.     private $criteria2Items;
  148.     /**
  149.      * @ORM\ManyToMany(targetEntity=Criteria3Item::class)
  150.      */
  151.     private $criteria3Items;
  153.     /**
  154.      * @ORM\ManyToMany(targetEntity=Criteria4Item::class)
  155.      */
  156.     private $criteria4Items;
  158.     /**
  159.      * @ORM\ManyToMany(targetEntity=Criteria5Item::class)
  160.      */
  161.     private $criteria5Items;
  163.     /**
  164.      * @ORM\Column(type="datetime", nullable=true)
  165.      */
  166.     private $firebaseTokenGeneratedAt;
  168.     /**
  169.      * @ORM\OneToMany(targetEntity=Scoring::class, mappedBy="user", orphanRemoval=true)
  170.      */
  171.     private $scorings;
  172.     /**
  173.      * @ORM\ManyToMany(targetEntity=Instance::class, inversedBy="users")
  174.      */
  175.     private Collection $instances;
  177.     /**
  178.      * @ORM\Column(type="boolean", options={"default": false})
  179.      */
  180.     private bool $allowSelfEdit = false;
  182.     /**
  183.      * @ORM\Column(type="boolean", options={"default": false})
  184.      */
  185.     private bool $anonymizationEnabled = false;
  187.     /**
  188.      * Indique si l'utilisateur a confirmé la popup d'anonymisation
  189.      * @ORM\Column(type="boolean", options={"default": false})
  190.      */
  191.     private bool $isAnonymisationConfirmed = false;
  192.     /**
  193.      * Retourne vrai si l'utilisateur a confirmé la popup d'anonymisation
  194.      */
  195.     public function isAnonymisationConfirmed(): bool
  196.     {
  197.         return $this->isAnonymisationConfirmed;
  198.     }
  200.     /**
  201.      * Définit la confirmation d'anonymisation
  202.      */
  203.     public function setAnonymisationConfirmed(bool $confirmed): self
  204.     {
  205.         $this->isAnonymisationConfirmed = $confirmed;
  206.         return $this;
  207.     }
  209.     /**
  210.      * @ORM\Column(type="string", length=512, nullable=true)
  211.      */
  212.     private ?string $firstName = null;
  214.     /**
  215.      * @ORM\Column(type="string", length=512, nullable=true)
  216.      */
  217.     private ?string $lastName = null;
  219.     /**
  220.      * @ORM\Column(type="string", length=512, nullable=true)
  221.      */
  222.     private ?string $entityCode = null;
  224.     /**
  225.      * @ORM\Column(type="string", length=512, nullable=true)
  226.      * @Assert\Email(message="Veuillez saisir un email professionnel valide")
  227.      */
  228.     private ?string $proEmail = null;
  230.     /**
  231.      * @ORM\Column(type="string", length=512, nullable=true)
  232.      * @Assert\Regex(
  233.      *     pattern="/^\d*$/",
  234.      *     message="Le téléphone professionnel doit contenir uniquement des chiffres."
  235.      * )
  236.      */
  237.     private ?string $proPhone = null;
  239.     /**
  240.      * @ORM\Column(type="string", length=255, nullable=true)
  241.      */
  242.     private ?string $photoPath = null;
  244.     /**
  245.      * @ORM\Column(type="boolean", options={"default": 0})
  246.      */
  247.     private bool $acceptPrivacy = false;
  249.     /**
  250.      * @ORM\Column(type="datetime_immutable", nullable=true)
  251.      */
  252.     private ?DateTimeImmutable $acceptPrivacyAt = null;
  254.     /**
  255.      * @ORM\Column(type="string", length=32, nullable=true)
  256.      */
  257.     private ?string $acceptPrivacyVersion = null;
  259.     /**
  260.      * @ORM\Column(type="boolean", options={"default": 0})
  261.      */
  262.     private bool $privacyChecked = false;
  264.     public function __construct()
  265.     {
  266.         $this->blogPostLikes = new ArrayCollection();
  267.         $this->createdAt = new \DateTime();
  268.         $this->blogPostCategories = new ArrayCollection();
  269.         $this->userNotificationEntries = new ArrayCollection();
  270.         $this->preference = new ArrayCollection();
  271.         $this->contributors = new ArrayCollection();
  272.         $this->oAuth2UserConsents = new ArrayCollection();
  273.         $this->blogPosts = new ArrayCollection();
  274.         $this->criteria1Items = new ArrayCollection();
  275.         $this->criteria2Items = new ArrayCollection();
  276.         $this->criteria3Items = new ArrayCollection();
  277.         $this->criteria4Items = new ArrayCollection();
  278.         $this->criteria5Items = new ArrayCollection();
  279.         $this->scorings = new ArrayCollection();
  280.         $this->instances = new ArrayCollection();
  281.         // Init updatedAt with the same value as createdAt at creation time
  282.         $this->updatedAt = $this->createdAt;
  283.     }
  285.     /**
  286.      * @return int|null
  287.      */
  288.     public function getId(): ?int
  289.     {
  290.         return $this->id;
  291.     }
  293.     /**
  294.      * @return string|null
  295.      */
  296.     public function getEmail(): ?string
  297.     {
  298.         return $this->email;
  299.     }
  301.     /**
  302.      * @param string $email
  303.      * @return $this
  304.      */
  305.     public function setEmail(string $email): self
  306.     {
  307.         $this->email = $email;
  309.         return $this;
  310.     }
  312.     public function getCreatedAt(): ?\DateTimeInterface
  313.     {
  314.         return $this->createdAt;
  315.     }
  317.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  318.     {
  319.         $this->createdAt = $createdAt;
  320.         // Keep updatedAt in sync initially if it's not set yet
  321.         if ($this->updatedAt === null) {
  322.             $this->updatedAt = $createdAt;
  323.         }
  324.         return $this;
  325.     }
  327.     public function getUpdatedAt(): ?\DateTimeInterface
  328.     {
  329.         return $this->updatedAt;
  330.     }
  332.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  333.     {
  334.         $this->updatedAt = $updatedAt;
  335.         return $this;
  336.     }
  338.     /**
  339.      * Met à jour automatiquement la date de modification avant insert
  340.      * @ORM\PrePersist
  341.      */
  342.     public function onPrePersist(): void
  343.     {
  344.         $now = new \DateTime();
  345.         if ($this->createdAt === null) {
  346.             $this->createdAt = $now;
  347.         }
  348.         $this->updatedAt = $this->createdAt ?? $now;
  349.     }
  351.     /**
  352.      * Met à jour automatiquement la date de modification avant update
  353.      * @ORM\PreUpdate
  354.      */
  355.     public function onPreUpdate(): void
  356.     {
  357.         $this->updatedAt = new \DateTime();
  358.     }
  360.     /**
  361.      * A visual identifier that represents this user.
  362.      *
  363.      * @see UserInterface
  364.      */
  365.     public function getUserIdentifier(): string
  366.     {
  367.         return (string) $this->email;
  368.     }
  370.     /**
  371.      * Required by UserEntityInterface for OAuth2 server
  372.      *
  373.      * @see UserEntityInterface
  374.      */
  375.     public function getIdentifier(): ?string
  376.     {
  377.         return (string) $this->id;
  378.     }
  380.     /**
  381.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  382.      */
  383.     public function getUsername(): string
  384.     {
  385.         return (string) $this->email;
  386.     }
  388.     public function __toString(): string
  389.     {
  390.         return (string) $this->email;
  391.     }
  393.     /**
  394.      * @see UserInterface
  395.      */
  396.     public function getRoles(): array
  397.     {
  398.         $roles = $this->roles;
  399.         // guarantee every user at least has ROLE_USER
  400.         $roles[] = User::ROLE_USER;
  402.         return array_unique($roles);
  403.     }
  405.     public function getRolesList(): string
  406.     {
  407.         return implode(", ", $this->roles);
  408.     }
  410.     public function getRolesString(): string
  411.     {
  412.         $roleString = "[";
  414.         foreach ($this->roles as $key => $role) {
  415.             $roleString .= '"' . $role . '"';
  416.             if ($key < count($this->roles) - 1)
  417.                 $roleString .= ',';
  418.         }
  420.         $roleString .= "]";
  422.         return $roleString;
  423.     }
  425.     public function hasRole(string $role): bool
  426.     {
  427.         return in_array($role, $this->getRoles());
  428.     }
  430.     /**
  431.      * @param array $roles
  432.      * @return $this
  433.      */
  434.     public function setRoles(array $roles): self
  435.     {
  436.         $this->roles = $roles;
  438.         return $this;
  439.     }
  441.     public function getPasswordConfirm(): ?string
  442.     {
  443.         return $this->passwordConfirm;
  444.     }
  446.     public function setPasswordConfirm(string $passwordConfirm): self
  447.     {
  448.         $this->passwordConfirm = $passwordConfirm;
  450.         return $this;
  451.     }
  453.     /**
  454.      * @see PasswordAuthenticatedUserInterface
  455.      */
  456.     public function getPassword(): ?string
  457.     {
  458.         return $this->password;
  459.     }
  461.     public function setPassword(string $password): self
  462.     {
  463.         $this->password = $password;
  465.         return $this;
  466.     }
  468.     /**
  469.      * Returning a salt is only needed, if you are not using a modern
  470.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  471.      *
  472.      * @see UserInterface
  473.      */
  474.     public function getSalt(): ?string
  475.     {
  476.         return null;
  477.     }
  479.     /**
  480.      * @see UserInterface
  481.      */
  482.     public function eraseCredentials()
  483.     {
  484.         // If you store any temporary, sensitive data on the user, clear it here
  485.         // $this->plainPassword = null;
  486.     }
  488.     /**
  489.      * @return Collection|BlogPostLike[]
  490.      */
  491.     public function getBlogPostLikes(): Collection
  492.     {
  493.         return $this->blogPostLikes;
  494.     }
  496.     public function addBlogPostLike(BlogPostLike $blogPostLike): self
  497.     {
  498.         if (!$this->blogPostLikes->contains($blogPostLike)) {
  499.             $this->blogPostLikes[] = $blogPostLike;
  500.             $blogPostLike->setUser($this);
  501.         }
  503.         return $this;
  504.     }
  506.     public function removeBlogPostLike(BlogPostLike $blogPostLike): self
  507.     {
  508.         if ($this->blogPostLikes->removeElement($blogPostLike)) {
  509.             // set the owning side to null (unless already changed)
  510.             if ($blogPostLike->getUser() === $this) {
  511.                 $blogPostLike->setUser(null);
  512.             }
  513.         }
  515.         return $this;
  516.     }
  518.     /**
  519.      * @return Collection|BlogPostCategory[]
  520.      */
  521.     public function getBlogPostCategories(): Collection
  522.     {
  523.         return $this->blogPostCategories;
  524.     }
  526.     public function addBlogPostCategory(BlogPostCategory $blogPostCategory): self
  527.     {
  528.         if (!$this->blogPostCategories->contains($blogPostCategory)) {
  529.             $this->blogPostCategories[] = $blogPostCategory;
  530.             $blogPostCategory->addUser($this);
  531.         }
  533.         return $this;
  534.     }
  536.     public function removeBlogPostCategory(BlogPostCategory $rubrique): self
  537.     {
  538.         $this->blogPostCategories->removeElement($rubrique);
  540.         return $this;
  541.     }
  543.     /**
  544.      * @return Collection<int, UserNotificationEntry>
  545.      */
  546.     public function getUserNotificationEntries(): Collection
  547.     {
  548.         return $this->userNotificationEntries;
  549.     }
  551.     public function addUserNotificationEntry(UserNotificationEntry $userNotificationEntry): self
  552.     {
  553.         if (!$this->userNotificationEntries->contains($userNotificationEntry)) {
  554.             $this->userNotificationEntries[] = $userNotificationEntry;
  555.             $userNotificationEntry->setUser($this);
  556.         }
  558.         return $this;
  559.     }
  561.     public function removeUserNotificationEntry(UserNotificationEntry $userNotificationEntry): self
  562.     {
  563.         if ($this->userNotificationEntries->removeElement($userNotificationEntry)) {
  564.             // set the owning side to null (unless already changed)
  565.             if ($userNotificationEntry->getUser() === $this) {
  566.                 $userNotificationEntry->setUser(null);
  567.             }
  568.         }
  570.         return $this;
  571.     }
  573.     public function isItmConnect(): ?bool
  574.     {
  575.         return $this->isItmConnect;
  576.     }
  578.     public function getIsItmConnect(): bool
  579.     {
  580.         return $this->isItmConnect;
  581.     }
  583.     public function setIsItmConnect(bool $ItmConnect): self
  584.     {
  585.         $this->isItmConnect = $ItmConnect;
  587.         return $this;
  588.     }
  590.     /**
  591.      * @return Collection<int, Preference>
  592.      */
  593.     public function getPreference(): Collection
  594.     {
  595.         return $this->preference;
  596.     }
  598.     public function getPreferenceString(): string
  599.     {
  600.         $preferences = $this->preference;
  601.         $preferenceString = "";
  602.         if (count($preferences) > 0) {
  603.             for ($i = 0; $i < count($preferences); $i++) {
  604.                 if ($i == count($preferences) - 1) {
  605.                     $preferenceString = $preferenceString . "" . $preferences[$i]->getId();
  606.                 } else {
  607.                     $preferenceString = $preferenceString . "" . $preferences[$i]->getId() . ",";
  608.                 }
  609.             }
  610.         }
  611.         return $preferenceString;
  612.     }
  614.     public function addPreference(Preference $preference): self
  615.     {
  616.         if (!$this->preference->contains($preference)) {
  617.             $this->preference[] = $preference;
  618.         }
  620.         return $this;
  621.     }
  623.     public function removePreference(Preference $preference): self
  624.     {
  625.         $this->preference->removeElement($preference);
  627.         return $this;
  628.     }
  630.     public function getRefreshToken(): ?string
  631.     {
  632.         return $this->refreshToken;
  633.     }
  635.     public function setRefreshToken(string $refreshToken): self
  636.     {
  637.         $this->refreshToken = $refreshToken;
  639.         return $this;
  640.     }
  642.     /**
  643.      * @return Collection<int, Contributor>
  644.      */
  645.     public function getContributors(): Collection
  646.     {
  647.         return $this->contributors;
  648.     }
  650.     public function addContributor(Contributor $contributor): self
  651.     {
  652.         if (!$this->contributors->contains($contributor)) {
  653.             $this->contributors[] = $contributor;
  654.             $contributor->setUser($this);
  655.         }
  657.         return $this;
  658.     }
  660.     public function removeContributor(Contributor $contributor): self
  661.     {
  662.         if ($this->contributors->removeElement($contributor)) {
  663.             // set the owning side to null (unless already changed)
  664.             if ($contributor->getUser() === $this) {
  665.                 $contributor->setUser(null);
  666.             }
  667.         }
  669.         return $this;
  670.     }
  672.     public function getTokenFirebase(): ?string
  673.     {
  674.         return $this->tokenFirebase;
  675.     }
  677.     public function setTokenFirebase(?string $tokenFirebase): self
  678.     {
  679.         $this->tokenFirebase = $tokenFirebase;
  681.         return $this;
  682.     }
  684.     public function isAcceptCgu(): ?bool
  685.     {
  686.         return $this->acceptCgu;
  687.     }
  689.     public function setAcceptCgu(?bool $acceptCgu): self
  690.     {
  691.         $this->acceptCgu = $acceptCgu;
  693.         return $this;
  694.     }
  696.     public function getUuid(): ?Uuid
  697.     {
  698.         return $this->uuid;
  699.     }
  701.     public function setUuid(Uuid $uuid): self
  702.     {
  703.         $this->uuid = $uuid;
  705.         return $this;
  706.     }
  708.     /**
  709.      * @return Collection<int, OAuth2UserConsent>
  710.      */
  711.     public function getOAuth2UserConsents(): Collection
  712.     {
  713.         return $this->oAuth2UserConsents;
  714.     }
  716.     public function addOAuth2UserConsent(OAuth2UserConsent $oAuth2UserConsent): self
  717.     {
  718.         if (!$this->oAuth2UserConsents->contains($oAuth2UserConsent)) {
  719.             $this->oAuth2UserConsents->add($oAuth2UserConsent);
  720.             $oAuth2UserConsent->setUser($this);
  721.         }
  723.         return $this;
  724.     }
  726.     public function removeOAuth2UserConsent(OAuth2UserConsent $oAuth2UserConsent): self
  727.     {
  728.         if ($this->oAuth2UserConsents->removeElement($oAuth2UserConsent)) {
  729.             // set the owning side to null (unless already changed)
  730.             if ($oAuth2UserConsent->getUser() === $this) {
  731.                 $oAuth2UserConsent->setUser(null);
  732.             }
  733.         }
  735.         return $this;
  736.     }
  738.     public function canAccessBO(): bool
  739.     {
  740.         return
  741.             $this->hasRole(User::ROLE_SUPER_ADMIN) ||
  742.             $this->hasRole(User::ROLE_ADMIN) ||
  743.             $this->hasRole(User::ROLE_DIRECTEUR) ||
  744.             $this->hasRole(User::ROLE_CHEF_REDACTEUR) ||
  745.             $this->hasRole(User::ROLE_ADJOINT_REDACTEUR) ||
  746.             $this->hasRole(User::ROLE_CHEF_RUBRIQUE) ||
  747.             $this->hasRole(User::ROLE_REDACTEUR);
  748.     }
  750.     /**
  751.      * @return Collection<int, BlogPost>
  752.      */
  753.     public function getBlogPosts(): Collection
  754.     {
  755.         return $this->blogPosts;
  756.     }
  758.     public function addBlogPost(BlogPost $blogPost): self
  759.     {
  760.         if (!$this->blogPosts->contains($blogPost)) {
  761.             $this->blogPosts[] = $blogPost;
  762.             $blogPost->setAuthor($this);
  763.         }
  765.         return $this;
  766.     }
  768.     public function removeBlogPost(BlogPost $blogPost): self
  769.     {
  770.         if ($this->blogPosts->removeElement($blogPost)) {
  771.             // set the owning side to null (unless already changed)
  772.             if ($blogPost->getAuthor() === $this) {
  773.                 $blogPost->setAuthor(null);
  774.             }
  775.         }
  777.         return $this;
  778.     }
  780.     /**
  781.      * @return Collection<int, Criteria1Item>
  782.      */
  783.     public function getCriteria1Items(): Collection
  784.     {
  785.         return $this->criteria1Items;
  786.     }
  788.     public function getCriteria1ItemsList(): string
  789.     {
  790.         return implode(", ", $this->criteria1Items->toArray());
  791.     }
  793.     public function getCriteria1ItemsString(): string
  794.     {
  795.         $string = "[";
  797.         foreach ($this->criteria1Items as $key => $criteria) {
  798.             $string .= '"' . $criteria . '"';
  799.             if ($key < count($this->criteria1Items) - 1)
  800.                 $string .= ',';
  801.         }
  803.         $string .= "]";
  805.         return $string;
  806.     }
  808.     public function addCriteria1Item(Criteria1Item $criteria1Item): self
  809.     {
  810.         if (!$this->criteria1Items->contains($criteria1Item)) {
  811.             $this->criteria1Items[] = $criteria1Item;
  812.         }
  814.         return $this;
  815.     }
  817.     /**
  818.      * @return Collection<int, Criteria2Item>
  819.      */
  820.     public function getCriteria2Items(): Collection
  821.     {
  822.         return $this->criteria2Items;
  823.     }
  825.     public function getCriteria2ItemsList(): string
  826.     {
  827.         return implode(", ", $this->criteria2Items->toArray());
  828.     }
  830.     public function getCriteria2ItemsString(): string
  831.     {
  832.         $string = "[";
  834.         foreach ($this->criteria2Items as $key => $criteria) {
  835.             $string .= '"' . $criteria . '"';
  836.             if ($key < count($this->criteria2Items) - 1)
  837.                 $string .= ',';
  838.         }
  840.         $string .= "]";
  842.         return $string;
  843.     }
  845.     public function addCriteria2Item(Criteria2Item $criteria2Item): self
  846.     {
  847.         if (!$this->criteria2Items->contains($criteria2Item)) {
  848.             $this->criteria2Items[] = $criteria2Item;
  849.         }
  851.         return $this;
  852.     }
  854.     /**
  855.      * @return Collection<int, Criteria3Item>
  856.      */
  857.     public function getCriteria3Items(): Collection
  858.     {
  859.         return $this->criteria3Items;
  860.     }
  862.     public function getCriteria3ItemsList(): string
  863.     {
  864.         return implode(", ", $this->criteria3Items->toArray());
  865.     }
  867.     public function getCriteria3ItemsString(): string
  868.     {
  869.         $string = "[";
  871.         foreach ($this->criteria3Items as $key => $criteria) {
  872.             $string .= '"' . $criteria . '"';
  873.             if ($key < count($this->criteria3Items) - 1)
  874.                 $string .= ',';
  875.         }
  877.         $string .= "]";
  879.         return $string;
  880.     }
  882.     public function addCriteria3Item(Criteria3Item $criteria3Item): self
  883.     {
  884.         if (!$this->criteria3Items->contains($criteria3Item)) {
  885.             $this->criteria3Items[] = $criteria3Item;
  886.         }
  888.         return $this;
  889.     }
  890.     /**
  891.      * @return Collection<int, Criteria4Item>
  892.      */
  893.     public function getCriteria4Items(): Collection
  894.     {
  895.         return $this->criteria4Items;
  896.     }
  898.     public function getCriteria4ItemsList(): string
  899.     {
  900.         return implode(", ", $this->criteria4Items->toArray());
  901.     }
  903.     public function getCriteria4ItemsString(): string
  904.     {
  905.         $string = "[";
  907.         foreach ($this->criteria4Items as $key => $criteria) {
  908.             $string .= '"' . $criteria . '"';
  909.             if ($key < count($this->criteria4Items) - 1)
  910.                 $string .= ',';
  911.         }
  913.         $string .= "]";
  915.         return $string;
  916.     }
  918.     public function addCriteria4Item(Criteria4Item $criteria4Item): self
  919.     {
  920.         if (!$this->criteria4Items->contains($criteria4Item)) {
  921.             $this->criteria4Items[] = $criteria4Item;
  922.         }
  924.         return $this;
  925.     }
  926.     /**
  927.      * @return Collection<int, Criteria5Item>
  928.      */
  929.     public function getCriteria5Items(): Collection
  930.     {
  931.         return $this->criteria5Items;
  932.     }
  934.     public function getCriteria5ItemsList(): string
  935.     {
  936.         return implode(", ", $this->criteria5Items->toArray());
  937.     }
  939.     public function getCriteria5ItemsString(): string
  940.     {
  941.         $string = "[";
  943.         foreach ($this->criteria5Items as $key => $criteria) {
  944.             $string .= '"' . $criteria . '"';
  945.             if ($key < count($this->criteria5Items) - 1)
  946.                 $string .= ',';
  947.         }
  949.         $string .= "]";
  951.         return $string;
  952.     }
  954.     // AVANT (bug) : public function addCriteria5Item(Criteria4Item $criteria5Item): self
  955.     public function addCriteria5Item(Criteria5Item $criteria5Item): self
  956.     {
  957.         if (!$this->criteria5Items->contains($criteria5Item)) {
  958.             $this->criteria5Items[] = $criteria5Item;
  959.         }
  960.         return $this;
  961.     }
  963.     public function getTokenFirebaseGeneratedAt(): ?\DateTimeInterface
  964.     {
  965.         return $this->firebaseTokenGeneratedAt;
  966.     }
  968.     public function setTokenFirebaseGeneratedAt(?\DateTimeInterface $firebaseTokenGeneratedAt): self
  969.     {
  970.         $this->firebaseTokenGeneratedAt = $firebaseTokenGeneratedAt;
  972.         return $this;
  973.     }
  975.     /**
  976.      * @return Collection<int, Scoring>
  977.      */
  978.     public function getScorings(): Collection
  979.     {
  980.         return $this->scorings;
  981.     }
  983.     public function addScoring(Scoring $scoring): self
  984.     {
  985.         if (!$this->scorings->contains($scoring)) {
  986.             $this->scorings[] = $scoring;
  987.             $scoring->setUser($this);
  988.         }
  990.         return $this;
  991.     }
  993.     public function removeScoring(Scoring $scoring): self
  994.     {
  995.         if ($this->scorings->removeElement($scoring)) {
  996.             if ($scoring->getUser() === $this) {
  997.                 $scoring->setUser(null);
  998.             }
  999.         }
  1001.         return $this;
  1002.     }
  1003.     /**
  1004.      * @return Collection<int, Instance>
  1005.      */
  1006.     public function getInstances(): Collection
  1007.     {
  1008.         return $this->instances;
  1009.     }
  1011.     public function getInstancesList(): string
  1012.     {
  1013.         return implode(", ", $this->instances->toArray());
  1014.     }
  1016.     public function getInstancesString(): string
  1017.     {
  1018.         $string = "[";
  1019.         foreach ($this->instances as $key => $instance) {
  1020.             $string .= '"' . $instance->getName() . '"';
  1021.             if ($key < count($this->instances) - 1) {
  1022.                 $string .= ',';
  1023.             }
  1024.         }
  1025.         $string .= "]";
  1026.         return $string;
  1027.     }
  1029.     public function addInstance(Instance $instance): self
  1030.     {
  1031.         if (!$this->instances->contains($instance)) {
  1032.             $this->instances[] = $instance;
  1033.         }
  1034.         return $this;
  1035.     }
  1037.     public function removeInstance(Instance $instance): self
  1038.     {
  1039.         $this->instances->removeElement($instance);
  1040.         return $this;
  1041.     }
  1043.     public function hasInstance(Instance $instance): bool
  1044.     {
  1045.         return $this->instances->contains($instance);
  1046.     }
  1048.     /**
  1049.      * @return bool
  1050.      */
  1051.     public function isAllowSelfEdit(): bool
  1052.     {
  1053.         return (bool) $this->allowSelfEdit;
  1054.     }
  1056.     /**
  1057.      * @param bool $allowSelfEdit 
  1058.      * @return self
  1059.      */
  1060.     public function setAllowSelfEdit(bool $allowSelfEdit): self
  1061.     {
  1062.         $this->allowSelfEdit = $allowSelfEdit;
  1063.         return $this;
  1064.     }
  1066.     /**
  1067.      * @return bool
  1068.      */
  1069.     public function isAnonymizationEnabled(): bool
  1070.     {
  1071.         return $this->anonymizationEnabled;
  1072.     }
  1074.     /**
  1075.      * @param bool $anonymizationEnabled 
  1076.      * @return self
  1077.      */
  1078.     public function setAnonymizationEnabled(bool $anonymizationEnabled): self
  1079.     {
  1080.         $this->anonymizationEnabled = $anonymizationEnabled;
  1081.         return $this;
  1082.     }
  1084.     /**
  1085.      * @return 
  1086.      */
  1087.     public function getFirstName(): ?string
  1088.     {
  1089.         return $this->firstName;
  1090.     }
  1092.     /**
  1093.      * @param  $firstName 
  1094.      * @return self
  1095.      */
  1096.     public function setFirstName(?string $firstName): self
  1097.     {
  1098.         $this->firstName = $firstName;
  1099.         return $this;
  1100.     }
  1102.     /**
  1103.      * @return 
  1104.      */
  1105.     public function getLastName(): ?string
  1106.     {
  1107.         return $this->lastName;
  1108.     }
  1110.     /**
  1111.      * @param  $lastName 
  1112.      * @return self
  1113.      */
  1114.     public function setLastName(?string $lastName): self
  1115.     {
  1116.         $this->lastName = $lastName;
  1117.         return $this;
  1118.     }
  1120.     /**
  1121.      * @return 
  1122.      */
  1123.     public function getEntityCode(): ?string
  1124.     {
  1125.         return $this->entityCode;
  1126.     }
  1128.     /**
  1129.      * @param  $entityCode 
  1130.      * @return self
  1131.      */
  1132.     public function setEntityCode(?string $entityCode): self
  1133.     {
  1134.         $this->entityCode = $entityCode;
  1135.         return $this;
  1136.     }
  1138.     /**
  1139.      * @return 
  1140.      */
  1141.     public function getPhotoPath(): ?string
  1142.     {
  1143.         return $this->photoPath;
  1144.     }
  1146.     /**
  1147.      * @param  $photoPath 
  1148.      * @return self
  1149.      */
  1150.     public function setPhotoPath(?string $photoPath): self
  1151.     {
  1152.         $this->photoPath = $photoPath;
  1153.         return $this;
  1154.     }
  1156.     /**
  1157.      * @return 
  1158.      */
  1159.     public function getProEmail(): ?string
  1160.     {
  1161.         return $this->proEmail;
  1162.     }
  1164.     /**
  1165.      * @param  $proEmail 
  1166.      * @return self
  1167.      */
  1168.     public function setProEmail(?string $proEmail): self
  1169.     {
  1170.         $this->proEmail = $proEmail;
  1171.         return $this;
  1172.     }
  1174.     /**
  1175.      * @return 
  1176.      */
  1177.     public function getProPhone(): ?string
  1178.     {
  1179.         return $this->proPhone;
  1180.     }
  1182.     /**
  1183.      * @param  $proPhone 
  1184.      * @return self
  1185.      */
  1186.     public function setProPhone(?string $proPhone): self
  1187.     {
  1188.         $this->proPhone = $proPhone;
  1189.         return $this;
  1190.     }
  1192.     public function isAcceptPrivacy(): bool
  1193.     {
  1194.         return $this->acceptPrivacy;
  1195.     }
  1197.     public function setAcceptPrivacy(bool $acceptPrivacy): self
  1198.     {
  1199.         $this->acceptPrivacy = $acceptPrivacy;
  1200.         return $this;
  1201.     }
  1203.     public function getAcceptPrivacyAt(): ?DateTimeImmutable
  1204.     {
  1205.         return $this->acceptPrivacyAt;
  1206.     }
  1208.     public function setAcceptPrivacyAt(?DateTimeImmutable $acceptPrivacyAt): self
  1209.     {
  1210.         $this->acceptPrivacyAt = $acceptPrivacyAt;
  1211.         return $this;
  1212.     }
  1214.     public function getAcceptPrivacyVersion(): ?string
  1215.     {
  1216.         return $this->acceptPrivacyVersion;
  1217.     }
  1219.     public function setAcceptPrivacyVersion(?string $acceptPrivacyVersion): self
  1220.     {
  1221.         $this->acceptPrivacyVersion = $acceptPrivacyVersion;
  1222.         return $this;
  1223.     }
  1225.     public function isPrivacyChecked(): bool
  1226.     {
  1227.         return $this->privacyChecked;
  1228.     }
  1230.     public function setPrivacyChecked(bool $value): self
  1231.     {
  1232.         $this->privacyChecked = $value;
  1233.         return $this;
  1234.     }
  1236.     #[Assert\Callback(groups: ['identity'])]
  1237.     public function validateIdentity(ExecutionContextInterface $context): void
  1238.     {
  1239.         // Si l’admin coche "Autoriser l’utilisateur à compléter/modifier ses infos"
  1240.         // => on n'impose pas les champs d’identité côté back-office.
  1241.         if ($this->isAllowSelfEdit() || $this->isAnonymizationEnabled()) {
  1242.             return;
  1243.         }
  1245.         // Sinon : ces champs deviennent obligatoires côté admin
  1246.         $lastName = trim((string) $this->getLastName());
  1247.         $firstName = trim((string) $this->getFirstName());
  1248.         $entity = trim((string) $this->getEntityCode());
  1250.         if ($lastName === '') {
  1251.             $context->buildViolation('Le nom est obligatoire.')
  1252.                 ->atPath('lastName')
  1253.                 ->addViolation();
  1254.         }
  1255.         if ($firstName === '') {
  1256.             $context->buildViolation('Le prénom est obligatoire.')
  1257.                 ->atPath('firstName')
  1258.                 ->addViolation();
  1259.         }
  1260.         if ($entity === '') {
  1261.             $context->buildViolation('L’entité / code entité est obligatoire.')
  1262.                 ->atPath('entityCode')
  1263.                 ->addViolation();
  1264.         }
  1265.     }
  1267.     // Criteria 1
  1268.     public function removeCriteria1Item(Criteria1Item $criteria1Item): self
  1269.     {
  1270.         $this->criteria1Items->removeElement($criteria1Item);
  1271.         return $this;
  1272.     }
  1274.     // Criteria 2
  1275.     public function removeCriteria2Item(Criteria2Item $criteria2Item): self
  1276.     {
  1277.         $this->criteria2Items->removeElement($criteria2Item);
  1278.         return $this;
  1279.     }
  1281.     // Criteria 3
  1282.     public function removeCriteria3Item(Criteria3Item $criteria3Item): self
  1283.     {
  1284.         $this->criteria3Items->removeElement($criteria3Item);
  1285.         return $this;
  1286.     }
  1288.     // Criteria 4
  1289.     public function removeCriteria4Item(Criteria4Item $criteria4Item): self
  1290.     {
  1291.         $this->criteria4Items->removeElement($criteria4Item);
  1292.         return $this;
  1293.     }
  1295.     // Criteria 5
  1296.     public function removeCriteria5Item(Criteria5Item $criteria5Item): self
  1297.     {
  1298.         $this->criteria5Items->removeElement($criteria5Item);
  1299.         return $this;
  1300.     }
  1303. }