src/Entity/User.php line 27

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Dae;
  6. use App\Entity\Autres;
  7. use App\Entity\Adresse;
  8. use App\Entity\Commande;
  9. use App\Entity\Entreprise;
  10. use App\Entity\Partenaire;
  11. use App\Entity\Particulier;
  12. use App\Entity\AgentInterne;
  13. use Doctrine\ORM\Mapping as ORM;
  14. use App\Repository\UserRepository;
  15. use Doctrine\Common\Collections\Collection;
  16. use Doctrine\Common\Collections\ArrayCollection;
  17. use Symfony\Component\Validator\Constraints as Assert;
  18. use Symfony\Component\Security\Core\User\UserInterface;
  19. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  20. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  22. #[ORM\Entity(repositoryClass: UserRepository::class)]
  23. #[ORM\InheritanceType(value: 'JOINED')]
  24. #[ORM\DiscriminatorColumn(name: 'type', type: 'string')]
  25. #[ORM\DiscriminatorMap(value: ['User' => User::class,'Particulier' => Particulier::class, 'Partenaire' => Partenaire::class, 'Entreprise' => Entreprise::class, 'Dae' => Dae::class, 'ChargeAssistance' => ChargeAssistance::class, 'AgentInterne' => AgentInterne::class,'Autres' => Autres::class])]
  26. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email', entityClass: User::class)]
  27. class User implements UserInterface, PasswordAuthenticatedUserInterface
  28. {
  29.     public const PARTIICULIER = 'Particulier';
  30.     public const ENTREPRISE = 'Entreprise';
  31.     public const AUTRES = 'Autres';
  34.     #[ORM\Id]
  35.     #[ORM\GeneratedValue]
  36.     #[ORM\Column(type: 'integer')]
  37.     private $id;
  39.     #[ORM\Column(type: 'string', length: 255, unique: true)]
  40.     #[Assert\Email]
  41.     private $email;
  43.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  44.     private $username;
  46.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  47.     private $password;
  49.     #[ORM\Column(type: 'json', length: 255)]
  50.     private $roles = [];
  52.     #[ORM\Column(type: 'boolean')]
  53.     private $isVerified = false;
  55.     #[ORM\ManyToMany(targetEntity: GroupePermission::class, inversedBy: 'users')]
  56.     private $group_permission;
  58.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Adresse::class, cascade: ['persist', 'remove'])]
  59.     private $adresses;
  61.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Commande::class, cascade: ['persist', 'remove'])]
  62.     private $commande;
  64.     #[ORM\Column(type: 'string', length: 1000, nullable: true)]
  65.     private $TokenReset;
  67.     #[ORM\Column(type: 'boolean')]
  68.     private $isDeleted = false;
  70.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: QuizReponse::class)]
  71.     private Collection $quizReponses;
  73.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Ressources::class, cascade: ['persist', 'remove'])]
  74.     private Collection $ressources;
  76.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: DocDemandeService::class, cascade: ['persist', 'remove'])]
  77.     private Collection $docDemande;
  79.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: InscriptionSessionFormation::class, cascade: ['persist', 'remove'])]
  80.     private Collection $inscriptionSessionFormations;
  82.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ForumReponse::class, cascade: ['persist', 'remove'])]
  83.     private ?Collection $forumResponses;
  85.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Sujetforum::class, cascade: ['persist', 'remove'])]
  86.     private ?Collection $sujetForums;
  88.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserFicheSatisfaction::class, orphanRemoval: true)]
  89.     private Collection $userFicheSatisfactions;
  91.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Notification::class)]
  92.     private Collection $notifications;
  94.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: DemandeService::class)]
  95.     private Collection $demandeServices;
  97.     public function __construct()
  98.     {
  99.         $this->group_permission = new ArrayCollection();
  100.         $this->adresses = new ArrayCollection();
  101.         $this->quizReponses = new ArrayCollection();
  102.         $this->ressources = new ArrayCollection();
  103.         $this->forumResponses = new ArrayCollection();
  104.         $this->sujetForums = new ArrayCollection();
  105.         $this->inscriptionSessionFormations = new ArrayCollection();
  106.         $this->commande = new ArrayCollection();
  107.         $this->docDemande = new ArrayCollection();
  108.         $this->userFicheSatisfactions = new ArrayCollection();
  109.         $this->notifications = new ArrayCollection();
  110.         $this->demandeServices = new ArrayCollection();
  111.     }
  113.     public function getId(): ?int
  114.     {
  115.         return $this->id;
  116.     }
  118.     public function getEmail(): ?string
  119.     {
  120.         return $this->email;
  121.     }
  123.     public function setEmail(string $email): self
  124.     {
  125.         $this->email = $email;
  127.         return $this;
  128.     }
  130.     public function getUsername(): ?string
  131.     {
  132.         return $this->username;
  133.     }
  135.     public function setUsername(string $username): self
  136.     {
  137.         $this->username = $username;
  139.         return $this;
  140.     }
  141.     public function getPassword(): ?string
  142.     {
  143.         return $this->password;
  144.     }
  146.     public function setPassword(?string $password): self
  147.     {
  148.         $this->password = $password;
  150.         return $this;
  151.     }
  154.      /**
  155.      * The public representation of the user (e.g. a username, an email address, etc.)
  156.      *
  157.      * @see UserInterface
  158.      */
  159.     public function getUserIdentifier(): string
  160.     {
  161.         return (string) $this->email;
  162.     }
  165.         public function getRoles(): array
  166.         {
  167.             $roles = [];
  168.             // guarantee every user at least has ROLE_USER$roles[] = 'ROLE_USER';
  169.             if ($this->isVerified() == 1) {
  170.                 $roles = $this->roles;
  171.                 return array_unique($roles);
  172.             }
  173.             //dd($roles);
  175.             return $roles;
  176.         }
  177.     public function setRoles(array $roles): self
  178.     {
  179.         $this->roles = $roles;
  181.         return $this;
  182.     }
  184.     /**
  185.      * Returning a salt is only needed, if you are not using a modern
  186.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  187.      *
  188.      * @see UserInterface
  189.      */
  190.     public function getSalt(): ?string
  191.     {
  192.         return null;
  193.     }
  195.     /**
  196.      * @see UserInterface
  197.      */
  198.     public function eraseCredentials()
  199.     {
  200.         // If you store any temporary, sensitive data on the user, clear it here
  201.         // $this->plainPassword = null;
  202.     }
  204.     public function isVerified(): bool
  205.     {
  206.         return $this->isVerified;
  207.     }
  209.     public function setIsVerified(bool $isVerified): self
  210.     {
  211.         $this->isVerified = $isVerified;
  213.         return $this;
  214.     }
  215.     public function getTokenReset(): ?string
  216.     {
  217.         return $this->TokenReset;
  218.     }
  220.     public function setTokenReset(?string $TokenReset): self
  221.     {
  222.         $this->TokenReset = $TokenReset;
  224.         return $this;
  225.     }
  227.     public function isDeleted(): bool
  228.     {
  229.         return $this->isDeleted;
  230.     }
  232.     public function setIsDeleted(bool $isDeleted): void
  233.     {
  234.         $this->isDeleted = $isDeleted;
  235.     }
  237.     /**
  238.      * @return Collection<int, GroupePermission>
  239.      */
  240.     public function getGroupPermission(): Collection
  241.     {
  242.         return $this->group_permission;
  243.     }
  245.     public function addGroupPermission(GroupePermission $groupPermission): self
  246.     {
  247.         if (!$this->group_permission->contains($groupPermission)) {
  248.             $this->group_permission[] = $groupPermission;
  249.         }
  251.         return $this;
  252.     }
  254.     public function removeGroupPermission(GroupePermission $groupPermission): self
  255.     {
  256.         $this->group_permission->removeElement($groupPermission);
  258.         return $this;
  259.     }
  261.     /**
  262.      * @return Collection<int, Adresse>
  263.      */
  264.     public function getAdresses(): Collection
  265.     {
  266.         return $this->adresses;
  267.     }
  269.     public function addAdress(Adresse $adress): self
  270.     {
  271.         if (!$this->adresses->contains($adress)) {
  272.             $this->adresses[] = $adress;
  273.             $adress->setUser($this);
  274.         }
  276.         return $this;
  277.     }
  279.     public function removeAdress(Adresse $adress): self
  280.     {
  281.         if ($this->adresses->removeElement($adress)) {
  282.             // set the owning side to null (unless already changed)
  283.             if ($adress->getUser() === $this) {
  284.                 $adress->setUser(null);
  285.             }
  286.         }
  288.         return $this;
  289.     }
  291.     public function isIsVerified(): ?bool
  292.     {
  293.         return $this->isVerified;
  294.     }
  296.     public function __toString()
  297.     {
  298.         return $this->username ?? $this->email ?? '';
  299.     }
  301.     /**
  302.      * @return Collection<int, QuizReponse>
  303.      */
  304.     public function getQuizReponses(): Collection
  305.     {
  306.         return $this->quizReponses;
  307.     }
  309.     public function addQuizReponse(QuizReponse $quizReponse): self
  310.     {
  311.         if (!$this->quizReponses->contains($quizReponse)) {
  312.             $this->quizReponses->add($quizReponse);
  313.             $quizReponse->setUser($this);
  314.         }
  316.         return $this;
  317.     }
  319.     public function removeQuizReponse(QuizReponse $quizReponse): self
  320.     {
  321.         if ($this->quizReponses->removeElement($quizReponse)) {
  322.             // set the owning side to null (unless already changed)
  323.             if ($quizReponse->getUser() === $this) {
  324.                 $quizReponse->setUser(null);
  325.             }
  326.         }
  328.         return $this;
  329.     }
  331.     /**
  332.      * @return Collection<int, Ressources>
  333.      */
  334.     public function getRessources(): Collection
  335.     {
  336.         return $this->ressources;
  337.     }
  339.     public function addRessource(Ressources $ressource): self
  340.     {
  341.         if (!$this->ressources->contains($ressource)) {
  342.             $this->ressources->add($ressource);
  343.             $ressource->setUser($this);
  344.         }
  346.         return $this;
  347.     }
  349.     public function removeRessource(Ressources $ressource): self
  350.     {
  351.         if ($this->ressources->removeElement($ressource)) {
  352.             // set the owning side to null (unless already changed)
  353.             if ($ressource->getUser() === $this) {
  354.                 $ressource->setUser(null);
  355.             }
  356.         }
  358.         return $this;
  359.     }
  361.     /**
  362.      * @return Collection<int, InscriptionSessionFormation>
  363.      */
  364.     public function getInscriptionSessionFormations(): Collection
  365.     {
  366.         return $this->inscriptionSessionFormations;
  367.     }
  369.     public function addInscriptionSessionFormation(InscriptionSessionFormation $inscriptionSessionFormation): self
  370.     {
  371.         if (!$this->inscriptionSessionFormations->contains($inscriptionSessionFormation)) {
  372.             $this->inscriptionSessionFormations->add($inscriptionSessionFormation);
  373.             $inscriptionSessionFormation->setUser($this);
  374.         }
  376.         return $this;
  377.     }
  379.     public function removeInscriptionSessionFormation(InscriptionSessionFormation $inscriptionSessionFormation): self
  380.     {
  381.         if ($this->inscriptionSessionFormations->removeElement($inscriptionSessionFormation)) {
  382.             // set the owning side to null (unless already changed)
  383.             if ($inscriptionSessionFormation->getUser() === $this) {
  384.                 $inscriptionSessionFormation->setUser(null);
  385.             }
  386.         }
  388.         return $this;
  389.     }
  392.     /**
  393.      * @return Collection<int, forumResponse>
  394.      */
  395.     public function getForumResponses(): Collection
  396.     {
  397.         return $this->forumResponses;
  398.     }
  400.     public function addForumResponses(ForumReponse $forumResponses): self
  401.     {
  402.         if (!$this->forumResponses->contains($forumResponses)) {
  403.             $this->forumResponses[] = $forumResponses;
  404.             $forumResponses->setUser($this);
  405.         }
  407.         return $this;
  408.     }
  410.     public function removeForumResponses(ForumReponse $forumResponses): self
  411.     {
  412.         if ($this->forumResponses->removeElement($forumResponses)) {
  413.             // set the owning side to null (unless already changed)
  414.             if ($forumResponses->getUser() === $this) {
  415.                 $forumResponses->setUser(null);
  416.             }
  417.         }
  419.         return $this;
  420.     }
  422.     /**
  423.      * @return Collection<int, sujetForum>
  424.      */
  425.     public function getSujetResponses(): Collection
  426.     {
  427.         return $this->sujetForums;
  428.     }
  430.     public function addSujetResponses(Sujetforum $sujetForum): self
  431.     {
  432.         if (!$this->sujetForums->contains($sujetForum)) {
  433.             $this->sujetForums[] = $sujetForum;
  434.             $sujetForum->setUser($this);
  435.         }
  437.         return $this;
  438.     }
  440.     public function removeSujetForums(Sujetforum $sujetForum): self
  441.     {
  442.         if ($this->sujetForums->removeElement($sujetForum)) {
  443.             // set the owning side to null (unless already changed)
  444.             if ($sujetForum->getUser() === $this) {
  445.                 $sujetForum->setUser(null);
  446.             }
  447.         }
  449.         return $this;
  450.     }
  452.     /**
  453.      * @return Collection<int, Commande>
  454.      */
  455.     public function getCommande(): Collection
  456.     {
  457.         return $this->commande;
  458.     }
  460.     public function addCommande(Commande $commande): self
  461.     {
  462.         if (!$this->commande->contains($commande)) {
  463.             $this->commande->add($commande);
  464.             $commande->setUser($this);
  465.         }
  467.         return $this;
  468.     }
  470.     public function removeCommande(Commande $commande): self
  471.     {
  472.         if ($this->commande->removeElement($commande)) {
  473.             // set the owning side to null (unless already changed)
  474.             if ($commande->getUser() === $this) {
  475.                 $commande->setUser(null);
  476.             }
  477.         }
  479.         return $this;
  480.     }
  482.     public function addForumResponse(ForumReponse $forumResponse): self
  483.     {
  484.         if (!$this->forumResponses->contains($forumResponse)) {
  485.             $this->forumResponses->add($forumResponse);
  486.             $forumResponse->setUser($this);
  487.         }
  489.         return $this;
  490.     }
  492.     public function removeForumResponse(ForumReponse $forumResponse): self
  493.     {
  494.         if ($this->forumResponses->removeElement($forumResponse)) {
  495.             // set the owning side to null (unless already changed)
  496.             if ($forumResponse->getUser() === $this) {
  497.                 $forumResponse->setUser(null);
  498.             }
  499.         }
  501.         return $this;
  502.     }
  504.     /**
  505.      * @return Collection<int, Sujetforum>
  506.      */
  507.     public function getSujetForums(): Collection
  508.     {
  509.         return $this->sujetForums;
  510.     }
  512.     public function addSujetForum(Sujetforum $sujetForum): self
  513.     {
  514.         if (!$this->sujetForums->contains($sujetForum)) {
  515.             $this->sujetForums->add($sujetForum);
  516.             $sujetForum->setUser($this);
  517.         }
  519.         return $this;
  520.     }
  522.     public function removeSujetForum(Sujetforum $sujetForum): self
  523.     {
  524.         if ($this->sujetForums->removeElement($sujetForum)) {
  525.             // set the owning side to null (unless already changed)
  526.             if ($sujetForum->getUser() === $this) {
  527.                 $sujetForum->setUser(null);
  528.             }
  529.         }
  531.         return $this;
  532.     }
  534.     /**
  535.      * @return Collection<int, DocDemandeService>
  536.      */
  537.     public function getDocDemande(): Collection
  538.     {
  539.         return $this->docDemande;
  540.     }
  542.     public function addDocDemande(DocDemandeService $docDemande): self
  543.     {
  544.         if (!$this->docDemande->contains($docDemande)) {
  545.             $this->docDemande->add($docDemande);
  546.             $docDemande->setUser($this);
  547.         }
  549.         return $this;
  550.     }
  552.     public function removeDocDemande(DocDemandeService $docDemande): self
  553.     {
  554.         if ($this->docDemande->removeElement($docDemande)) {
  555.             // set the owning side to null (unless already changed)
  556.             if ($docDemande->getUser() === $this) {
  557.                 $docDemande->setUser(null);
  558.             }
  559.         }
  561.         return $this;
  562.     }
  564.     /**
  565.      * @return Collection<int, UserFicheSatisfaction>
  566.      */
  567.     public function getUserFicheSatisfactions(): Collection
  568.     {
  569.         return $this->userFicheSatisfactions;
  570.     }
  572.     public function addUserFicheSatisfaction(UserFicheSatisfaction $userFicheSatisfaction): self
  573.     {
  574.         if (!$this->userFicheSatisfactions->contains($userFicheSatisfaction)) {
  575.             $this->userFicheSatisfactions->add($userFicheSatisfaction);
  576.             $userFicheSatisfaction->setUser($this);
  577.         }
  579.         return $this;
  580.     }
  582.     public function removeUserFicheSatisfaction(UserFicheSatisfaction $userFicheSatisfaction): self
  583.     {
  584.         if ($this->userFicheSatisfactions->removeElement($userFicheSatisfaction)) {
  585.             // set the owning side to null (unless already changed)
  586.             if ($userFicheSatisfaction->getUser() === $this) {
  587.                 $userFicheSatisfaction->setUser(null);
  588.             }
  589.         }
  591.         return $this;
  592.     }
  594.     public function isIsDeleted(): ?bool
  595.     {
  596.         return $this->isDeleted;
  597.     }
  599.     /**
  600.      * @return Collection<int, Notification>
  601.      */
  602.     public function getNotifications(): Collection
  603.     {
  604.         return $this->notifications;
  605.     }
  607.     public function addNotification(Notification $notification): self
  608.     {
  609.         if (!$this->notifications->contains($notification)) {
  610.             $this->notifications->add($notification);
  611.             $notification->setUser($this);
  612.         }
  614.         return $this;
  615.     }
  617.     public function removeNotification(Notification $notification): self
  618.     {
  619.         if ($this->notifications->removeElement($notification)) {
  620.             // set the owning side to null (unless already changed)
  621.             if ($notification->getUser() === $this) {
  622.                 $notification->setUser(null);
  623.             }
  624.         }
  626.         return $this;
  627.     }
  629.     /**
  630.      * @return Collection<int, DemandeService>
  631.      */
  632.     public function getDemandeServices(): Collection
  633.     {
  634.         return $this->demandeServices;
  635.     }
  637.     public function addDemandeService(DemandeService $demandeService): self
  638.     {
  639.         if (!$this->demandeServices->contains($demandeService)) {
  640.             $this->demandeServices->add($demandeService);
  641.             $demandeService->setUser($this);
  642.         }
  644.         return $this;
  645.     }
  647.     public function removeDemandeService(DemandeService $demandeService): self
  648.     {
  649.         if ($this->demandeServices->removeElement($demandeService)) {
  650.             // set the owning side to null (unless already changed)
  651.             if ($demandeService->getUser() === $this) {
  652.                 $demandeService->setUser(null);
  653.             }
  654.         }
  656.         return $this;
  657.     }
  658. }