src/Entity/User.php line 17

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="There is already an account with this email")
  16.  */
  17. class User implements UserInterface, PasswordAuthenticatedUserInterface
  18. {
  19.     /**
  20.      * @ORM\Id
  21.      * @ORM\GeneratedValue
  22.      * @ORM\Column(type="integer")
  23.      */
  24.     private $id;
  26.     /**
  27.      * @ORM\Column(type="string", length=180, unique=true)
  28.      */
  29.     private $email;
  31.     /**
  32.      * @ORM\Column(type="json")
  33.      */
  34.     private $roles = [];
  36.     /**
  37.      * @var string The hashed password
  38.      * @ORM\Column(type="string")
  39.      */
  40.     private $password;
  42.     /**
  43.      * @ORM\Column(type="string", length=255, nullable=true)
  44.      */
  45.     private $Civilite;
  47.     /**
  48.      * @ORM\Column(type="string", length=255, nullable=true)
  49.      */
  50.     private $Nom;
  52.     /**
  53.      * @ORM\Column(type="string", length=255, nullable=true)
  54.      */
  55.     private $Prenom;
  57.     /**
  58.      * @ORM\Column(type="string", length=255, nullable=true)
  59.      */
  60.     private $RaisonSociale;
  62.     /**
  63.      * @ORM\Column(type="integer", nullable=true)
  64.      */
  65.     private $Siret;
  67.     /**
  68.      * @ORM\Column(type="string", length=255, nullable=true)
  69.      */
  70.     private $Tva;
  72.     /**
  73.      * @ORM\Column(type="string", length=255, nullable=true)
  74.      */
  75.     private $Adresse;
  77.     /**
  78.      * @ORM\Column(type="string", length=255, nullable=true)
  79.      */
  80.     private $CodePostal;
  82.     /**
  83.      * @ORM\Column(type="string", length=255, nullable=true)
  84.      */
  85.     private $Telephone;
  87.     /**
  88.      * @ORM\Column(type="string", length=255, nullable=true)
  89.      */
  90.     private $Logo;
  92.     /**
  93.      * @ORM\Column(type="string", length=255, nullable=true)
  94.      */
  95.     private $Type;
  97.     /**
  98.      * @ORM\OneToMany(targetEntity=Favoris::class, mappedBy="User")
  99.      */
  100.     private $favoris;
  102.     /**
  103.      * @ORM\OneToMany(targetEntity=Annonces::class, mappedBy="User")
  104.      */
  105.     private $annonces;
  107.     /**
  108.      * @ORM\OneToMany(targetEntity=NotesEnseignes::class, mappedBy="User")
  109.      */
  110.     private $notesEnseignes;
  112.     /**
  113.      * @ORM\OneToMany(targetEntity=NotesAnnonces::class, mappedBy="User")
  114.      */
  115.     private $notesAnnonces;
  117.     /**
  118.      * @ORM\OneToMany(targetEntity=Alertes::class, mappedBy="User")
  119.      */
  120.     private $alertes;
  122.     /**
  123.      * @ORM\Column(type="boolean")
  124.      */
  125.     private $Actif = 1;
  127.     /**
  128.      * @ORM\Column(type="integer", nullable=true)
  129.      */
  130.     private $Credits = 100;
  132.     /**
  133.      * @ORM\ManyToOne(targetEntity=Villes::class, inversedBy="users")
  134.      */
  135.     private $Villes;
  137.     /**
  138.      * @ORM\ManyToOne(targetEntity=Pays::class, inversedBy="users")
  139.      */
  140.     private $Pays;
  142.     /**
  143.      * @ORM\Column(type="datetime")
  144.      */
  145.     private $Created;
  147.     /**
  148.      * @ORM\Column(type="string", length=255, nullable=true)
  149.      */
  150.     private $TokenMobile;
  152.     /**
  153.      * @ORM\OneToMany(targetEntity=Commandes::class, mappedBy="User")
  154.      */
  155.     private $commandes;
  157.     /**
  158.      * @ORM\OneToMany(targetEntity=Factures::class, mappedBy="User")
  159.      */
  160.     private $factures;
  162.     public function __construct()
  163.     {
  164.         $this->favoris = new ArrayCollection();
  165.         $this->annonces = new ArrayCollection();
  166.         $this->notesEnseignes = new ArrayCollection();
  167.         $this->notesAnnonces = new ArrayCollection();
  168.         $this->alertes = new ArrayCollection();
  169.         $this->commandes = new ArrayCollection();
  170.         $this->factures = new ArrayCollection();
  171.     }
  173.     public function getId(): ?int
  174.     {
  175.         return $this->id;
  176.     }
  178.     public function getEmail(): ?string
  179.     {
  180.         return $this->email;
  181.     }
  183.     public function setEmail(string $email): self
  184.     {
  185.         $this->email = $email;
  187.         return $this;
  188.     }
  190.     /**
  191.      * A visual identifier that represents this user.
  192.      *
  193.      * @see UserInterface
  194.      */
  195.     public function getUserIdentifier(): string
  196.     {
  197.         return (string) $this->email;
  198.     }
  200.     /**
  201.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  202.      */
  203.     public function getUsername(): string
  204.     {
  205.         return (string) $this->email;
  206.     }
  208.     /**
  209.      * @see UserInterface
  210.      */
  211.     public function getRoles(): array
  212.     {
  213.         $roles = $this->roles;
  214.         // guarantee every user at least has ROLE_USER
  215.         $roles[] = 'ROLE_USER';
  217.         return array_unique($roles);
  218.     }
  220.     public function setRoles(array $roles): self
  221.     {
  222.         $this->roles = $roles;
  224.         return $this;
  225.     }
  227.     /**
  228.      * @see PasswordAuthenticatedUserInterface
  229.      */
  230.     public function getPassword(): string
  231.     {
  232.         return $this->password;
  233.     }
  235.     public function setPassword(string $password): self
  236.     {
  237.         $this->password = $password;
  239.         return $this;
  240.     }
  242.     /**
  243.      * Returning a salt is only needed, if you are not using a modern
  244.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  245.      *
  246.      * @see UserInterface
  247.      */
  248.     public function getSalt(): ?string
  249.     {
  250.         return null;
  251.     }
  253.     /**
  254.      * @see UserInterface
  255.      */
  256.     public function eraseCredentials()
  257.     {
  258.         // If you store any temporary, sensitive data on the user, clear it here
  259.         // $this->plainPassword = null;
  260.     }
  262.     public function getCivilite(): ?string
  263.     {
  264.         return $this->Civilite;
  265.     }
  267.     public function setCivilite(?string $Civilite): self
  268.     {
  269.         $this->Civilite = $Civilite;
  271.         return $this;
  272.     }
  274.     public function getNom(): ?string
  275.     {
  276.         return $this->Nom;
  277.     }
  279.     public function setNom(?string $Nom): self
  280.     {
  281.         $this->Nom = $Nom;
  283.         return $this;
  284.     }
  286.     public function getPrenom(): ?string
  287.     {
  288.         return $this->Prenom;
  289.     }
  291.     public function setPrenom(?string $Prenom): self
  292.     {
  293.         $this->Prenom = $Prenom;
  295.         return $this;
  296.     }
  298.     public function getRaisonSociale(): ?string
  299.     {
  300.         return $this->RaisonSociale;
  301.     }
  303.     public function setRaisonSociale(?string $RaisonSociale): self
  304.     {
  305.         $this->RaisonSociale = $RaisonSociale;
  307.         return $this;
  308.     }
  310.     public function getSiret(): ?int
  311.     {
  312.         return $this->Siret;
  313.     }
  315.     public function setSiret(?int $Siret): self
  316.     {
  317.         $this->Siret = $Siret;
  319.         return $this;
  320.     }
  322.     public function getTva(): ?string
  323.     {
  324.         return $this->Tva;
  325.     }
  327.     public function setTva(?string $Tva): self
  328.     {
  329.         $this->Tva = $Tva;
  331.         return $this;
  332.     }
  334.     public function getAdresse(): ?string
  335.     {
  336.         return $this->Adresse;
  337.     }
  339.     public function setAdresse(?string $Adresse): self
  340.     {
  341.         $this->Adresse = $Adresse;
  343.         return $this;
  344.     }
  346.     public function getCodePostal(): ?string
  347.     {
  348.         return $this->CodePostal;
  349.     }
  351.     public function setCodePostal(?string $CodePostal): self
  352.     {
  353.         $this->CodePostal = $CodePostal;
  355.         return $this;
  356.     }
  358.     public function getTelephone(): ?string
  359.     {
  360.         return $this->Telephone;
  361.     }
  363.     public function setTelephone(?string $Telephone): self
  364.     {
  365.         $this->Telephone = $Telephone;
  367.         return $this;
  368.     }
  370.     public function getLogo(): ?string
  371.     {
  372.         return $this->Logo;
  373.     }
  375.     public function setLogo(?string $Logo): self
  376.     {
  377.         $this->Logo = $Logo;
  379.         return $this;
  380.     }
  382.     public function getType(): ?string
  383.     {
  384.         return $this->Type;
  385.     }
  387.     public function setType(?string $Type): self
  388.     {
  389.         $this->Type = $Type;
  391.         return $this;
  392.     }
  394.     /**
  395.      * @return Collection<int, Favoris>
  396.      */
  397.     public function getFavoris(): Collection
  398.     {
  399.         return $this->favoris;
  400.     }
  402.     public function addFavori(Favoris $favori): self
  403.     {
  404.         if (!$this->favoris->contains($favori)) {
  405.             $this->favoris[] = $favori;
  406.             $favori->setUser($this);
  407.         }
  409.         return $this;
  410.     }
  412.     public function removeFavori(Favoris $favori): self
  413.     {
  414.         if ($this->favoris->removeElement($favori)) {
  415.             // set the owning side to null (unless already changed)
  416.             if ($favori->getUser() === $this) {
  417.                 $favori->setUser(null);
  418.             }
  419.         }
  421.         return $this;
  422.     }
  424.     /**
  425.      * @return Collection<int, Annonces>
  426.      */
  427.     public function getAnnonces(): Collection
  428.     {
  429.         return $this->annonces;
  430.     }
  432.     public function addAnnonce(Annonces $annonce): self
  433.     {
  434.         if (!$this->annonces->contains($annonce)) {
  435.             $this->annonces[] = $annonce;
  436.             $annonce->setUser($this);
  437.         }
  439.         return $this;
  440.     }
  442.     public function removeAnnonce(Annonces $annonce): self
  443.     {
  444.         if ($this->annonces->removeElement($annonce)) {
  445.             // set the owning side to null (unless already changed)
  446.             if ($annonce->getUser() === $this) {
  447.                 $annonce->setUser(null);
  448.             }
  449.         }
  451.         return $this;
  452.     }
  454.     /**
  455.      * @return Collection<int, NotesEnseignes>
  456.      */
  457.     public function getNotesEnseignes(): Collection
  458.     {
  459.         return $this->notesEnseignes;
  460.     }
  462.     public function addNotesEnseigne(NotesEnseignes $notesEnseigne): self
  463.     {
  464.         if (!$this->notesEnseignes->contains($notesEnseigne)) {
  465.             $this->notesEnseignes[] = $notesEnseigne;
  466.             $notesEnseigne->setUser($this);
  467.         }
  469.         return $this;
  470.     }
  472.     public function removeNotesEnseigne(NotesEnseignes $notesEnseigne): self
  473.     {
  474.         if ($this->notesEnseignes->removeElement($notesEnseigne)) {
  475.             // set the owning side to null (unless already changed)
  476.             if ($notesEnseigne->getUser() === $this) {
  477.                 $notesEnseigne->setUser(null);
  478.             }
  479.         }
  481.         return $this;
  482.     }
  484.     /**
  485.      * @return Collection<int, NotesAnnonces>
  486.      */
  487.     public function getNotesAnnonces(): Collection
  488.     {
  489.         return $this->notesAnnonces;
  490.     }
  492.     public function addNotesAnnonce(NotesAnnonces $notesAnnonce): self
  493.     {
  494.         if (!$this->notesAnnonces->contains($notesAnnonce)) {
  495.             $this->notesAnnonces[] = $notesAnnonce;
  496.             $notesAnnonce->setUser($this);
  497.         }
  499.         return $this;
  500.     }
  502.     public function removeNotesAnnonce(NotesAnnonces $notesAnnonce): self
  503.     {
  504.         if ($this->notesAnnonces->removeElement($notesAnnonce)) {
  505.             // set the owning side to null (unless already changed)
  506.             if ($notesAnnonce->getUser() === $this) {
  507.                 $notesAnnonce->setUser(null);
  508.             }
  509.         }
  511.         return $this;
  512.     }
  514.     /**
  515.      * @return Collection<int, Alertes>
  516.      */
  517.     public function getAlertes(): Collection
  518.     {
  519.         return $this->alertes;
  520.     }
  522.     public function addAlerte(Alertes $alerte): self
  523.     {
  524.         if (!$this->alertes->contains($alerte)) {
  525.             $this->alertes[] = $alerte;
  526.             $alerte->setUser($this);
  527.         }
  529.         return $this;
  530.     }
  532.     public function removeAlerte(Alertes $alerte): self
  533.     {
  534.         if ($this->alertes->removeElement($alerte)) {
  535.             // set the owning side to null (unless already changed)
  536.             if ($alerte->getUser() === $this) {
  537.                 $alerte->setUser(null);
  538.             }
  539.         }
  541.         return $this;
  542.     }
  544.     public function isActif(): ?bool
  545.     {
  546.         return $this->Actif;
  547.     }
  549.     public function setActif(bool $Actif): self
  550.     {
  551.         $this->Actif = $Actif;
  553.         return $this;
  554.     }
  556.     public function getCredits(): ?int
  557.     {
  558.         return $this->Credits;
  559.     }
  561.     public function setCredits(?int $Credits): self
  562.     {
  563.         $this->Credits = $Credits;
  565.         return $this;
  566.     }
  568.     public function getVilles(): ?Villes
  569.     {
  570.         return $this->Villes;
  571.     }
  573.     public function setVilles(?Villes $Villes): self
  574.     {
  575.         $this->Villes = $Villes;
  577.         return $this;
  578.     }
  580.     public function getPays(): ?Pays
  581.     {
  582.         return $this->Pays;
  583.     }
  585.     public function setPays(?Pays $Pays): self
  586.     {
  587.         $this->Pays = $Pays;
  589.         return $this;
  590.     }
  592.     public function getCreated(): ?\DateTimeInterface
  593.     {
  594.         return $this->Created;
  595.     }
  597.     public function setCreated(\DateTimeInterface $Created): self
  598.     {
  599.         $this->Created = $Created;
  601.         return $this;
  602.     }
  604.     public function getTokenMobile(): ?string
  605.     {
  606.         return $this->TokenMobile;
  607.     }
  609.     public function setTokenMobile(?string $TokenMobile): self
  610.     {
  611.         $this->TokenMobile = $TokenMobile;
  613.         return $this;
  614.     }
  616.     /**
  617.      * @return Collection<int, Commandes>
  618.      */
  619.     public function getCommandes(): Collection
  620.     {
  621.         return $this->commandes;
  622.     }
  624.     public function addCommande(Commandes $commande): self
  625.     {
  626.         if (!$this->commandes->contains($commande)) {
  627.             $this->commandes[] = $commande;
  628.             $commande->setUser($this);
  629.         }
  631.         return $this;
  632.     }
  634.     public function removeCommande(Commandes $commande): self
  635.     {
  636.         if ($this->commandes->removeElement($commande)) {
  637.             // set the owning side to null (unless already changed)
  638.             if ($commande->getUser() === $this) {
  639.                 $commande->setUser(null);
  640.             }
  641.         }
  643.         return $this;
  644.     }
  646.     /**
  647.      * @return Collection<int, Factures>
  648.      */
  649.     public function getFactures(): Collection
  650.     {
  651.         return $this->factures;
  652.     }
  654.     public function addFacture(Factures $facture): self
  655.     {
  656.         if (!$this->factures->contains($facture)) {
  657.             $this->factures[] = $facture;
  658.             $facture->setUser($this);
  659.         }
  661.         return $this;
  662.     }
  664.     public function removeFacture(Factures $facture): self
  665.     {
  666.         if ($this->factures->removeElement($facture)) {
  667.             // set the owning side to null (unless already changed)
  668.             if ($facture->getUser() === $this) {
  669.                 $facture->setUser(null);
  670.             }
  671.         }
  673.         return $this;
  674.     }
  675. }