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;
  13. /**
  14.  * @ORM\Entity(repositoryClass=UserRepository::class)
  15.  * @ORM\Table(name="Users")
  16.  * @UniqueEntity(fields={"email"}, message="There is already an account with this email")
  17.  * @ORM\HasLifecycleCallbacks()
  18.  */
  19. class User implements UserInterface, PasswordAuthenticatedUserInterface
  20. {
  21.     /**
  22.      * @ORM\Id
  23.      * @ORM\GeneratedValue
  24.      * @ORM\Column(type="integer")
  25.      */
  26.     private $id;
  28.     /**
  29.      * @ORM\Column(type="string", length=180, unique=true)
  30.      */
  31.     private $email;
  33.     /**
  34.      * @ORM\Column(type="json")
  35.      */
  36.     private $roles = [];
  38.     /**
  39.      * @var string The hashed password
  40.      * @ORM\Column(type="string")
  41.      */
  42.     private $password;
  45.     /**
  46.      * @ORM\Column(type="string", length=255)
  47.      */
  48.     private $nom;
  50.     /**
  51.      * @ORM\Column(type="string", length=255)
  52.      */
  53.     private $prenom;
  55.     /**
  56.      * @ORM\Column(type="string", length=15)
  57.      */
  58.     private $tel;
  60.     /**
  61.      * @ORM\Column(type="integer")
  62.      */
  63.     private $civilite;
  65.     /**
  66.      * @ORM\Column(type="boolean")
  67.      */
  68.     private $status;
  70.     /**
  71.      * @ORM\Column(type="datetime")
  72.      */
  73.     private $created_at;
  75.     /**
  76.      * @ORM\Column(type="datetime", nullable=true)
  77.      */
  78.     private $updated_at;
  80.     /**
  81.      * @ORM\ManyToOne(targetEntity="App\Entity\Pays", inversedBy="users")
  82.      */
  83.     private $pays;
  85.     /**
  86.      * @ORM\OneToMany(targetEntity="App\Entity\Loginattemp", mappedBy="user", orphanRemoval=true)
  87.      */
  88.     private $loginattemps;
  90.     /**
  91.      * @ORM\OneToMany(targetEntity="App\Entity\Tracking", mappedBy="user")
  92.      */
  93.     private $trackings;
  95.     /**
  96.      * @ORM\OneToMany(targetEntity="App\Entity\Evenement", mappedBy="user")
  97.      */
  98.     private $evenements;
  100.     /**
  101.      * @ORM\OneToMany(targetEntity="App\Entity\News", mappedBy="user")
  102.      */
  103.     private $news;
  105.     /**
  106.      * @ORM\OneToMany(targetEntity="App\Entity\Formation", mappedBy="user", orphanRemoval=true)
  107.      */
  108.     private $formations;
  110.     /**
  111.      * @ORM\OneToMany(targetEntity="App\Entity\ChapitreFormation", mappedBy="user")
  112.      */
  113.     private $chapitresFormation;
  115.     /**
  116.      * @ORM\OneToMany(targetEntity="App\Entity\FichierFormation", mappedBy="user")
  117.      */
  118.     private $fichierFormations;
  120.     /**
  121.      * @ORM\OneToMany(targetEntity="App\Entity\Video", mappedBy="user")
  122.      */
  123.     private $videos;
  125.     /**
  126.      * @ORM\OneToMany(targetEntity=ResetPassword::class, mappedBy="user")
  127.      */
  128.     private $resetPasswords;
  130.     /**
  131.      * @ORM\OneToMany(targetEntity=NewsletterTypeUsers::class, mappedBy="user", orphanRemoval=true)
  132.      */
  133.     private $newsletterTypeUsers;
  135.     /**
  136.      * @ORM\Column(type="string", length=255, nullable=true)
  137.      */
  138.     private $avatar;
  140.     /**
  141.      * @ORM\OneToMany(targetEntity=Package::class, mappedBy="user")
  142.      */
  143.     private $packages;
  145.     /**
  146.      * @ORM\OneToMany(targetEntity=Souscription::class, mappedBy="user", orphanRemoval=true)
  147.      */
  148.     private $souscriptions;
  150.     /**
  151.      * @ORM\OneToMany(targetEntity=Facture::class, mappedBy="user")
  152.      */
  153.     private $factures;
  155.     /**
  156.      * @ORM\OneToMany(targetEntity=UserSubscription::class, mappedBy="user")
  157.      */
  158.     private $userSubscriptions;
  160.     /**
  161.      * @ORM\Column(type="string", length=255, nullable=true)
  162.      */
  163.     private $profil;
  165.     /**
  166.      * @ORM\Column(type="string", length=255, nullable=true)
  167.      */
  168.     private $societe;
  170.     /**
  171.      * @ORM\Column(type="integer", nullable=true)
  172.      */
  173.     private $categorie;
  175.     /**
  176.      * @ORM\OneToMany(targetEntity=Update::class, mappedBy="user")
  177.      */
  178.     private $updates;
  180.     /**
  181.      * @ORM\OneToMany(targetEntity=UserBookmark::class, mappedBy="user", orphanRemoval=true)
  182.      */
  183.     private $bookmarks;
  186.     const civilites = ['M','Mme','Mlle'],
  187.         civilites_long =['Monsieur','Madame','Mademoiselle'];
  190.     /**
  191.      * User constructor. setting status to true
  192.      */
  193.     function __construct()
  194.     {
  195.         $this->status=true;
  196.         $this->roles = ['ROLE_USER'];
  197.         $this->created_at=new \DateTime();
  198.         $this->loginattemps = new ArrayCollection();
  199.         $this->trackings = new ArrayCollection();
  200.         $this->evenements = new ArrayCollection();
  201.         $this->news = new ArrayCollection();
  202.         $this->formations = new ArrayCollection();
  203.         $this->chapitresFormation = new ArrayCollection();
  204.         $this->fichierFormations = new ArrayCollection();
  205.         $this->videos = new ArrayCollection();
  206.         $this->resetPasswords = new ArrayCollection();
  207.         $this->newsletterTypeUsers = new ArrayCollection();
  208.         $this->packages = new ArrayCollection();
  209.         $this->souscriptions = new ArrayCollection();
  210.         $this->factures = new ArrayCollection();
  211.         $this->userSubscriptions = new ArrayCollection();
  212.         $this->updates = new ArrayCollection();
  213.         $this->bookmarks = new ArrayCollection();
  214.     }
  216.     public function getId(): ?int
  217.     {
  218.         return $this->id;
  219.     }
  221.     public function getEmail(): ?string
  222.     {
  223.         return $this->email;
  224.     }
  226.     public function setEmail(string $email): self
  227.     {
  228.         $this->email = $email;
  230.         return $this;
  231.     }
  233.     /**
  234.      * A visual identifier that represents this user.
  235.      *
  236.      * @see UserInterface
  237.      */
  238.     public function getUsername(): string
  239. //    public function getUserIdentifier(): string
  240.     {
  241.         return (string) $this->email;
  242.     }
  244.     /**
  245.      * @see UserInterface
  246.      */
  247.     public function getroles(): array
  248.     {
  249.         $roles=$this->roles;
  250.         $roles[] = 'ROLE_USER';
  252.         return array_unique($roles);
  253.     }
  255.     public function getFullRole(): string
  256.     {
  257.         if(in_array('ROLE_SUPER_ADMIN',$this->roles)){
  258.             return "Super Admin";
  259.         }else if(in_array('ROLE_TECH',$this->roles)){
  260.             return "Technicien";
  261.         }else if(in_array('ROLE_ADMIN',$this->roles)){
  262.             return "Editeur";
  263.         }else return "Membre";
  265.     }
  267.     public function setroles(array $roles): self
  268.     {
  269.         $this->roles = $roles;
  271.         return $this;
  272.     }
  274.     /**
  275.      * @see UserInterface
  276.      */
  277.     public function getPassword(): string
  278.     {
  279.         return (string) $this->password;
  280.     }
  282.     public function setPassword(string $password): self
  283.     {
  284.         $this->password = $password;
  286.         return $this;
  287.     }
  289.     /**
  290.      * @see UserInterface
  291.      *
  292.      * @return String
  293.      */
  294.     public function getSalt()
  295.     {
  296.         // not needed when using the "bcrypt" algorithm in security.yaml
  297.     }
  299.     /**
  300.      * @see UserInterface
  301.      */
  302.     public function eraseCredentials()
  303.     {
  304.         // If you store any temporary, sensitive data on the user, clear it here
  305.         // $this->plainPassword = null;
  306.     }
  308.     public function getNom(): ?string
  309.     {
  310.         return $this->nom;
  311.     }
  313.     public function setNom(string $nom): self
  314.     {
  315.         $this->nom = $nom;
  317.         return $this;
  318.     }
  320.     public function getPrenom(): ?string
  321.     {
  322.         return $this->prenom;
  323.     }
  325.     public function setPrenom(string $prenom): self
  326.     {
  327.         $this->prenom = $prenom;
  329.         return $this;
  330.     }
  332.     public function getTel(): ?string
  333.     {
  334.         return $this->tel;
  335.     }
  337.     public function setTel(string $tel): self
  338.     {
  339.         $this->tel = $tel;
  341.         return $this;
  342.     }
  344.     public function getCivilite(): ?int
  345.     {
  346.         return $this->civilite;
  347.     }
  349.     public function getFullCivilite(): ?string
  350.     {
  351.         return self::civilites[$this->civilite];
  352.     }
  353.     public function getFullCiviliteLong(): ?string
  354.     {
  355.         return self::civilites_long[$this->civilite];
  356.     }
  360.     public function setCivilite(int $civilite): self
  361.     {
  362.         $this->civilite = $civilite;
  364.         return $this;
  365.     }
  367.     public function getStatus(): ?bool
  368.     {
  369.         return $this->status;
  370.     }
  372.     public function setStatus(bool $status): self
  373.     {
  374.         $this->status = $status;
  376.         return $this;
  377.     }
  379.     public function getCreatedAt(): ?\DateTimeInterface
  380.     {
  381.         return $this->created_at;
  382.     }
  384.     public function setCreatedAt(\DateTimeInterface $created_at): self
  385.     {
  386.         $this->created_at = $created_at;
  388.         return $this;
  389.     }
  391.     public function getUpdatedAt(): ?\DateTimeInterface
  392.     {
  393.         return $this->updated_at;
  394.     }
  396.     public function setUpdatedAt(?\DateTimeInterface $updated_at): self
  397.     {
  398.         $this->updated_at = $updated_at;
  400.         return $this;
  401.     }
  404.     //privates ---------------<
  406.     /**
  407.      * @ORM\PrePersist
  408.      */
  409.     private function setPreCreated(){
  410.         $this->status=true;
  411.         $this->roles = 'ROLE_USER';
  412.         $this->created_at=new \DateTime();
  413.     }
  415.     /**
  416.      * @ORM\PreUpdate
  417.      */
  418.     private function setPreUpdate(){
  419.         $this->updated_at=new \DateTime();
  420.     }
  422.     public function getPays(): ?Pays
  423.     {
  424.         return $this->pays;
  425.     }
  427.     public function setPays(?Pays $pays): self
  428.     {
  429.         $this->pays = $pays;
  431.         return $this;
  432.     }
  434.     /**
  435.      * @return Collection|Loginattemp[]
  436.      */
  437.     public function getLoginattemps(): Collection
  438.     {
  439.         return $this->loginattemps;
  440.     }
  442.     public function addLoginattemp(Loginattemp $loginattemp): self
  443.     {
  444.         if (!$this->loginattemps->contains($loginattemp)) {
  445.             $this->loginattemps[] = $loginattemp;
  446.             $loginattemp->setUser($this);
  447.         }
  449.         return $this;
  450.     }
  452.     public function removeLoginattemp(Loginattemp $loginattemp): self
  453.     {
  454.         if ($this->loginattemps->contains($loginattemp)) {
  455.             $this->loginattemps->removeElement($loginattemp);
  456.             // set the owning side to null (unless already changed)
  457.             if ($loginattemp->getUser() === $this) {
  458.                 $loginattemp->setUser(null);
  459.             }
  460.         }
  462.         return $this;
  463.     }
  465.     /**
  466.      * @return Collection|Tracking[]
  467.      */
  468.     public function getTrackings(): Collection
  469.     {
  470.         return $this->trackings;
  471.     }
  473.     public function addTracking(Tracking $tracking): self
  474.     {
  475.         if (!$this->trackings->contains($tracking)) {
  476.             $this->trackings[] = $tracking;
  477.             $tracking->setUser($this);
  478.         }
  480.         return $this;
  481.     }
  483.     public function removeTracking(Tracking $tracking): self
  484.     {
  485.         if ($this->trackings->contains($tracking)) {
  486.             $this->trackings->removeElement($tracking);
  487.             // set the owning side to null (unless already changed)
  488.             if ($tracking->getUser() === $this) {
  489.                 $tracking->setUser(null);
  490.             }
  491.         }
  493.         return $this;
  494.     }
  496.     /**
  497.      * @return Collection|Evenement[]
  498.      */
  499.     public function getEvenements(): Collection
  500.     {
  501.         return $this->evenements;
  502.     }
  504.     public function addEvenement(Evenement $evenement): self
  505.     {
  506.         if (!$this->evenements->contains($evenement)) {
  507.             $this->evenements[] = $evenement;
  508.             $evenement->setUser($this);
  509.         }
  511.         return $this;
  512.     }
  514.     public function removeEvenement(Evenement $evenement): self
  515.     {
  516.         if ($this->evenements->contains($evenement)) {
  517.             $this->evenements->removeElement($evenement);
  518.             // set the owning side to null (unless already changed)
  519.             if ($evenement->getUser() === $this) {
  520.                 $evenement->setUser(null);
  521.             }
  522.         }
  524.         return $this;
  525.     }
  527.     /**
  528.      * @return Collection|News[]
  529.      */
  530.     public function getNews(): Collection
  531.     {
  532.         return $this->news;
  533.     }
  535.     public function addNews(News $news): self
  536.     {
  537.         if (!$this->news->contains($news)) {
  538.             $this->news[] = $news;
  539.             $news->setUser($this);
  540.         }
  542.         return $this;
  543.     }
  545.     public function removeNews(News $news): self
  546.     {
  547.         if ($this->news->contains($news)) {
  548.             $this->news->removeElement($news);
  549.             // set the owning side to null (unless already changed)
  550.             if ($news->getUser() === $this) {
  551.                 $news->setUser(null);
  552.             }
  553.         }
  555.         return $this;
  556.     }
  558.     /**
  559.      * @return Collection|Formation[]
  560.      */
  561.     public function getFormations(): Collection
  562.     {
  563.         return $this->formations;
  564.     }
  566.     public function addFormation(Formation $formation): self
  567.     {
  568.         if (!$this->formations->contains($formation)) {
  569.             $this->formations[] = $formation;
  570.             $formation->setUser($this);
  571.         }
  573.         return $this;
  574.     }
  576.     public function removeFormation(Formation $formation): self
  577.     {
  578.         if ($this->formations->contains($formation)) {
  579.             $this->formations->removeElement($formation);
  580.             // set the owning side to null (unless already changed)
  581.             if ($formation->getUser() === $this) {
  582.                 $formation->setUser(null);
  583.             }
  584.         }
  586.         return $this;
  587.     }
  589.     /**
  590.      * @return Collection|ChapitreFormation[]
  591.      */
  592.     public function getChapitresFormation(): Collection
  593.     {
  594.         return $this->chapitresFormation;
  595.     }
  597.     public function addChapitresFormation(ChapitreFormation $chapitresFormation): self
  598.     {
  599.         if (!$this->chapitresFormation->contains($chapitresFormation)) {
  600.             $this->chapitresFormation[] = $chapitresFormation;
  601.             $chapitresFormation->setUser($this);
  602.         }
  604.         return $this;
  605.     }
  607.     public function removeChapitresFormation(ChapitreFormation $chapitresFormation): self
  608.     {
  609.         if ($this->chapitresFormation->contains($chapitresFormation)) {
  610.             $this->chapitresFormation->removeElement($chapitresFormation);
  611.             // set the owning side to null (unless already changed)
  612.             if ($chapitresFormation->getUser() === $this) {
  613.                 $chapitresFormation->setUser(null);
  614.             }
  615.         }
  617.         return $this;
  618.     }
  620.     /**
  621.      * @return Collection|FichierFormation[]
  622.      */
  623.     public function getFichierFormations(): Collection
  624.     {
  625.         return $this->fichierFormations;
  626.     }
  628.     public function addFichierFormation(FichierFormation $fichierFormation): self
  629.     {
  630.         if (!$this->fichierFormations->contains($fichierFormation)) {
  631.             $this->fichierFormations[] = $fichierFormation;
  632.             $fichierFormation->setUser($this);
  633.         }
  635.         return $this;
  636.     }
  638.     public function removeFichierFormation(FichierFormation $fichierFormation): self
  639.     {
  640.         if ($this->fichierFormations->contains($fichierFormation)) {
  641.             $this->fichierFormations->removeElement($fichierFormation);
  642.             // set the owning side to null (unless already changed)
  643.             if ($fichierFormation->getUser() === $this) {
  644.                 $fichierFormation->setUser(null);
  645.             }
  646.         }
  648.         return $this;
  649.     }
  651.     /**
  652.      * @return Collection|Video[]
  653.      */
  654.     public function getVideos(): Collection
  655.     {
  656.         return $this->videos;
  657.     }
  659.     public function addVideo(Video $video): self
  660.     {
  661.         if (!$this->videos->contains($video)) {
  662.             $this->videos[] = $video;
  663.             $video->setUser($this);
  664.         }
  666.         return $this;
  667.     }
  669.     public function removeVideo(Video $video): self
  670.     {
  671.         if ($this->videos->contains($video)) {
  672.             $this->videos->removeElement($video);
  673.             // set the owning side to null (unless already changed)
  674.             if ($video->getUser() === $this) {
  675.                 $video->setUser(null);
  676.             }
  677.         }
  679.         return $this;
  680.     }
  682.     /**
  683.      * @return Collection|ResetPassword[]
  684.      */
  685.     public function getResetPasswords(): Collection
  686.     {
  687.         return $this->resetPasswords;
  688.     }
  690.     public function addResetPassword(ResetPassword $resetPassword): self
  691.     {
  692.         if (!$this->resetPasswords->contains($resetPassword)) {
  693.             $this->resetPasswords[] = $resetPassword;
  694.             $resetPassword->setUser($this);
  695.         }
  697.         return $this;
  698.     }
  700.     public function removeResetPassword(ResetPassword $resetPassword): self
  701.     {
  702.         if ($this->resetPasswords->contains($resetPassword)) {
  703.             $this->resetPasswords->removeElement($resetPassword);
  704.             // set the owning side to null (unless already changed)
  705.             if ($resetPassword->getUser() === $this) {
  706.                 $resetPassword->setUser(null);
  707.             }
  708.         }
  710.         return $this;
  711.     }
  713.     /**
  714.      * @return Collection|NewsletterTypeUsers[]
  715.      */
  716.     public function getNewsletterTypeUsers(): Collection
  717.     {
  718.         return $this->newsletterTypeUsers;
  719.     }
  721.     public function addNewsletterTypeUser(NewsletterTypeUsers $newsletterTypeUser): self
  722.     {
  723.         if (!$this->newsletterTypeUsers->contains($newsletterTypeUser)) {
  724.             $this->newsletterTypeUsers[] = $newsletterTypeUser;
  725.             $newsletterTypeUser->setUser($this);
  726.         }
  728.         return $this;
  729.     }
  731.     public function removeNewsletterTypeUser(NewsletterTypeUsers $newsletterTypeUser): self
  732.     {
  733.         if ($this->newsletterTypeUsers->contains($newsletterTypeUser)) {
  734.             $this->newsletterTypeUsers->removeElement($newsletterTypeUser);
  735.             // set the owning side to null (unless already changed)
  736.             if ($newsletterTypeUser->getUser() === $this) {
  737.                 $newsletterTypeUser->setUser(null);
  738.             }
  739.         }
  741.         return $this;
  742.     }
  744.     public function getAvatar(): ?string
  745.     {
  746.         return $this->avatar;
  747.     }
  749.     public function setAvatar(?string $avatar): self
  750.     {
  751.         $this->avatar = $avatar;
  753.         return $this;
  754.     }
  756.     /**
  757.      * @return Collection|Package[]
  758.      */
  759.     public function getPackages(): Collection
  760.     {
  761.         return $this->packages;
  762.     }
  764.     public function addPackage(Package $package): self
  765.     {
  766.         if (!$this->packages->contains($package)) {
  767.             $this->packages[] = $package;
  768.             $package->setUser($this);
  769.         }
  771.         return $this;
  772.     }
  774.     public function removePackage(Package $package): self
  775.     {
  776.         if ($this->packages->contains($package)) {
  777.             $this->packages->removeElement($package);
  778.             // set the owning side to null (unless already changed)
  779.             if ($package->getUser() === $this) {
  780.                 $package->setUser(null);
  781.             }
  782.         }
  784.         return $this;
  785.     }
  787.     /**
  788.      * @return Collection|Souscription[]
  789.      */
  790.     public function getSouscriptions(): Collection
  791.     {
  792.         return $this->souscriptions;
  793.     }
  795.     public function addSouscription(Souscription $souscription): self
  796.     {
  797.         if (!$this->souscriptions->contains($souscription)) {
  798.             $this->souscriptions[] = $souscription;
  799.             $souscription->setUser($this);
  800.         }
  802.         return $this;
  803.     }
  805.     public function removeSouscription(Souscription $souscription): self
  806.     {
  807.         if ($this->souscriptions->contains($souscription)) {
  808.             $this->souscriptions->removeElement($souscription);
  809.             // set the owning side to null (unless already changed)
  810.             if ($souscription->getUser() === $this) {
  811.                 $souscription->setUser(null);
  812.             }
  813.         }
  815.         return $this;
  816.     }
  818.     /**
  819.      * @return Collection|Facture[]
  820.      */
  821.     public function getFactures(): Collection
  822.     {
  823.         return $this->factures;
  824.     }
  826.     public function addFacture(Facture $facture): self
  827.     {
  828.         if (!$this->factures->contains($facture)) {
  829.             $this->factures[] = $facture;
  830.             $facture->setUser($this);
  831.         }
  833.         return $this;
  834.     }
  836.     public function removeFacture(Facture $facture): self
  837.     {
  838.         if ($this->factures->contains($facture)) {
  839.             $this->factures->removeElement($facture);
  840.             // set the owning side to null (unless already changed)
  841.             if ($facture->getUser() === $this) {
  842.                 $facture->setUser(null);
  843.             }
  844.         }
  846.         return $this;
  847.     }
  849.     /**
  850.      * @return Collection|UserSubscription[]
  851.      */
  852.     public function getUserSubscriptions(): Collection
  853.     {
  854.         return $this->userSubscriptions;
  855.     }
  857.     public function addUserSubscription(UserSubscription $userSubscription): self
  858.     {
  859.         if (!$this->userSubscriptions->contains($userSubscription)) {
  860.             $this->userSubscriptions[] = $userSubscription;
  861.             $userSubscription->setUser($this);
  862.         }
  864.         return $this;
  865.     }
  867.     public function removeUserSubscription(UserSubscription $userSubscription): self
  868.     {
  869.         if ($this->userSubscriptions->contains($userSubscription)) {
  870.             $this->userSubscriptions->removeElement($userSubscription);
  871.             // set the owning side to null (unless already changed)
  872.             if ($userSubscription->getUser() === $this) {
  873.                 $userSubscription->setUser(null);
  874.             }
  875.         }
  877.         return $this;
  878.     }
  880.     public function getProfil(): ?string
  881.     {
  882.         return $this->profil;
  883.     }
  885.     public function setProfil(?string $profil): self
  886.     {
  887.         $this->profil = $profil;
  889.         return $this;
  890.     }
  892.     public function getSociete(): ?string
  893.     {
  894.         return $this->societe;
  895.     }
  897.     public function setSociete(?string $societe): self
  898.     {
  899.         $this->societe = $societe;
  901.         return $this;
  902.     }
  904.     public function getCategorie(): ?int
  905.     {
  906.         return $this->categorie;
  907.     }
  909.     public function setCategorie(?int $categorie): self
  910.     {
  911.         $this->categorie = $categorie;
  913.         return $this;
  914.     }
  916.     /**
  917.      * @return Collection|Update[]
  918.      */
  919.     public function getUpdates(): Collection
  920.     {
  921.         return $this->updates;
  922.     }
  924.     public function addUpdate(Update $update): self
  925.     {
  926.         if (!$this->updates->contains($update)) {
  927.             $this->updates[] = $update;
  928.             $update->setUser($this);
  929.         }
  931.         return $this;
  932.     }
  934.     public function removeUpdate(Update $update): self
  935.     {
  936.         if ($this->updates->removeElement($update)) {
  937.             // set the owning side to null (unless already changed)
  938.             if ($update->getUser() === $this) {
  939.                 $update->setUser(null);
  940.             }
  941.         }
  943.         return $this;
  944.     }
  946.     /**
  947.      * @return Collection|UserBookmark[]
  948.      */
  949.     public function getBookmarks(): Collection
  950.     {
  951.         return $this->bookmarks;
  952.     }
  954.     public function addBookmark(UserBookmark $bookmark): self
  955.     {
  956.         if (!$this->bookmarks->contains($bookmark)) {
  957.             $this->bookmarks[] = $bookmark;
  958.             $bookmark->setUser($this);
  959.         }
  961.         return $this;
  962.     }
  964.     public function removeBookmark(UserBookmark $bookmark): self
  965.     {
  966.         if ($this->bookmarks->removeElement($bookmark)) {
  967.             // set the owning side to null (unless already changed)
  968.             if ($bookmark->getUser() === $this) {
  969.                 $bookmark->setUser(null);
  970.             }
  971.         }
  973.         return $this;
  974.     }
  976. }