src/Entity/User.php line 18

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  13. /**
  14.  * @ORM\Entity(repositoryClass=UserRepository::class)
  15.  * @UniqueEntity(fields={"email"}, message="Il existe déjà un compte avec cette adresse e-mail.")
  16.  * @ORM\HasLifecycleCallbacks()
  17.  */
  18. class User implements UserInterface, PasswordAuthenticatedUserInterface
  19. {
  20.     /**
  21.      * @ORM\Id
  22.      * @ORM\GeneratedValue
  23.      * @ORM\Column(type="integer")
  24.      */
  25.     private $id;
  27.     /**
  28.      * @ORM\Column(type="string", length=180, unique=true)
  29.      */
  30.     private $email;
  32.     /**
  33.      * @ORM\Column(type="json")
  34.      */
  35.     private $roles = [];
  37.     /**
  38.      * @var string The hashed password
  39.      * @ORM\Column(type="string")
  40.      */
  41.     private $password;
  43.     /**
  44.      * @ORM\Column(type="string", length=100)
  45.      */
  46.     private $nom;
  48.     /**
  49.      * @ORM\Column(type="string", length=100)
  50.      */
  51.     private $prenom;
  53.     /**
  54.      * @ORM\Column(type="date", nullable=true)
  55.      */
  56.     private $dateNaissance = null;
  58.     /**
  59.      * @ORM\Column(type="string", length=20)
  60.      */
  61.     private $telephone;
  63.     /**
  64.      * @ORM\OneToMany(targetEntity=Trajet::class, mappedBy="conducteur")
  65.      */
  66.     private $trajets;
  68.     /**
  69.      * @ORM\OneToMany(targetEntity=Reservation::class, mappedBy="passager")
  70.      */
  71.     private $reservations;
  73.     /**
  74.      * @ORM\OneToMany(targetEntity=Message::class, mappedBy="expediteur")
  75.      */
  76.     private $messagesExpediteur;
  78.     /**
  79.      * @ORM\OneToMany(targetEntity=Message::class, mappedBy="destinataire")
  80.      */
  81.     private $messagesDestinataire;
  83.     /**
  84.      * @ORM\OneToMany(targetEntity=Notes::class, mappedBy="noteur")
  85.      */
  86.     private $notesNoteur;
  88.     /**
  89.      * @ORM\OneToMany(targetEntity=Notes::class, mappedBy="notePour")
  90.      */
  91.     private $notesPour;
  93.     /**
  94.      * @ORM\Column(type="boolean", nullable=true)
  95.      */
  96.     private $conducteurVerifie;
  98.     /**
  99.      * @ORM\Column(type="boolean")
  100.      */
  101.     private $isVerified = false;
  103.     /**
  104.      * @ORM\OneToMany(targetEntity=Document::class, mappedBy="user", cascade={"persist", "remove"})
  105.      */
  106.     private $documents;
  108.     /**
  109.      * @ORM\Column(type="string", length=255, nullable=true)
  110.      */
  111.     private $photo;
  113.     /**
  114.      * @ORM\Column(type="datetime")
  115.      */
  116.     private $createdAt;
  118.     /**
  119.      * @ORM\OneToMany(targetEntity=PushSubscription::class, mappedBy="user")
  120.      */
  121.     private $pushSubscriptions;
  123.     /**
  124.      * @ORM\Column(type="text", nullable=true)
  125.      */
  126.     private $description;
  128.     /**
  129.      * @ORM\PrePersist
  130.      */
  131.     public function setCreatedAtValue(): void
  132.     {
  133.         $this->createdAt = new \DateTime();
  134.     }
  136.     /**
  137.      * @ORM\Column(type="string", length=255, nullable=true)
  138.      */
  139.     private $stripeAccountId;
  141.     /**
  142.      * @ORM\Column(type="json", nullable=true)
  143.      */
  144.     private $preferences = [];
  146.     /**
  147.      * @ORM\OneToMany(targetEntity=Notification::class, mappedBy="user", orphanRemoval=true)
  148.      */
  149.     private $notifications;
  151.     public function __construct()
  152.     {
  153.         $this->trajets = new ArrayCollection();
  154.         $this->reservations = new ArrayCollection();
  155.         $this->messages = new ArrayCollection();
  156.         $this->messagesExpediteur = new ArrayCollection();
  157.         $this->messagesDestinataire = new ArrayCollection();
  158.         $this->notesNoteur = new ArrayCollection();
  159.         $this->notesPour = new ArrayCollection();
  160.         $this->documents = new ArrayCollection();
  161.         $this->pushSubscriptions = new ArrayCollection();
  162.         $this->notifications = new ArrayCollection();
  164.     }
  166.     public function getId(): ?int
  167.     {
  168.         return $this->id;
  169.     }
  171.     public function getEmail(): ?string
  172.     {
  173.         return $this->email;
  174.     }
  176.     public function setEmail(string $email): self
  177.     {
  178.         $this->email = $email;
  180.         return $this;
  181.     }
  183.     /**
  184.      * A visual identifier that represents this user.
  185.      *
  186.      * @see UserInterface
  187.      */
  188.     public function getUserIdentifier(): string
  189.     {
  190.         return (string) $this->email;
  191.     }
  193.     /**
  194.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  195.      */
  196.     public function getUsername(): string
  197.     {
  198.         return (string) $this->email;
  199.     }
  201.     /**
  202.      * @see UserInterface
  203.      */
  204.     public function getRoles(): array
  205.     {
  206.         $roles = $this->roles;
  207.         // guarantee every user at least has ROLE_USER
  208.         $roles[] = 'ROLE_USER';
  210.         return array_unique($roles);
  211.     }
  213.     public function setRoles(array $roles): self
  214.     {
  215.         $this->roles = $roles;
  217.         return $this;
  218.     }
  220.     /**
  221.      * @see PasswordAuthenticatedUserInterface
  222.      */
  223.     public function getPassword(): string
  224.     {
  225.         return $this->password;
  226.     }
  228.     public function setPassword(string $password): self
  229.     {
  230.         $this->password = $password;
  232.         return $this;
  233.     }
  235.     /**
  236.      * Returning a salt is only needed, if you are not using a modern
  237.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  238.      *
  239.      * @see UserInterface
  240.      */
  241.     public function getSalt(): ?string
  242.     {
  243.         return null;
  244.     }
  246.     /**
  247.      * @see UserInterface
  248.      */
  249.     public function eraseCredentials()
  250.     {
  251.         // If you store any temporary, sensitive data on the user, clear it here
  252.         // $this->plainPassword = null;
  253.     }
  255.     public function getNom(): ?string
  256.     {
  257.         return $this->nom;
  258.     }
  260.     public function setNom(string $nom): self
  261.     {
  262.         $this->nom = $nom;
  264.         return $this;
  265.     }
  267.     public function getPrenom(): ?string
  268.     {
  269.         return $this->prenom;
  270.     }
  272.     public function setPrenom(string $prenom): self
  273.     {
  274.         $this->prenom = $prenom;
  276.         return $this;
  277.     }
  279.     public function getDateNaissance(): ?\DateTimeInterface
  280.     {
  281.         return $this->dateNaissance;
  282.     }
  284.     public function setDateNaissance(?\DateTimeInterface $dateNaissance): self
  285.     {
  286.         $this->dateNaissance = $dateNaissance;
  287.         return $this;
  288.     }
  290.     public function getTelephone(): ?string
  291.     {
  292.         return $this->telephone;
  293.     }
  295.     public function setTelephone(string $telephone): self
  296.     {
  297.         $this->telephone = $telephone;
  299.         return $this;
  300.     }
  302.     /**
  303.      * @return Collection<int, Trajet>
  304.      */
  305.     public function getTrajets(): Collection
  306.     {
  307.         return $this->trajets;
  308.     }
  310.     public function addTrajet(Trajet $trajet): self
  311.     {
  312.         if (!$this->trajets->contains($trajet)) {
  313.             $this->trajets[] = $trajet;
  314.             $trajet->setConducteur($this);
  315.         }
  317.         return $this;
  318.     }
  320.     public function removeTrajet(Trajet $trajet): self
  321.     {
  322.         if ($this->trajets->removeElement($trajet)) {
  323.             // set the owning side to null (unless already changed)
  324.             if ($trajet->getConducteur() === $this) {
  325.                 $trajet->setConducteur(null);
  326.             }
  327.         }
  329.         return $this;
  330.     }
  332.     /**
  333.      * @return Collection<int, Reservation>
  334.      */
  335.     public function getReservations(): Collection
  336.     {
  337.         return $this->reservations;
  338.     }
  340.     public function addReservation(Reservation $reservation): self
  341.     {
  342.         if (!$this->reservations->contains($reservation)) {
  343.             $this->reservations[] = $reservation;
  344.             $reservation->setPassager($this);
  345.         }
  347.         return $this;
  348.     }
  350.     public function removeReservation(Reservation $reservation): self
  351.     {
  352.         if ($this->reservations->removeElement($reservation)) {
  353.             // set the owning side to null (unless already changed)
  354.             if ($reservation->getPassager() === $this) {
  355.                 $reservation->setPassager(null);
  356.             }
  357.         }
  359.         return $this;
  360.     }
  362.     /**
  363.      * @return Collection<int, Message>
  364.      */
  365.     public function getMessagesExpediteur(): Collection
  366.     {
  367.         return $this->messagesExpediteur;
  368.     }
  370.     public function addMessagesExpediteur(Message $messagesExpediteur): self
  371.     {
  372.         if (!$this->messagesExpediteur->contains($messagesExpediteur)) {
  373.             $this->messagesExpediteur[] = $messagesExpediteur;
  374.             $messagesExpediteur->setExpediteur($this);
  375.         }
  377.         return $this;
  378.     }
  380.     public function removeMessagesExpediteur(Message $messagesExpediteur): self
  381.     {
  382.         if ($this->messagesExpediteur->removeElement($messagesExpediteur)) {
  383.             // set the owning side to null (unless already changed)
  384.             if ($messagesExpediteur->getExpediteur() === $this) {
  385.                 $messagesExpediteur->setExpediteur(null);
  386.             }
  387.         }
  389.         return $this;
  390.     }
  392.     /**
  393.      * @return Collection<int, Message>
  394.      */
  395.     public function getMessagesDestinataire(): Collection
  396.     {
  397.         return $this->messagesDestinataire;
  398.     }
  400.     public function addMessagesDestinataire(Message $messagesDestinataire): self
  401.     {
  402.         if (!$this->messagesDestinataire->contains($messagesDestinataire)) {
  403.             $this->messagesDestinataire[] = $messagesDestinataire;
  404.             $messagesDestinataire->setDestinataire($this);
  405.         }
  407.         return $this;
  408.     }
  410.     public function removeMessagesDestinataire(Message $messagesDestinataire): self
  411.     {
  412.         if ($this->messagesDestinataire->removeElement($messagesDestinataire)) {
  413.             // set the owning side to null (unless already changed)
  414.             if ($messagesDestinataire->getDestinataire() === $this) {
  415.                 $messagesDestinataire->setDestinataire(null);
  416.             }
  417.         }
  419.         return $this;
  420.     }
  422.     /**
  423.      * @return Collection<int, Notes>
  424.      */
  425.     public function getNotesNoteur(): Collection
  426.     {
  427.         return $this->notesNoteur;
  428.     }
  430.     public function addNotesNoteur(Notes $notesNoteur): self
  431.     {
  432.         if (!$this->notesNoteur->contains($notesNoteur)) {
  433.             $this->notesNoteur[] = $notesNoteur;
  434.             $notesNoteur->setNoteur($this);
  435.         }
  437.         return $this;
  438.     }
  440.     public function removeNotesNoteur(Notes $notesNoteur): self
  441.     {
  442.         if ($this->notesNoteur->removeElement($notesNoteur)) {
  443.             // set the owning side to null (unless already changed)
  444.             if ($notesNoteur->getNoteur() === $this) {
  445.                 $notesNoteur->setNoteur(null);
  446.             }
  447.         }
  449.         return $this;
  450.     }
  452.     /**
  453.      * @return Collection<int, Notes>
  454.      */
  455.     public function getNotesPour(): Collection
  456.     {
  457.         return $this->notesPour;
  458.     }
  460.     public function addNotesPour(Notes $notesPour): self
  461.     {
  462.         if (!$this->notesPour->contains($notesPour)) {
  463.             $this->notesPour[] = $notesPour;
  464.             $notesPour->setNotePour($this);
  465.         }
  467.         return $this;
  468.     }
  470.     public function removeNotesPour(Notes $notesPour): self
  471.     {
  472.         if ($this->notesPour->removeElement($notesPour)) {
  473.             // set the owning side to null (unless already changed)
  474.             if ($notesPour->getNotePour() === $this) {
  475.                 $notesPour->setNotePour(null);
  476.             }
  477.         }
  479.         return $this;
  480.     }
  482.     public function isConducteurVerifie(): ?bool
  483.     {
  484.         return $this->conducteurVerifie;
  485.     }
  487.     public function setConducteurVerifie(?bool $conducteurVerifie): self
  488.     {
  489.         $this->conducteurVerifie = $conducteurVerifie;
  491.         return $this;
  492.     }
  494.     public function isVerified(): bool
  495.     {
  496.         return $this->isVerified;
  497.     }
  499.     public function setIsVerified(bool $isVerified): self
  500.     {
  501.         $this->isVerified = $isVerified;
  503.         return $this;
  504.     }
  506.     /**
  507.      * @return Collection<int, Document>
  508.      */
  509.     public function getDocuments(): Collection
  510.     {
  511.         return $this->documents;
  512.     }
  514.     public function addDocument(Document $document): self
  515.     {
  516.         if (!$this->documents->contains($document)) {
  517.             $this->documents[] = $document;
  518.             $document->setUser($this);
  519.         }
  521.         return $this;
  522.     }
  524.     public function removeDocument(Document $document): self
  525.     {
  526.         if ($this->documents->removeElement($document)) {
  527.             // set the owning side to null (unless already changed)
  528.             if ($document->getUser() === $this) {
  529.                 $document->setUser(null);
  530.             }
  531.         }
  533.         return $this;
  534.     }
  536.     public function getDocumentByType(string $type): ?Document
  537.     {
  538.         foreach ($this->documents as $doc) {
  539.             if ($doc->getTypeDocument() === $type) {
  540.                 return $doc;
  541.             }
  542.         }
  543.         return null;
  544.     }
  546.     public function getPhoto(): ?string
  547.     {
  548.         return $this->photo;
  549.     }
  551.     public function setPhoto(?string $photo): self
  552.     {
  553.         $this->photo = $photo;
  555.         return $this;
  556.     }
  558.     public function getCreatedAt(): ?\DateTimeInterface
  559.     {
  560.         return $this->createdAt;
  561.     }
  563.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  564.     {
  565.         $this->createdAt = $createdAt;
  566.         return $this;
  567.     }
  569.     /**
  570.      * @return Collection<int, PushSubscription>
  571.      */
  572.     public function getPushSubscriptions(): Collection
  573.     {
  574.         return $this->pushSubscriptions;
  575.     }
  577.     public function addPushSubscription(PushSubscription $pushSubscription): self
  578.     {
  579.         if (!$this->pushSubscriptions->contains($pushSubscription)) {
  580.             $this->pushSubscriptions[] = $pushSubscription;
  581.             $pushSubscription->setUser($this);
  582.         }
  584.         return $this;
  585.     }
  587.     public function removePushSubscription(PushSubscription $pushSubscription): self
  588.     {
  589.         if ($this->pushSubscriptions->removeElement($pushSubscription)) {
  590.             // set the owning side to null (unless already changed)
  591.             if ($pushSubscription->getUser() === $this) {
  592.                 $pushSubscription->setUser(null);
  593.             }
  594.         }
  596.         return $this;
  597.     }
  599.     public function getDescription(): ?string
  600.     {
  601.         return $this->description;
  602.     }
  604.     public function setDescription(?string $description): self
  605.     {
  606.         $this->description = $description;
  608.         return $this;
  609.     }
  611.     public function getPreferences(): array
  612.     {
  613.         return $this->preferences ?? [];
  614.     }
  616.     public function setPreferences(array $preferences): self
  617.     {
  618.         $this->preferences = $preferences;
  619.         return $this;
  620.     }
  623.     public function isProfilVerifieComplet(): bool
  624.     {
  625.         $doc = $this->getDocumentByType("identite");
  627.         return $this->isVerified() && $this->hasVerifiedIdentity()
  628.             // && $this->hasVerifiedPhone() // Pour plus tard
  629.         ;
  630.     }
  632.     public function hasVerifiedIdentity(): bool
  633.     {
  634.         $doc = $this->getDocumentByType("identite");
  635.         return $doc && $doc->getStatus() === Document::STATUS_APPROVED;
  636.     }
  638.     public function hasVerifiedPhone(): bool
  639.     {
  640.         return false; // à remplacer plus tard par vraie vérif
  641.     }
  643.     // Compte supprimé ! 
  644.     public function anonymiser(): void
  645.     {
  646.         $this->setNom('');
  647.         $this->setPrenom('Utilisateur supprimé');
  648.         $this->setDateNaissance(null);
  649.         $this->setEmail('deleted_' . $this->getId() . '@halogari.yt');
  650.         $this->setTelephone(0000 . $this->getId());
  651.         $this->setPassword('');
  652.         $this->setPhoto(null);
  653.         $this->setDescription(null);
  654.         $this->setIsVerified(false);
  655.     }
  657.     public function getStripeAccountId(): ?string
  658.     {
  659.         return $this->stripeAccountId;
  660.     }
  662.     public function setStripeAccountId(?string $stripeAccountId): self
  663.     {
  664.         $this->stripeAccountId = $stripeAccountId;
  665.         return $this;
  666.     }
  668.     public function getAge(): ?int
  669.     {
  670.         if (!$this->dateNaissance) {
  671.             return null;
  672.         }
  674.         $today = new \DateTimeImmutable();
  675.         return $today->diff($this->dateNaissance)->y;
  676.     }
  678.     public function getNotifications(): Collection
  679.     {
  680.         return $this->notifications;
  681.     }
  682. }