src/Entity/UserVendeur.php line 20

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserVendeurRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use App\Entity\Traits\Ficherdate;
  10. use App\Entity\ClientUser;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  15. /**
  16.  * @ORM\Entity(repositoryClass=UserVendeurRepository::class)
  17.  * @UniqueEntity(fields={"email"}, message="un compte existe déjà avec cet e-mail")
  18.  * @ORM\HasLifecycleCallbacks
  19.  */
  20. class UserVendeur implements UserInterface, PasswordAuthenticatedUserInterface
  21. {
  24.     use Ficherdate;
  26.     /**
  27.      * @ORM\Id
  28.      * @ORM\GeneratedValue
  29.      * @ORM\Column(type="integer")
  30.      */
  31.     private $id;
  33.     /**
  34.      * @ORM\Column(type="string", length=180, unique=true)
  35.      */
  36.     private $email;
  38.     /**
  39.      * @ORM\Column(type="json")
  40.      */
  41.     private $roles = [];
  43.     /**
  44.      * @var string The hashed password
  45.      * @ORM\Column(type="string")
  46.      */
  47.     private $password;
  49.     /**
  50.      * @ORM\Column(type="boolean")
  51.      */
  52.     private $isVerified = false;
  54.     /**
  55.      * @ORM\Column(type="string", length=255)
  56.      */
  57.     private $nom;
  59.     /**
  60.      * @ORM\Column(type="string", length=255)
  61.      */
  62.     private $prenom;
  64.     /**
  65.      * @ORM\Column(type="string", length=255)
  66.      */
  67.     private $nomBoutique;
  69.     /**
  70.      * @ORM\Column(type="string", length=255)
  71.      */
  72.     private $categorie;
  74.     /**
  75.      * @ORM\Column(type="string", length=255)
  76.      */
  77.     private $numero;
  79.     /**
  80.      * @ORM\Column(type="string", length=255, nullable=true)
  81.      */
  82.     private $description;
  84.     /**
  85.      * @ORM\Column(type="string", length=255)
  86.      */
  87.     private $geolocalisation;
  89.     /**
  90.      * @ORM\Column(type="string", length=255)
  91.      */
  92.     private $compte;
  94.     /**
  95.      * @ORM\OneToMany(targetEntity=Livraison::class, mappedBy="userVendeur", orphanRemoval=true)
  96.      */
  97.     private $livraisons;
  99.     /**
  100.      * @ORM\OneToMany(targetEntity=Suivre::class, mappedBy="userVendeur", orphanRemoval=true)
  101.      */
  102.     private $suivres;
  104.     /**
  105.      * @ORM\OneToMany(targetEntity=Articles::class, mappedBy="vendeurs", orphanRemoval=true)
  106.      */
  107.     private $articles;
  109.     /**
  110.      * @ORM\OneToMany(targetEntity=CouvertureProfil::class, mappedBy="vendeurs")
  111.      */
  112.     private $couvertureProfils;
  114.     /**
  115.      * @ORM\OneToMany(targetEntity=PhotoVendeurs::class, mappedBy="vendeurs", orphanRemoval=true)
  116.      */
  117.     private $photoVendeurs;
  119.     public function __construct()
  120.     {
  121.         $this->livraisons = new ArrayCollection();
  122.         $this->suivres = new ArrayCollection();
  123.         $this->articles = new ArrayCollection();
  124.         $this->couvertureProfils = new ArrayCollection();
  125.         $this->photoVendeurs = new ArrayCollection();
  126.     }
  128.     
  129.     public function getId(): ?int
  130.     {
  131.         return $this->id;
  132.     }
  134.     public function getEmail(): ?string
  135.     {
  136.         return $this->email;
  137.     }
  139.     public function setEmail(string $email): self
  140.     {
  141.         $this->email = $email;
  143.         return $this;
  144.     }
  146.     /**
  147.      * A visual identifier that represents this user.
  148.      *
  149.      * @see UserInterface
  150.      */
  151.     public function getUserIdentifier(): string
  152.     {
  153.         return (string) $this->email;
  154.     }
  156.     /**
  157.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  158.      */
  159.     public function getUsername(): string
  160.     {
  161.         return (string) $this->email;
  162.     }
  164.     /**
  165.      * @see UserInterface
  166.      */
  167.     public function getRoles(): array
  168.     {
  169.         $roles = $this->roles;
  170.         // guarantee every user at least has ROLE_USER
  171.         $roles[] = 'ROLE_USER';
  173.         return array_unique($roles);
  174.     }
  176.     public function setRoles(array $roles): self
  177.     {
  178.         $this->roles = $roles;
  180.         return $this;
  181.     }
  183.     /**
  184.      * @see PasswordAuthenticatedUserInterface
  185.      */
  186.     public function getPassword(): string
  187.     {
  188.         return $this->password;
  189.     }
  191.     public function setPassword(string $password): self
  192.     {
  193.         $this->password = $password;
  195.         return $this;
  196.     }
  198.     /**
  199.      * Returning a salt is only needed, if you are not using a modern
  200.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  201.      *
  202.      * @see UserInterface
  203.      */
  204.     public function getSalt(): ?string
  205.     {
  206.         return null;
  207.     }
  209.     /**
  210.      * @see UserInterface
  211.      */
  212.     public function eraseCredentials()
  213.     {
  214.         // If you store any temporary, sensitive data on the user, clear it here
  215.         // $this->plainPassword = null;
  216.     }
  218.     public function isVerified(): bool
  219.     {
  220.         return $this->isVerified;
  221.     }
  223.     public function setIsVerified(bool $isVerified): self
  224.     {
  225.         $this->isVerified = $isVerified;
  227.         return $this;
  228.     }
  230.     public function getNom(): ?string
  231.     {
  232.         return $this->nom;
  233.     }
  235.     public function setNom(string $nom): self
  236.     {
  237.         $this->nom = $nom;
  239.         return $this;
  240.     }
  242.     public function getPrenom(): ?string
  243.     {
  244.         return $this->prenom;
  245.     }
  247.     public function setPrenom(string $prenom): self
  248.     {
  249.         $this->prenom = $prenom;
  251.         return $this;
  252.     }
  254.     public function getToutleNom(): string
  255.     {
  257.         return $this->getNom() . ' ' . $this->getPrenom();
  258.     }
  260.     public function getNomBoutique(): ?string
  261.     {
  262.         return $this->nomBoutique;
  263.     }
  265.     public function setNomBoutique(string $nomBoutique): self
  266.     {
  267.         $this->nomBoutique = $nomBoutique;
  269.         return $this;
  270.     }
  272.     public function getCategorie(): ?string
  273.     {
  274.         return $this->categorie;
  275.     }
  277.     public function setCategorie(string $categorie): self
  278.     {
  279.         $this->categorie = $categorie;
  281.         return $this;
  282.     }
  284.     public function getNumero(): ?int
  285.     {
  286.         return $this->numero;
  287.     }
  289.     public function setNumero(int $numero): self
  290.     {
  291.         $this->numero = $numero;
  293.         return $this;
  294.     }
  296.     public function getDescription(): ?string
  297.     {
  298.         return $this->description;
  299.     }
  301.     public function setDescription(?string $description): self
  302.     {
  303.         $this->description = $description;
  305.         return $this;
  306.     }
  308.     public function getGeolocalisation(): ?string
  309.     {
  310.         return $this->geolocalisation;
  311.     }
  313.     public function setGeolocalisation(string $geolocalisation): self
  314.     {
  315.         $this->geolocalisation = $geolocalisation;
  317.         return $this;
  318.     }
  321.     public function getCompte(): ?string
  322.     {
  323.         return $this->compte;
  324.     }
  326.     public function setCompte(string $compte): self
  327.     {
  328.         $this->compte = $compte;
  330.         return $this;
  331.     }
  333.     /**
  334.      * @return Collection<int, Livraison>
  335.      */
  336.     public function getLivraisons(): Collection
  337.     {
  338.         return $this->livraisons;
  339.     }
  341.     public function addLivraison(Livraison $livraison): self
  342.     {
  343.         if (!$this->livraisons->contains($livraison)) {
  344.             $this->livraisons[] = $livraison;
  345.             $livraison->setUserVendeur($this);
  346.         }
  348.         return $this;
  349.     }
  351.     public function removeLivraison(Livraison $livraison): self
  352.     {
  353.         if ($this->livraisons->removeElement($livraison)) {
  354.             // set the owning side to null (unless already changed)
  355.             if ($livraison->getUserVendeur() === $this) {
  356.                 $livraison->setUserVendeur(null);
  357.             }
  358.         }
  360.         return $this;
  361.     }
  363.     /**
  364.      * @return Collection<int, Suivre>
  365.      */
  366.     public function getSuivres(): Collection
  367.     {
  368.         return $this->suivres;
  369.     }
  371.     public function addSuivre(Suivre $suivre): self
  372.     {
  373.         if (!$this->suivres->contains($suivre)) {
  374.             $this->suivres[] = $suivre;
  375.             $suivre->setUserVendeur($this);
  376.         }
  378.         return $this;
  379.     }
  381.     public function removeSuivre(Suivre $suivre): self
  382.     {
  383.         if ($this->suivres->removeElement($suivre)) {
  384.             // set the owning side to null (unless already changed)
  385.             if ($suivre->getUserVendeur() === $this) {
  386.                 $suivre->setUserVendeur(null);
  387.             }
  388.         }
  390.         return $this;
  391.     }
  393.     /**
  394.      * @return Collection<int, Articles>
  395.      */
  396.     public function getArticles(): Collection
  397.     {
  398.         return $this->articles;
  399.     }
  401.     public function addArticle(Articles $article): self
  402.     {
  403.         if (!$this->articles->contains($article)) {
  404.             $this->articles[] = $article;
  405.             $article->setVendeurs($this);
  406.         }
  408.         return $this;
  409.     }
  411.     public function removeArticle(Articles $article): self
  412.     {
  413.         if ($this->articles->removeElement($article)) {
  414.             // set the owning side to null (unless already changed)
  415.             if ($article->getVendeurs() === $this) {
  416.                 $article->setVendeurs(null);
  417.             }
  418.         }
  420.         return $this;
  421.     }
  424.     /**
  425.      * cette fonction permet de voir si une boutique est abonné à une boutique
  426.      * 
  427.      * @param UserVendeur $userVendeur
  428.      * @return boolean
  429.      */
  430.     public function BoutiqueAbonneAboutique(ClientUser $userUser): bool 
  431.     {
  433.         foreach ($this->suivres as $suivres) {
  434.             
  435.             if ($suivres->getUserClient() == $userUser) return true;
  436.         }
  438.         return false;
  439.         
  440.     }
  442.     /**
  443.      * @return Collection<int, CouvertureProfil>
  444.      */
  445.     public function getCouvertureProfils(): Collection
  446.     {
  447.         return $this->couvertureProfils;
  448.     }
  450.     public function addCouvertureProfil(CouvertureProfil $couvertureProfil): self
  451.     {
  452.         if (!$this->couvertureProfils->contains($couvertureProfil)) {
  453.             $this->couvertureProfils[] = $couvertureProfil;
  454.             $couvertureProfil->setVendeurs($this);
  455.         }
  457.         return $this;
  458.     }
  460.     public function removeCouvertureProfil(CouvertureProfil $couvertureProfil): self
  461.     {
  462.         if ($this->couvertureProfils->removeElement($couvertureProfil)) {
  463.             // set the owning side to null (unless already changed)
  464.             if ($couvertureProfil->getVendeurs() === $this) {
  465.                 $couvertureProfil->setVendeurs(null);
  466.             }
  467.         }
  469.         return $this;
  470.     }
  472.     /**
  473.      * @return Collection<int, PhotoVendeurs>
  474.      */
  475.     public function getPhotoVendeurs(): Collection
  476.     {
  477.         return $this->photoVendeurs;
  478.     }
  480.     public function addPhotoVendeur(PhotoVendeurs $photoVendeur): self
  481.     {
  482.         if (!$this->photoVendeurs->contains($photoVendeur)) {
  483.             $this->photoVendeurs[] = $photoVendeur;
  484.             $photoVendeur->setVendeurs($this);
  485.         }
  487.         return $this;
  488.     }
  490.     public function removePhotoVendeur(PhotoVendeurs $photoVendeur): self
  491.     {
  492.         if ($this->photoVendeurs->removeElement($photoVendeur)) {
  493.             // set the owning side to null (unless already changed)
  494.             if ($photoVendeur->getVendeurs() === $this) {
  495.                 $photoVendeur->setVendeurs(null);
  496.             }
  497.         }
  499.         return $this;
  500.     }
  502.     
  503. }