src/Entity/User.php line 18

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Core\Annotation\ApiResource;
  6. use App\Repository\UserRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  15. #[ORM\Entity(repositoryClass: UserRepository::class)]
  16. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  17. #[ApiResource]
  18. class User implements UserInterface, PasswordAuthenticatedUserInterface
  19. {
  20.     #[ORM\Id]
  21.     #[ORM\GeneratedValue]
  22.     #[ORM\Column]
  23.     private ?int $id = null;
  25.     #[ORM\Column(length: 180, unique: true)]
  26.     private ?string $email = null;
  28.     #[ORM\Column]
  29.     private array $roles = [];
  31.     /**
  32.      * @var string The hashed password
  33.      */
  34.     #[ORM\Column]
  35.     private ?string $password = null;
  37.     #[ORM\Column(length: 255 , nullable: true)]
  38.     private ?string $adresse = null;
  40.     #[ORM\Column(length: 255 , nullable: true)]
  41.     private ?string $phone = null;
  43.     #[ORM\Column(length: 255 , nullable: true) ]
  44.     private ?string $options = null;
  46.     #[ORM\Column(length: 255, nullable: true)]
  47.     private ?string $logo = null;
  49.     #[ORM\Column(length: 255, nullable: true)]
  50.     private ?string $nom = null;
  52.     #[ORM\Column(length: 255, nullable: true)]
  53.     private ?string $prenom = null;
  55.     #[ORM\Column(length: 255, nullable: true)]
  56.     private ?string $phone1 = null;
  58.     #[ORM\Column(length: 255, nullable: true)]
  59.     private ?string $fb = null;
  61.     #[ORM\Column(length: 255, nullable: true)]
  62.     private ?string $Linkedin = null;
  64.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  65.     private ?string $biographie = null;
  67.     #[ORM\Column(length: 255, nullable: true)]
  68.     private ?string $cv = null;
  70.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Diplome::class,cascade: ['remove'])]
  71.     private Collection $diplome;
  73.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Certificat::class,cascade: ['remove'])]
  74.     private Collection $certificat;
  76.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Experience::class,cascade: ['remove'])]
  77.     private Collection $experiences;
  79.     #[ORM\Column(length: 255, nullable: true)]
  80.     private ?string $poste = null;
  82.     #[ORM\OneToMany(mappedBy: 'formateur', targetEntity: Formation::class,cascade: ['remove'])]
  83.     private Collection $formations;
  85.     #[ORM\Column(length: 255, nullable: true)]
  86.     private ?string $pays = null;
  88.     #[ORM\Column(length: 255, nullable: true)]
  89.     private ?string $type = null;
  91.     #[ORM\Column(length: 255, nullable: true)]
  92.     private ?string $responsable = null;
  94.     #[ORM\OneToMany(mappedBy: 'stagiaire', targetEntity: InscritSession::class,cascade: ['remove'])]
  95.     private Collection $inscritSessions;
  96. //    #[ORM\ManyToOne(inversedBy: 'user')]
  97. //   private ?Messageinscrit $messageinscrit = null;
  99.    #[ORM\OneToMany(mappedBy: 'user', targetEntity: Messageinscrit::class,cascade: ['remove'])]
  100.    private Collection $messageinscrits;
  102.    #[ORM\Column(length: 255, nullable: true)]
  103.    private ?string $siteweb = null;
  105.    #[ORM\Column(length: 255, nullable: true)]
  106.    private ?string $github = null;
  108.    #[ORM\Column(length: 255, nullable: true)]
  109.    private ?string $twitter = null;
  111. #[ORM\OneToMany(mappedBy: 'user', targetEntity: Reclamation::class,cascade: ['remove'])]
  112.  private Collection $reclamations;
  114. #[ORM\OneToMany(mappedBy: 'user', targetEntity: Evaluation::class,cascade: ['remove'])]
  115. private Collection $evaluations;
  117. #[ORM\OneToMany(mappedBy: 'formateur', targetEntity: Evenement::class,cascade: ['remove'])]
  118. private Collection $evenements;
  120. #[ORM\OneToMany(mappedBy: 'formateur', targetEntity: VirtualClassroom::class,cascade: ['remove'])]
  121. private Collection $virtualClassrooms;
  123. #[ORM\OneToMany(mappedBy: 'destinataire', targetEntity: Reponsereclamation::class,cascade: ['remove'])]
  124. private Collection $reponsereclamations;
  126. #[ORM\Column(nullable: true)]
  127. private ?bool $vue = null;
  131. #[ORM\OneToMany(mappedBy: 'relationus', targetEntity: Offresinscrit::class,cascade: ['remove'])]
  132. private Collection $offresinscrits;
  134. #[ORM\OneToMany(mappedBy: 'destinataire', targetEntity: Reponsemessage::class,cascade: ['remove'])]
  135. private Collection $reponsemessages;
  137. #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  138. private ?\DateTimeInterface $date = null;
  140. #[ORM\Column(length: 255, nullable: true)]
  141. private ?string $vu = null;
  143. #[ORM\OneToMany(mappedBy: 'user', targetEntity: Demmandeformation::class,cascade: ['remove'])]
  144. private Collection $demmandeformations;
  146. #[ORM\OneToMany(mappedBy: 'user', targetEntity: Demandeprofil::class,cascade: ['remove'])]
  147. private Collection $demandeprofils;
  149. #[ORM\OneToMany(mappedBy: 'expediteur', targetEntity: ReponseDemandeFormation::class,cascade: ['remove'])]
  150. private Collection $reponseDemandeFormations;
  152. #[ORM\OneToMany(mappedBy: 'destinataire', targetEntity: ReponseDemandeFormation::class,cascade: ['remove'])]
  153. private Collection $reponseDemandeFormationsdest;
  155. #[ORM\OneToMany(mappedBy: 'user', targetEntity: Emailsadmin::class,cascade: ['remove'])]
  156. private Collection $emailsadmins;
  158. #[ORM\ManyToMany(targetEntity: TacheAssistant::class, inversedBy: 'users')]
  159. private Collection $taches;
  160. #[ORM\OneToMany(mappedBy: 'user', targetEntity: Trace::class,cascade: ['remove'])]
  161. private Collection $traces;
  163. #[ORM\Column(length: 255, nullable: true)]
  164. private ?string $ipadress = null;
  166. #[ORM\OneToMany(mappedBy: 'student', targetEntity: EmailStudent::class,cascade: ['remove'])]
  167. private Collection $emailStudents;
  169. #[ORM\OneToMany(mappedBy: 'user', targetEntity: Signature::class)]
  170. private Collection $signatures;
  172. #[ORM\OneToMany(mappedBy: 'user', targetEntity: Ipadresse::class , cascade: ['remove'])]
  173. private Collection $ipadresses;
  175. #[ORM\Column(nullable: true)]
  176. private ?bool $isActive = null;
  178. #[ORM\OneToMany(mappedBy: 'formateur', targetEntity: FormationElearning::class)]
  179. private Collection $formationElearnings;
  181. #[ORM\OneToMany(mappedBy: 'user', targetEntity: Commande::class)]
  182. private Collection $commandes;
  184. #[ORM\OneToMany(mappedBy: 'user', targetEntity: EvaluationElearning::class)]
  185. private Collection $evaluationElearnings;
  187. #[ORM\Column(length: 255, nullable: true)]
  188. private ?string $nomsociete = null;
  190. #[ORM\Column(length: 255, nullable: true)]
  191. private ?string $adressesociete = null;
  193. #[ORM\Column(length: 255, nullable: true)]
  194. private ?string $matricule = null;
  196. #[ORM\OneToMany(mappedBy: 'user', targetEntity: CommentElearning::class)]
  197. private Collection $commentElearnings;
  199. #[ORM\ManyToMany(targetEntity: CommentElearning::class, mappedBy: 'likedBy')]
  200. private Collection $commentLikes;
  202. #[ORM\OneToMany(mappedBy: 'sender', targetEntity: ChatFormation::class)]
  203. private Collection $chatFormations;
  205. #[ORM\OneToMany(mappedBy: 'user', targetEntity: Coupon::class)]
  206. private Collection $coupons;
  216.     public function __construct()
  217.     {
  218.         $this->diplome = new ArrayCollection();
  219.         $this->certificat = new ArrayCollection();
  220.         $this->experiences = new ArrayCollection();
  221.         $this->formations = new ArrayCollection();
  222.         $this->inscritSessions = new ArrayCollection();
  223.         $this->messageinscrits = new ArrayCollection();
  224.         $this->reclamations = new ArrayCollection();
  225.         $this->evaluations = new ArrayCollection();
  226.         $this->evenements = new ArrayCollection();
  227.         $this->virtualClassrooms = new ArrayCollection();
  228.         $this->reponsereclamations = new ArrayCollection();
  229.         $this->offresinscrits = new ArrayCollection();
  230.         $this->reponsemessages = new ArrayCollection();
  231.         $this->demmandeformations = new ArrayCollection();
  232.         $this->demandeprofils = new ArrayCollection();
  233.         $this->reponseDemandeFormations = new ArrayCollection();
  234.         $this->reponseDemandeFormationsdest = new ArrayCollection();
  235.         $this->emailsadmins = new ArrayCollection();
  236.         $this->taches = new ArrayCollection();
  237.         $this->traces = new ArrayCollection();
  238.         $this->emailStudents = new ArrayCollection();
  239.         $this->signatures = new ArrayCollection();
  240.         $this->ipadresses = new ArrayCollection();
  241.         $this->formationElearnings = new ArrayCollection();
  242.         $this->commandes = new ArrayCollection();
  243.         $this->evaluationElearnings = new ArrayCollection();
  244.         $this->commentElearnings = new ArrayCollection();
  245.         $this->commentLikes = new ArrayCollection();
  246.         $this->chatFormations = new ArrayCollection();
  247.         $this->coupons = new ArrayCollection();
  249.     }
  250.     public function __toString(): string
  251.     {
  252.         return $this->getNom();
  253.     }
  255.     public function getId(): ?int
  256.     {
  257.         return $this->id;
  258.     }
  260.     public function getEmail(): ?string
  261.     {
  262.         return $this->email;
  263.     }
  265.     public function setEmail(string $email): self
  266.     {
  267.         $this->email = $email;
  269.         return $this;
  270.     }
  272.     /**
  273.      * A visual identifier that represents this user.
  274.      *
  275.      * @see UserInterface
  276.      */
  277.     public function getUserIdentifier(): string
  278.     {
  279.         return (string) $this->email;
  280.     }
  282.     /**
  283.      * @see UserInterface
  284.      */
  285.     public function getRoles(): array
  286.     {
  287.         $roles = $this->roles;
  288.         // guarantee every user at least has ROLE_USER
  289.         $roles[] = 'ROLE_USER';
  291.         return array_unique($roles);
  292.     }
  294.     public function setRoles(array $roles): self
  295.     {
  296.         $this->roles = $roles;
  298.         return $this;
  299.     }
  301.     /**
  302.      * @see PasswordAuthenticatedUserInterface
  303.      */
  304.     public function getPassword(): string
  305.     {
  306.         return $this->password;
  307.     }
  309.     public function setPassword(string $password): self
  310.     {
  311.         $this->password = $password;
  313.         return $this;
  314.     }
  316.     /**
  317.      * @see UserInterface
  318.      */
  319.     public function eraseCredentials()
  320.     {
  321.         // If you store any temporary, sensitive data on the user, clear it here
  322.         // $this->plainPassword = null;
  323.     }
  325.     public function getAdresse(): ?string
  326.     {
  327.         return $this->adresse;
  328.     }
  330.     public function setAdresse(?string $adresse): self
  331.     {
  332.         $this->adresse = $adresse;
  334.         return $this;
  335.     }
  337.     public function getPhone(): ?string
  338.     {
  339.         return $this->phone;
  340.     }
  342.     public function setPhone(string $phone): self
  343.     {
  344.         $this->phone = $phone;
  346.         return $this;
  347.     }
  349.     public function getOptions(): ?string
  350.     {
  351.         return $this->options;
  352.     }
  354.     public function setOptions(string $options): self
  355.     {
  356.         $this->options = $options;
  358.         return $this;
  359.     }
  361.     public function getLogo(): ?string
  362.     {
  363.         return $this->logo;
  364.     }
  366.     public function setLogo(?string $logo): self
  367.     {
  368.         $this->logo = $logo;
  370.         return $this;
  371.     }
  373.     public function getNom(): ?string
  374.     {
  375.         return $this->nom;
  376.     }
  378.     public function setNom(?string $nom): self
  379.     {
  380.         $this->nom = $nom;
  382.         return $this;
  383.     }
  385.     public function getPrenom(): ?string
  386.     {
  387.         return $this->prenom;
  388.     }
  390.     public function setPrenom(?string $prenom): self
  391.     {
  392.         $this->prenom = $prenom;
  394.         return $this;
  395.     }
  397.     public function getPhone1(): ?string
  398.     {
  399.         return $this->phone1;
  400.     }
  402.     public function setPhone1(?string $phone1): self
  403.     {
  404.         $this->phone1 = $phone1;
  406.         return $this;
  407.     }
  409.     public function getFb(): ?string
  410.     {
  411.         return $this->fb;
  412.     }
  414.     public function setFb(?string $fb): self
  415.     {
  416.         $this->fb = $fb;
  418.         return $this;
  419.     }
  421.     public function getLinkedin(): ?string
  422.     {
  423.         return $this->Linkedin;
  424.     }
  426.     public function setLinkedin(?string $Linkedin): self
  427.     {
  428.         $this->Linkedin = $Linkedin;
  430.         return $this;
  431.     }
  433.     public function getBiographie(): ?string
  434.     {
  435.         return $this->biographie;
  436.     }
  438.     public function setBiographie(?string $biographie): self
  439.     {
  440.         $this->biographie = $biographie;
  442.         return $this;
  443.     }
  445.     public function getCv(): ?string
  446.     {
  447.         return $this->cv;
  448.     }
  450.     public function setCv(?string $cv): self
  451.     {
  452.         $this->cv = $cv;
  454.         return $this;
  455.     }
  457.     /**
  458.      * @return Collection<int, Diplome>
  459.      */
  460.     public function getDiplome(): Collection
  461.     {
  462.         return $this->diplome;
  463.     }
  465.     public function addDiplome(Diplome $diplome): self
  466.     {
  467.         if (!$this->diplome->contains($diplome)) {
  468.             $this->diplome->add($diplome);
  469.             $diplome->setUser($this);
  470.         }
  472.         return $this;
  473.     }
  475.     public function removeDiplome(Diplome $diplome): self
  476.     {
  477.         if ($this->diplome->removeElement($diplome)) {
  478.             // set the owning side to null (unless already changed)
  479.             if ($diplome->getUser() === $this) {
  480.                 $diplome->setUser(null);
  481.             }
  482.         }
  484.         return $this;
  485.     }
  487.     /**
  488.      * @return Collection<int, Certificat>
  489.      */
  490.     public function getCertificat(): Collection
  491.     {
  492.         return $this->certificat;
  493.     }
  495.     public function addCertificat(Certificat $certificat): self
  496.     {
  497.         if (!$this->certificat->contains($certificat)) {
  498.             $this->certificat->add($certificat);
  499.             $certificat->setUser($this);
  500.         }
  502.         return $this;
  503.     }
  505.     public function removeCertificat(Certificat $certificat): self
  506.     {
  507.         if ($this->certificat->removeElement($certificat)) {
  508.             // set the owning side to null (unless already changed)
  509.             if ($certificat->getUser() === $this) {
  510.                 $certificat->setUser(null);
  511.             }
  512.         }
  514.         return $this;
  515.     }
  517.     /**
  518.      * @return Collection<int, Experience>
  519.      */
  520.     public function getExperiences(): Collection
  521.     {
  522.         return $this->experiences;
  523.     }
  525.     public function addExperience(Experience $experience): self
  526.     {
  527.         if (!$this->experiences->contains($experience)) {
  528.             $this->experiences->add($experience);
  529.             $experience->setUser($this);
  530.         }
  532.         return $this;
  533.     }
  535.     public function removeExperience(Experience $experience): self
  536.     {
  537.         if ($this->experiences->removeElement($experience)) {
  538.             // set the owning side to null (unless already changed)
  539.             if ($experience->getUser() === $this) {
  540.                 $experience->setUser(null);
  541.             }
  542.         }
  544.         return $this;
  545.     }
  547.     public function getPoste(): ?string
  548.     {
  549.         return $this->poste;
  550.     }
  552.     public function setPoste(?string $poste): self
  553.     {
  554.         $this->poste = $poste;
  556.         return $this;
  557.     }
  559.     /**
  560.      * @return Collection<int, Formation>
  561.      */
  562.     public function getFormations(): Collection
  563.     {
  564.         return $this->formations;
  565.     }
  567.     public function addFormation(Formation $formation): self
  568.     {
  569.         if (!$this->formations->contains($formation)) {
  570.             $this->formations->add($formation);
  571.             $formation->setFormateur($this);
  572.         }
  574.         return $this;
  575.     }
  577.     public function removeFormation(Formation $formation): self
  578.     {
  579.         if ($this->formations->removeElement($formation)) {
  580.             // set the owning side to null (unless already changed)
  581.             if ($formation->getFormateur() === $this) {
  582.                 $formation->setFormateur(null);
  583.             }
  584.         }
  586.         return $this;
  587.     }
  589.     public function getPays(): ?string
  590.     {
  591.         return $this->pays;
  592.     }
  594.     public function setPays(?string $pays): self
  595.     {
  596.         $this->pays = $pays;
  598.         return $this;
  599.     }
  601.     public function getType(): ?string
  602.     {
  603.         return $this->type;
  604.     }
  606.     public function setType(?string $type): self
  607.     {
  608.         $this->type = $type;
  610.         return $this;
  611.     }
  613.     public function getResponsable(): ?string
  614.     {
  615.         return $this->responsable;
  616.     }
  618.     public function setResponsable(?string $responsable): self
  619.     {
  620.         $this->responsable = $responsable;
  622.         return $this;
  623.     }
  625.     /**
  626.      * @return Collection<int, InscritSession>
  627.      */
  628.     public function getInscritSessions(): Collection
  629.     {
  630.         return $this->inscritSessions;
  631.     }
  633.     public function addInscritSession(InscritSession $inscritSession): self
  634.     {
  635.         if (!$this->inscritSessions->contains($inscritSession)) {
  636.             $this->inscritSessions->add($inscritSession);
  637.             $inscritSession->setStagiaire($this);
  638.         }
  640.         return $this;
  641.     }
  643.     public function removeInscritSession(InscritSession $inscritSession): self
  644.     {
  645.         if ($this->inscritSessions->removeElement($inscritSession)) {
  646.             // set the owning side to null (unless already changed)
  647.             if ($inscritSession->getStagiaire() === $this) {
  648.                 $inscritSession->setStagiaire(null);
  649.             }
  650.         }
  652.         return $this;
  653.     }
  656. //    public function getMessageinscrit(): ?Messageinscrit
  657. //    {
  658. //        return $this->messageinscrit;
  659. //    }
  660. //
  661. //    public function setMessageinscrit(?Messageinscrit $messageinscrit): self
  662. //    {
  663. //        $this->messageinscrit = $messageinscrit;
  664. //
  665. //        return $this;
  666. //    }
  668.     /**
  669.      * @return Collection<int, Messageinscrit>
  670.      */
  671.     public function getMessageinscrits(): Collection
  672.     {
  673.         return $this->messageinscrits;
  674.     }
  676.     public function addMessageinscrit(Messageinscrit $messageinscrit): self
  677.     {
  678.         if (!$this->messageinscrits->contains($messageinscrit)) {
  679.             $this->messageinscrits->add($messageinscrit);
  680.             $messageinscrit->setUser($this);
  681.         }
  683.         return $this;
  684.     }
  686.     public function removeMessageinscrit(Messageinscrit $messageinscrit): self
  687.     {
  688.         if ($this->messageinscrits->removeElement($messageinscrit)) {
  689.             // set the owning side to null (unless already changed)
  690.             if ($messageinscrit->getUser() === $this) {
  691.                 $messageinscrit->setUser(null);
  692.             }
  693.         }
  695.         return $this;
  696.     }
  698.     public function getSiteweb(): ?string
  699.     {
  700.         return $this->siteweb;
  701.     }
  703.     public function setSiteweb(?string $siteweb): self
  704.     {
  705.         $this->siteweb = $siteweb;
  707.         return $this;
  708.     }
  710.     public function getGithub(): ?string
  711.     {
  712.         return $this->github;
  713.     }
  715.     public function setGithub(?string $github): self
  716.     {
  717.         $this->github = $github;
  719.         return $this;
  720.     }
  722.     public function getTwitter(): ?string
  723.     {
  724.         return $this->twitter;
  725.     }
  727.     public function setTwitter(?string $twitter): self
  728.     {
  729.         $this->twitter = $twitter;
  731.         return $this;
  732.     }
  736.     /**
  737.      * @return Collection<int, Reclamation>
  738.      */
  739.     public function getReclamations(): Collection
  740.     {
  741.         return $this->reclamations;
  742.     }
  744.     public function addReclamation(Reclamation $reclamation): self
  745.     {
  746.         if (!$this->reclamations->contains($reclamation)) {
  747.             $this->reclamations->add($reclamation);
  748.             $reclamation->setUser($this);
  749.         }
  751.         return $this;
  752.     }
  754.     public function removeReclamation(Reclamation $reclamation): self
  755.     {
  756.         if ($this->reclamations->removeElement($reclamation)) {
  757.             // set the owning side to null (unless already changed)
  758.             if ($reclamation->getUser() === $this) {
  759.                 $reclamation->setUser(null);
  760.             }
  761.         }
  763.         return $this;
  764.     }
  766.     /**
  767.      * @return Collection<int, Evaluation>
  768.      */
  769.     public function getEvaluations(): Collection
  770.     {
  771.         return $this->evaluations;
  772.     }
  774.     public function addEvaluation(Evaluation $evaluation): self
  775.     {
  776.         if (!$this->evaluations->contains($evaluation)) {
  777.             $this->evaluations->add($evaluation);
  778.             $evaluation->setUser($this);
  779.         }
  781.         return $this;
  782.     }
  784.     public function removeEvaluation(Evaluation $evaluation): self
  785.     {
  786.         if ($this->evaluations->removeElement($evaluation)) {
  787.             // set the owning side to null (unless already changed)
  788.             if ($evaluation->getUser() === $this) {
  789.                 $evaluation->setUser(null);
  790.             }
  791.         }
  793.         return $this;
  794.     }
  796.     /**
  797.      * @return Collection<int, Evenement>
  798.      */
  799.     public function getEvenements(): Collection
  800.     {
  801.         return $this->evenements;
  802.     }
  804.     public function addEvenement(Evenement $evenement): self
  805.     {
  806.         if (!$this->evenements->contains($evenement)) {
  807.             $this->evenements->add($evenement);
  808.             $evenement->setFormateur($this);
  809.         }
  811.         return $this;
  812.     }
  814.     public function removeEvenement(Evenement $evenement): self
  815.     {
  816.         if ($this->evenements->removeElement($evenement)) {
  817.             // set the owning side to null (unless already changed)
  818.             if ($evenement->getFormateur() === $this) {
  819.                 $evenement->setFormateur(null);
  820.             }
  821.         }
  823.         return $this;
  824.     }
  826.     /**
  827.      * @return Collection<int, VirtualClassroom>
  828.      */
  829.     public function getVirtualClassrooms(): Collection
  830.     {
  831.         return $this->virtualClassrooms;
  832.     }
  834.     public function addVirtualClassroom(VirtualClassroom $virtualClassroom): self
  835.     {
  836.         if (!$this->virtualClassrooms->contains($virtualClassroom)) {
  837.             $this->virtualClassrooms->add($virtualClassroom);
  838.             $virtualClassroom->setFormateur($this);
  839.         }
  841.         return $this;
  842.     }
  844.     public function removeVirtualClassroom(VirtualClassroom $virtualClassroom): self
  845.     {
  846.         if ($this->virtualClassrooms->removeElement($virtualClassroom)) {
  847.             // set the owning side to null (unless already changed)
  848.             if ($virtualClassroom->getFormateur() === $this) {
  849.                 $virtualClassroom->setFormateur(null);
  850.             }
  851.         }
  853.         return $this;
  854.     }
  856.     /**
  857.      * @return Collection<int, Reponsereclamation>
  858.      */
  859.     public function getReponsereclamations(): Collection
  860.     {
  861.         return $this->reponsereclamations;
  862.     }
  864.     public function addReponsereclamation(Reponsereclamation $reponsereclamation): self
  865.     {
  866.         if (!$this->reponsereclamations->contains($reponsereclamation)) {
  867.             $this->reponsereclamations->add($reponsereclamation);
  868.             $reponsereclamation->setDestinataire($this);
  869.         }
  871.         return $this;
  872.     }
  874.     public function removeReponsereclamation(Reponsereclamation $reponsereclamation): self
  875.     {
  876.         if ($this->reponsereclamations->removeElement($reponsereclamation)) {
  877.             // set the owning side to null (unless already changed)
  878.             if ($reponsereclamation->getDestinataire() === $this) {
  879.                 $reponsereclamation->setDestinataire(null);
  880.             }
  881.         }
  883.         return $this;
  884.     }
  886.     public function isVue(): ?bool
  887.     {
  888.         return $this->vue;
  889.     }
  891.     public function setVue(?bool $vue): self
  892.     {
  893.         $this->vue = $vue;
  895.         return $this;
  896.     }
  899.     /**
  900.      * @return Collection<int, Offresinscrit>
  901.      */
  902.     public function getOffresinscrits(): Collection
  903.     {
  904.         return $this->offresinscrits;
  905.     }
  907.     public function addOffresinscrit(Offresinscrit $offresinscrit): self
  908.     {
  909.         if (!$this->offresinscrits->contains($offresinscrit)) {
  910.             $this->offresinscrits->add($offresinscrit);
  911.             $offresinscrit->setRelationus($this);
  912.         }
  914.         return $this;
  915.     }
  917.     public function removeOffresinscrit(Offresinscrit $offresinscrit): self
  918.     {
  919.         if ($this->offresinscrits->removeElement($offresinscrit)) {
  920.             // set the owning side to null (unless already changed)
  921.             if ($offresinscrit->getRelationus() === $this) {
  922.                 $offresinscrit->setRelationus(null);
  923.             }
  924.         }
  926.         return $this;
  927.     }
  929.     /**
  930.      * @return Collection<int, Reponsemessage>
  931.      */
  932.     public function getReponsemessages(): Collection
  933.     {
  934.         return $this->reponsemessages;
  935.     }
  937.     public function addReponsemessage(Reponsemessage $reponsemessage): self
  938.     {
  939.         if (!$this->reponsemessages->contains($reponsemessage)) {
  940.             $this->reponsemessages->add($reponsemessage);
  941.             $reponsemessage->setDestinataire($this);
  942.         }
  944.         return $this;
  945.     }
  947.     public function removeReponsemessage(Reponsemessage $reponsemessage): self
  948.     {
  949.         if ($this->reponsemessages->removeElement($reponsemessage)) {
  950.             // set the owning side to null (unless already changed)
  951.             if ($reponsemessage->getDestinataire() === $this) {
  952.                 $reponsemessage->setDestinataire(null);
  953.             }
  954.         }
  956.         return $this;
  957.     }
  959.     public function getDate(): ?\DateTimeInterface
  960.     {
  961.         return $this->date;
  962.     }
  964.     public function setDate(?\DateTimeInterface $date): self
  965.     {
  966.         $this->date = $date;
  968.         return $this;
  969.     }
  971.     public function getVu(): ?string
  972.     {
  973.         return $this->vu;
  974.     }
  976.     public function setVu(?string $vu): self
  977.     {
  978.         $this->vu = $vu;
  980.         return $this;
  981.     }
  983.     /**
  984.      * @return Collection<int, Demmandeformation>
  985.      */
  986.     public function getDemmandeformations(): Collection
  987.     {
  988.         return $this->demmandeformations;
  989.     }
  991.     public function addDemmandeformation(Demmandeformation $demmandeformation): self
  992.     {
  993.         if (!$this->demmandeformations->contains($demmandeformation)) {
  994.             $this->demmandeformations->add($demmandeformation);
  995.             $demmandeformation->setUser($this);
  996.         }
  998.         return $this;
  999.     }
  1001.     public function removeDemmandeformation(Demmandeformation $demmandeformation): self
  1002.     {
  1003.         if ($this->demmandeformations->removeElement($demmandeformation)) {
  1004.             // set the owning side to null (unless already changed)
  1005.             if ($demmandeformation->getUser() === $this) {
  1006.                 $demmandeformation->setUser(null);
  1007.             }
  1008.         }
  1010.         return $this;
  1011.     }
  1013.     /**
  1014.      * @return Collection<int, Demandeprofil>
  1015.      */
  1016.     public function getDemandeprofils(): Collection
  1017.     {
  1018.         return $this->demandeprofils;
  1019.     }
  1021.     public function addDemandeprofil(Demandeprofil $demandeprofil): self
  1022.     {
  1023.         if (!$this->demandeprofils->contains($demandeprofil)) {
  1024.             $this->demandeprofils->add($demandeprofil);
  1025.             $demandeprofil->setUser($this);
  1026.         }
  1028.         return $this;
  1029.     }
  1031.     public function removeDemandeprofil(Demandeprofil $demandeprofil): self
  1032.     {
  1033.         if ($this->demandeprofils->removeElement($demandeprofil)) {
  1034.             // set the owning side to null (unless already changed)
  1035.             if ($demandeprofil->getUser() === $this) {
  1036.                 $demandeprofil->setUser(null);
  1037.             }
  1038.         }
  1040.         return $this;
  1041.     }
  1043.     /**
  1044.      * @return Collection<int, ReponseDemandeFormation>
  1045.      */
  1046.     public function getReponseDemandeFormations(): Collection
  1047.     {
  1048.         return $this->reponseDemandeFormations;
  1049.     }
  1051.     public function addReponseDemandeFormation(ReponseDemandeFormation $reponseDemandeFormation): self
  1052.     {
  1053.         if (!$this->reponseDemandeFormations->contains($reponseDemandeFormation)) {
  1054.             $this->reponseDemandeFormations->add($reponseDemandeFormation);
  1055.             $reponseDemandeFormation->setExpediteur($this);
  1056.         }
  1058.         return $this;
  1059.     }
  1061.     public function removeReponseDemandeFormation(ReponseDemandeFormation $reponseDemandeFormation): self
  1062.     {
  1063.         if ($this->reponseDemandeFormations->removeElement($reponseDemandeFormation)) {
  1064.             // set the owning side to null (unless already changed)
  1065.             if ($reponseDemandeFormation->getExpediteur() === $this) {
  1066.                 $reponseDemandeFormation->setExpediteur(null);
  1067.             }
  1068.         }
  1070.         return $this;
  1071.     }
  1073.     /**
  1074.      * @return Collection<int, ReponseDemandeFormation>
  1075.      */
  1076.     public function getReponseDemandeFormationsdest(): Collection
  1077.     {
  1078.         return $this->reponseDemandeFormationsdest;
  1079.     }
  1081.     public function addReponseDemandeFormationsdest(ReponseDemandeFormation $reponseDemandeFormationsdest): self
  1082.     {
  1083.         if (!$this->reponseDemandeFormationsdest->contains($reponseDemandeFormationsdest)) {
  1084.             $this->reponseDemandeFormationsdest->add($reponseDemandeFormationsdest);
  1085.             $reponseDemandeFormationsdest->setDestinataire($this);
  1086.         }
  1088.         return $this;
  1089.     }
  1091.     public function removeReponseDemandeFormationsdest(ReponseDemandeFormation $reponseDemandeFormationsdest): self
  1092.     {
  1093.         if ($this->reponseDemandeFormationsdest->removeElement($reponseDemandeFormationsdest)) {
  1094.             // set the owning side to null (unless already changed)
  1095.             if ($reponseDemandeFormationsdest->getDestinataire() === $this) {
  1096.                 $reponseDemandeFormationsdest->setDestinataire(null);
  1097.             }
  1098.         }
  1100.         return $this;
  1101.     }
  1103.     /**
  1104.      * @return Collection<int, Emailsadmin>
  1105.      */
  1106.     public function getEmailsadmins(): Collection
  1107.     {
  1108.         return $this->emailsadmins;
  1109.     }
  1111.     public function addEmailsadmin(Emailsadmin $emailsadmin): self
  1112.     {
  1113.         if (!$this->emailsadmins->contains($emailsadmin)) {
  1114.             $this->emailsadmins->add($emailsadmin);
  1115.             $emailsadmin->setUser($this);
  1116.         }
  1118.         return $this;
  1119.     }
  1121.     public function removeEmailsadmin(Emailsadmin $emailsadmin): self
  1122.     {
  1123.         if ($this->emailsadmins->removeElement($emailsadmin)) {
  1124.             // set the owning side to null (unless already changed)
  1125.             if ($emailsadmin->getUser() === $this) {
  1126.                 $emailsadmin->setUser(null);
  1127.             }
  1128.         }
  1130.         return $this;
  1131.     }
  1133.     /**
  1134.      * @return Collection<int, TacheAssistant>
  1135.      */
  1136.     public function getTaches(): Collection
  1137.     {
  1138.         return $this->taches;
  1139.     }
  1141.     public function addTach(TacheAssistant $tach): self
  1142.     {
  1143.         if (!$this->taches->contains($tach)) {
  1144.             $this->taches->add($tach);
  1145.         }
  1147.         return $this;
  1148.     }
  1150.     public function removeTach(TacheAssistant $tach): self
  1151.     {
  1152.         $this->taches->removeElement($tach);
  1154.         return $this;
  1155.     }
  1158.     /**
  1159.      * @return Collection<int, Trace>
  1160.      */
  1161.     public function getTraces(): Collection
  1162.     {
  1163.         return $this->traces;
  1164.     }
  1166.     public function addTrace(Trace $trace): self
  1167.     {
  1168.         if (!$this->traces->contains($trace)) {
  1169.             $this->traces->add($trace);
  1170.         }
  1172.         return $this;
  1173.     }
  1175.     public function removeTrace(Trace $trace): self
  1176.     {
  1177.         $this->traces->removeElement($trace);
  1179.         return $this;
  1180.     }
  1182.     public function getIpadress(): ?string
  1183.     {
  1184.         return $this->ipadress;
  1185.     }
  1187.     public function setIpadress(?string $ipadress): self
  1188.     {
  1189.         $this->ipadress = $ipadress;
  1191.         return $this;
  1192.     }
  1194.     /**
  1195.      * @return Collection<int, EmailStudent>
  1196.      */
  1197.     public function getEmailStudents(): Collection
  1198.     {
  1199.         return $this->emailStudents;
  1200.     }
  1202.     public function addEmailStudent(EmailStudent $emailStudent): self
  1203.     {
  1204.         if (!$this->emailStudents->contains($emailStudent)) {
  1205.             $this->emailStudents->add($emailStudent);
  1206.             $emailStudent->setStudent($this);
  1207.         }
  1209.         return $this;
  1210.     }
  1212.     public function removeEmailStudent(EmailStudent $emailStudent): self
  1213.     {
  1214.         if ($this->emailStudents->removeElement($emailStudent)) {
  1215.             // set the owning side to null (unless already changed)
  1216.             if ($emailStudent->getStudent() === $this) {
  1217.                 $emailStudent->setStudent(null);
  1218.             }
  1219.         }
  1221.         return $this;
  1222.     }
  1224.     /**
  1225.      * @return Collection<int, Signature>
  1226.      */
  1227.     public function getSignatures(): Collection
  1228.     {
  1229.         return $this->signatures;
  1230.     }
  1232.     public function addSignature(Signature $signature): self
  1233.     {
  1234.         if (!$this->signatures->contains($signature)) {
  1235.             $this->signatures->add($signature);
  1236.             $signature->setUser($this);
  1237.         }
  1239.         return $this;
  1240.     }
  1242.     public function removeSignature(Signature $signature): self
  1243.     {
  1244.         if ($this->signatures->removeElement($signature)) {
  1245.             // set the owning side to null (unless already changed)
  1246.             if ($signature->getUser() === $this) {
  1247.                 $signature->setUser(null);
  1248.             }
  1249.         }
  1251.         return $this;
  1252.     }
  1254.     /**
  1255.      * @return Collection<int, Ipadresse>
  1256.      */
  1257.     public function getIpadresses(): Collection
  1258.     {
  1259.         return $this->ipadresses;
  1260.     }
  1262.     public function addIpadress(Ipadresse $ipadress): self
  1263.     {
  1264.         if (!$this->ipadresses->contains($ipadress)) {
  1265.             $this->ipadresses->add($ipadress);
  1266.             $ipadress->setUser($this);
  1267.         }
  1269.         return $this;
  1270.     }
  1272.     public function removeIpadress(Ipadresse $ipadress): self
  1273.     {
  1274.         if ($this->ipadresses->removeElement($ipadress)) {
  1275.             // set the owning side to null (unless already changed)
  1276.             if ($ipadress->getUser() === $this) {
  1277.                 $ipadress->setUser(null);
  1278.             }
  1279.         }
  1281.         return $this;
  1282.     }
  1284.     public function isIsActive(): ?bool
  1285.     {
  1286.         return $this->isActive;
  1287.     }
  1289.     public function setIsActive(?bool $isActive): self
  1290.     {
  1291.         $this->isActive = $isActive;
  1293.         return $this;
  1294.     }
  1296.     /**
  1297.      * @return Collection<int, FormationElearning>
  1298.      */
  1299.     public function getFormationElearnings(): Collection
  1300.     {
  1301.         return $this->formationElearnings;
  1302.     }
  1304.     public function addFormationElearning(FormationElearning $formationElearning): self
  1305.     {
  1306.         if (!$this->formationElearnings->contains($formationElearning)) {
  1307.             $this->formationElearnings->add($formationElearning);
  1308.             $formationElearning->setFormateur($this);
  1309.         }
  1311.         return $this;
  1312.     }
  1314.     public function removeFormationElearning(FormationElearning $formationElearning): self
  1315.     {
  1316.         if ($this->formationElearnings->removeElement($formationElearning)) {
  1317.             // set the owning side to null (unless already changed)
  1318.             if ($formationElearning->getFormateur() === $this) {
  1319.                 $formationElearning->setFormateur(null);
  1320.             }
  1321.         }
  1323.         return $this;
  1324.     }
  1326.     /**
  1327.      * @return Collection<int, Commande>
  1328.      */
  1329.     public function getCommandes(): Collection
  1330.     {
  1331.         return $this->commandes;
  1332.     }
  1334.     public function addCommande(Commande $commande): self
  1335.     {
  1336.         if (!$this->commandes->contains($commande)) {
  1337.             $this->commandes->add($commande);
  1338.             $commande->setUser($this);
  1339.         }
  1341.         return $this;
  1342.     }
  1344.     public function removeCommande(Commande $commande): self
  1345.     {
  1346.         if ($this->commandes->removeElement($commande)) {
  1347.             // set the owning side to null (unless already changed)
  1348.             if ($commande->getUser() === $this) {
  1349.                 $commande->setUser(null);
  1350.             }
  1351.         }
  1353.         return $this;
  1354.     }
  1356.     /**
  1357.      * @return Collection<int, EvaluationElearning>
  1358.      */
  1359.     public function getEvaluationElearnings(): Collection
  1360.     {
  1361.         return $this->evaluationElearnings;
  1362.     }
  1364.     public function addEvaluationElearning(EvaluationElearning $evaluationElearning): self
  1365.     {
  1366.         if (!$this->evaluationElearnings->contains($evaluationElearning)) {
  1367.             $this->evaluationElearnings->add($evaluationElearning);
  1368.             $evaluationElearning->setUser($this);
  1369.         }
  1371.         return $this;
  1372.     }
  1374.     public function removeEvaluationElearning(EvaluationElearning $evaluationElearning): self
  1375.     {
  1376.         if ($this->evaluationElearnings->removeElement($evaluationElearning)) {
  1377.             // set the owning side to null (unless already changed)
  1378.             if ($evaluationElearning->getUser() === $this) {
  1379.                 $evaluationElearning->setUser(null);
  1380.             }
  1381.         }
  1383.         return $this;
  1384.     }
  1386.     public function getNomsociete(): ?string
  1387.     {
  1388.         return $this->nomsociete;
  1389.     }
  1391.     public function setNomsociete(?string $nomsociete): self
  1392.     {
  1393.         $this->nomsociete = $nomsociete;
  1395.         return $this;
  1396.     }
  1398.     public function getAdressesociete(): ?string
  1399.     {
  1400.         return $this->adressesociete;
  1401.     }
  1403.     public function setAdressesociete(?string $adressesociete): self
  1404.     {
  1405.         $this->adressesociete = $adressesociete;
  1407.         return $this;
  1408.     }
  1410.     public function getMatricule(): ?string
  1411.     {
  1412.         return $this->matricule;
  1413.     }
  1415.     public function setMatricule(?string $matricule): self
  1416.     {
  1417.         $this->matricule = $matricule;
  1419.         return $this;
  1420.     }
  1422.     /**
  1423.      * @return Collection<int, CommentElearning>
  1424.      */
  1425.     public function getCommentElearnings(): Collection
  1426.     {
  1427.         return $this->commentElearnings;
  1428.     }
  1430.     public function addCommentElearning(CommentElearning $commentElearning): self
  1431.     {
  1432.         if (!$this->commentElearnings->contains($commentElearning)) {
  1433.             $this->commentElearnings->add($commentElearning);
  1434.             $commentElearning->setUser($this);
  1435.         }
  1437.         return $this;
  1438.     }
  1440.     public function removeCommentElearning(CommentElearning $commentElearning): self
  1441.     {
  1442.         if ($this->commentElearnings->removeElement($commentElearning)) {
  1443.             // set the owning side to null (unless already changed)
  1444.             if ($commentElearning->getUser() === $this) {
  1445.                 $commentElearning->setUser(null);
  1446.             }
  1447.         }
  1449.         return $this;
  1450.     }
  1452.     /**
  1453.      * @return Collection<int, CommentElearning>
  1454.      */
  1455.     public function getCommentLikes(): Collection
  1456.     {
  1457.         return $this->commentLikes;
  1458.     }
  1460.     public function addCommentLike(CommentElearning $commentLike): self
  1461.     {
  1462.         if (!$this->commentLikes->contains($commentLike)) {
  1463.             $this->commentLikes->add($commentLike);
  1464.             $commentLike->addLikedBy($this);
  1465.         }
  1467.         return $this;
  1468.     }
  1470.     public function removeCommentLike(CommentElearning $commentLike): self
  1471.     {
  1472.         if ($this->commentLikes->removeElement($commentLike)) {
  1473.             $commentLike->removeLikedBy($this);
  1474.         }
  1476.         return $this;
  1477.     }
  1479.     /**
  1480.      * @return Collection<int, ChatFormation>
  1481.      */
  1482.     public function getChatFormations(): Collection
  1483.     {
  1484.         return $this->chatFormations;
  1485.     }
  1487.     public function addChatFormation(ChatFormation $chatFormation): self
  1488.     {
  1489.         if (!$this->chatFormations->contains($chatFormation)) {
  1490.             $this->chatFormations->add($chatFormation);
  1491.             $chatFormation->setSender($this);
  1492.         }
  1494.         return $this;
  1495.     }
  1497.     public function removeChatFormation(ChatFormation $chatFormation): self
  1498.     {
  1499.         if ($this->chatFormations->removeElement($chatFormation)) {
  1500.             // set the owning side to null (unless already changed)
  1501.             if ($chatFormation->getSender() === $this) {
  1502.                 $chatFormation->setSender(null);
  1503.             }
  1504.         }
  1506.         return $this;
  1507.     }
  1509.     /**
  1510.      * @return Collection<int, Coupon>
  1511.      */
  1512.     public function getCoupons(): Collection
  1513.     {
  1514.         return $this->coupons;
  1515.     }
  1517.     public function addCoupon(Coupon $coupon): self
  1518.     {
  1519.         if (!$this->coupons->contains($coupon)) {
  1520.             $this->coupons->add($coupon);
  1521.             $coupon->setUser($this);
  1522.         }
  1524.         return $this;
  1525.     }
  1527.     public function removeCoupon(Coupon $coupon): self
  1528.     {
  1529.         if ($this->coupons->removeElement($coupon)) {
  1530.             // set the owning side to null (unless already changed)
  1531.             if ($coupon->getUser() === $this) {
  1532.                 $coupon->setUser(null);
  1533.             }
  1534.         }
  1536.         return $this;
  1537.     }
  1544. }