src/Entity/User.php line 25

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Core\Annotation\ApiResource;
  6. use App\Repository\UserRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  13. use Symfony\Component\Serializer\Annotation\Groups;
  14. use Symfony\Component\Serializer\Annotation\SerializedName;
  16. /**
  17.  * @ORM\Entity(repositoryClass=UserRepository::class)
  18.  * @ORM\Table(name="`user`")
  19.  * @UniqueEntity(fields={"telephone"}, message="There is already an account with this telephone")
  20.  * @ApiResource(
  21.  * normalizationContext={"groups"={"user:read"}},
  22.  * denormalizationContext={"groups"={"user:write"}}
  23.  * )
  24.  */
  25. class User implements UserInterface, PasswordAuthenticatedUserInterface
  26. {
  27.     /**
  28.      * @ORM\Id
  29.      * @ORM\GeneratedValue
  30.      * @ORM\Column(type="integer")
  31.      * @Groups({"user:read"})
  32.      * @Groups({"commandes:read","produit:read"})
  33.      */
  34.     private $id;
  36.     /**
  37.      * @ORM\Column(type="string", length=180, unique=true)
  38.      * @Groups({"user:read","commandes:read","produit:read","user:write"})
  39.      */
  40.     private $telephone;
  42.     /**
  43.      * @ORM\Column(type="json")
  44.      * @Groups({"user:read","commandes:read","produit:read"})
  45.      */
  46.     private $roles = [];
  48.     /**
  49.      * @var string The hashed password
  50.      * @ORM\Column(type="string")
  51.      *
  52.      */
  53.     private $password;
  55.     /**
  56.      * @Groups("user:write")
  57.      * @SerializedName("password")
  58.      */
  59.     protected $plainPassword;
  61.     /**
  62.      * @ORM\Column(type="string", length=255, nullable=true)
  63.      * @Groups({"user:read","commandes:read","produit:read","user:write"})
  64.      */
  65.     private $nom;
  67.     /**
  68.      * @ORM\Column(type="string", length=255, nullable=true)
  69.      * @Groups({"user:read","commandes:read","produit:read","user:write"})
  70.      */
  71.     private $prenoms;
  73.     /**
  74.      * @ORM\Column(type="string", length=255, nullable=true)
  75.      * @Groups({"user:read","commandes:read","produit:read","user:write"})
  76.      */
  77.     private $email;
  79.     /**
  80.      * @ORM\Column(type="string", length=255, nullable=true)
  81.      * @Groups({"user:read","commandes:read","produit:read","user:write"})
  82.      */
  83.     private $sexe;
  85.     /**
  86.      * @ORM\Column(type="string", length=255, nullable=true)
  87.      * @Groups({"user:read","produit:read","user:write"})
  88.      */
  89.     private $adresse;
  91.     /**
  92.      * @ORM\Column(type="string", length=255, nullable=true)
  93.      * @Groups({"user:read","commandes:read","produit:read","user:write"})
  94.      */
  95.     private $secteurActivite;
  97.     /**
  98.      * @ORM\Column(type="string", length=255, nullable=true)
  99.      * @Groups({"user:read","commandes:read","produit:read","user:write"})
  100.      */
  101.     private $terminal;
  103.     /**
  104.      * @ORM\OneToMany(targetEntity=Produits::class, mappedBy="utilisateur")
  105.      * @Groups({"user:read"})
  106.      */
  107.     private $produits;
  109.     /**
  110.      * @ORM\OneToMany(targetEntity=Commandes::class, mappedBy="client")
  111.      *
  112.      */
  113.     private $commandes;
  115.     /**
  116.      * @ORM\OneToMany(targetEntity=AdresseLivraison::class, mappedBy="client")
  117.      *
  118.      */
  119.     private $adresseLivraisons;
  122.     /**
  123.      * @ORM\Column(type="boolean")
  124.      * @Groups({"user:read"})
  125.      */
  126.     private $isVerified = false;
  128.     /**
  129.      * @ORM\OneToMany(targetEntity=ApiToken::class, mappedBy="utilisateur")
  130.      *
  131.      */
  132.     private $fcm_tokens;
  134.     /**
  135.      * @ORM\ManyToOne(targetEntity=Quartier::class, inversedBy="user")
  136.      * @Groups({"user:read","user:write"})
  137.      *
  138.      */
  139.     private $localite;
  141.     /**
  142.      * @Groups("user:read","user:write")
  143.      *
  144.      *
  145.      */
  146.     protected $localites;
  148.     /**
  149.      * @ORM\Column(type="string", length=255, nullable=true)
  150.      * @Groups({"user:read"})
  151.      */
  152.     private $fcm_token;
  154.     /**
  155.      * @ORM\OneToMany(targetEntity=FavorisProduits::class, mappedBy="utilisateurs")
  156.      * @Groups({"user:read","favoris:read"})
  157.      */
  158.     private $favoris;
  161.     public function __construct()
  162.     {
  163.         $this->produits = new ArrayCollection();
  164.         $this->commandes = new ArrayCollection();
  165.         $this->adresseLivraisons = new ArrayCollection();
  166.         $this->fcm_tokens = new ArrayCollection();
  167.         $this->favoris = new ArrayCollection();
  168.     }
  170.     public function getId(): ?int
  171.     {
  172.         return $this->id;
  173.     }
  175.     public function getTelephone(): ?string
  176.     {
  177.         return $this->telephone;
  178.     }
  180.     public function setTelephone(string $telephone): self
  181.     {
  182.         $this->telephone = $telephone;
  184.         return $this;
  185.     }
  187.     /**
  188.      * A visual identifier that represents this user.
  189.      *
  190.      * @see UserInterface
  191.      */
  192.     public function getUserIdentifier(): string
  193.     {
  194.         return (string)$this->nom;
  195.     }
  197.     /**
  198.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  199.      */
  200.     public function getUsername(): string
  201.     {
  202.         return (string)$this->telephone;
  203.     }
  205.     /**
  206.      * @see UserInterface
  207.      */
  208.     public function getRoles(): array
  209.     {
  210.         $roles = $this->roles;
  211.         // guarantee every user at least has ROLE_USER
  212.         $roles[] = 'ROLE_USER';
  214.         return array_unique($roles);
  215.     }
  217.     public function setRoles(array $roles): self
  218.     {
  219.         $this->roles = $roles;
  221.         return $this;
  222.     }
  224.     /**
  225.      * @see PasswordAuthenticatedUserInterface
  226.      */
  227.     public function getPassword(): string
  228.     {
  229.         return $this->password;
  230.     }
  232.     public function setPassword(string $password): self
  233.     {
  234.         $this->password = $password;
  236.         return $this;
  237.     }
  239.     /**
  240.      * Returning a salt is only needed, if you are not using a modern
  241.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  242.      *
  243.      * @see UserInterface
  244.      */
  245.     public function getSalt(): ?string
  246.     {
  247.         return null;
  248.     }
  250.     /**
  251.      * @see UserInterface
  252.      */
  253.     public function eraseCredentials()
  254.     {
  255.         // If you store any temporary, sensitive data on the user, clear it here
  256.         // $this->plainPassword = null;
  257.     }
  259.     public function getNom(): ?string
  260.     {
  261.         return $this->nom;
  262.     }
  264.     public function setNom(?string $nom): self
  265.     {
  266.         $this->nom = $nom;
  268.         return $this;
  269.     }
  271.     public function getPrenoms(): ?string
  272.     {
  273.         return $this->prenoms;
  274.     }
  276.     public function setPrenoms(?string $prenoms): self
  277.     {
  278.         $this->prenoms = $prenoms;
  280.         return $this;
  281.     }
  283.     public function getEmail(): ?string
  284.     {
  285.         return $this->email;
  286.     }
  288.     public function setEmail(?string $email): self
  289.     {
  290.         $this->email = $email;
  292.         return $this;
  293.     }
  295.     public function getSexe(): ?string
  296.     {
  297.         return $this->sexe;
  298.     }
  300.     public function setSexe(?string $sexe): self
  301.     {
  302.         $this->sexe = $sexe;
  304.         return $this;
  305.     }
  307.     public function getAdresse(): ?string
  308.     {
  309.         return $this->adresse;
  310.     }
  312.     public function setAdresse(?string $adresse): self
  313.     {
  314.         $this->adresse = $adresse;
  316.         return $this;
  317.     }
  319.     public function getSecteurActivite(): ?string
  320.     {
  321.         return $this->secteurActivite;
  322.     }
  324.     public function setSecteurActivite(?string $secteurActivite): self
  325.     {
  326.         $this->secteurActivite = $secteurActivite;
  328.         return $this;
  329.     }
  331.     public function getTerminal(): ?string
  332.     {
  333.         return $this->terminal;
  334.     }
  336.     public function setTerminal(?string $terminal): self
  337.     {
  338.         $this->terminal = $terminal;
  340.         return $this;
  341.     }
  343.     /**
  344.      * @return Collection<int, Produits>
  345.      */
  346.     public function getProduits(): Collection
  347.     {
  348.         return $this->produits;
  349.     }
  351.     public function addProduit(Produits $produit): self
  352.     {
  353.         if (!$this->produits->contains($produit)) {
  354.             $this->produits[] = $produit;
  355.             $produit->setUtilisateur($this);
  356.         }
  358.         return $this;
  359.     }
  361.     public function removeProduit(Produits $produit): self
  362.     {
  363.         if ($this->produits->removeElement($produit)) {
  364.             // set the owning side to null (unless already changed)
  365.             if ($produit->getUtilisateur() === $this) {
  366.                 $produit->setUtilisateur(null);
  367.             }
  368.         }
  370.         return $this;
  371.     }
  373.     /**
  374.      * @return Collection<int, Commandes>
  375.      */
  376.     public function getCommandes(): Collection
  377.     {
  378.         return $this->commandes;
  379.     }
  381.     public function addCommande(Commandes $commande): self
  382.     {
  383.         if (!$this->commandes->contains($commande)) {
  384.             $this->commandes[] = $commande;
  385.             $commande->setClient($this);
  386.         }
  388.         return $this;
  389.     }
  391.     public function removeCommande(Commandes $commande): self
  392.     {
  393.         if ($this->commandes->removeElement($commande)) {
  394.             // set the owning side to null (unless already changed)
  395.             if ($commande->getClient() === $this) {
  396.                 $commande->setClient(null);
  397.             }
  398.         }
  400.         return $this;
  401.     }
  403.     /**
  404.      * @return Collection<int, AdresseLivraison>
  405.      */
  406.     public function getAdresseLivraisons(): Collection
  407.     {
  408.         return $this->adresseLivraisons;
  409.     }
  411.     public function addAdresseLivraison(AdresseLivraison $adresseLivraison): self
  412.     {
  413.         if (!$this->adresseLivraisons->contains($adresseLivraison)) {
  414.             $this->adresseLivraisons[] = $adresseLivraison;
  415.             $adresseLivraison->setClient($this);
  416.         }
  418.         return $this;
  419.     }
  421.     public function removeAdresseLivraison(AdresseLivraison $adresseLivraison): self
  422.     {
  423.         if ($this->adresseLivraisons->removeElement($adresseLivraison)) {
  424.             // set the owning side to null (unless already changed)
  425.             if ($adresseLivraison->getClient() === $this) {
  426.                 $adresseLivraison->setClient(null);
  427.             }
  428.         }
  430.         return $this;
  431.     }
  433.     public function isVerified(): bool
  434.     {
  435.         return $this->isVerified;
  436.     }
  438.     public function setIsVerified(bool $isVerified): self
  439.     {
  440.         $this->isVerified = $isVerified;
  442.         return $this;
  443.     }
  445.     /**
  446.      * @return Collection<int, ApiToken>
  447.      */
  448.     public function getFcmTokens(): Collection
  449.     {
  450.         return $this->fcm_tokens;
  451.     }
  453.     public function addFcmTokens(ApiToken $fcmTokens): self
  454.     {
  455.         if (!$this->fcm_tokens->contains($fcmTokens)) {
  456.             $this->fcm_tokens[] = $fcmTokens;
  457.             $fcmTokens->setUtilisateur($this);
  458.         }
  460.         return $this;
  461.     }
  463.     public function removeFcmTokens(ApiToken $fcmTokens): self
  464.     {
  465.         if ($this->fcm_token->removeElement($fcmTokens)) {
  466.             // set the owning side to null (unless already changed)
  467.             if ($fcmTokens->getUtilisateur() === $this) {
  468.                 $fcmTokens->setUtilisateur(null);
  469.             }
  470.         }
  472.         return $this;
  473.     }
  475.     /**
  476.      * @return mixed
  477.      */
  478.     public function getPlainPassword()
  479.     {
  480.         return $this->plainPassword;
  481.     }
  483.     /**
  484.      * @param mixed $plainPassword
  485.      */
  486.     public function setPlainPassword($plainPassword): void
  487.     {
  488.         $this->plainPassword = $plainPassword;
  489.     }
  491.     public function isIsVerified(): ?bool
  492.     {
  493.         return $this->isVerified;
  494.     }
  496.     public function getLocalite()
  497.     {
  498.        return $this->localite;
  500.     }
  502. //    /**
  503. //     *  @Groups({"user:read"})
  504. //     */
  505. //    public function getLocalites():?Quartier
  506. //    {
  507. //
  508. //        return $this->localite;
  509. //    }
  511.     public function setLocalite(?Quartier $localite): self
  512.     {
  513.         $this->localite = $localite;
  515.         return $this;
  516.     }
  518.     public function getFcmToken(): ?string
  519.     {
  520.         return $this->fcm_token;
  521.     }
  523.     public function setFcmToken(?string $fcm_token): self
  524.     {
  525.         $this->fcm_token = $fcm_token;
  527.         return $this;
  528.     }
  530.     /**
  531.      * @return Collection<int, FavorisProduits>
  532.      */
  533.     public function getFavoris(): Collection
  534.     {
  535.         return $this->favoris;
  536.     }
  538.     public function addFavori(FavorisProduits $favori): self
  539.     {
  540.         if (!$this->favoris->contains($favori)) {
  541.             $this->favoris[] = $favori;
  542.             $favori->setUtilisateurs($this);
  543.         }
  545.         return $this;
  546.     }
  548.     public function removeFavori(FavorisProduits $favori): self
  549.     {
  550.         if ($this->favoris->removeElement($favori)) {
  551.             // set the owning side to null (unless already changed)
  552.             if ($favori->getUtilisateurs() === $this) {
  553.                 $favori->setUtilisateurs(null);
  554.             }
  555.         }
  557.         return $this;
  558.     }
  559. }