src/Entity/User.php line 15

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\Entity(repositoryClass: UserRepository::class)]
  14. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  15. class User implements UserInterface, PasswordAuthenticatedUserInterface
  16. {
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column]
  20.     private ?int $id = null;
  22.     #[ORM\Column(length: 180, unique: true)]
  23.     private ?string $email = null;
  25.     #[ORM\Column]
  26.     private array $roles = [];
  28.     /**
  29.      * @var string The hashed password
  30.      */
  31.     #[ORM\Column]
  32.     private ?string $password = null;
  34.     #[ORM\Column(type: 'boolean')]
  35.     private $isVerified = false;
  37.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Articles::class)]
  38.     private Collection $articles;
  40.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Annonces::class)]
  41.     private Collection $annonces;
  43.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Images::class)]
  44.     private Collection $images;
  46.     #[ORM\OneToMany(mappedBy: 'sender', targetEntity: Messages::class)]
  47.     private Collection $messages;
  49.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: PostLike::class)]
  50.     private Collection $postLikes;
  52.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Resetemail::class)]
  53.     private Collection $resetemails;
  55.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Visiteurs::class)]
  56.     private Collection $visiteurs;
  58.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Event::class)]
  59.     private Collection $events;
  61.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Reservations::class)]
  62.     private Collection $reservations;
  64.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Factures::class)]
  65.     private Collection $factures;
  67.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Wallet::class)]
  68.     private Collection $wallets;
  70.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Transactions::class)]
  71.     private Collection $transactions;
  73.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Alertes::class)]
  74.     private Collection $alertes;
  76.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: CommentairesLocataires::class)]
  77.     private Collection $commentairesLocataires;
  79.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: CommentairesLogements::class)]
  80.     private Collection $commentairesLogements;
  82.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: CommentairesProprietaires::class)]
  83.     private Collection $commentairesProprietaires;
  85.     #[ORM\Column(nullable: true)]
  86.     private ?\DateTimeImmutable $created_at = null;
  88.     #[ORM\Column(length: 255, nullable: true)]
  89.     private ?string $nom = null;
  91.     #[ORM\Column(length: 255, nullable: true)]
  92.     private ?string $prenom = null;
  94.     #[ORM\Column(length: 255, nullable: true)]
  95.     private ?string $adresse = null;
  97.     #[ORM\Column(length: 255, nullable: true)]
  98.     private ?string $telephone = null;
  100.     #[ORM\Column(length: 255, nullable: true)]
  101.     private ?string $facebook = null;
  103.     #[ORM\Column(length: 255, nullable: true)]
  104.     private ?string $instagram = null;
  106.     #[ORM\Column(length: 255, nullable: true)]
  107.     private ?string $linkedin = null;
  109.     #[ORM\Column(length: 255, nullable: true)]
  110.     private ?string $twitter = null;
  112.     #[ORM\Column(length: 255, nullable: true)]
  113.     private ?string $siteperso = null;
  115.     #[ORM\Column(length: 255, nullable: true)]
  116.     private ?string $id_google = null;
  118.     #[ORM\Column(length: 255, nullable: true)]
  119.     private ?string $slug = null;
  121.     #[ORM\Column(length: 255, nullable: true)]
  122.     private ?string $image = null;
  124.     #[ORM\Column(length: 255, nullable: true)]
  125.     private ?string $avarar_google = null;
  127.     #[ORM\ManyToOne(inversedBy: 'users')]
  128.     private ?Agences $agence = null;
  130.     #[ORM\ManyToOne(inversedBy: 'users')]
  131.     private ?Hotels $hotel = null;
  133.     #[ORM\Column(length: 255, nullable: true)]
  134.     private ?string $type = null;
  136.     #[ORM\Column(length: 255, nullable: true)]
  137.     private ?string $psedo = null;
  139.     #[ORM\Column(length: 255, nullable: true)]
  140.     private ?string $credits = null;
  142.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Recherche::class)]
  143.     private Collection $recherches;
  145.     #[ORM\Column(length: 255, nullable: true)]
  146.     private ?string $validation = null;
  148.     #[ORM\Column(length: 255, nullable: true)]
  149.     private ?string $domaine = null;
  151.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Contact::class)]
  152.     private Collection $contacts;
  154.     public function __construct()
  155.     {
  156.         $this->articles = new ArrayCollection();
  157.         $this->annonces = new ArrayCollection();
  158.         $this->images = new ArrayCollection();
  159.         $this->messages = new ArrayCollection();
  160.         $this->postLikes = new ArrayCollection();
  161.         $this->resetemails = new ArrayCollection();
  162.         $this->visiteurs = new ArrayCollection();
  163.         $this->events = new ArrayCollection();
  164.         $this->reservations = new ArrayCollection();
  165.         $this->factures = new ArrayCollection();
  166.         $this->wallets = new ArrayCollection();
  167.         $this->transactions = new ArrayCollection();
  168.         $this->alertes = new ArrayCollection();
  169.         $this->commentairesLocataires = new ArrayCollection();
  170.         $this->commentairesLogements = new ArrayCollection();
  171.         $this->commentairesProprietaires = new ArrayCollection();
  172.         $this->recherches = new ArrayCollection();
  173.         $this->contacts = new ArrayCollection();
  174.     }
  176.     public function getId(): ?int
  177.     {
  178.         return $this->id;
  179.     }
  181.     public function getEmail(): ?string
  182.     {
  183.         return $this->email;
  184.     }
  186.     public function setEmail(string $email): self
  187.     {
  188.         $this->email = $email;
  190.         return $this;
  191.     }
  193.     /**
  194.      * A visual identifier that represents this user.
  195.      *
  196.      * @see UserInterface
  197.      */
  198.     public function getUserIdentifier(): string
  199.     {
  200.         return (string) $this->email;
  201.     }
  203.     /**
  204.      * @see UserInterface
  205.      */
  206.     public function getRoles(): array
  207.     {
  208.         $roles = $this->roles;
  209.         // guarantee every user at least has ROLE_USER
  210.         $roles[] = 'ROLE_USER';
  212.         return array_unique($roles);
  213.     }
  215.     public function setRoles(array $roles): self
  216.     {
  217.         $this->roles = $roles;
  219.         return $this;
  220.     }
  222.     /**
  223.      * @see PasswordAuthenticatedUserInterface
  224.      */
  225.     public function getPassword(): string
  226.     {
  227.         return $this->password;
  228.     }
  230.     public function setPassword(string $password): self
  231.     {
  232.         $this->password = $password;
  234.         return $this;
  235.     }
  237.     /**
  238.      * @see UserInterface
  239.      */
  240.     public function eraseCredentials()
  241.     {
  242.         // If you store any temporary, sensitive data on the user, clear it here
  243.         // $this->plainPassword = null;
  244.     }
  246.     public function isVerified(): bool
  247.     {
  248.         return $this->isVerified;
  249.     }
  251.     public function setIsVerified(bool $isVerified): self
  252.     {
  253.         $this->isVerified = $isVerified;
  255.         return $this;
  256.     }
  258.     /**
  259.      * @return Collection<int, Articles>
  260.      */
  261.     public function getArticles(): Collection
  262.     {
  263.         return $this->articles;
  264.     }
  266.     public function addArticle(Articles $article): self
  267.     {
  268.         if (!$this->articles->contains($article)) {
  269.             $this->articles->add($article);
  270.             $article->setUser($this);
  271.         }
  273.         return $this;
  274.     }
  276.     public function removeArticle(Articles $article): self
  277.     {
  278.         if ($this->articles->removeElement($article)) {
  279.             // set the owning side to null (unless already changed)
  280.             if ($article->getUser() === $this) {
  281.                 $article->setUser(null);
  282.             }
  283.         }
  285.         return $this;
  286.     }
  288.     /**
  289.      * @return Collection<int, Annonces>
  290.      */
  291.     public function getAnnonces(): Collection
  292.     {
  293.         return $this->annonces;
  294.     }
  296.     public function addAnnonce(Annonces $annonce): self
  297.     {
  298.         if (!$this->annonces->contains($annonce)) {
  299.             $this->annonces->add($annonce);
  300.             $annonce->setUser($this);
  301.         }
  303.         return $this;
  304.     }
  306.     public function removeAnnonce(Annonces $annonce): self
  307.     {
  308.         if ($this->annonces->removeElement($annonce)) {
  309.             // set the owning side to null (unless already changed)
  310.             if ($annonce->getUser() === $this) {
  311.                 $annonce->setUser(null);
  312.             }
  313.         }
  315.         return $this;
  316.     }
  318.     /**
  319.      * @return Collection<int, Images>
  320.      */
  321.     public function getImages(): Collection
  322.     {
  323.         return $this->images;
  324.     }
  326.     public function addImage(Images $image): self
  327.     {
  328.         if (!$this->images->contains($image)) {
  329.             $this->images->add($image);
  330.             $image->setUser($this);
  331.         }
  333.         return $this;
  334.     }
  336.     public function removeImage(Images $image): self
  337.     {
  338.         if ($this->images->removeElement($image)) {
  339.             // set the owning side to null (unless already changed)
  340.             if ($image->getUser() === $this) {
  341.                 $image->setUser(null);
  342.             }
  343.         }
  345.         return $this;
  346.     }
  348.     /**
  349.      * @return Collection<int, Messages>
  350.      */
  351.     public function getMessages(): Collection
  352.     {
  353.         return $this->messages;
  354.     }
  356.     public function addMessage(Messages $message): self
  357.     {
  358.         if (!$this->messages->contains($message)) {
  359.             $this->messages->add($message);
  360.             $message->setSender($this);
  361.         }
  363.         return $this;
  364.     }
  366.     public function removeMessage(Messages $message): self
  367.     {
  368.         if ($this->messages->removeElement($message)) {
  369.             // set the owning side to null (unless already changed)
  370.             if ($message->getSender() === $this) {
  371.                 $message->setSender(null);
  372.             }
  373.         }
  375.         return $this;
  376.     }
  378.     /**
  379.      * @return Collection<int, PostLike>
  380.      */
  381.     public function getPostLikes(): Collection
  382.     {
  383.         return $this->postLikes;
  384.     }
  386.     public function addPostLike(PostLike $postLike): self
  387.     {
  388.         if (!$this->postLikes->contains($postLike)) {
  389.             $this->postLikes->add($postLike);
  390.             $postLike->setUser($this);
  391.         }
  393.         return $this;
  394.     }
  396.     public function removePostLike(PostLike $postLike): self
  397.     {
  398.         if ($this->postLikes->removeElement($postLike)) {
  399.             // set the owning side to null (unless already changed)
  400.             if ($postLike->getUser() === $this) {
  401.                 $postLike->setUser(null);
  402.             }
  403.         }
  405.         return $this;
  406.     }
  408.     /**
  409.      * @return Collection<int, Resetemail>
  410.      */
  411.     public function getResetemails(): Collection
  412.     {
  413.         return $this->resetemails;
  414.     }
  416.     public function addResetemail(Resetemail $resetemail): self
  417.     {
  418.         if (!$this->resetemails->contains($resetemail)) {
  419.             $this->resetemails->add($resetemail);
  420.             $resetemail->setUser($this);
  421.         }
  423.         return $this;
  424.     }
  426.     public function removeResetemail(Resetemail $resetemail): self
  427.     {
  428.         if ($this->resetemails->removeElement($resetemail)) {
  429.             // set the owning side to null (unless already changed)
  430.             if ($resetemail->getUser() === $this) {
  431.                 $resetemail->setUser(null);
  432.             }
  433.         }
  435.         return $this;
  436.     }
  438.     /**
  439.      * @return Collection<int, Visiteurs>
  440.      */
  441.     public function getVisiteurs(): Collection
  442.     {
  443.         return $this->visiteurs;
  444.     }
  446.     public function addVisiteur(Visiteurs $visiteur): self
  447.     {
  448.         if (!$this->visiteurs->contains($visiteur)) {
  449.             $this->visiteurs->add($visiteur);
  450.             $visiteur->setUser($this);
  451.         }
  453.         return $this;
  454.     }
  456.     public function removeVisiteur(Visiteurs $visiteur): self
  457.     {
  458.         if ($this->visiteurs->removeElement($visiteur)) {
  459.             // set the owning side to null (unless already changed)
  460.             if ($visiteur->getUser() === $this) {
  461.                 $visiteur->setUser(null);
  462.             }
  463.         }
  465.         return $this;
  466.     }
  468.     /**
  469.      * @return Collection<int, Event>
  470.      */
  471.     public function getEvents(): Collection
  472.     {
  473.         return $this->events;
  474.     }
  476.     public function addEvent(Event $event): self
  477.     {
  478.         if (!$this->events->contains($event)) {
  479.             $this->events->add($event);
  480.             $event->setUser($this);
  481.         }
  483.         return $this;
  484.     }
  486.     public function removeEvent(Event $event): self
  487.     {
  488.         if ($this->events->removeElement($event)) {
  489.             // set the owning side to null (unless already changed)
  490.             if ($event->getUser() === $this) {
  491.                 $event->setUser(null);
  492.             }
  493.         }
  495.         return $this;
  496.     }
  498.     /**
  499.      * @return Collection<int, Reservations>
  500.      */
  501.     public function getReservations(): Collection
  502.     {
  503.         return $this->reservations;
  504.     }
  506.     public function addReservation(Reservations $reservation): self
  507.     {
  508.         if (!$this->reservations->contains($reservation)) {
  509.             $this->reservations->add($reservation);
  510.             $reservation->setUser($this);
  511.         }
  513.         return $this;
  514.     }
  516.     public function removeReservation(Reservations $reservation): self
  517.     {
  518.         if ($this->reservations->removeElement($reservation)) {
  519.             // set the owning side to null (unless already changed)
  520.             if ($reservation->getUser() === $this) {
  521.                 $reservation->setUser(null);
  522.             }
  523.         }
  525.         return $this;
  526.     }
  528.     /**
  529.      * @return Collection<int, Factures>
  530.      */
  531.     public function getFactures(): Collection
  532.     {
  533.         return $this->factures;
  534.     }
  536.     public function addFacture(Factures $facture): self
  537.     {
  538.         if (!$this->factures->contains($facture)) {
  539.             $this->factures->add($facture);
  540.             $facture->setUser($this);
  541.         }
  543.         return $this;
  544.     }
  546.     public function removeFacture(Factures $facture): self
  547.     {
  548.         if ($this->factures->removeElement($facture)) {
  549.             // set the owning side to null (unless already changed)
  550.             if ($facture->getUser() === $this) {
  551.                 $facture->setUser(null);
  552.             }
  553.         }
  555.         return $this;
  556.     }
  557.     
  558.     /**
  559.      * @return Collection<int, Wallet>
  560.      */
  561.     public function getWallets(): Collection
  562.     {
  563.         return $this->wallets;
  564.     }
  566.     public function addWallet(Wallet $wallet): self
  567.     {
  568.         if (!$this->wallets->contains($wallet)) {
  569.             $this->wallets->add($wallet);
  570.             $wallet->setUser($this);
  571.         }
  573.         return $this;
  574.     }
  576.     public function removeWallet(Wallet $wallet): self
  577.     {
  578.         if ($this->wallets->removeElement($wallet)) {
  579.             // set the owning side to null (unless already changed)
  580.             if ($wallet->getUser() === $this) {
  581.                 $wallet->setUser(null);
  582.             }
  583.         }
  585.         return $this;
  586.     }
  588.     /**
  589.      * @return Collection<int, Transactions>
  590.      */
  591.     public function getTransactions(): Collection
  592.     {
  593.         return $this->transactions;
  594.     }
  596.     public function addTransaction(Transactions $transaction): self
  597.     {
  598.         if (!$this->transactions->contains($transaction)) {
  599.             $this->transactions->add($transaction);
  600.             $transaction->setUser($this);
  601.         }
  603.         return $this;
  604.     }
  606.     public function removeTransaction(Transactions $transaction): self
  607.     {
  608.         if ($this->transactions->removeElement($transaction)) {
  609.             // set the owning side to null (unless already changed)
  610.             if ($transaction->getUser() === $this) {
  611.                 $transaction->setUser(null);
  612.             }
  613.         }
  615.         return $this;
  616.     }
  618.     /**
  619.      * @return Collection<int, Alertes>
  620.      */
  621.     public function getAlertes(): Collection
  622.     {
  623.         return $this->alertes;
  624.     }
  626.     public function addAlerte(Alertes $alerte): self
  627.     {
  628.         if (!$this->alertes->contains($alerte)) {
  629.             $this->alertes->add($alerte);
  630.             $alerte->setUser($this);
  631.         }
  633.         return $this;
  634.     }
  636.     public function removeAlerte(Alertes $alerte): self
  637.     {
  638.         if ($this->alertes->removeElement($alerte)) {
  639.             // set the owning side to null (unless already changed)
  640.             if ($alerte->getUser() === $this) {
  641.                 $alerte->setUser(null);
  642.             }
  643.         }
  645.         return $this;
  646.     }
  648.     /**
  649.      * @return Collection<int, CommentairesLocataires>
  650.      */
  651.     public function getCommentairesLocataires(): Collection
  652.     {
  653.         return $this->commentairesLocataires;
  654.     }
  656.     public function addCommentairesLocataire(CommentairesLocataires $commentairesLocataire): self
  657.     {
  658.         if (!$this->commentairesLocataires->contains($commentairesLocataire)) {
  659.             $this->commentairesLocataires->add($commentairesLocataire);
  660.             $commentairesLocataire->setUser($this);
  661.         }
  663.         return $this;
  664.     }
  666.     public function removeCommentairesLocataire(CommentairesLocataires $commentairesLocataire): self
  667.     {
  668.         if ($this->commentairesLocataires->removeElement($commentairesLocataire)) {
  669.             // set the owning side to null (unless already changed)
  670.             if ($commentairesLocataire->getUser() === $this) {
  671.                 $commentairesLocataire->setUser(null);
  672.             }
  673.         }
  675.         return $this;
  676.     }
  678.     /**
  679.      * @return Collection<int, CommentairesLogements>
  680.      */
  681.     public function getCommentairesLogements(): Collection
  682.     {
  683.         return $this->commentairesLogements;
  684.     }
  686.     public function addCommentairesLogement(CommentairesLogements $commentairesLogement): self
  687.     {
  688.         if (!$this->commentairesLogements->contains($commentairesLogement)) {
  689.             $this->commentairesLogements->add($commentairesLogement);
  690.             $commentairesLogement->setUser($this);
  691.         }
  693.         return $this;
  694.     }
  696.     public function removeCommentairesLogement(CommentairesLogements $commentairesLogement): self
  697.     {
  698.         if ($this->commentairesLogements->removeElement($commentairesLogement)) {
  699.             // set the owning side to null (unless already changed)
  700.             if ($commentairesLogement->getUser() === $this) {
  701.                 $commentairesLogement->setUser(null);
  702.             }
  703.         }
  705.         return $this;
  706.     }
  708.     /**
  709.      * @return Collection<int, CommentairesProprietaires>
  710.      */
  711.     public function getCommentairesProprietaires(): Collection
  712.     {
  713.         return $this->commentairesProprietaires;
  714.     }
  716.     public function addCommentairesProprietaire(CommentairesProprietaires $commentairesProprietaire): self
  717.     {
  718.         if (!$this->commentairesProprietaires->contains($commentairesProprietaire)) {
  719.             $this->commentairesProprietaires->add($commentairesProprietaire);
  720.             $commentairesProprietaire->setUser($this);
  721.         }
  723.         return $this;
  724.     }
  726.     public function removeCommentairesProprietaire(CommentairesProprietaires $commentairesProprietaire): self
  727.     {
  728.         if ($this->commentairesProprietaires->removeElement($commentairesProprietaire)) {
  729.             // set the owning side to null (unless already changed)
  730.             if ($commentairesProprietaire->getUser() === $this) {
  731.                 $commentairesProprietaire->setUser(null);
  732.             }
  733.         }
  735.         return $this;
  736.     }
  738.     public function getCreatedAt(): ?\DateTimeImmutable
  739.     {
  740.         return $this->created_at;
  741.     }
  743.     public function setCreatedAt(?\DateTimeImmutable $created_at): self
  744.     {
  745.         $this->created_at = $created_at;
  747.         return $this;
  748.     }
  750.     public function getNom(): ?string
  751.     {
  752.         return $this->nom;
  753.     }
  755.     public function setNom(?string $nom): self
  756.     {
  757.         $this->nom = $nom;
  759.         return $this;
  760.     }
  762.     public function getPrenom(): ?string
  763.     {
  764.         return $this->prenom;
  765.     }
  767.     public function setPrenom(?string $prenom): self
  768.     {
  769.         $this->prenom = $prenom;
  771.         return $this;
  772.     }
  774.     public function getAdresse(): ?string
  775.     {
  776.         return $this->adresse;
  777.     }
  779.     public function setAdresse(?string $adresse): self
  780.     {
  781.         $this->adresse = $adresse;
  783.         return $this;
  784.     }
  786.     public function getTelephone(): ?string
  787.     {
  788.         return $this->telephone;
  789.     }
  791.     public function setTelephone(?string $telephone): self
  792.     {
  793.         $this->telephone = $telephone;
  795.         return $this;
  796.     }
  798.     public function getFacebook(): ?string
  799.     {
  800.         return $this->facebook;
  801.     }
  803.     public function setFacebook(?string $facebook): self
  804.     {
  805.         $this->facebook = $facebook;
  807.         return $this;
  808.     }
  810.     public function getInstagram(): ?string
  811.     {
  812.         return $this->instagram;
  813.     }
  815.     public function setInstagram(?string $instagram): self
  816.     {
  817.         $this->instagram = $instagram;
  819.         return $this;
  820.     }
  822.     public function getLinkedin(): ?string
  823.     {
  824.         return $this->linkedin;
  825.     }
  827.     public function setLinkedin(?string $linkedin): self
  828.     {
  829.         $this->linkedin = $linkedin;
  831.         return $this;
  832.     }
  834.     public function getTwitter(): ?string
  835.     {
  836.         return $this->twitter;
  837.     }
  839.     public function setTwitter(?string $twitter): self
  840.     {
  841.         $this->twitter = $twitter;
  843.         return $this;
  844.     }
  846.     public function getSiteperso(): ?string
  847.     {
  848.         return $this->siteperso;
  849.     }
  851.     public function setSiteperso(?string $siteperso): self
  852.     {
  853.         $this->siteperso = $siteperso;
  855.         return $this;
  856.     }
  858.     public function getIdGoogle(): ?string
  859.     {
  860.         return $this->id_google;
  861.     }
  863.     public function setIdGoogle(?string $id_google): self
  864.     {
  865.         $this->id_google = $id_google;
  867.         return $this;
  868.     }
  870.     public function getSlug(): ?string
  871.     {
  872.         return $this->slug;
  873.     }
  875.     public function setSlug(?string $slug): self
  876.     {
  877.         $this->slug = $slug;
  879.         return $this;
  880.     }
  882.     public function getImage(): ?string
  883.     {
  884.         return $this->image;
  885.     }
  887.     public function setImage(?string $image): self
  888.     {
  889.         $this->image = $image;
  891.         return $this;
  892.     }
  894.     public function getAvararGoogle(): ?string
  895.     {
  896.         return $this->avarar_google;
  897.     }
  899.     public function setAvararGoogle(?string $avarar_google): self
  900.     {
  901.         $this->avarar_google = $avarar_google;
  903.         return $this;
  904.     }
  906.     public function getAgence(): ?Agences
  907.     {
  908.         return $this->agence;
  909.     }
  911.     public function setAgence(?Agences $agence): self
  912.     {
  913.         $this->agence = $agence;
  915.         return $this;
  916.     }
  918.     public function getHotel(): ?Hotels
  919.     {
  920.         return $this->hotel;
  921.     }
  923.     public function setHotel(?Hotels $hotel): self
  924.     {
  925.         $this->hotel = $hotel;
  927.         return $this;
  928.     }
  930.     public function getType(): ?string
  931.     {
  932.         return $this->type;
  933.     }
  935.     public function setType(?string $type): self
  936.     {
  937.         $this->type = $type;
  939.         return $this;
  940.     }
  942.     public function getPsedo(): ?string
  943.     {
  944.         return $this->psedo;
  945.     }
  947.     public function setPsedo(?string $psedo): self
  948.     {
  949.         $this->psedo = $psedo;
  951.         return $this;
  952.     }
  954.     public function getCredits(): ?string
  955.     {
  956.         return $this->credits;
  957.     }
  959.     public function setCredits(?string $credits): self
  960.     {
  961.         $this->credits = $credits;
  963.         return $this;
  964.     }
  966.     /**
  967.      * @return Collection<int, Recherche>
  968.      */
  969.     public function getRecherches(): Collection
  970.     {
  971.         return $this->recherches;
  972.     }
  974.     public function addRecherch(Recherche $recherch): self
  975.     {
  976.         if (!$this->recherches->contains($recherch)) {
  977.             $this->recherches->add($recherch);
  978.             $recherch->setUser($this);
  979.         }
  981.         return $this;
  982.     }
  984.     public function removeRecherch(Recherche $recherch): self
  985.     {
  986.         if ($this->recherches->removeElement($recherch)) {
  987.             // set the owning side to null (unless already changed)
  988.             if ($recherch->getUser() === $this) {
  989.                 $recherch->setUser(null);
  990.             }
  991.         }
  993.         return $this;
  994.     }
  996.     public function getValidation(): ?string
  997.     {
  998.         return $this->validation;
  999.     }
  1001.     public function setValidation(?string $validation): self
  1002.     {
  1003.         $this->validation = $validation;
  1005.         return $this;
  1006.     }
  1008.     public function getDomaine(): ?string
  1009.     {
  1010.         return $this->domaine;
  1011.     }
  1013.     public function setDomaine(?string $domaine): self
  1014.     {
  1015.         $this->domaine = $domaine;
  1017.         return $this;
  1018.     }
  1020.     /**
  1021.      * @return Collection<int, Contact>
  1022.      */
  1023.     public function getContacts(): Collection
  1024.     {
  1025.         return $this->contacts;
  1026.     }
  1028.     public function addContact(Contact $contact): self
  1029.     {
  1030.         if (!$this->contacts->contains($contact)) {
  1031.             $this->contacts->add($contact);
  1032.             $contact->setUser($this);
  1033.         }
  1035.         return $this;
  1036.     }
  1038.     public function removeContact(Contact $contact): self
  1039.     {
  1040.         if ($this->contacts->removeElement($contact)) {
  1041.             // set the owning side to null (unless already changed)
  1042.             if ($contact->getUser() === $this) {
  1043.                 $contact->setUser(null);
  1044.             }
  1045.         }
  1047.         return $this;
  1048.     }
  1049. }