src/Entity/User.php line 36

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Actualites\Actualites;
  6. use App\Entity\Articles\Articles;
  7. use App\Entity\Common\IdTrait;
  8. use App\Entity\Hotels\Hotels;
  9. use App\Entity\Logs\Logs;
  10. use App\Entity\Posts\Posts;
  11. use App\Entity\Restaurants\Restaurants;
  12. use App\Entity\Salons\Salons;
  13. use DateTime;
  14. use DateTimeImmutable;
  15. use DateTimeInterface;
  16. use Doctrine\Common\Collections\ArrayCollection;
  17. use Doctrine\Common\Collections\Collection;
  18. use Exception;
  19. use Symfony\Component\HttpFoundation\File\File;
  20. use Symfony\Component\HttpFoundation\File\UploadedFile;
  21. use Symfony\Component\PasswordHasher\Hasher\PasswordHasherAwareInterface;
  22. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  23. use Symfony\Component\Validator\Constraints as Assert;
  24. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  25. use Gedmo\Mapping\Annotation as Gedmo;
  26. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  27. use Doctrine\ORM\Mapping as ORM;
  28. use Symfony\Component\Security\Core\User\UserInterface;
  30. /**
  31.  * @ORM\Entity(repositoryClass="App\Repository\UserRepository")
  32.  * @Vich\Uploadable
  33.  * @UniqueEntity("email", message="Cet utilisateur existe déjà, veuillez réessayer")
  34.  * @method string getUserIdentifier()
  35.  */
  36. class User implements UserInterface, PasswordHasherAwareInterface, PasswordAuthenticatedUserInterface
  37. {
  38.     const ROLES = [
  39.         'ROLE_SUPER_ADMIN' => 'Super administrateur',
  40.         'ROLE_ADMIN' => 'Administrateur',
  41.         'ROLE_USER' => 'Utilisateur',
  42.     ];
  44.     const ROLESPUBLIC = [
  45.         'ROLE_HOTELLERIE' => 'Hôtelleries',
  46.         'ROLE_RESTAURATION' => 'Restaurations',
  47.         'ROLE_AGENCEVOYAGE' => 'Agence de voyages',
  48.         'ROLE_LOISIR' => 'Loisirs',
  49.         'ROLE_TRANSPORT' => 'Transports',
  50.     ];
  52.     use IdTrait;
  54.     /**
  55.      * @ORM\Column(type="string", length=180, unique=true)
  56.      * @Assert\NotBlank(message="Veuillez saisir une adresse email")
  57.      * @Assert\Email(message="Veuillez saisir un email valide")
  58.      */
  59.     private $email;
  61.     /**
  62.      * @ORM\Column(type="array")
  63.      */
  64.     private $roles;
  66.     /**
  67.      * @var string
  68.      */
  69.     private $role;
  71.     /**
  72.      * @var string The hashed password
  73.      * @ORM\Column(type="string")
  74.      * @Assert\NotBlank(message="Veuillez saisir un mot de passe")
  75.      * @Assert\Length(min="6", minMessage="Votre mot de passe doit comporter au minimum 6 cataères")
  76.      */
  77.     private $password;
  79.     /**
  80.      * @ORM\Column(type="string", length=255)
  81.      * @Assert\NotBlank(message="Veuillez saisir un nom d'utilisateur")
  82.      */
  83.     private $username;
  85.     /**
  86.      * @ORM\Column(type="string", length=50, nullable=true)
  87.      * @Assert\NotBlank(message="Veuillez saisir un numéro de téléphone")
  88.      */
  89.     private $contacts;
  91.     /**
  92.      * @ORM\Column(type="string", length=255, nullable=true)
  93.      */
  94.     private $address;
  96.     /**
  97.      * NOTE: This is not a mapped field of entity metadata, just a simple property.
  98.      *
  99.      * @Vich\UploadableField(mapping="photos", fileNameProperty="filename")
  100.      * @var File|null
  101.      * @Assert\Image(
  102.      *     mimeTypes={"image/jpeg", "image/png"},
  103.      *     maxHeight=500,
  104.      *     maxWidth=600,
  105.      * )
  106.      */
  107.     private $imageFile;
  109.     /**
  110.      * @var string|null
  111.      * @ORM\Column(type="string", length=255, nullable=true)
  112.      */
  113.     private $filename;
  115.     /**
  116.      * @ORM\Column(type="boolean", options={"default": 0})
  117.      */
  118.     private $enabled;
  120.     /**
  121.      * @var DateTime $createdAt
  122.      * @ORM\Column(type="datetime")
  123.      *
  124.      * @Gedmo\Timestampable(on="create")
  125.      */
  126.     private $createdAt;
  128.     /**
  129.      * @var DateTime $updatedAt
  130.      * @ORM\Column(type="datetime", nullable=true)
  131.      *
  132.      * @Gedmo\Timestampable(on="update")
  133.      */
  134.     private $updatedAt;
  136.     /**
  137.      * @ORM\Column(type="datetime", nullable=true)
  138.      */
  139.     private $lastLogin;
  141.     /**
  142.      * @ORM\OneToMany(targetEntity="App\Entity\Actualites\Actualites", mappedBy="user")
  143.      */
  144.     private $actualites;
  146.     /**
  147.      * @ORM\Column(type="string", length=255, nullable=true)
  148.      * @Assert\NotBlank(message="Veuillez saisir votre nom de famille")
  149.      * @Assert\Length(
  150.      *     min="3", minMessage="Le nom doit comporter au minimum 3 cataères",
  151.      *     max="15", maxMessage="Le nom doit comporter au plus 15 cataères",
  152.      * )
  153.      */
  154.     private $nom;
  156.     /**
  157.      * @ORM\Column(type="string", length=255, nullable=true)
  158.      * @Assert\NotBlank(message="Veuillez saisir votre prenom")
  159.      * @Assert\Length(
  160.      *     min="3", minMessage="Le prenom doit comporter au minimum 3 cataères",
  161.      *     max="100", maxMessage="Le prenom doit comporter au plus 100 cataères",
  162.      * )
  163.      */
  164.     private $prenoms;
  166.     /**
  167.      * @ORM\OneToMany(targetEntity="App\Entity\Logs\Logs", mappedBy="user")
  168.      */
  169.     private $logs;
  171.     /**
  172.      * @ORM\OneToMany(targetEntity="App\Entity\Institutions", mappedBy="user")
  173.      */
  174.     private $institutions;
  176.     /**
  177.      * @ORM\OneToMany(targetEntity="App\Entity\Actualites\Actualites", mappedBy="updatedBy")
  178.      */
  179.     private $actualitesUpatedBy;
  181.     /**
  182.      * @ORM\OneToMany(targetEntity="App\Entity\Brochures", mappedBy="user")
  183.      */
  184.     private $brochures;
  186.     /**
  187.      * @ORM\OneToMany(targetEntity="App\Entity\Articles\Articles", mappedBy="user")
  188.      */
  189.     private $articles;
  191.     /**
  192.      * @ORM\OneToMany(targetEntity="App\Entity\Posts\Posts", mappedBy="user")
  193.      */
  194.     private $posts;
  196.     /**
  197.      * @ORM\OneToMany(targetEntity="App\Entity\Directions", mappedBy="user")
  198.      */
  199.     private $directions;
  201.     /**
  202.      * @ORM\OneToMany(targetEntity="App\Entity\Partenaires", mappedBy="user")
  203.      */
  204.     private $partenaires;
  206.     /**
  207.      * @ORM\OneToMany(targetEntity="App\Entity\Documentations", mappedBy="user")
  208.      */
  209.     private $documentations;
  211.     /**
  212.      * @ORM\OneToMany(targetEntity="App\Entity\Salons\Salons", mappedBy="user")
  213.      */
  214.     private $salons;
  216.     /**
  217.      * @ORM\OneToMany(targetEntity="App\Entity\Seminaires", mappedBy="user")
  218.      */
  219.     private $seminaires;
  221.     /**
  222.      * @ORM\ManyToOne(targetEntity="App\Entity\Categorieacteurs", inversedBy="user")
  223.      */
  224.     private $domaines;
  226.     /**
  227.      * @ORM\OneToMany(targetEntity="App\Entity\Hotels\Hotels", mappedBy="user")
  228.      */
  229.     private $hotels;
  231.     /**
  232.      * @ORM\OneToMany(targetEntity="App\Entity\Restaurants\Restaurants", mappedBy="user")
  233.      */
  234.     private $restaurants;
  236.     public function __construct()
  237.     {
  238.         $this->roles = ['ROLE_USER'];
  239.         $this->actualites = new ArrayCollection();
  240.         $this->logs = new ArrayCollection();
  241.         $this->institutions = new ArrayCollection();
  242.         $this->actualitesUpatedBy = new ArrayCollection();
  243.         $this->brochures = new ArrayCollection();
  244.         $this->articles = new ArrayCollection();
  245.         $this->posts = new ArrayCollection();
  246.         $this->directions = new ArrayCollection();
  247.         $this->partenaires = new ArrayCollection();
  248.         $this->documentations = new ArrayCollection();
  249.         $this->salons = new ArrayCollection();
  250.         $this->seminaires = new ArrayCollection();
  251.         $this->hotels = new ArrayCollection();
  252.         $this->restaurants = new ArrayCollection();
  253.     }
  255.     public function getEmail(): ?string
  256.     {
  257.         return $this->email;
  258.     }
  260.     public function setEmail(string $email): self
  261.     {
  262.         $this->email = $email;
  264.         return $this;
  265.     }
  267.     /**
  268.      * A visual identifier that represents this user.
  269.      *
  270.      * @see UserInterface
  271.      */
  272.     public function getUsername(): ?string
  273.     {
  274.         return $this->username;
  275.     }
  277.     /**
  278.      * @return string|null
  279.      */
  280.     public function getFullname(): ?string
  281.     {
  282.         return $this->nom. ' '.$this->prenoms;
  283.     }
  285.     /**
  286.      * @see UserInterface
  287.      */
  288.     public function getRoles(): array
  289.     {
  290.         $roles = $this->roles;
  291.         // guarantee every user at least has ROLE_USER
  292.         $roles[] = 'ROLE_USER';
  294.         return array_unique($roles);
  295.     }
  297.     public function setRoles(array $roles): self
  298.     {
  299.         $this->roles = $roles;
  301.         return $this;
  302.     }
  304.     /**
  305.      * @return string
  306.      */
  307.     public function getRole(): ?string
  308.     {
  309.         return $this->role;
  310.     }
  312.     /**
  313.      * @param string|null $role
  314.      * @return User
  315.      */
  316.     public function setRole(?string $role): User
  317.     {
  318.         $this->role = $role;
  319.         return $this;
  320.     }
  322.     public function getRolesType(): string {
  323.         return self::ROLESPUBLIC[$this->role];
  324.     }
  326.     /**
  327.      * @see UserInterface
  328.      */
  329.     public function getPassword(): ?string
  330.     {
  331.         return $this->password;
  332.     }
  334.     public function setPassword(string $password): self
  335.     {
  336.         $this->password = $password;
  338.         return $this;
  339.     }
  341.     /**
  342.      * @see UserInterface
  343.      */
  344.     public function getSalt(): ?string
  345.     {
  346.         return '';
  347.     }
  349.     /**
  350.      * @see UserInterface
  351.      */
  352.     public function eraseCredentials()
  353.     {
  354.         // If you store any temporary, sensitive data on the user, clear it here
  355.         // $this->plainPassword = null;
  356.     }
  358.     public function setUsername(string $username): self
  359.     {
  360.         $this->username = $username;
  362.         return $this;
  363.     }
  365.     public function getContacts(): ?string
  366.     {
  367.         return $this->contacts;
  368.     }
  370.     public function setContacts(?string $contacts): self
  371.     {
  372.         $this->contacts = $contacts;
  374.         return $this;
  375.     }
  377.     public function getAddress(): ?string
  378.     {
  379.         return $this->address;
  380.     }
  382.     public function setAddress(?string $address): self
  383.     {
  384.         $this->address = $address;
  386.         return $this;
  387.     }
  389.     /**
  390.      * @return File|null
  391.      */
  392.     public function getImageFile(): ?File
  393.     {
  394.         return $this->imageFile;
  395.     }
  397.     /**
  398.      * @param File|null $imageFile
  399.      * @return User
  400.      * @throws Exception
  401.      */
  402.     public function setImageFile(?File $imageFile): User
  403.     {
  404.         $this->imageFile = $imageFile;
  405.         if ($this->imageFile instanceof UploadedFile) {
  406.             // It is required that at least one field changes if you are using doctrine
  407.             // otherwise the event listeners won't be called and the file is lost
  408.             $this->updatedAt = new DateTimeImmutable('now');
  409.         }
  410.         return $this;
  411.     }
  413.     /**
  414.      * @return string|null
  415.      */
  416.     public function getFilename(): ?string
  417.     {
  418.         return $this->filename;
  419.     }
  421.     /**
  422.      * @param string|null $filename
  423.      * @return User
  424.      */
  425.     public function setFilename(?string $filename): User
  426.     {
  427.         $this->filename = $filename;
  428.         return $this;
  429.     }
  431.     /**
  432.      * @return mixed
  433.      */
  434.     public function getEnabled()
  435.     {
  436.         return $this->enabled;
  437.     }
  439.     /**
  440.      * @param mixed $enabled
  441.      * @return User
  442.      */
  443.     public function setEnabled($enabled): User
  444.     {
  445.         $this->enabled = $enabled;
  446.         return $this;
  447.     }
  449.     public function getCreatedAt(): ?DateTimeInterface
  450.     {
  451.         return $this->createdAt;
  452.     }
  454.     public function getUpdatedAt(): ?DateTimeInterface
  455.     {
  456.         return $this->updatedAt;
  457.     }
  459.     public function getLastLogin(): ?DateTimeInterface
  460.     {
  461.         return $this->lastLogin;
  462.     }
  464.     public function setLastLogin(DateTimeInterface $lastLogin): self
  465.     {
  466.         $this->lastLogin = $lastLogin;
  468.         return $this;
  469.     }
  471.     /**
  472.      * @return Collection|Actualites[]
  473.      */
  474.     public function getActualites(): Collection
  475.     {
  476.         return $this->actualites;
  477.     }
  479.     /**
  480.      * @param Actualites $actualite
  481.      * @return $this
  482.      */
  483.     public function addActualite(Actualites $actualite): self
  484.     {
  485.         if (!$this->actualites->contains($actualite)) {
  486.             $this->actualites[] = $actualite;
  487.             $actualite->setUser($this);
  488.         }
  490.         return $this;
  491.     }
  493.     public function removeActualite(Actualites $actualite): self
  494.     {
  495.         if ($this->actualites->contains($actualite)) {
  496.             $this->actualites->removeElement($actualite);
  497.             // set the owning side to null (unless already changed)
  498.             if ($actualite->getUser() === $this) {
  499.                 $actualite->setUser(null);
  500.             }
  501.         }
  503.         return $this;
  504.     }
  506.     public function getNom(): ?string
  507.     {
  508.         return $this->nom;
  509.     }
  511.     public function setNom(string $nom): self
  512.     {
  513.         $this->nom = $nom;
  515.         return $this;
  516.     }
  518.     public function getPrenoms(): ?string
  519.     {
  520.         return $this->prenoms;
  521.     }
  523.     public function setPrenoms(string $prenoms): self
  524.     {
  525.         $this->prenoms = $prenoms;
  527.         return $this;
  528.     }
  530.     /**
  531.      * @return Collection|Logs[]
  532.      */
  533.     public function getLogs(): Collection
  534.     {
  535.         return $this->logs;
  536.     }
  538.     public function addLog(Logs $log): self
  539.     {
  540.         if (!$this->logs->contains($log)) {
  541.             $this->logs[] = $log;
  542.             $log->setUser($this);
  543.         }
  545.         return $this;
  546.     }
  548.     public function removeLog(Logs $log): self
  549.     {
  550.         if ($this->logs->contains($log)) {
  551.             $this->logs->removeElement($log);
  552.             // set the owning side to null (unless already changed)
  553.             if ($log->getUser() === $this) {
  554.                 $log->setUser(null);
  555.             }
  556.         }
  558.         return $this;
  559.     }
  561.     /**
  562.      * @return Collection|Institutions[]
  563.      */
  564.     public function getInstitutions(): Collection
  565.     {
  566.         return $this->institutions;
  567.     }
  569.     public function addInstitution(Institutions $institution): self
  570.     {
  571.         if (!$this->institutions->contains($institution)) {
  572.             $this->institutions[] = $institution;
  573.             $institution->setUser($this);
  574.         }
  576.         return $this;
  577.     }
  579.     public function removeInstitution(Institutions $institution): self
  580.     {
  581.         if ($this->institutions->contains($institution)) {
  582.             $this->institutions->removeElement($institution);
  583.             // set the owning side to null (unless already changed)
  584.             if ($institution->getUser() === $this) {
  585.                 $institution->setUser(null);
  586.             }
  587.         }
  589.         return $this;
  590.     }
  592.     /**
  593.      * @return Collection|Actualites[]
  594.      */
  595.     public function getActualitesUpatedBy(): Collection
  596.     {
  597.         return $this->actualitesUpatedBy;
  598.     }
  600.     public function addActualitesUpatedBy(Actualites $actualitesUpatedBy): self
  601.     {
  602.         if (!$this->actualitesUpatedBy->contains($actualitesUpatedBy)) {
  603.             $this->actualitesUpatedBy[] = $actualitesUpatedBy;
  604.             $actualitesUpatedBy->setUpdatedBy($this);
  605.         }
  607.         return $this;
  608.     }
  610.     public function removeActualitesUpatedBy(Actualites $actualitesUpatedBy): self
  611.     {
  612.         if ($this->actualitesUpatedBy->contains($actualitesUpatedBy)) {
  613.             $this->actualitesUpatedBy->removeElement($actualitesUpatedBy);
  614.             // set the owning side to null (unless already changed)
  615.             if ($actualitesUpatedBy->getUpdatedBy() === $this) {
  616.                 $actualitesUpatedBy->setUpdatedBy(null);
  617.             }
  618.         }
  620.         return $this;
  621.     }
  623.     /**
  624.      * @return Collection|Brochures[]
  625.      */
  626.     public function getBrochures(): Collection
  627.     {
  628.         return $this->brochures;
  629.     }
  631.     public function addBrochure(Brochures $brochure): self
  632.     {
  633.         if (!$this->brochures->contains($brochure)) {
  634.             $this->brochures[] = $brochure;
  635.             $brochure->setUser($this);
  636.         }
  638.         return $this;
  639.     }
  641.     public function removeBrochure(Brochures $brochure): self
  642.     {
  643.         if ($this->brochures->contains($brochure)) {
  644.             $this->brochures->removeElement($brochure);
  645.             // set the owning side to null (unless already changed)
  646.             if ($brochure->getUser() === $this) {
  647.                 $brochure->setUser(null);
  648.             }
  649.         }
  651.         return $this;
  652.     }
  654.     /**
  655.      * @return Collection|Articles[]
  656.      */
  657.     public function getArticles(): Collection
  658.     {
  659.         return $this->articles;
  660.     }
  662.     public function addArticle(Articles $article): self
  663.     {
  664.         if (!$this->articles->contains($article)) {
  665.             $this->articles[] = $article;
  666.             $article->setUser($this);
  667.         }
  669.         return $this;
  670.     }
  672.     public function removeArticle(Articles $article): self
  673.     {
  674.         if ($this->articles->contains($article)) {
  675.             $this->articles->removeElement($article);
  676.             // set the owning side to null (unless already changed)
  677.             if ($article->getUser() === $this) {
  678.                 $article->setUser(null);
  679.             }
  680.         }
  682.         return $this;
  683.     }
  685.     /**
  686.      * @return Collection|Posts[]
  687.      */
  688.     public function getPosts(): Collection
  689.     {
  690.         return $this->posts;
  691.     }
  693.     public function addPost(Posts $post): self
  694.     {
  695.         if (!$this->posts->contains($post)) {
  696.             $this->posts[] = $post;
  697.             $post->setUser($this);
  698.         }
  700.         return $this;
  701.     }
  703.     public function removePost(Posts $post): self
  704.     {
  705.         if ($this->posts->contains($post)) {
  706.             $this->posts->removeElement($post);
  707.             // set the owning side to null (unless already changed)
  708.             if ($post->getUser() === $this) {
  709.                 $post->setUser(null);
  710.             }
  711.         }
  713.         return $this;
  714.     }
  716.     /**
  717.      * @return Collection|Directions[]
  718.      */
  719.     public function getDirections(): Collection
  720.     {
  721.         return $this->directions;
  722.     }
  724.     public function addDirection(Directions $direction): self
  725.     {
  726.         if (!$this->directions->contains($direction)) {
  727.             $this->directions[] = $direction;
  728.             $direction->setUser($this);
  729.         }
  731.         return $this;
  732.     }
  734.     public function removeDirection(Directions $direction): self
  735.     {
  736.         if ($this->directions->contains($direction)) {
  737.             $this->directions->removeElement($direction);
  738.             // set the owning side to null (unless already changed)
  739.             if ($direction->getUser() === $this) {
  740.                 $direction->setUser(null);
  741.             }
  742.         }
  744.         return $this;
  745.     }
  747.     /**
  748.      * @return Collection|Partenaires[]
  749.      */
  750.     public function getPartenaires(): Collection
  751.     {
  752.         return $this->partenaires;
  753.     }
  755.     public function addPartenaire(Partenaires $partenaire): self
  756.     {
  757.         if (!$this->partenaires->contains($partenaire)) {
  758.             $this->partenaires[] = $partenaire;
  759.             $partenaire->setUser($this);
  760.         }
  762.         return $this;
  763.     }
  765.     public function removePartenaire(Partenaires $partenaire): self
  766.     {
  767.         if ($this->partenaires->contains($partenaire)) {
  768.             $this->partenaires->removeElement($partenaire);
  769.             // set the owning side to null (unless already changed)
  770.             if ($partenaire->getUser() === $this) {
  771.                 $partenaire->setUser(null);
  772.             }
  773.         }
  775.         return $this;
  776.     }
  778.     /**
  779.      * @return Collection|Documentations[]
  780.      */
  781.     public function getDocumentations(): Collection
  782.     {
  783.         return $this->documentations;
  784.     }
  786.     public function addDocumentation(Documentations $documentation): self
  787.     {
  788.         if (!$this->documentations->contains($documentation)) {
  789.             $this->documentations[] = $documentation;
  790.             $documentation->setUser($this);
  791.         }
  793.         return $this;
  794.     }
  796.     public function removeDocumentation(Documentations $documentation): self
  797.     {
  798.         if ($this->documentations->contains($documentation)) {
  799.             $this->documentations->removeElement($documentation);
  800.             // set the owning side to null (unless already changed)
  801.             if ($documentation->getUser() === $this) {
  802.                 $documentation->setUser(null);
  803.             }
  804.         }
  806.         return $this;
  807.     }
  809.     /**
  810.      * @return Collection|Salons[]
  811.      */
  812.     public function getSalons(): Collection
  813.     {
  814.         return $this->salons;
  815.     }
  817.     public function addSalon(Salons $salon): self
  818.     {
  819.         if (!$this->salons->contains($salon)) {
  820.             $this->salons[] = $salon;
  821.             $salon->setUser($this);
  822.         }
  824.         return $this;
  825.     }
  827.     public function removeSalon(Salons $salon): self
  828.     {
  829.         if ($this->salons->contains($salon)) {
  830.             $this->salons->removeElement($salon);
  831.             // set the owning side to null (unless already changed)
  832.             if ($salon->getUser() === $this) {
  833.                 $salon->setUser(null);
  834.             }
  835.         }
  837.         return $this;
  838.     }
  840.     /**
  841.      * @return Collection|Seminaires[]
  842.      */
  843.     public function getSeminaires(): Collection
  844.     {
  845.         return $this->seminaires;
  846.     }
  848.     public function addSeminaire(Seminaires $seminaire): self
  849.     {
  850.         if (!$this->seminaires->contains($seminaire)) {
  851.             $this->seminaires[] = $seminaire;
  852.             $seminaire->setUser($this);
  853.         }
  855.         return $this;
  856.     }
  858.     public function removeSeminaire(Seminaires $seminaire): self
  859.     {
  860.         if ($this->seminaires->contains($seminaire)) {
  861.             $this->seminaires->removeElement($seminaire);
  862.             // set the owning side to null (unless already changed)
  863.             if ($seminaire->getUser() === $this) {
  864.                 $seminaire->setUser(null);
  865.             }
  866.         }
  868.         return $this;
  869.     }
  871.     public function getDomaines(): ?Categorieacteurs
  872.     {
  873.         return $this->domaines;
  874.     }
  876.     public function setDomaines(?Categorieacteurs $domaines): self
  877.     {
  878.         $this->domaines = $domaines;
  880.         return $this;
  881.     }
  883.     /**
  884.      * @return Collection|Hotels[]
  885.      */
  886.     public function getHotels(): Collection
  887.     {
  888.         return $this->hotels;
  889.     }
  891.     public function addHotel(Hotels $hotel): self
  892.     {
  893.         if (!$this->hotels->contains($hotel)) {
  894.             $this->hotels[] = $hotel;
  895.             $hotel->setUser($this);
  896.         }
  898.         return $this;
  899.     }
  901.     public function removeHotel(Hotels $hotel): self
  902.     {
  903.         if ($this->hotels->contains($hotel)) {
  904.             $this->hotels->removeElement($hotel);
  905.             // set the owning side to null (unless already changed)
  906.             if ($hotel->getUser() === $this) {
  907.                 $hotel->setUser(null);
  908.             }
  909.         }
  911.         return $this;
  912.     }
  914.     /**
  915.      * @return Collection|Restaurants[]
  916.      */
  917.     public function getRestaurants(): Collection
  918.     {
  919.         return $this->restaurants;
  920.     }
  922.     public function addRestaurant(Restaurants $restaurant): self
  923.     {
  924.         if (!$this->restaurants->contains($restaurant)) {
  925.             $this->restaurants[] = $restaurant;
  926.             $restaurant->setUser($this);
  927.         }
  929.         return $this;
  930.     }
  932.     public function removeRestaurant(Restaurants $restaurant): self
  933.     {
  934.         if ($this->restaurants->contains($restaurant)) {
  935.             $this->restaurants->removeElement($restaurant);
  936.             // set the owning side to null (unless already changed)
  937.             if ($restaurant->getUser() === $this) {
  938.                 $restaurant->setUser(null);
  939.             }
  940.         }
  942.         return $this;
  943.     }
  945.     /**
  946.      * @return string
  947.      */
  948.     public function __toString(): string
  949.     {
  950.         return $this->nom. ' '. $this->prenoms;
  951.     }
  953.     public function getPasswordHasherName(): ?string
  954.     {
  955.         return null;
  956.     }
  958.     public function __call($name, $arguments): void
  959.     {
  960.         // TODO: Implement @method string getUserIdentifier()
  961.     }
  962. }