src/Entity/User.php line 19

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  12. use Symfony\Component\Serializer\Annotation\Groups;
  14. /**
  15.  * @ORM\Entity(repositoryClass=UserRepository::class)
  16.  * @ORM\Table(name="`user`")
  17.  * @UniqueEntity(fields={"email"}, message="There is already an account with this email")
  18.  */
  19. class User implements UserInterface, PasswordAuthenticatedUserInterface
  20. {
  21.     /**
  22.      * @ORM\Id
  23.      * @ORM\GeneratedValue
  24.      * @ORM\Column(type="integer")
  25.      * @Groups({"message","post","post-group-session","conversation"})
  26.      */
  27.     private $id;
  29.     /**
  30.      * @ORM\Column(type="string", length=181)
  31.      */
  32.     private $email;
  34.     /**
  35.      * @ORM\Column(type="json")
  36.      */
  37.     private $roles = [];
  39.     /**
  40.      * @var string The hashed password
  41.      * @ORM\Column(type="string")
  42.      */
  43.     private $password;
  45.     /**
  46.      * @ORM\Column(type="boolean")
  47.      */
  48.     private $isVerified = false;
  50.     /**
  51.      * @ORM\Column(type="integer", nullable=true)
  52.      */
  53.     private $idCustomer;
  55.     /**
  56.      * @ORM\Column(type="integer", nullable=true)
  57.      */
  58.     private $idUserProfil;
  60.     /**
  61.      * @ORM\Column(type="string", length=45, nullable=true)
  62.      */
  63.     private $job;
  65.     /**
  66.      * @ORM\Column(type="string", length=45, nullable=true)
  67.      */
  68.     private $service;
  70.     /**
  71.      * @ORM\Column(type="string", length=255, nullable=true)
  72.      */
  73.     private $schoolDegree1;
  75.     /**
  76.      * @ORM\Column(type="string", length=255, nullable=true)
  77.      */
  78.     private $schoolDegree2;
  80.     /**
  81.      * @ORM\Column(type="string", length=255, nullable=true)
  82.      */
  83.     private $userName;
  85.     /**
  86.      * @ORM\Column(type="string", length=255, nullable=true)
  87.      * @Groups({"message","post","post-group-session","conversation"})
  88.      */
  89.     private $lastName;
  91.     /**
  92.      * @ORM\Column(type="string", length=255, nullable=true)
  93.      * @Groups({"message","post","post-group-session","conversation"})
  94.      */
  95.     private $firstName;
  97.     /**
  98.      * @ORM\Column(type="boolean", nullable=true)
  99.      */
  100.     private $isActive;
  102.     /**
  103.      * @ORM\OneToMany(targetEntity=ParticipantConversation::class, mappedBy="user")
  104.      */
  105.     private $participants;
  107.     /**
  108.      * @ORM\OneToMany(targetEntity=Message::class, mappedBy="user")
  109.      */
  110.     private $messages;
  112.     /**
  113.      * @ORM\OneToMany(targetEntity=ForumTopic::class, mappedBy="user")
  114.      */
  115.     private $forumTopics;
  117.     /**
  118.      * @ORM\OneToMany(targetEntity=ForumPost::class, mappedBy="user")
  119.      */
  120.     private $forumPosts;
  122.     /**
  123.      * @ORM\ManyToMany(targetEntity=LMSFormation::class, mappedBy="user")
  124.      */
  125.     private $lMSFormations;
  127.     /**
  128.      * @ORM\OneToMany(targetEntity=LMSAnswerUser::class, mappedBy="user")
  129.      */
  130.     private $lMSAnswerUsers;
  132.     /**
  133.      * @ORM\ManyToMany(targetEntity=GroupSession::class, mappedBy="user")
  134.      */
  135.     private $groupSessions;
  137.     /**
  138.      * @ORM\OneToMany(targetEntity=GroupSessionMessage::class, mappedBy="user")
  139.      */
  140.     private $groupSessionMessages;
  142.     /**
  143.      * @ORM\ManyToMany(targetEntity=LMSContent::class, mappedBy="userProgression")
  144.      */
  145.     private $lMSContents;
  147.     /**
  148.      * @ORM\OneToMany(targetEntity=LMSAnswerSurveyUser::class, mappedBy="user")
  149.      */
  150.     private $lMSAnswerSurveyUsers;
  152.     /**
  153.      * @ORM\OneToMany(targetEntity=Notification::class, mappedBy="user")
  154.      */
  155.     private $notifications;
  157.     /**
  158.      * onSite / remote : définit le type de formation lors de l'inscription de l'étudiant et du paiemement. 
  159.      */
  160.     private $typeCourseSession;
  162.     /**
  163.      * @ORM\ManyToMany(targetEntity=LMSModule::class, mappedBy="user")
  164.      */
  165.     private $lMSModules;
  167.     /**
  168.      * @ORM\OneToMany(targetEntity=LMSFreeAnswerSurvey::class, mappedBy="user")
  169.      */
  170.     private $lMSFreeAnswerSurveys;
  172.     /**
  173.      * @ORM\ManyToMany(targetEntity=LMSSequence::class, inversedBy="users")
  174.      */
  175.     private $LMSSequences;
  177.     /**
  178.      * @ORM\Column(type="boolean", nullable=true)
  179.      */
  180.     private $isProfessional;
  182.     public function __construct()
  183.     {
  184.         $this->participants = new ArrayCollection();
  185.         $this->messages = new ArrayCollection();
  186.         $this->forumTopics = new ArrayCollection();
  187.         $this->forumPosts = new ArrayCollection();
  188.         $this->lMSFormations = new ArrayCollection();
  189.         $this->lMSAnswerUsers = new ArrayCollection();
  190.         $this->groupSessions = new ArrayCollection();
  191.         $this->groupSessionMessages = new ArrayCollection();
  192.         $this->lMSContents = new ArrayCollection();
  193.         $this->lMSAnswerSurveyUsers = new ArrayCollection();
  194.         $this->notifications = new ArrayCollection();
  195.         $this->typeCourseSession = 0;
  196.         $this->lMSModules = new ArrayCollection();
  197.         $this->lMSFreeAnswerSurveys = new ArrayCollection();
  198.         $this->LMSSequences = new ArrayCollection();
  199.     }
  201.     public function getId(): ?int
  202.     {
  203.         return $this->id;
  204.     }
  206.     public function getEmail(): ?string
  207.     {
  208.         return $this->email;
  209.     }
  211.     public function setEmail(string $email): self
  212.     {
  213.         $this->email = $email;
  215.         return $this;
  216.     }
  218.     /**
  219.      * A visual identifier that represents this user.
  220.      *
  221.      * @see UserInterface
  222.      */
  223.     public function getUserIdentifier(): string
  224.     {
  225.         return (string) $this->email;
  226.     }
  228.     /**
  229.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  230.      */
  231.     public function getUsername(): string
  232.     {
  233.         return (string) $this->userName;
  234.     }
  236.     /**
  237.      * @see UserInterface
  238.      */
  239.     public function getRoles(): array
  240.     {
  241.         $roles = $this->roles;
  242.         // guarantee every user at least has ROLE_USER
  243.         $roles[] = 'ROLE_USER';
  245.         return array_unique($roles);
  246.     }
  248.     public function setRoles(array $roles): self
  249.     {
  250.         $this->roles = $roles;
  252.         return $this;
  253.     }
  255.     /**
  256.      * @see PasswordAuthenticatedUserInterface
  257.      */
  258.     public function getPassword(): string
  259.     {
  260.         return $this->password;
  261.     }
  263.     public function setPassword(string $password): self
  264.     {
  265.         $this->password = $password;
  267.         return $this;
  268.     }
  270.     /**
  271.      * Returning a salt is only needed, if you are not using a modern
  272.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  273.      *
  274.      * @see UserInterface
  275.      */
  276.     public function getSalt(): ?string
  277.     {
  278.         return null;
  279.     }
  281.     /**
  282.      * @see UserInterface
  283.      */
  284.     public function eraseCredentials()
  285.     {
  286.         // If you store any temporary, sensitive data on the user, clear it here
  287.         // $this->plainPassword = null;
  288.     }
  290.     public function isVerified(): bool
  291.     {
  292.         return $this->isVerified;
  293.     }
  295.     public function setIsVerified(bool $isVerified): self
  296.     {
  297.         $this->isVerified = $isVerified;
  299.         return $this;
  300.     }
  302.     public function getIdCustomer(): ?int
  303.     {
  304.         return $this->idCustomer;
  305.     }
  307.     public function setIdCustomer(int $idCustomer): self
  308.     {
  309.         $this->idCustomer = $idCustomer;
  311.         return $this;
  312.     }
  314.     public function getIdUserProfil(): ?int
  315.     {
  316.         return $this->idUserProfil;
  317.     }
  319.     public function setIdUserProfil(int $idUserProfil): self
  320.     {
  321.         $this->idUserProfil = $idUserProfil;
  323.         return $this;
  324.     }
  326.     public function getJob(): ?string
  327.     {
  328.         return $this->job;
  329.     }
  331.     public function setJob(?string $job): self
  332.     {
  333.         $this->job = $job;
  335.         return $this;
  336.     }
  338.     public function getService(): ?string
  339.     {
  340.         return $this->service;
  341.     }
  343.     public function setService(?string $service): self
  344.     {
  345.         $this->service = $service;
  347.         return $this;
  348.     }
  350.     public function getSchoolDegree1(): ?string
  351.     {
  352.         return $this->schoolDegree1;
  353.     }
  355.     public function setSchoolDegree1(?string $schoolDegree1): self
  356.     {
  357.         $this->schoolDegree1 = $schoolDegree1;
  359.         return $this;
  360.     }
  362.     public function getSchoolDegree2(): ?string
  363.     {
  364.         return $this->schoolDegree2;
  365.     }
  367.     public function setSchoolDegree2(?string $schoolDegree2): self
  368.     {
  369.         $this->schoolDegree2 = $schoolDegree2;
  371.         return $this;
  372.     }
  374.     public function setUserName(?string $userName): self
  375.     {
  376.         $this->userName = $userName;
  378.         return $this;
  379.     }
  381.     public function getLastName(): ?string
  382.     {
  383.         return $this->lastName;
  384.     }
  386.     public function setLastName(?string $lastName): self
  387.     {
  388.         $this->lastName = $lastName;
  390.         return $this;
  391.     }
  393.     public function getFirstName(): ?string
  394.     {
  395.         return $this->firstName;
  396.     }
  398.     public function setFirstName(?string $firstName): self
  399.     {
  400.         $this->firstName = $firstName;
  402.         return $this;
  403.     }
  405.     public function getIsActive(): ?bool
  406.     {
  407.         return $this->isActive;
  408.     }
  410.     public function setIsActive(?bool $isActive): self
  411.     {
  412.         $this->isActive = $isActive;
  414.         return $this;
  415.     }
  417.     /**
  418.      * @return Collection<int, ParticipantConversation>
  419.      */
  420.     public function getParticipants(): Collection
  421.     {
  422.         return $this->participants;
  423.     }
  425.     public function addParticipant(ParticipantConversation $participant): self
  426.     {
  427.         if (!$this->participants->contains($participant)) {
  428.             $this->participants[] = $participant;
  429.             $participant->setUser($this);
  430.         }
  432.         return $this;
  433.     }
  435.     public function removeParticipant(ParticipantConversation $participant): self
  436.     {
  437.         if ($this->participants->removeElement($participant)) {
  438.             // set the owning side to null (unless already changed)
  439.             if ($participant->getUser() === $this) {
  440.                 $participant->setUser(null);
  441.             }
  442.         }
  444.         return $this;
  445.     }
  447.     /**
  448.      * @return Collection<int, Message>
  449.      */
  450.     public function getMessages(): Collection
  451.     {
  452.         return $this->messages;
  453.     }
  455.     public function addMessage(Message $message): self
  456.     {
  457.         if (!$this->messages->contains($message)) {
  458.             $this->messages[] = $message;
  459.             $message->setMessages($this);
  460.         }
  462.         return $this;
  463.     }
  465.     public function removeMessage(Message $message): self
  466.     {
  467.         if ($this->messages->removeElement($message)) {
  468.             // set the owning side to null (unless already changed)
  469.             if ($message->getMessages() === $this) {
  470.                 $message->setMessages(null);
  471.             }
  472.         }
  474.         return $this;
  475.     }
  477.     /**
  478.      * @return Collection<int, ForumTopic>
  479.      */
  480.     public function getForumTopics(): Collection
  481.     {
  482.         return $this->forumTopics;
  483.     }
  485.     public function addForumTopic(ForumTopic $forumTopic): self
  486.     {
  487.         if (!$this->forumTopics->contains($forumTopic)) {
  488.             $this->forumTopics[] = $forumTopic;
  489.             $forumTopic->setUser($this);
  490.         }
  492.         return $this;
  493.     }
  495.     public function removeForumTopic(ForumTopic $forumTopic): self
  496.     {
  497.         if ($this->forumTopics->removeElement($forumTopic)) {
  498.             // set the owning side to null (unless already changed)
  499.             if ($forumTopic->getUser() === $this) {
  500.                 $forumTopic->setUser(null);
  501.             }
  502.         }
  504.         return $this;
  505.     }
  507.     /**
  508.      * @return Collection<int, ForumPost>
  509.      */
  510.     public function getForumPosts(): Collection
  511.     {
  512.         return $this->forumPosts;
  513.     }
  515.     public function addForumPost(ForumPost $forumPost): self
  516.     {
  517.         if (!$this->forumPosts->contains($forumPost)) {
  518.             $this->forumPosts[] = $forumPost;
  519.             $forumPost->setUser($this);
  520.         }
  522.         return $this;
  523.     }
  525.     public function removeForumPost(ForumPost $forumPost): self
  526.     {
  527.         if ($this->forumPosts->removeElement($forumPost)) {
  528.             // set the owning side to null (unless already changed)
  529.             if ($forumPost->getUser() === $this) {
  530.                 $forumPost->setUser(null);
  531.             }
  532.         }
  534.         return $this;
  535.     }
  537.     /**
  538.      * @return Collection<int, LMSFormation>
  539.      */
  540.     public function getLMSFormations(): Collection
  541.     {
  542.         return $this->lMSFormations;
  543.     }
  545.     public function addLMSFormation(LMSFormation $lMSFormation): self
  546.     {
  547.         if (!$this->lMSFormations->contains($lMSFormation)) {
  548.             $this->lMSFormations[] = $lMSFormation;
  549.             $lMSFormation->addUser($this);
  550.         }
  552.         return $this;
  553.     }
  555.     public function removeLMSFormation(LMSFormation $lMSFormation): self
  556.     {
  557.         if ($this->lMSFormations->removeElement($lMSFormation)) {
  558.             $lMSFormation->removeUser($this);
  559.         }
  561.         return $this;
  562.     }
  564.     /**
  565.      * @return Collection<int, LMSAnswerUser>
  566.      */
  567.     public function getLMSAnswerUsers(): Collection
  568.     {
  569.         return $this->lMSAnswerUsers;
  570.     }
  572.     public function addLMSAnswerUser(LMSAnswerUser $lMSAnswerUser): self
  573.     {
  574.         if (!$this->lMSAnswerUsers->contains($lMSAnswerUser)) {
  575.             $this->lMSAnswerUsers[] = $lMSAnswerUser;
  576.             $lMSAnswerUser->setUser($this);
  577.         }
  579.         return $this;
  580.     }
  582.     public function removeLMSAnswerUser(LMSAnswerUser $lMSAnswerUser): self
  583.     {
  584.         if ($this->lMSAnswerUsers->removeElement($lMSAnswerUser)) {
  585.             // set the owning side to null (unless already changed)
  586.             if ($lMSAnswerUser->getUser() === $this) {
  587.                 $lMSAnswerUser->setUser(null);
  588.             }
  589.         }
  591.         return $this;
  592.     }
  594.     /**
  595.      * @return Collection<int, GroupSession>
  596.      */
  597.     public function getGroupSessions(): Collection
  598.     {
  599.         return $this->groupSessions;
  600.     }
  602.     public function addGroupSession(GroupSession $groupSession): self
  603.     {
  604.         if (!$this->groupSessions->contains($groupSession)) {
  605.             $this->groupSessions[] = $groupSession;
  606.             $groupSession->addUser($this);
  607.         }
  609.         return $this;
  610.     }
  612.     public function removeGroupSession(GroupSession $groupSession): self
  613.     {
  614.         if ($this->groupSessions->removeElement($groupSession)) {
  615.             $groupSession->removeUser($this);
  616.         }
  618.         return $this;
  619.     }
  621.     /**
  622.      * @return Collection<int, GroupSessionMessage>
  623.      */
  624.     public function getGroupSessionMessages(): Collection
  625.     {
  626.         return $this->groupSessionMessages;
  627.     }
  629.     public function addGroupSessionMessage(GroupSessionMessage $groupSessionMessage): self
  630.     {
  631.         if (!$this->groupSessionMessages->contains($groupSessionMessage)) {
  632.             $this->groupSessionMessages[] = $groupSessionMessage;
  633.             $groupSessionMessage->setUser($this);
  634.         }
  636.         return $this;
  637.     }
  639.     public function removeGroupSessionMessage(GroupSessionMessage $groupSessionMessage): self
  640.     {
  641.         if ($this->groupSessionMessages->removeElement($groupSessionMessage)) {
  642.             // set the owning side to null (unless already changed)
  643.             if ($groupSessionMessage->getUser() === $this) {
  644.                 $groupSessionMessage->setUser(null);
  645.             }
  646.         }
  648.         return $this;
  649.     }
  651.     /**
  652.      * @return Collection<int, LMSContent>
  653.      */
  654.     public function getLMSContents(): Collection
  655.     {
  656.         return $this->lMSContents;
  657.     }
  659.     public function addLMSContent(LMSContent $lMSContent): self
  660.     {
  661.         if (!$this->lMSContents->contains($lMSContent)) {
  662.             $this->lMSContents[] = $lMSContent;
  663.             $lMSContent->addUserProgression($this);
  664.         }
  666.         return $this;
  667.     }
  669.     public function removeLMSContent(LMSContent $lMSContent): self
  670.     {
  671.         if ($this->lMSContents->removeElement($lMSContent)) {
  672.             $lMSContent->removeUserProgression($this);
  673.         }
  675.         return $this;
  676.     }
  678.     /**
  679.      * @return Collection<int, LMSAnswerSurveyUser>
  680.      */
  681.     public function getLMSAnswerSurveyUsers(): Collection
  682.     {
  683.         return $this->lMSAnswerSurveyUsers;
  684.     }
  686.     public function addLMSAnswerSurveyUser(LMSAnswerSurveyUser $lMSAnswerSurveyUser): self
  687.     {
  688.         if (!$this->lMSAnswerSurveyUsers->contains($lMSAnswerSurveyUser)) {
  689.             $this->lMSAnswerSurveyUsers[] = $lMSAnswerSurveyUser;
  690.             $lMSAnswerSurveyUser->setUser($this);
  691.         }
  693.         return $this;
  694.     }
  696.     public function removeLMSAnswerSurveyUser(LMSAnswerSurveyUser $lMSAnswerSurveyUser): self
  697.     {
  698.         if ($this->lMSAnswerSurveyUsers->removeElement($lMSAnswerSurveyUser)) {
  699.             // set the owning side to null (unless already changed)
  700.             if ($lMSAnswerSurveyUser->getUser() === $this) {
  701.                 $lMSAnswerSurveyUser->setUser(null);
  702.             }
  703.         }
  705.         return $this;
  706.     }
  708.     /**
  709.      * @return Collection<int, Notification>
  710.      */
  711.     public function getNotifications(): Collection
  712.     {
  713.         return $this->notifications;
  714.     }
  716.     public function addNotification(Notification $notification): self
  717.     {
  718.         if (!$this->notifications->contains($notification)) {
  719.             $this->notifications[] = $notification;
  720.             $notification->setUser($this);
  721.         }
  723.         return $this;
  724.     }
  726.     public function removeNotification(Notification $notification): self
  727.     {
  728.         if ($this->notifications->removeElement($notification)) {
  729.             // set the owning side to null (unless already changed)
  730.             if ($notification->getUser() === $this) {
  731.                 $notification->setUser(null);
  732.             }
  733.         }
  735.         return $this;
  736.     }
  738.     /**
  739.      * Get onSite / remote : définit le type de formation lors de l'inscription de l'étudiant et du paiemement.
  740.      */ 
  741.     public function getTypeCourseSession()
  742.     {
  743.         return $this->typeCourseSession;
  744.     }
  746.     /**
  747.      * Set onSite / remote : définit le type de formation lors de l'inscription de l'étudiant et du paiemement.
  748.      *
  749.      * @return  self
  750.      */ 
  751.     public function setTypeCourseSession($typeCourseSession)
  752.     {
  753.         $this->typeCourseSession = $typeCourseSession;
  755.         return $this;
  756.     }
  758.     /**
  759.      * @return Collection<int, LMSModule>
  760.      */
  761.     public function getLMSModules(): Collection
  762.     {
  763.         return $this->lMSModules;
  764.     }
  766.     public function addLMSModule(LMSModule $lMSModule): self
  767.     {
  768.         if (!$this->lMSModules->contains($lMSModule)) {
  769.             $this->lMSModules[] = $lMSModule;
  770.             $lMSModule->addUser($this);
  771.         }
  773.         return $this;
  774.     }
  776.     public function removeLMSModule(LMSModule $lMSModule): self
  777.     {
  778.         if ($this->lMSModules->removeElement($lMSModule)) {
  779.             $lMSModule->removeUser($this);
  780.         }
  782.         return $this;
  783.     }
  785.     /**
  786.      * @return Collection<int, LMSFreeAnswerSurvey>
  787.      */
  788.     public function getLMSFreeAnswerSurveys(): Collection
  789.     {
  790.         return $this->lMSFreeAnswerSurveys;
  791.     }
  793.     public function addLMSFreeAnswerSurvey(LMSFreeAnswerSurvey $lMSFreeAnswerSurvey): self
  794.     {
  795.         if (!$this->lMSFreeAnswerSurveys->contains($lMSFreeAnswerSurvey)) {
  796.             $this->lMSFreeAnswerSurveys[] = $lMSFreeAnswerSurvey;
  797.             $lMSFreeAnswerSurvey->setUser($this);
  798.         }
  800.         return $this;
  801.     }
  803.     public function removeLMSFreeAnswerSurvey(LMSFreeAnswerSurvey $lMSFreeAnswerSurvey): self
  804.     {
  805.         if ($this->lMSFreeAnswerSurveys->removeElement($lMSFreeAnswerSurvey)) {
  806.             // set the owning side to null (unless already changed)
  807.             if ($lMSFreeAnswerSurvey->getUser() === $this) {
  808.                 $lMSFreeAnswerSurvey->setUser(null);
  809.             }
  810.         }
  812.         return $this;
  813.     }
  815.     /**
  816.      * @return Collection<int, LMSSequence>
  817.      */
  818.     public function getLMSSequences(): Collection
  819.     {
  820.         return $this->LMSSequences;
  821.     }
  823.     public function addLMSSequence(LMSSequence $lMSSequence): self
  824.     {
  825.         if (!$this->LMSSequences->contains($lMSSequence)) {
  826.             $this->LMSSequences[] = $lMSSequence;
  827.         }
  829.         return $this;
  830.     }
  832.     public function removeLMSSequence(LMSSequence $lMSSequence): self
  833.     {
  834.         $this->LMSSequences->removeElement($lMSSequence);
  836.         return $this;
  837.     }
  839.     public function getIsProfessional(): ?bool
  840.     {
  841.         return $this->isProfessional;
  842.     }
  844.     public function setIsProfessional(?bool $isProfessional): self
  845.     {
  846.         $this->isProfessional = $isProfessional;
  848.         return $this;
  849.     }
  850. }