src\Entity\User.php line 17

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;
  13. #[ORM\Table(name: 'Users')]
  14. #[ORM\Entity(repositoryClass: UserRepository::class)]
  15. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  16. #[ORM\HasLifecycleCallbacks]
  17. class User implements UserInterface, PasswordAuthenticatedUserInterface
  18. {
  19.     #[ORM\Id]
  20.     #[ORM\GeneratedValue]
  21.     #[ORM\Column(type: 'integer')]
  22.     private $id;
  24.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  25.     private $email;
  27.     #[ORM\Column(type: 'json')]
  28.     private $roles = [];
  30.     /**
  31.      * @var string The hashed password
  32.      */
  33.     #[ORM\Column(type: 'string')]
  34.     private $password;
  37.     #[ORM\Column(type: 'string', length: 255)]
  38.     private $nom;
  40.     #[ORM\Column(type: 'string', length: 255)]
  41.     private $prenom;
  43.     #[ORM\Column(type: 'string', length: 15)]
  44.     private $tel;
  46.     #[ORM\Column(type: 'integer')]
  47.     private $civilite;
  49.     #[ORM\Column(type: 'boolean')]
  50.     private $status;
  52.     #[ORM\Column(type: 'datetime')]
  53.     private $created_at;
  55.     #[ORM\Column(type: 'datetime', nullable: true)]
  56.     private $updated_at;
  58.     #[ORM\ManyToOne(targetEntity: \App\Entity\Pays::class, inversedBy: 'users')]
  59.     private $pays;
  61.     #[ORM\OneToMany(targetEntity: \App\Entity\Loginattemp::class, mappedBy: 'user', orphanRemoval: true)]
  62.     private $loginattemps;
  64.     #[ORM\OneToMany(targetEntity: \App\Entity\Tracking::class, mappedBy: 'user')]
  65.     private $trackings;
  67.     #[ORM\OneToMany(targetEntity: \App\Entity\Evenement::class, mappedBy: 'user')]
  68.     private $evenements;
  70.     #[ORM\OneToMany(targetEntity: \App\Entity\News::class, mappedBy: 'user')]
  71.     private $news;
  73.     #[ORM\OneToMany(targetEntity: \App\Entity\Formation::class, mappedBy: 'user', orphanRemoval: true)]
  74.     private $formations;
  76.     #[ORM\OneToMany(targetEntity: \App\Entity\ChapitreFormation::class, mappedBy: 'user')]
  77.     private $chapitresFormation;
  79.     #[ORM\OneToMany(targetEntity: \App\Entity\FichierFormation::class, mappedBy: 'user')]
  80.     private $fichierFormations;
  82.     #[ORM\OneToMany(targetEntity: \App\Entity\Video::class, mappedBy: 'user')]
  83.     private $videos;
  85.     #[ORM\OneToMany(targetEntity: ResetPassword::class, mappedBy: 'user')]
  86.     private $resetPasswords;
  88.     #[ORM\OneToMany(targetEntity: NewsletterTypeUsers::class, mappedBy: 'user', orphanRemoval: true)]
  89.     private $newsletterTypeUsers;
  91.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  92.     private $avatar;
  94.     #[ORM\OneToMany(targetEntity: Package::class, mappedBy: 'user')]
  95.     private $packages;
  97.     #[ORM\OneToMany(targetEntity: Souscription::class, mappedBy: 'user', orphanRemoval: true)]
  98.     private $souscriptions;
  100.     #[ORM\OneToMany(targetEntity: Facture::class, mappedBy: 'user')]
  101.     private $factures;
  103.     #[ORM\OneToMany(targetEntity: UserSubscription::class, mappedBy: 'user')]
  104.     private $userSubscriptions;
  106.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  107.     private $profil;
  109.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  110.     private $societe;
  112.     #[ORM\Column(type: 'integer', nullable: true)]
  113.     private $categorie;
  115.     #[ORM\OneToMany(targetEntity: Update::class, mappedBy: 'user')]
  116.     private $updates;
  118.     #[ORM\OneToMany(targetEntity: UserBookmark::class, mappedBy: 'user', orphanRemoval: true)]
  119.     private $bookmarks;
  122.     const civilites = ['M','Mme','Mlle'],
  123.         civilites_long =['Monsieur','Madame','Mademoiselle'];
  126.     /**
  127.      * User constructor. setting status to true
  128.      */
  129.     function __construct()
  130.     {
  131.         $this->status=true;
  132.         $this->roles = ['ROLE_USER'];
  133.         $this->created_at=new \DateTime();
  134.         $this->loginattemps = new ArrayCollection();
  135.         $this->trackings = new ArrayCollection();
  136.         $this->evenements = new ArrayCollection();
  137.         $this->news = new ArrayCollection();
  138.         $this->formations = new ArrayCollection();
  139.         $this->chapitresFormation = new ArrayCollection();
  140.         $this->fichierFormations = new ArrayCollection();
  141.         $this->videos = new ArrayCollection();
  142.         $this->resetPasswords = new ArrayCollection();
  143.         $this->newsletterTypeUsers = new ArrayCollection();
  144.         $this->packages = new ArrayCollection();
  145.         $this->souscriptions = new ArrayCollection();
  146.         $this->factures = new ArrayCollection();
  147.         $this->userSubscriptions = new ArrayCollection();
  148.         $this->updates = new ArrayCollection();
  149.         $this->bookmarks = new ArrayCollection();
  150.     }
  152.     public function getId(): ?int
  153.     {
  154.         return $this->id;
  155.     }
  157.     public function getEmail(): ?string
  158.     {
  159.         return $this->email;
  160.     }
  162.     public function setEmail(string $email): self
  163.     {
  164.         $this->email = $email;
  166.         return $this;
  167.     }
  169.     /**
  170.      * A visual identifier that represents this user.
  171.      *
  172.      * @see UserInterface
  173.      */
  174.     public function getUsername(): string
  175. //    public function getUserIdentifier(): string
  176.     {
  177.         return (string) $this->email;
  178.     }
  180.     /**
  181.      * @see UserInterface
  182.      */
  183.     public function getroles(): array
  184.     {
  185.         $roles=$this->roles;
  186.         $roles[] = 'ROLE_USER';
  188.         return array_unique($roles);
  189.     }
  191.     public function getFullRole(): string
  192.     {
  193.         if(in_array('ROLE_SUPER_ADMIN',$this->roles)){
  194.             return "Super Admin";
  195.         }else if(in_array('ROLE_TECH',$this->roles)){
  196.             return "Technicien";
  197.         }else if(in_array('ROLE_ADMIN',$this->roles)){
  198.             return "Editeur";
  199.         }else return "Membre";
  201.     }
  203.     public function setroles(array $roles): self
  204.     {
  205.         $this->roles = $roles;
  207.         return $this;
  208.     }
  210.     /**
  211.      * @see UserInterface
  212.      */
  213.     public function getPassword(): string
  214.     {
  215.         return (string) $this->password;
  216.     }
  218.     public function setPassword(string $password): self
  219.     {
  220.         $this->password = $password;
  222.         return $this;
  223.     }
  225.     /**
  226.      * @see UserInterface
  227.      *
  228.      * @return String
  229.      */
  230.     public function getSalt()
  231.     {
  232.         // not needed when using the "bcrypt" algorithm in security.yaml
  233.     }
  235.     /**
  236.      * @see UserInterface
  237.      */
  238.     public function eraseCredentials()
  239.     {
  240.         // If you store any temporary, sensitive data on the user, clear it here
  241.         // $this->plainPassword = null;
  242.     }
  244.     public function getNom(): ?string
  245.     {
  246.         return $this->nom;
  247.     }
  249.     public function setNom(string $nom): self
  250.     {
  251.         $this->nom = $nom;
  253.         return $this;
  254.     }
  256.     public function getPrenom(): ?string
  257.     {
  258.         return $this->prenom;
  259.     }
  261.     public function setPrenom(string $prenom): self
  262.     {
  263.         $this->prenom = $prenom;
  265.         return $this;
  266.     }
  268.     public function getTel(): ?string
  269.     {
  270.         return $this->tel;
  271.     }
  273.     public function setTel(string $tel): self
  274.     {
  275.         $this->tel = $tel;
  277.         return $this;
  278.     }
  280.     public function getCivilite(): ?int
  281.     {
  282.         return $this->civilite;
  283.     }
  285.     public function getFullCivilite(): ?string
  286.     {
  287.         return self::civilites[$this->civilite];
  288.     }
  289.     public function getFullCiviliteLong(): ?string
  290.     {
  291.         return self::civilites_long[$this->civilite];
  292.     }
  296.     public function setCivilite(int $civilite): self
  297.     {
  298.         $this->civilite = $civilite;
  300.         return $this;
  301.     }
  303.     public function getStatus(): ?bool
  304.     {
  305.         return $this->status;
  306.     }
  308.     public function setStatus(bool $status): self
  309.     {
  310.         $this->status = $status;
  312.         return $this;
  313.     }
  315.     public function getCreatedAt(): ?\DateTimeInterface
  316.     {
  317.         return $this->created_at;
  318.     }
  320.     public function setCreatedAt(\DateTimeInterface $created_at): self
  321.     {
  322.         $this->created_at = $created_at;
  324.         return $this;
  325.     }
  327.     public function getUpdatedAt(): ?\DateTimeInterface
  328.     {
  329.         return $this->updated_at;
  330.     }
  332.     public function setUpdatedAt(?\DateTimeInterface $updated_at): self
  333.     {
  334.         $this->updated_at = $updated_at;
  336.         return $this;
  337.     }
  340.     //privates ---------------<
  341.     #[ORM\PrePersist]
  342.     private function setPreCreated(){
  343.         $this->status=true;
  344.         $this->roles = 'ROLE_USER';
  345.         $this->created_at=new \DateTime();
  346.     }
  348.     #[ORM\PreUpdate]
  349.     private function setPreUpdate(){
  350.         $this->updated_at=new \DateTime();
  351.     }
  353.     public function getPays(): ?Pays
  354.     {
  355.         return $this->pays;
  356.     }
  358.     public function setPays(?Pays $pays): self
  359.     {
  360.         $this->pays = $pays;
  362.         return $this;
  363.     }
  365.     /**
  366.      * @return Collection|Loginattemp[]
  367.      */
  368.     public function getLoginattemps(): Collection
  369.     {
  370.         return $this->loginattemps;
  371.     }
  373.     public function addLoginattemp(Loginattemp $loginattemp): self
  374.     {
  375.         if (!$this->loginattemps->contains($loginattemp)) {
  376.             $this->loginattemps[] = $loginattemp;
  377.             $loginattemp->setUser($this);
  378.         }
  380.         return $this;
  381.     }
  383.     public function removeLoginattemp(Loginattemp $loginattemp): self
  384.     {
  385.         if ($this->loginattemps->contains($loginattemp)) {
  386.             $this->loginattemps->removeElement($loginattemp);
  387.             // set the owning side to null (unless already changed)
  388.             if ($loginattemp->getUser() === $this) {
  389.                 $loginattemp->setUser(null);
  390.             }
  391.         }
  393.         return $this;
  394.     }
  396.     /**
  397.      * @return Collection|Tracking[]
  398.      */
  399.     public function getTrackings(): Collection
  400.     {
  401.         return $this->trackings;
  402.     }
  404.     public function addTracking(Tracking $tracking): self
  405.     {
  406.         if (!$this->trackings->contains($tracking)) {
  407.             $this->trackings[] = $tracking;
  408.             $tracking->setUser($this);
  409.         }
  411.         return $this;
  412.     }
  414.     public function removeTracking(Tracking $tracking): self
  415.     {
  416.         if ($this->trackings->contains($tracking)) {
  417.             $this->trackings->removeElement($tracking);
  418.             // set the owning side to null (unless already changed)
  419.             if ($tracking->getUser() === $this) {
  420.                 $tracking->setUser(null);
  421.             }
  422.         }
  424.         return $this;
  425.     }
  427.     /**
  428.      * @return Collection|Evenement[]
  429.      */
  430.     public function getEvenements(): Collection
  431.     {
  432.         return $this->evenements;
  433.     }
  435.     public function addEvenement(Evenement $evenement): self
  436.     {
  437.         if (!$this->evenements->contains($evenement)) {
  438.             $this->evenements[] = $evenement;
  439.             $evenement->setUser($this);
  440.         }
  442.         return $this;
  443.     }
  445.     public function removeEvenement(Evenement $evenement): self
  446.     {
  447.         if ($this->evenements->contains($evenement)) {
  448.             $this->evenements->removeElement($evenement);
  449.             // set the owning side to null (unless already changed)
  450.             if ($evenement->getUser() === $this) {
  451.                 $evenement->setUser(null);
  452.             }
  453.         }
  455.         return $this;
  456.     }
  458.     /**
  459.      * @return Collection|News[]
  460.      */
  461.     public function getNews(): Collection
  462.     {
  463.         return $this->news;
  464.     }
  466.     public function addNews(News $news): self
  467.     {
  468.         if (!$this->news->contains($news)) {
  469.             $this->news[] = $news;
  470.             $news->setUser($this);
  471.         }
  473.         return $this;
  474.     }
  476.     public function removeNews(News $news): self
  477.     {
  478.         if ($this->news->contains($news)) {
  479.             $this->news->removeElement($news);
  480.             // set the owning side to null (unless already changed)
  481.             if ($news->getUser() === $this) {
  482.                 $news->setUser(null);
  483.             }
  484.         }
  486.         return $this;
  487.     }
  489.     /**
  490.      * @return Collection|Formation[]
  491.      */
  492.     public function getFormations(): Collection
  493.     {
  494.         return $this->formations;
  495.     }
  497.     public function addFormation(Formation $formation): self
  498.     {
  499.         if (!$this->formations->contains($formation)) {
  500.             $this->formations[] = $formation;
  501.             $formation->setUser($this);
  502.         }
  504.         return $this;
  505.     }
  507.     public function removeFormation(Formation $formation): self
  508.     {
  509.         if ($this->formations->contains($formation)) {
  510.             $this->formations->removeElement($formation);
  511.             // set the owning side to null (unless already changed)
  512.             if ($formation->getUser() === $this) {
  513.                 $formation->setUser(null);
  514.             }
  515.         }
  517.         return $this;
  518.     }
  520.     /**
  521.      * @return Collection|ChapitreFormation[]
  522.      */
  523.     public function getChapitresFormation(): Collection
  524.     {
  525.         return $this->chapitresFormation;
  526.     }
  528.     public function addChapitresFormation(ChapitreFormation $chapitresFormation): self
  529.     {
  530.         if (!$this->chapitresFormation->contains($chapitresFormation)) {
  531.             $this->chapitresFormation[] = $chapitresFormation;
  532.             $chapitresFormation->setUser($this);
  533.         }
  535.         return $this;
  536.     }
  538.     public function removeChapitresFormation(ChapitreFormation $chapitresFormation): self
  539.     {
  540.         if ($this->chapitresFormation->contains($chapitresFormation)) {
  541.             $this->chapitresFormation->removeElement($chapitresFormation);
  542.             // set the owning side to null (unless already changed)
  543.             if ($chapitresFormation->getUser() === $this) {
  544.                 $chapitresFormation->setUser(null);
  545.             }
  546.         }
  548.         return $this;
  549.     }
  551.     /**
  552.      * @return Collection|FichierFormation[]
  553.      */
  554.     public function getFichierFormations(): Collection
  555.     {
  556.         return $this->fichierFormations;
  557.     }
  559.     public function addFichierFormation(FichierFormation $fichierFormation): self
  560.     {
  561.         if (!$this->fichierFormations->contains($fichierFormation)) {
  562.             $this->fichierFormations[] = $fichierFormation;
  563.             $fichierFormation->setUser($this);
  564.         }
  566.         return $this;
  567.     }
  569.     public function removeFichierFormation(FichierFormation $fichierFormation): self
  570.     {
  571.         if ($this->fichierFormations->contains($fichierFormation)) {
  572.             $this->fichierFormations->removeElement($fichierFormation);
  573.             // set the owning side to null (unless already changed)
  574.             if ($fichierFormation->getUser() === $this) {
  575.                 $fichierFormation->setUser(null);
  576.             }
  577.         }
  579.         return $this;
  580.     }
  582.     /**
  583.      * @return Collection|Video[]
  584.      */
  585.     public function getVideos(): Collection
  586.     {
  587.         return $this->videos;
  588.     }
  590.     public function addVideo(Video $video): self
  591.     {
  592.         if (!$this->videos->contains($video)) {
  593.             $this->videos[] = $video;
  594.             $video->setUser($this);
  595.         }
  597.         return $this;
  598.     }
  600.     public function removeVideo(Video $video): self
  601.     {
  602.         if ($this->videos->contains($video)) {
  603.             $this->videos->removeElement($video);
  604.             // set the owning side to null (unless already changed)
  605.             if ($video->getUser() === $this) {
  606.                 $video->setUser(null);
  607.             }
  608.         }
  610.         return $this;
  611.     }
  613.     /**
  614.      * @return Collection|ResetPassword[]
  615.      */
  616.     public function getResetPasswords(): Collection
  617.     {
  618.         return $this->resetPasswords;
  619.     }
  621.     public function addResetPassword(ResetPassword $resetPassword): self
  622.     {
  623.         if (!$this->resetPasswords->contains($resetPassword)) {
  624.             $this->resetPasswords[] = $resetPassword;
  625.             $resetPassword->setUser($this);
  626.         }
  628.         return $this;
  629.     }
  631.     public function removeResetPassword(ResetPassword $resetPassword): self
  632.     {
  633.         if ($this->resetPasswords->contains($resetPassword)) {
  634.             $this->resetPasswords->removeElement($resetPassword);
  635.             // set the owning side to null (unless already changed)
  636.             if ($resetPassword->getUser() === $this) {
  637.                 $resetPassword->setUser(null);
  638.             }
  639.         }
  641.         return $this;
  642.     }
  644.     /**
  645.      * @return Collection|NewsletterTypeUsers[]
  646.      */
  647.     public function getNewsletterTypeUsers(): Collection
  648.     {
  649.         return $this->newsletterTypeUsers;
  650.     }
  652.     public function addNewsletterTypeUser(NewsletterTypeUsers $newsletterTypeUser): self
  653.     {
  654.         if (!$this->newsletterTypeUsers->contains($newsletterTypeUser)) {
  655.             $this->newsletterTypeUsers[] = $newsletterTypeUser;
  656.             $newsletterTypeUser->setUser($this);
  657.         }
  659.         return $this;
  660.     }
  662.     public function removeNewsletterTypeUser(NewsletterTypeUsers $newsletterTypeUser): self
  663.     {
  664.         if ($this->newsletterTypeUsers->contains($newsletterTypeUser)) {
  665.             $this->newsletterTypeUsers->removeElement($newsletterTypeUser);
  666.             // set the owning side to null (unless already changed)
  667.             if ($newsletterTypeUser->getUser() === $this) {
  668.                 $newsletterTypeUser->setUser(null);
  669.             }
  670.         }
  672.         return $this;
  673.     }
  675.     public function getAvatar(): ?string
  676.     {
  677.         return $this->avatar;
  678.     }
  680.     public function setAvatar(?string $avatar): self
  681.     {
  682.         $this->avatar = $avatar;
  684.         return $this;
  685.     }
  687.     /**
  688.      * @return Collection|Package[]
  689.      */
  690.     public function getPackages(): Collection
  691.     {
  692.         return $this->packages;
  693.     }
  695.     public function addPackage(Package $package): self
  696.     {
  697.         if (!$this->packages->contains($package)) {
  698.             $this->packages[] = $package;
  699.             $package->setUser($this);
  700.         }
  702.         return $this;
  703.     }
  705.     public function removePackage(Package $package): self
  706.     {
  707.         if ($this->packages->contains($package)) {
  708.             $this->packages->removeElement($package);
  709.             // set the owning side to null (unless already changed)
  710.             if ($package->getUser() === $this) {
  711.                 $package->setUser(null);
  712.             }
  713.         }
  715.         return $this;
  716.     }
  718.     /**
  719.      * @return Collection|Souscription[]
  720.      */
  721.     public function getSouscriptions(): Collection
  722.     {
  723.         return $this->souscriptions;
  724.     }
  726.     public function addSouscription(Souscription $souscription): self
  727.     {
  728.         if (!$this->souscriptions->contains($souscription)) {
  729.             $this->souscriptions[] = $souscription;
  730.             $souscription->setUser($this);
  731.         }
  733.         return $this;
  734.     }
  736.     public function removeSouscription(Souscription $souscription): self
  737.     {
  738.         if ($this->souscriptions->contains($souscription)) {
  739.             $this->souscriptions->removeElement($souscription);
  740.             // set the owning side to null (unless already changed)
  741.             if ($souscription->getUser() === $this) {
  742.                 $souscription->setUser(null);
  743.             }
  744.         }
  746.         return $this;
  747.     }
  749.     /**
  750.      * @return Collection|Facture[]
  751.      */
  752.     public function getFactures(): Collection
  753.     {
  754.         return $this->factures;
  755.     }
  757.     public function addFacture(Facture $facture): self
  758.     {
  759.         if (!$this->factures->contains($facture)) {
  760.             $this->factures[] = $facture;
  761.             $facture->setUser($this);
  762.         }
  764.         return $this;
  765.     }
  767.     public function removeFacture(Facture $facture): self
  768.     {
  769.         if ($this->factures->contains($facture)) {
  770.             $this->factures->removeElement($facture);
  771.             // set the owning side to null (unless already changed)
  772.             if ($facture->getUser() === $this) {
  773.                 $facture->setUser(null);
  774.             }
  775.         }
  777.         return $this;
  778.     }
  780.     /**
  781.      * @return Collection|UserSubscription[]
  782.      */
  783.     public function getUserSubscriptions(): Collection
  784.     {
  785.         return $this->userSubscriptions;
  786.     }
  788.     public function addUserSubscription(UserSubscription $userSubscription): self
  789.     {
  790.         if (!$this->userSubscriptions->contains($userSubscription)) {
  791.             $this->userSubscriptions[] = $userSubscription;
  792.             $userSubscription->setUser($this);
  793.         }
  795.         return $this;
  796.     }
  798.     public function removeUserSubscription(UserSubscription $userSubscription): self
  799.     {
  800.         if ($this->userSubscriptions->contains($userSubscription)) {
  801.             $this->userSubscriptions->removeElement($userSubscription);
  802.             // set the owning side to null (unless already changed)
  803.             if ($userSubscription->getUser() === $this) {
  804.                 $userSubscription->setUser(null);
  805.             }
  806.         }
  808.         return $this;
  809.     }
  811.     public function getProfil(): ?string
  812.     {
  813.         return $this->profil;
  814.     }
  816.     public function setProfil(?string $profil): self
  817.     {
  818.         $this->profil = $profil;
  820.         return $this;
  821.     }
  823.     public function getSociete(): ?string
  824.     {
  825.         return $this->societe;
  826.     }
  828.     public function setSociete(?string $societe): self
  829.     {
  830.         $this->societe = $societe;
  832.         return $this;
  833.     }
  835.     public function getCategorie(): ?int
  836.     {
  837.         return $this->categorie;
  838.     }
  840.     public function setCategorie(?int $categorie): self
  841.     {
  842.         $this->categorie = $categorie;
  844.         return $this;
  845.     }
  847.     /**
  848.      * @return Collection|Update[]
  849.      */
  850.     public function getUpdates(): Collection
  851.     {
  852.         return $this->updates;
  853.     }
  855.     public function addUpdate(Update $update): self
  856.     {
  857.         if (!$this->updates->contains($update)) {
  858.             $this->updates[] = $update;
  859.             $update->setUser($this);
  860.         }
  862.         return $this;
  863.     }
  865.     public function removeUpdate(Update $update): self
  866.     {
  867.         if ($this->updates->removeElement($update)) {
  868.             // set the owning side to null (unless already changed)
  869.             if ($update->getUser() === $this) {
  870.                 $update->setUser(null);
  871.             }
  872.         }
  874.         return $this;
  875.     }
  877.     /**
  878.      * @return Collection|UserBookmark[]
  879.      */
  880.     public function getBookmarks(): Collection
  881.     {
  882.         return $this->bookmarks;
  883.     }
  885.     public function addBookmark(UserBookmark $bookmark): self
  886.     {
  887.         if (!$this->bookmarks->contains($bookmark)) {
  888.             $this->bookmarks[] = $bookmark;
  889.             $bookmark->setUser($this);
  890.         }
  892.         return $this;
  893.     }
  895.     public function removeBookmark(UserBookmark $bookmark): self
  896.     {
  897.         if ($this->bookmarks->removeElement($bookmark)) {
  898.             // set the owning side to null (unless already changed)
  899.             if ($bookmark->getUser() === $this) {
  900.                 $bookmark->setUser(null);
  901.             }
  902.         }
  904.         return $this;
  905.     }
  907. }