src/Entity/User.php line 23

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;
  12. use Symfony\Component\Validator\Constraints as Assert;
  13. use Symfony\Component\Serializer\Annotation\Groups;
  15. /**
  16.  * @ORM\Entity(repositoryClass=UserRepository::class)
  17.  * @method string getUserIdentifier()
  18.  * @UniqueEntity(fields={"email"}, message="Il semble que vous ayez déjà un compte")
  19.  * @UniqueEntity(fields={"Cin"}, message="Il semble que vous ayez déjà un compte avec ce CIN.")
  22.  */
  23. class User implements UserInterface, PasswordAuthenticatedUserInterface
  24. {
  25.     const ROLE_CLIENT = 'ROLE_CLIENT';
  26.     const ROLE_SUPER_ADMIN = 'ROLE_SUPER_ADMIN';
  28.     const ROLE_ADMIN = 'ROLE_ADMIN';
  35.     /**
  36.      * @ORM\Id()
  37.      * @ORM\GeneratedValue()
  38.      * @ORM\Column(type="integer")
  39.      */
  40.     private $id;
  42.     /**
  43.      * @ORM\Column(type="string", length=180, unique=true  , nullable=true)
  44.      * @Assert\Email()
  45.      */
  46.     private $email;
  48.     /**
  49.      * @ORM\Column(type="json")
  50.      */
  51.     private $roles = [];
  53.     /**
  54.      * @var string The hashed password
  55.      * @ORM\Column(type="string", nullable=true)
  56.      */
  57.     private $password;
  59.     /**
  60.      * @var string The plain password
  61.      *
  62.      * @Assert\Length(
  63.      *     min=6,
  64.      *     allowEmptyString=true,
  65.      * )
  66.      */
  67.     private $plainPassword;
  69.     /**
  70.      * @ORM\Column(type="string", length=255, nullable=true)
  71.      * @Assert\Length(
  72.      *     max = 25,
  73.      *      maxMessage = "Le prénom ne peut pas dépasser {{ limit }} caractères"
  74.      * )
  75.      * @Assert\Regex(
  76.      *     pattern="/^[a-zA-ZÀ-ÖØ-öø-ÿ\- ]*$/",
  77.      *     message="Le prénom doit contenir uniquement des lettres."
  78.      * )
  80.      */
  81.     private $firstName;
  82.     /**
  83.      * @ORM\Column(type="string", length=255, nullable=true)
  84.      * @Assert\Length(
  85.      *     max = 25,
  86.      *      maxMessage = "Le nom ne peut pas dépasser {{ limit }} caractères"
  87.      * )
  88.      * @Assert\Regex(
  89.      *     pattern="/^[a-zA-ZÀ-ÖØ-öø-ÿ\- ]*$/",
  90.      *     message="Le nom doit contenir uniquement des lettres."
  91.      * )
  92.      */
  93.     private $lastName;
  94.     /**
  95.      * @ORM\Column(type="string", length=255, nullable=true)
  96.      */
  97.     private $mobile;
  100.     /**
  101.      * @ORM\Column(type="boolean", nullable=true)
  102.      */
  103.     private $annuler;
  105.     /**
  106.      * @ORM\Column(type="string", length=255 , unique=true )
  107.      */
  108.     private $Cin;
  110.     /**
  111.      * @ORM\Column(type="string", nullable=true)
  112.      * @Assert\Regex(
  113.      *     pattern="/^\d{24}$/",
  114.      *     message="Le RIB doit être composé de 24 chiffres.",
  115.      * )
  116.      */
  117.     private $rib;
  119.     /**
  120.      * @ORM\Column(type="string", length=255, nullable=true)
  121.      * @Assert\Length(
  122.      *     max = 25,
  123.      *      maxMessage = "La Banque  ne peut pas dépasser {{ limit }} caractères"
  124.      * )
  125.      * @Assert\Regex(
  126.      *     pattern="/^[a-zA-ZÀ-ÖØ-öø-ÿ\- ]*$/",
  127.      *     message="Le Banque doit contenir uniquement des lettres."
  128.      * )
  129.      */
  130.     private $banque;
  132.     /**
  133.      * @ORM\Column(type="string", length=255, nullable=true)
  134.      * @Assert\Length(
  135.      *     max = 25,
  136.      *      maxMessage = "La Ville  ne peut pas dépasser {{ limit }} caractères"
  137.      * )
  138.      * @Assert\Regex(
  139.      *     pattern="/^[a-zA-ZÀ-ÖØ-öø-ÿ\- ]*$/",
  140.      *     message="Le Ville doit contenir uniquement des lettres."
  141.      * )
  142.      */
  143.     private $ville;
  146.     /**
  147.      * @ORM\Column(type="string", length=10, nullable=true)
  148.      */
  149.     private $gendre;
  151.     /**
  152.      * @ORM\Column(type="date", nullable=true)
  153.      */
  154.     private $datenaissance;
  156.     /**
  157.      * @ORM\Column(type="string", length=255, nullable=true)
  158.      */
  159.     private $adresse;
  161.     /**
  162.      * @ORM\ManyToOne(targetEntity=User::class, inversedBy="users")
  163.      */
  164.     private $referral;
  166.     /**
  167.      * @ORM\OneToMany(targetEntity=User::class, mappedBy="referral")
  168.      */
  169.     private $users;
  171.     /**
  172.      * @ORM\Column(type="string", length=255, nullable=true)
  173.      */
  174.     private $matrecul;
  176.     /**
  177.      * @ORM\Column(type="datetime",nullable=true))
  178.      */
  179.     private $dateaffiliate;
  181.     /**
  182.      * @ORM\Column(type="string", length=255,  nullable=true))
  183.      */
  184.     private $status;
  186.     /**
  187.      * @ORM\Column(type="string", length=255, nullable=true)
  188.      */
  189.     private $picture;
  191.     /**
  192.      * @ORM\OneToMany(targetEntity=Orders::class, mappedBy="user")
  193.      */
  194.     private $orders;
  196.     /**
  197.      * @ORM\OneToMany(targetEntity=Commission::class, mappedBy="user")
  198.      */
  199.     private $commissions;
  201.     /**
  202.      * @ORM\OneToMany(targetEntity=Bonus::class, mappedBy="user")
  203.      */
  204.     private $bonuses;
  206.     /**
  207.      * @ORM\OneToMany(targetEntity=Paiement::class, mappedBy="user")
  208.      */
  209.     private $paiements;
  211.     /**
  212.      * @ORM\Column(type="decimal", precision=10, scale=2, nullable=true)
  213.      */
  214.     private $Balance;
  216.     /**
  217.      * @ORM\OneToMany(targetEntity=UserGift::class, mappedBy="user")
  218.      */
  219.     private $userGifts;
  221.     /**
  222.      * @ORM\Column(type="string", length=255, nullable=true)
  223.      */
  224.     private $resetPasswordToken;
  226.     /**
  227.      * @ORM\Column(type="datetime", nullable=true)
  228.      */
  229.     private $resetPasswordTokenExpiresAt;
  231.     /**
  232.      * @ORM\OneToMany(targetEntity=PasswordResetRequest::class, mappedBy="user")
  233.      */
  234.     private $passwordResetRequests;
  237.     public function __construct()
  238.     {
  239.         $this->users = new ArrayCollection();
  240.         $this->orders = new ArrayCollection();
  241.         $this->commissions = new ArrayCollection();
  242.         $this->bonuses = new ArrayCollection();
  243.         $this->paiements = new ArrayCollection();
  244.         $this->userGifts = new ArrayCollection();
  245.         $this->passwordResetRequests = new ArrayCollection();
  246.     }
  252.     public function getId(): ?int
  253.     {
  254.         return $this->id;
  255.     }
  257.     public function getEmail(): ?string
  258.     {
  259.         return $this->email;
  260.     }
  262.     public function setEmail(string $email): self
  263.     {
  264.         $this->email = $email;
  266.         return $this;
  267.     }
  269.     /**
  270.      * A visual identifier that represents this user.
  271.      *
  272.      * @see UserInterface
  273.      */
  274.     public function getUsername(): string
  275.     {
  276.         return (string)$this->email;
  277.     }
  279.     /**
  280.      * @see UserInterface
  281.      */
  282.     public function getRoles(): array
  283.     {
  284.         $roles = $this->roles;
  285.         // guarantee every user at least has ROLE_USER
  286.         $roles[] = self::ROLE_CLIENT;
  288.         return array_unique($roles);
  289.     }
  291.     public function setRoles(array $roles): self
  292.     {
  293.         $this->roles = $roles;
  295.         return $this;
  296.     }
  298.     public function addRole(string $role): self
  299.     {
  300.         if (array_search($role, $this->getRoles()) === FALSE)
  301.             $this->roles[] = $role;
  303.         return $this;
  304.     }
  306.     public function hasRole(string $role): bool
  307.     {
  308.         return array_search($role, $this->getRoles()) !== FALSE;
  309.     }
  311.     /**
  312.      * @see UserInterface
  313.      */
  314.     public function getPassword(): string
  315.     {
  316.         return (string)$this->password;
  317.     }
  319.     public function setPassword(string $password): self
  320.     {
  321.         $this->password = $password;
  323.         return $this;
  324.     }
  326.     public function getPlainPassword(): ?string
  327.     {
  328.         return $this->plainPassword;
  329.     }
  331.     public function setPlainPassword(string $plainPassword): self
  332.     {
  333.         $this->plainPassword = $plainPassword;
  335.         return $this;
  336.     }
  338.     /**
  339.      * @see UserInterface
  340.      */
  341.     public function getSalt()
  342.     {
  343.         // not needed when using the "bcrypt" algorithm in security.yaml
  344.     }
  346.     /**
  347.      * @see UserInterface
  348.      */
  349.     public function eraseCredentials()
  350.     {
  351.         // If you store any temporary, sensitive data on the user, clear it here
  352.         $this->plainPassword = null;
  353.     }
  355.     public function getFirstName(): ?string
  356.     {
  357.         return $this->firstName;
  358.     }
  360.     public function setFirstName(string $firstName): self
  361.     {
  362.         $this->firstName = $firstName;
  364.         return $this;
  365.     }
  367.     public function getLastName(): ?string
  368.     {
  369.         return $this->lastName;
  370.     }
  372.     public function setLastName(string $lastName): self
  373.     {
  374.         $this->lastName = $lastName;
  376.         return $this;
  377.     }
  379.     public function getMobile(): ?string
  380.     {
  381.         return $this->mobile;
  382.     }
  384.     public function setMobile(?string $mobile): self
  385.     {
  386.         $this->mobile = $mobile;
  388.         return $this;
  389.     }
  393.     public function stringRole()
  394.     {
  395.         $role = 'Client';
  397.         if ($this->hasRole(self::ROLE_ADMIN)) {
  398.             $role = 'Admin';
  399.         }elseif ($this->hasRole(self::ROLE_SUPER_ADMIN)) {
  400.             $role = 'Super Admin';
  401.         }
  403.         return $role;
  404.     }
  408.     public function getStringRole(): string
  409. {
  410.     if ($this->hasRole(self::ROLE_ADMIN)) {
  411.         return 'Admin';
  412.     } elseif ($this->hasRole(self::ROLE_SUPER_ADMIN)) {
  413.         return 'Super Admin';
  414.     } elseif ($this->hasRole(self::ROLE_CLIENT)) {
  415.         return 'Client';
  416.     }
  418.     // Retour par défaut si aucun rôle ne correspond
  419.     return 'Unknown Role';
  420. }
  424.     public function getAnnuler(): ?bool
  425.     {
  426.         return $this->annuler;
  427.     }
  429.     public function setAnnuler(?bool $annuler): self
  430.     {
  431.         $this->annuler = $annuler;
  433.         return $this;
  434.     }
  437.     public function isAnnuler(): ?bool
  438.     {
  439.         return $this->annuler;
  440.     }
  442.     public function getCin(): ?string
  443.     {
  444.         return $this->Cin;
  445.     }
  447.     public function setCin(string $Cin): self
  448.     {
  449.         $this->Cin = $Cin;
  451.         return $this;
  452.     }
  456.     public function getBanque(): ?string
  457.     {
  458.         return $this->banque;
  459.     }
  461.     public function setBanque(?string $banque): self
  462.     {
  463.         $this->banque = $banque;
  465.         return $this;
  466.     }
  468.     public function getVille(): ?string
  469.     {
  470.         return $this->ville;
  471.     }
  473.     public function setVille(?string $ville): self
  474.     {
  475.         $this->ville = $ville;
  477.         return $this;
  478.     }
  480.     public function getGendre(): ?string
  481.     {
  482.         return $this->gendre;
  483.     }
  485.     public function setGendre(?string $gendre): self
  486.     {
  487.         $this->gendre = $gendre;
  489.         return $this;
  490.     }
  492.     public function getDatenaissance(): ?\DateTimeInterface
  493.     {
  494.         return $this->datenaissance;
  495.     }
  497.     public function setDatenaissance(?\DateTimeInterface $datenaissance): self
  498.     {
  499.         $this->datenaissance = $datenaissance;
  501.         return $this;
  502.     }
  504.     public function getAdresse(): ?string
  505.     {
  506.         return $this->adresse;
  507.     }
  509.     public function setAdresse(?string $adresse): self
  510.     {
  511.         $this->adresse = $adresse;
  513.         return $this;
  514.     }
  516.     public function getReferral(): ?self
  517.     {
  518.         return $this->referral;
  519.     }
  521.     public function setReferral(?self $referral): self
  522.     {
  523.         $this->referral = $referral;
  525.         return $this;
  526.     }
  528.     /**
  529.      * @return Collection<int, self>
  530.      */
  531.     public function getUsers(): Collection
  532.     {
  533.         return $this->users;
  534.     }
  536.     public function addUser(self $user): self
  537.     {
  538.         if (!$this->users->contains($user)) {
  539.             $this->users[] = $user;
  540.             $user->setReferral($this);
  541.         }
  543.         return $this;
  544.     }
  546.     public function removeUser(self $user): self
  547.     {
  548.         if ($this->users->removeElement($user)) {
  549.             // set the owning side to null (unless already changed)
  550.             if ($user->getReferral() === $this) {
  551.                 $user->setReferral(null);
  552.             }
  553.         }
  555.         return $this;
  556.     }
  558.     public function getMatrecul(): ?string
  559.     {
  560.         return $this->matrecul;
  561.     }
  563.     public function setMatrecul(?string $matrecul): self
  564.     {
  565.         $this->matrecul = $matrecul;
  567.         return $this;
  568.     }
  570.     public function getDateaffiliate(): ?\DateTimeInterface
  571.     {
  572.         return $this->dateaffiliate;
  573.     }
  575.     public function setDateaffiliate(\DateTimeInterface $dateaffiliate): self
  576.     {
  577.         $this->dateaffiliate = $dateaffiliate;
  579.         return $this;
  580.     }
  582.     public function getStatus(): ?string
  583.     {
  584.         return $this->status;
  585.     }
  587.     public function setStatus(string $status): self
  588.     {
  589.         $this->status = $status;
  591.         return $this;
  592.     }
  594.     public function getPicture(): ?string
  595.     {
  596.         return $this->picture;
  597.     }
  599.     public function setPicture(?string $picture): self
  600.     {
  601.         $this->picture = $picture;
  603.         return $this;
  604.     }
  606.     /**
  607.      * @return mixed
  608.      */
  609.     public function getRib()
  610.     {
  611.         return $this->rib;
  612.     }
  614.     /**
  615.      * @param mixed $rib
  616.      */
  617.     public function setRib($rib): void
  618.     {
  619.         $this->rib = $rib;
  620.     }
  622.     /**
  623.      * @return Collection<int, Orders>
  624.      */
  625.     public function getOrders(): Collection
  626.     {
  627.         return $this->orders;
  628.     }
  630.     public function addOrder(Orders $order): self
  631.     {
  632.         if (!$this->orders->contains($order)) {
  633.             $this->orders[] = $order;
  634.             $order->setUser($this);
  635.         }
  637.         return $this;
  638.     }
  640.     public function removeOrder(Orders $order): self
  641.     {
  642.         if ($this->orders->removeElement($order)) {
  643.             // set the owning side to null (unless already changed)
  644.             if ($order->getUser() === $this) {
  645.                 $order->setUser(null);
  646.             }
  647.         }
  649.         return $this;
  650.     }
  652.     /**
  653.      * @return Collection<int, Commission>
  654.      */
  655.     public function getCommissions(): Collection
  656.     {
  657.         return $this->commissions;
  658.     }
  660.     public function addCommission(Commission $commission): self
  661.     {
  662.         if (!$this->commissions->contains($commission)) {
  663.             $this->commissions[] = $commission;
  664.             $commission->setUser($this);
  665.         }
  667.         return $this;
  668.     }
  670.     public function removeCommission(Commission $commission): self
  671.     {
  672.         if ($this->commissions->removeElement($commission)) {
  673.             // set the owning side to null (unless already changed)
  674.             if ($commission->getUser() === $this) {
  675.                 $commission->setUser(null);
  676.             }
  677.         }
  679.         return $this;
  680.     }
  682.     /**
  683.      * @return Collection<int, Bonus>
  684.      */
  685.     public function getBonuses(): Collection
  686.     {
  687.         return $this->bonuses;
  688.     }
  690.     public function addBonus(Bonus $bonus): self
  691.     {
  692.         if (!$this->bonuses->contains($bonus)) {
  693.             $this->bonuses[] = $bonus;
  694.             $bonus->setUser($this);
  695.         }
  697.         return $this;
  698.     }
  700.     public function removeBonus(Bonus $bonus): self
  701.     {
  702.         if ($this->bonuses->removeElement($bonus)) {
  703.             // set the owning side to null (unless already changed)
  704.             if ($bonus->getUser() === $this) {
  705.                 $bonus->setUser(null);
  706.             }
  707.         }
  709.         return $this;
  710.     }
  712.     /**
  713.      * @return Collection<int, Paiement>
  714.      */
  715.     public function getPaiements(): Collection
  716.     {
  717.         return $this->paiements;
  718.     }
  720.     public function addPaiement(Paiement $paiement): self
  721.     {
  722.         if (!$this->paiements->contains($paiement)) {
  723.             $this->paiements[] = $paiement;
  724.             $paiement->setUser($this);
  725.         }
  727.         return $this;
  728.     }
  730.     public function removePaiement(Paiement $paiement): self
  731.     {
  732.         if ($this->paiements->removeElement($paiement)) {
  733.             // set the owning side to null (unless already changed)
  734.             if ($paiement->getUser() === $this) {
  735.                 $paiement->setUser(null);
  736.             }
  737.         }
  739.         return $this;
  740.     }
  742.     public function getBalance(): ?string
  743.     {
  744.         return $this->Balance;
  745.     }
  747.     public function setBalance(?string $Balance): self
  748.     {
  749.         $this->Balance = $Balance;
  751.         return $this;
  752.     }
  754.     /**
  755.      * @return Collection<int, UserGift>
  756.      */
  757.     public function getUserGifts(): Collection
  758.     {
  759.         return $this->userGifts;
  760.     }
  762.     public function addUserGift(UserGift $userGift): self
  763.     {
  764.         if (!$this->userGifts->contains($userGift)) {
  765.             $this->userGifts[] = $userGift;
  766.             $userGift->setUser($this);
  767.         }
  769.         return $this;
  770.     }
  772.     public function removeUserGift(UserGift $userGift): self
  773.     {
  774.         if ($this->userGifts->removeElement($userGift)) {
  775.             // set the owning side to null (unless already changed)
  776.             if ($userGift->getUser() === $this) {
  777.                 $userGift->setUser(null);
  778.             }
  779.         }
  781.         return $this;
  782.     }
  784.     public function getResetPasswordToken(): ?string
  785.     {
  786.         return $this->resetPasswordToken;
  787.     }
  789.     public function setResetPasswordToken(?string $resetPasswordToken): self
  790.     {
  791.         $this->resetPasswordToken = $resetPasswordToken;
  793.         return $this;
  794.     }
  796.     public function getResetPasswordTokenExpiresAt(): ?\DateTimeInterface
  797.     {
  798.         return $this->resetPasswordTokenExpiresAt;
  799.     }
  801.     public function setResetPasswordTokenExpiresAt(?\DateTimeInterface $resetPasswordTokenExpiresAt): self
  802.     {
  803.         $this->resetPasswordTokenExpiresAt = $resetPasswordTokenExpiresAt;
  805.         return $this;
  806.     }
  808.     /**
  809.      * @return Collection<int, PasswordResetRequest>
  810.      */
  811.     public function getPasswordResetRequests(): Collection
  812.     {
  813.         return $this->passwordResetRequests;
  814.     }
  816.     public function addPasswordResetRequest(PasswordResetRequest $passwordResetRequest): self
  817.     {
  818.         if (!$this->passwordResetRequests->contains($passwordResetRequest)) {
  819.             $this->passwordResetRequests[] = $passwordResetRequest;
  820.             $passwordResetRequest->setUser($this);
  821.         }
  823.         return $this;
  824.     }
  826.     public function removePasswordResetRequest(PasswordResetRequest $passwordResetRequest): self
  827.     {
  828.         if ($this->passwordResetRequests->removeElement($passwordResetRequest)) {
  829.             // set the owning side to null (unless already changed)
  830.             if ($passwordResetRequest->getUser() === $this) {
  831.                 $passwordResetRequest->setUser(null);
  832.             }
  833.         }
  835.         return $this;
  836.     }
  840. }