src/Entity/User.php line 24

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use App\Validator\PhoneNumberConstraint;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Scheb\TwoFactorBundle\Model\Email\TwoFactorInterface;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  14. use Symfony\Component\Serializer\Annotation\Groups;
  16. /**
  17.  * Utilisateur et administrateurs.
  18.  *
  19.  * @UniqueEntity(fields={"username"}, message="Ce compte existe déjà")
  20.  */
  21. #[ORM\Table]
  22. #[ORM\Index(name: 'username', columns: ['username'])]
  23. #[ORM\Entity(repositoryClass: UserRepository::class)]
  24. class User implements UserInterface, \Serializable, PasswordAuthenticatedUserInterface, TwoFactorInterface
  25. {
  26.     // ------------- Maintainers -----------------------
  27.     /** User prospect status */
  28.     public const PROSPECT = 1;
  29.     /** User authorized status */
  30.     public const AUTHORIZED = 2;
  31.     /** User inactive status */
  32.     public const EXPIRED = 3;
  34.     // ------------- Clients -----------------------
  35.     /** Client prospect status */
  36.     public const CLIENT_PROSPECT = 4;
  37.     /** Client suspended status */
  38.     public const SUSPENDED = 5;
  39.     /** Client closed status */
  40.     public const CLOSED = 6;
  41.     /** Client status */
  42.     public const CLIENT = 7;
  43.     /** Client expired status */
  44.     public const CLIENT_EXPIRED = 8;
  46.     protected static $statusLabels = [
  47.         1 => 'Prospect',
  48.         2 => 'Authorized',
  49.         3 => 'Expired',
  50.     ];
  52.     protected static $clientStatusLabels = [
  53.         4 => 'ProspectClient',
  54.         5 => 'Suspended',
  55.         6 => 'Closed',
  56.         7 => 'Client',
  57.         8 => 'Expired',
  58.     ];
  60.     /**
  61.      * @Groups({"user:read"})
  62.      */
  63.     #[ORM\Id]
  64.     #[ORM\GeneratedValue]
  65.     #[ORM\Column(type: 'integer')]
  66.     private $id;
  68.     /**
  69.      * @Groups({"user:read"})
  70.      */
  71.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  72.     private $username;
  74.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  75.     private $password;
  77.     /**
  78.      * @Groups({"user:read"})
  79.      */
  80.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  81.     private $email;
  83.     #[ORM\Column(type: 'boolean', nullable: true)]
  84.     private $isActive;
  86.     #[ORM\Column(type: 'string', nullable: true)]
  87.     private $zone;
  89.     #[ORM\Column(type: 'json')]
  90.     private $roles = [];
  92.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  93.     private $hash;
  95.     #[ORM\Column(type: 'boolean', options: ['default' => false])]
  96.     private bool $admin = false;
  98.     /**
  99.      * @Groups({"user:read"})
  100.      */
  101.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  102.     private $nom;
  104.     /**
  105.      * @Groups({"user:read"})
  106.      */
  107.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  108.     private $prenom;
  110.     /**
  111.      * @PhoneNumberConstraint()
  112.      *
  113.      * @Groups({"user:read"})
  114.      */
  115.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  116.     private $numtel;
  118.     #[ORM\Column(type: 'boolean', nullable: true)]
  119.     private $cgu;
  121.     /**
  122.      * @var Abonnement[]|Collection
  123.      */
  124.     #[ORM\OneToMany(targetEntity: Abonnement::class, mappedBy: 'user', cascade: ['persist'])]
  125.     #[ORM\OrderBy(['datefin' => 'DESC'])]
  126.     private Collection $abonnements;
  128.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  129.     private $civilite;
  131.     #[ORM\Column(type: 'datetime', nullable: true)]
  132.     private $naissance;
  134.     /**
  135.      * @Groups({"user:read"})
  136.      */
  137.     #[ORM\Column(type: 'text', nullable: true)]
  138.     private $address;
  140.     /**
  141.      * @Groups({"user:read"})
  142.      */
  143.     #[ORM\Column(type: 'string', length: 50, nullable: true)]
  144.     private $zip;
  146.     /**
  147.      * @Groups({"user:read"})
  148.      */
  149.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  150.     private $city;
  152.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  153.     private $country;
  155.     #[ORM\Column(type: 'boolean', nullable: true)]
  156.     private $communication;
  158.     #[ORM\Column(type: 'boolean')]
  159.     private $isVerified = false;
  161.     #[ORM\Column(type: 'datetime', nullable: true)]
  162.     private $deletedAt;
  164.     #[ORM\Column(type: 'datetime', nullable: true)]
  165.     private $datecreation;
  167.     #[ORM\Column(type: 'datetime', nullable: true)]
  168.     private $datemodification;
  170.     #[ORM\Column(type: 'boolean', nullable: true)]
  171.     private $optin;
  173.     #[ORM\Column(type: 'integer', nullable: true)]
  174.     private $fantome;
  176.     #[ORM\Column(type: 'boolean', nullable: true)]
  177.     private $getemail;
  179.     /**
  180.      * @Groups({"bike:upsert"})
  181.      */
  182.     #[ORM\Column(type: 'integer', nullable: true)]
  183.     private $iduserfo;
  185.     #[ORM\Column(type: 'integer', nullable: true)]
  186.     private $doubleauth;
  188.     #[ORM\OneToMany(targetEntity: Contact::class, mappedBy: 'utilisateur')]
  189.     private $contacts;
  191.     #[ORM\OneToMany(targetEntity: Offre::class, mappedBy: 'createur')]
  192.     private $offres;
  194.     #[ORM\OneToMany(targetEntity: Facture::class, mappedBy: 'user')]
  195.     private $factures;
  197.     #[ORM\OneToMany(targetEntity: LogsUser::class, mappedBy: 'client')]
  198.     private $logsUsersClient;
  200.     #[ORM\OneToMany(targetEntity: LogsUser::class, mappedBy: 'mainteneur')]
  201.     private $logsUsersMainteneur;
  203.     #[ORM\OneToMany(targetEntity: LogsUser::class, mappedBy: 'user', cascade: ['persist'])]
  204.     private $logsUsersUser;
  206.     #[ORM\OneToMany(targetEntity: LogsUser::class, mappedBy: 'administrateur')]
  207.     private $logsUsersAdmin;
  209.     #[ORM\Column(type: 'string', nullable: true)]
  210.     private $authCode;
  212.     #[ORM\Column(type: 'datetime', nullable: true)]
  213.     private $validityCode;
  215.     #[ORM\OneToMany(targetEntity: Notes::class, mappedBy: 'User')]
  216.     private $notes;
  218.     #[ORM\JoinColumn(nullable: true)]
  219.     #[ORM\OneToMany(targetEntity: Bike::class, mappedBy: 'user', cascade: ['persist', 'remove'], orphanRemoval: true)]
  220.     private $bikes;
  222.     /**
  223.      * @var string
  224.      */
  225.     #[ORM\Column(name: 'id_document', type: 'string', length: 250, nullable: true)]
  226.     private $idDocument;
  228.     /**
  229.      * @var AbonnementLuckey[]|Collection
  230.      */
  231.     #[ORM\OneToMany(targetEntity: AbonnementLuckey::class, mappedBy: 'user')]
  232.     private $abonnementsLuckey;
  234.     #[ORM\OneToOne(targetEntity: UserLuckey::class, mappedBy: 'user', cascade: ['persist', 'remove'])]
  235.     private $luckeyId;
  237.     #[ORM\OneToMany(targetEntity: LogsMail::class, mappedBy: 'user')]
  238.     private $logsMails;
  240.     #[ORM\OneToMany(targetEntity: Card::class, mappedBy: 'user')]
  241.     private $cards;
  243.     public function __construct()
  244.     {
  245.         $this->isActive = true;
  246.         $this->abonnements = new ArrayCollection();
  247.         $this->contacts = new ArrayCollection();
  248.         $this->offres = new ArrayCollection();
  249.         $this->factures = new ArrayCollection();
  250.         $this->logsUsersClient = new ArrayCollection();
  251.         $this->logsUsersMainteneur = new ArrayCollection();
  252.         $this->logsUsersUser = new ArrayCollection();
  253.         $this->logsUsersAdmin = new ArrayCollection();
  254.         $this->notes = new ArrayCollection();
  255.         $this->bikes = new ArrayCollection();
  256.         $this->abonnementsLuckey = new ArrayCollection();
  257.         $this->logsMails = new ArrayCollection();
  258.         $this->cards = new ArrayCollection();
  259.     }
  261.     public function __toString()
  262.     {
  263.         if (null !== $this->username) {
  264.             return $this->username;
  265.         }
  267.         if (null !== $this->nom) {
  268.             return $this->nom;
  269.         }
  271.         return '';
  272.     }
  274.     public function getSalt(): ?string
  275.     {
  276.         // you *may* need a real salt depending on your encoder
  277.         // see section on salt below
  278.         return null;
  279.     }
  281.     public function eraseCredentials()
  282.     {
  283.         // Nothing
  284.     }
  286.     /** @see \Serializable::serialize() */
  287.     public function serialize()
  288.     {
  289.         return serialize([
  290.             $this->id,
  291.             $this->username,
  292.             $this->password,
  293.             // see section on salt below
  294.             // $this->salt,
  295.         ]);
  296.     }
  298.     /** @see \Serializable::unserialize() */
  299.     public function unserialize($serialized)
  300.     {
  301.         list(
  302.             $this->id,
  303.             $this->username,
  304.             $this->password,
  305.             // see section on salt below
  306.             // $this->salt
  307.         ) = unserialize($serialized, ['allowed_classes' => false]);
  308.     }
  310.     /**
  311.      * The public representation of the user (e.g. a username, an email address, etc.).
  312.      *
  313.      * @see UserInterface
  314.      */
  315.     public function getUserIdentifier(): string
  316.     {
  317.         return (string) $this->username;
  318.     }
  320.     public function getId()
  321.     {
  322.         return $this->id;
  323.     }
  325.     public function getUsername(): ?string
  326.     {
  327.         return $this->username;
  328.     }
  330.     public function setUsername(?string $username): self
  331.     {
  332.         $this->username = $username;
  334.         return $this;
  335.     }
  337.     public function getPassword(): ?string
  338.     {
  339.         return $this->password;
  340.     }
  342.     public function setPassword(?string $password): self
  343.     {
  344.         $this->password = $password;
  346.         return $this;
  347.     }
  349.     public function getEmail(): ?string
  350.     {
  351.         return $this->email;
  352.     }
  354.     public function setEmail(?string $email): self
  355.     {
  356.         $this->email = $email;
  358.         return $this;
  359.     }
  361.     public function getIsActive(): ?bool
  362.     {
  363.         return $this->isActive;
  364.     }
  366.     public function setIsActive(bool $isActive): self
  367.     {
  368.         $this->isActive = $isActive;
  370.         return $this;
  371.     }
  373.     public function getZone(): ?string
  374.     {
  375.         return $this->zone;
  376.     }
  378.     public function setZone(?string $zone): self
  379.     {
  380.         $this->zone = $zone;
  382.         return $this;
  383.     }
  385.     public function getHash(): ?string
  386.     {
  387.         return $this->hash;
  388.     }
  390.     public function setHash(?string $hash): self
  391.     {
  392.         $this->hash = $hash;
  394.         return $this;
  395.     }
  397.     public function getAdmin(): ?bool
  398.     {
  399.         return $this->admin;
  400.     }
  402.     public function setAdmin(bool $admin): self
  403.     {
  404.         $this->admin = $admin;
  406.         return $this;
  407.     }
  409.     public function getNom(): ?string
  410.     {
  411.         return $this->nom;
  412.     }
  414.     public function setNom(string $nom): self
  415.     {
  416.         $this->nom = $nom;
  418.         return $this;
  419.     }
  421.     public function getPrenom(): ?string
  422.     {
  423.         return $this->prenom;
  424.     }
  426.     public function setPrenom(string $prenom): self
  427.     {
  428.         $this->prenom = $prenom;
  430.         return $this;
  431.     }
  433.     public function getFullName(): string
  434.     {
  435.         return $this->prenom . ' ' . $this->nom;
  436.     }
  438.     public function getNumtel(): ?string
  439.     {
  440.         return $this->numtel;
  441.     }
  443.     public function setNumtel(?string $numtel): self
  444.     {
  445.         $this->numtel = $numtel;
  447.         return $this;
  448.     }
  450.     public function getCgu(): ?bool
  451.     {
  452.         return $this->cgu;
  453.     }
  455.     public function setCgu(?bool $cgu): self
  456.     {
  457.         $this->cgu = $cgu;
  459.         return $this;
  460.     }
  462.     /**
  463.      * @return Abonnement[]|Collection
  464.      */
  465.     public function getAbonnements(): Collection
  466.     {
  467.         return $this->abonnements;
  468.     }
  470.     /**
  471.      * If User get One active subscription return the first one it found
  472.      * If user get no active subscription return the closest one from now
  473.      * if user don't get subscription, retur null.
  474.      *
  475.      * @throws \Exception
  476.      */
  477.     public function getClosestSubscription(): ?Abonnement
  478.     {
  479.         $now = new \DateTime(
  480.             'now',
  481.             new \DateTimeZone('Europe/Paris')
  482.         );
  484.         if ($this->abonnements->isEmpty()) {
  485.             return null;
  486.         }
  488.         if (1 === $this->abonnements->count()) {
  489.             return $this->abonnements->first();
  490.         }
  492.         foreach ($this->abonnements as $abo) {
  493.             if ($abo->getDatedebut() <= $now && $abo->getDatefin() >= $now) {
  494.                 return $abo;
  495.             }
  496.         }
  498.         // Find closest subscription beetween now and middle of interval
  499.         $res = [];
  500.         $nowTimestamp = $now->getTimestamp();
  501.         foreach ($this->abonnements as $abo) {
  502.             $timeInterval = abs(
  503.                 $nowTimestamp -
  504.                 (
  505.                     (
  506.                         $abo->getDatedebut()->getTimestamp()
  507.                         + $abo->getDatefin()->getTimestamp()
  508.                     )
  509.                     / 2
  510.                 )
  511.             );
  513.             $res[$timeInterval] = $abo;
  514.         }
  516.         ksort($res);
  518.         return current($res);
  519.     }
  521.     public function addAbonnement(Abonnement $abonnement): self
  522.     {
  523.         if (!$this->abonnements->contains($abonnement)) {
  524.             $this->abonnements->add($abonnement);
  525.             $abonnement->setUser($this);
  526.         }
  528.         return $this;
  529.     }
  531.     public function removeAbonnement(Abonnement $abonnement): self
  532.     {
  533.         if ($this->abonnements->removeElement($abonnement)) {
  534.             // set the owning side to null (unless already changed)
  535.             if ($abonnement->getUser() === $this) {
  536.                 $abonnement->setUser(null);
  537.             }
  538.         }
  540.         return $this;
  541.     }
  543.     public function getCivilite(): ?string
  544.     {
  545.         return $this->civilite;
  546.     }
  548.     public function setCivilite(?string $civilite): self
  549.     {
  550.         $this->civilite = $civilite;
  552.         return $this;
  553.     }
  555.     public function getNaissance(): ?\DateTimeInterface
  556.     {
  557.         return $this->naissance;
  558.     }
  560.     public function setNaissance(?\DateTimeInterface $naissance): self
  561.     {
  562.         $this->naissance = $naissance;
  564.         return $this;
  565.     }
  567.     public function getAddress(): ?string
  568.     {
  569.         return $this->address;
  570.     }
  572.     public function setAddress(?string $address): self
  573.     {
  574.         $this->address = $address;
  576.         return $this;
  577.     }
  579.     public function getZip(): ?string
  580.     {
  581.         return $this->zip;
  582.     }
  584.     public function setZip(?string $zip): self
  585.     {
  586.         $this->zip = $zip;
  588.         return $this;
  589.     }
  591.     public function getCity(): ?string
  592.     {
  593.         return $this->city;
  594.     }
  596.     public function setCity(?string $city): self
  597.     {
  598.         $this->city = $city;
  600.         return $this;
  601.     }
  603.     public function getCountry(): ?string
  604.     {
  605.         return $this->country;
  606.     }
  608.     public function setCountry(?string $country): self
  609.     {
  610.         $this->country = $country;
  612.         return $this;
  613.     }
  615.     public function getCommunication(): ?bool
  616.     {
  617.         return $this->communication;
  618.     }
  620.     public function setCommunication(?bool $communication): self
  621.     {
  622.         $this->communication = $communication;
  624.         return $this;
  625.     }
  627.     public function isVerified(): bool
  628.     {
  629.         return $this->isVerified;
  630.     }
  632.     public function setIsVerified(bool $isVerified): self
  633.     {
  634.         $this->isVerified = $isVerified;
  636.         return $this;
  637.     }
  639.     public function getDeletedAt(): ?\DateTimeInterface
  640.     {
  641.         return $this->deletedAt;
  642.     }
  644.     public function setDeletedAt(?\DateTimeInterface $deletedAt): self
  645.     {
  646.         $this->deletedAt = $deletedAt;
  648.         return $this;
  649.     }
  651.     public function getDatecreation(): ?\DateTimeInterface
  652.     {
  653.         return $this->datecreation;
  654.     }
  656.     public function setDatecreation(?\DateTimeInterface $datecreation): self
  657.     {
  658.         $this->datecreation = $datecreation;
  660.         return $this;
  661.     }
  663.     public function getDatemodification(): ?\DateTimeInterface
  664.     {
  665.         return $this->datemodification;
  666.     }
  668.     public function setDatemodification(?\DateTimeInterface $datemodification): self
  669.     {
  670.         $this->datemodification = $datemodification;
  672.         return $this;
  673.     }
  675.     public function getOptin(): ?bool
  676.     {
  677.         return $this->optin;
  678.     }
  680.     public function setOptin(?bool $optin): self
  681.     {
  682.         $this->optin = $optin;
  684.         return $this;
  685.     }
  687.     public function getFantome(): ?int
  688.     {
  689.         return $this->fantome;
  690.     }
  692.     public function setFantome(?int $fantome): self
  693.     {
  694.         $this->fantome = $fantome;
  696.         return $this;
  697.     }
  699.     public function getRoles(): array
  700.     {
  701.         $roles = $this->roles;
  702.         // guarantee every user at least has ROLE_USER
  703.         // $roles[] = 'ROLE_USER';
  705.         return array_unique($roles);
  706.     }
  708.     public function setRoles(array $roles): self
  709.     {
  710.         $this->roles = $roles;
  712.         return $this;
  713.     }
  715.     public function getGetemail(): ?bool
  716.     {
  717.         return $this->getemail;
  718.     }
  720.     public function setGetemail(?bool $getemail): self
  721.     {
  722.         $this->getemail = $getemail;
  724.         return $this;
  725.     }
  727.     public function getIduserfo(): ?int
  728.     {
  729.         return $this->iduserfo;
  730.     }
  732.     public function setIduserfo(?int $iduserfo): self
  733.     {
  734.         $this->iduserfo = $iduserfo;
  736.         return $this;
  737.     }
  739.     public function getDoubleauth(): ?int
  740.     {
  741.         return $this->doubleauth;
  742.     }
  744.     public function setDoubleauth(?int $doubleauth): self
  745.     {
  746.         $this->doubleauth = $doubleauth;
  748.         return $this;
  749.     }
  751.     /**
  752.      * @return Collection|Contact[]
  753.      */
  754.     public function getContacts(): Collection
  755.     {
  756.         return $this->contacts;
  757.     }
  759.     public function addContact(Contact $contact): self
  760.     {
  761.         if (!$this->contacts->contains($contact)) {
  762.             $this->contacts[] = $contact;
  763.             $contact->setUtilisateur($this);
  764.         }
  766.         return $this;
  767.     }
  769.     public function removeContact(Contact $contact): self
  770.     {
  771.         if ($this->contacts->removeElement($contact)) {
  772.             // set the owning side to null (unless already changed)
  773.             if ($contact->getUtilisateur() === $this) {
  774.                 $contact->setUtilisateur(null);
  775.             }
  776.         }
  778.         return $this;
  779.     }
  781.     /**
  782.      * @return Collection|Offre[]
  783.      */
  784.     public function getOffres(): Collection
  785.     {
  786.         return $this->offres;
  787.     }
  789.     public function addOffre(Offre $offre): self
  790.     {
  791.         if (!$this->offres->contains($offre)) {
  792.             $this->offres[] = $offre;
  793.             $offre->setCreateur($this);
  794.         }
  796.         return $this;
  797.     }
  799.     public function removeOffre(Offre $offre): self
  800.     {
  801.         if ($this->offres->removeElement($offre)) {
  802.             // set the owning side to null (unless already changed)
  803.             if ($offre->getCreateur() === $this) {
  804.                 $offre->setCreateur(null);
  805.             }
  806.         }
  808.         return $this;
  809.     }
  811.     /**
  812.      * @return Collection<int, Facture>
  813.      */
  814.     public function getFactures(): Collection
  815.     {
  816.         return $this->factures;
  817.     }
  819.     public function addFacture(Facture $facture): self
  820.     {
  821.         if (!$this->factures->contains($facture)) {
  822.             $this->factures[] = $facture;
  823.             $facture->setUser($this);
  824.         }
  826.         return $this;
  827.     }
  829.     public function removeFacture(Facture $facture): self
  830.     {
  831.         if ($this->factures->removeElement($facture)) {
  832.             // set the owning side to null (unless already changed)
  833.             if ($facture->getUser() === $this) {
  834.                 $facture->setUser(null);
  835.             }
  836.         }
  838.         return $this;
  839.     }
  841.     /**
  842.      * @return Collection|LogsUser[]
  843.      */
  844.     public function getLogsUsersClient(): Collection
  845.     {
  846.         return $this->logsUsersClient;
  847.     }
  849.     public function addLogsUserClient(LogsUser $logsUserClient): self
  850.     {
  851.         if (!$this->logsUsersClient->contains($logsUserClient)) {
  852.             $this->logsUsersClient[] = $logsUserClient;
  853.             $logsUserClient->setUser($this);
  854.         }
  856.         return $this;
  857.     }
  859.     public function removeLogsUserClient(LogsUser $logsUserClient): self
  860.     {
  861.         if ($this->logsUsersClient->removeElement($logsUserClient)) {
  862.             // set the owning side to null (unless already changed)
  863.             if ($logsUserClient->getUser() === $this) {
  864.                 $logsUserClient->setUser(null);
  865.             }
  866.         }
  868.         return $this;
  869.     }
  871.     /**
  872.      * @return Collection|LogsUser[]
  873.      */
  874.     public function getLogsUsersMainteneur(): Collection
  875.     {
  876.         return $this->logsUsersMainteneur;
  877.     }
  879.     public function addLogsUserMainteneur(LogsUser $logsUserMainteneur): self
  880.     {
  881.         if (!$this->logsUsersMainteneur->contains($logsUserMainteneur)) {
  882.             $this->logsUsersMainteneur[] = $logsUserMainteneur;
  883.             $logsUserMainteneur->setUser($this);
  884.         }
  886.         return $this;
  887.     }
  889.     public function removeLogsUserMainteneur(LogsUser $logsUserMainteneur): self
  890.     {
  891.         if ($this->logsUsersMainteneur->removeElement($logsUserMainteneur)) {
  892.             // set the owning side to null (unless already changed)
  893.             if ($logsUserMainteneur->getUser() === $this) {
  894.                 $logsUserMainteneur->setUser(null);
  895.             }
  896.         }
  898.         return $this;
  899.     }
  901.     /**
  902.      * @return Collection|LogsUser[]
  903.      */
  904.     public function getLogsUsersUser(): Collection
  905.     {
  906.         return $this->logsUsersUser;
  907.     }
  909.     public function addLogsUserUser(LogsUser $logsUserUser): self
  910.     {
  911.         if (!$this->logsUsersUser->contains($logsUserUser)) {
  912.             $this->logsUsersUser[] = $logsUserUser;
  913.             $logsUserUser->setUser($this);
  914.         }
  916.         return $this;
  917.     }
  919.     public function removeLogsUserUser(LogsUser $logsUserUser): self
  920.     {
  921.         if ($this->logsUsersUser->removeElement($logsUserUser)) {
  922.             // set the owning side to null (unless already changed)
  923.             if ($logsUserUser->getUser() === $this) {
  924.                 $logsUserUser->setUser(null);
  925.             }
  926.         }
  928.         return $this;
  929.     }
  931.     /**
  932.      * @return Collection|LogsUser[]
  933.      */
  934.     public function getLogsUsersAdmin(): Collection
  935.     {
  936.         return $this->logsUsersAdmin;
  937.     }
  939.     public function addLogsUserAdmin(LogsUser $logsUserAdmin): self
  940.     {
  941.         if (!$this->logsUsersAdmin->contains($logsUserAdmin)) {
  942.             $this->logsUsersAdmin[] = $logsUserAdmin;
  943.             $logsUserAdmin->setUser($this);
  944.         }
  946.         return $this;
  947.     }
  949.     public function removeLogsUserAdmin(LogsUser $logsUserAdmin): self
  950.     {
  951.         if ($this->logsUsersAdmin->removeElement($logsUserAdmin)) {
  952.             // set the owning side to null (unless already changed)
  953.             if ($logsUserAdmin->getUser() === $this) {
  954.                 $logsUserAdmin->setUser(null);
  955.             }
  956.         }
  958.         return $this;
  959.     }
  961.     /** Fonctions statiques */
  963.     /**
  964.      * Get label for specific user status code.
  965.      *
  966.      * @param int $status Status index
  967.      */
  968.     public static function getStatusLabel($status): string
  969.     {
  970.         return self::$statusLabels[$status];
  971.     }
  973.     /**
  974.      * Get user statuses array.
  975.      */
  976.     public static function getStatusLabels(): array
  977.     {
  978.         return self::$statusLabels;
  979.     }
  981.     /**
  982.      * Get label for specific client status code.
  983.      *
  984.      * @param int $status Status index
  985.      */
  986.     public static function getClientStatusLabel($status): string
  987.     {
  988.         return self::$clientStatusLabels[$status];
  989.     }
  991.     /**
  992.      * Get client statuses array.
  993.      */
  994.     public static function getClientStatusLabels(): array
  995.     {
  996.         return self::$clientStatusLabels;
  997.     }
  999.     public function isEmailAuthEnabled(): bool
  1000.     {
  1001.         return true; // This can be a persisted field to switch email code authentication on/off
  1002.     }
  1004.     public function getEmailAuthRecipient(): string
  1005.     {
  1006.         return $this->email;
  1007.     }
  1009.     public function getEmailAuthCode(): string
  1010.     {
  1011.         if (null === $this->authCode) {
  1012.             throw new \LogicException('The email authentication code was not set');
  1013.         }
  1015.         return $this->authCode;
  1016.     }
  1018.     public function setEmailAuthCode(string $authCode): void
  1019.     {
  1020.         $this->authCode = $authCode;
  1021.     }
  1023.     public function deleteEmailAuthCode(): void
  1024.     {
  1025.         $this->authCode = null;
  1026.     }
  1028.     public function getValidityCode(): ?\DateTimeInterface
  1029.     {
  1030.         return $this->validityCode;
  1031.     }
  1033.     public function setValidityCode(?\DateTimeInterface $validityCode): self
  1034.     {
  1035.         $this->validityCode = $validityCode;
  1037.         return $this;
  1038.     }
  1040.     /**
  1041.      * @return Collection<int, Notes>
  1042.      */
  1043.     public function getNotes(): Collection
  1044.     {
  1045.         return $this->notes;
  1046.     }
  1048.     public function addNote(Notes $note): self
  1049.     {
  1050.         if (!$this->notes->contains($note)) {
  1051.             $this->notes[] = $note;
  1052.             $note->setUser($this);
  1053.         }
  1055.         return $this;
  1056.     }
  1058.     public function removeNote(Notes $note): self
  1059.     {
  1060.         if ($this->notes->removeElement($note)) {
  1061.             // set the owning side to null (unless already changed)
  1062.             if ($note->getUser() === $this) {
  1063.                 $note->setUser(null);
  1064.             }
  1065.         }
  1067.         return $this;
  1068.     }
  1070.     /**
  1071.      * @return Bike[]|\Doctrine\Common\Collections\Collection
  1072.      */
  1073.     public function getBikes(): Collection
  1074.     {
  1075.         return $this->bikes;
  1076.     }
  1078.     public function addBike(Bike $bike): self
  1079.     {
  1080.         if (!$this->bikes->contains($bike)) {
  1081.             $this->bikes[] = $bike;
  1082.             $bike->setUser($this);
  1083.         }
  1085.         return $this;
  1086.     }
  1088.     public function removeBike(Bike $bike): self
  1089.     {
  1090.         if ($this->bikes->contains($bike)) {
  1091.             $this->bikes->removeElement($bike);
  1092.             // set the owning side to null (unless already changed)
  1093.             if ($bike->getUser() === $this) {
  1094.                 $bike->setUser(null);
  1095.             }
  1096.         }
  1098.         return $this;
  1099.     }
  1101.     /**
  1102.      * Get the value of idDocument.
  1103.      *
  1104.      * @return string
  1105.      */
  1106.     public function getIdDocument()
  1107.     {
  1108.         return $this->idDocument;
  1109.     }
  1111.     /**
  1112.      * Set the value of idDocument.
  1113.      *
  1114.      * @return self
  1115.      */
  1116.     public function setIdDocument(?string $idDocument)
  1117.     {
  1118.         $this->idDocument = $idDocument;
  1120.         return $this;
  1121.     }
  1123.     /**
  1124.      * Anonymize user.
  1125.      *
  1126.      * @return $this
  1127.      */
  1128.     public function anonymize(): self
  1129.     {
  1130.         $this->setDeletedAt(new \DateTime(
  1131.             'now',
  1132.             new \DateTimeZone('Europe/Paris')
  1133.         ))
  1134.             ->setUsername(null)
  1135.             ->setPassword('')
  1136.             ->setEmail('')
  1137.             ->setIsActive(false)
  1138.             ->setRoles(['ROLE_CLOTURE'])
  1139.             ->setHash(null)
  1140.             ->setAdmin(false)
  1141.             ->setNom('')
  1142.             ->setPrenom('')
  1143.             ->setNumtel('')
  1144.             ->setCgu(null)
  1145.             ->setCivilite('')
  1146.             ->setNaissance(null)
  1147.             ->setAddress('')
  1148.             ->setZip(null)
  1149.             ->setCity('')
  1150.             ->setCountry('')
  1151.             ->setIsVerified(false)
  1152.             ->setDatecreation(null)
  1153.             ->setOptin(null)
  1154.         ;
  1156.         return $this;
  1157.     }
  1159.     /**
  1160.      * @return Collection<int, AbonnementLuckey>
  1161.      */
  1162.     public function getAbonnementsLuckey(): Collection
  1163.     {
  1164.         return $this->abonnementsLuckey;
  1165.     }
  1167.     public function getLuckeyId(): ?UserLuckey
  1168.     {
  1169.         return $this->luckeyId;
  1170.     }
  1172.     public function setLuckeyId(UserLuckey $luckeyId): self
  1173.     {
  1174.         // set the owning side of the relation if necessary
  1175.         if ($luckeyId->getUser() !== $this) {
  1176.             $luckeyId->setUser($this);
  1177.         }
  1179.         $this->luckeyId = $luckeyId;
  1181.         return $this;
  1182.     }
  1184.     /**
  1185.      * @return Collection<int, LogsMail>
  1186.      */
  1187.     public function getLogsMails(): Collection
  1188.     {
  1189.         return $this->logsMails;
  1190.     }
  1192.     /**
  1193.      * @return Card[]|Collection
  1194.      */
  1195.     public function getCards(): Collection
  1196.     {
  1197.         return $this->cards;
  1198.     }
  1200.     public function addCard(Card $card): self
  1201.     {
  1202.         if (!$this->cards->contains($card)) {
  1203.             $this->cards[] = $card;
  1204.             $card->setUser($this);
  1205.         }
  1207.         return $this;
  1208.     }
  1210.     public function removeCard(Card $card): self
  1211.     {
  1212.         if ($this->cards->removeElement($card)) {
  1213.             // set the owning side to null (unless already changed)
  1214.             if ($card->getUser() === $this) {
  1215.                 $card->setUser(null);
  1216.             }
  1217.         }
  1219.         return $this;
  1220.     }
  1221. }