src/Entity/User.php line 18

  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.  * @UniqueEntity(fields={"email"}, message="There is already an account with this email")
  15.  */
  16. #[ORM\Entity(repositoryClass: UserRepository::class)]
  17. #[ORM\Table(name: '`user`')]
  18. class User implements UserInterface, PasswordAuthenticatedUserInterface
  19. {
  20.     #[ORM\Id]
  21.     #[ORM\GeneratedValue]
  22.     #[ORM\Column(type: 'integer')]
  23.     private $id;
  25.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  26.     private $email;
  28.     #[ORM\Column(type: 'json')]
  29.     private $roles = [];
  31.     #[ORM\Column(type: 'string')]
  32.     private $password;
  34.     #[ORM\Column(type: 'string', length: 255)]
  35.     private $firstName;
  37.     #[ORM\Column(type: 'string', length: 255)]
  38.     private $lastName;
  40.     #[ORM\Column(type: 'datetime_immutable')]
  41.     private $createdAt;
  43.     #[ORM\OneToMany(mappedBy: 'atUser', targetEntity: Adress::class, orphanRemoval: false)]
  44.     private $adress;
  46.     #[ORM\Column(type: 'boolean')]
  47.     private $isVerified = false;
  49.     #[ORM\OneToMany(mappedBy: 'userOf', targetEntity: Order::class)]
  50.     private $orders;
  52.     #[ORM\OneToMany(mappedBy: 'forUser', targetEntity: Notifications::class, orphanRemoval: true)]
  53.     private $notifications;
  55.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  56.     private $stripeUserId;
  58.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  59.     private $societe;
  61.     #[ORM\Column(type: 'boolean')]
  62.     private $IsBanned;
  64.     #[ORM\OneToMany(mappedBy: 'userOf', targetEntity: Help::class)]
  65.     private Collection $helps;
  67.     public function __construct()
  68.     {
  69.         $this->createdAt = new \DateTimeImmutable();
  70.         $this->adress = new ArrayCollection();
  71.         $this->orders = new ArrayCollection();
  72.         $this->notifications = new ArrayCollection();
  73.         $this->IsBanned = false;
  74.         $this->helps = new ArrayCollection();
  75.     }
  77.     public function __toString()
  78.     {
  79.         return $this->firstName . ' ' . $this->lastName;
  80.     }
  82.     public function getId(): ?int
  83.     {
  84.         return $this->id;
  85.     }
  87.     public function getEmail(): ?string
  88.     {
  89.         return $this->email;
  90.     }
  92.     public function setEmail(string $email): self
  93.     {
  94.         $this->email = $email;
  96.         return $this;
  97.     }
  99.     /**
  100.      * A visual identifier that represents this user.
  101.      *
  102.      * @see UserInterface
  103.      */
  104.     public function getUserIdentifier(): string
  105.     {
  106.         return (string) $this->email;
  107.     }
  109.     /**
  110.      * @see UserInterface
  111.      */
  112.     public function getRoles(): array
  113.     {
  114.         $roles = $this->roles;
  115.         // guarantee every user at least has ROLE_USER
  116.         $roles[] = 'ROLE_USER';
  118.         return array_unique($roles);
  119.     }
  121.     public function setRoles(array $roles): self
  122.     {
  123.         $this->roles = $roles;
  125.         return $this;
  126.     }
  128.     /**
  129.      * @see PasswordAuthenticatedUserInterface
  130.      */
  131.     public function getPassword(): string
  132.     {
  133.         return $this->password;
  134.     }
  136.     public function setPassword(string $password): self
  137.     {
  138.         $this->password = $password;
  140.         return $this;
  141.     }
  143.     /**
  144.      * @see UserInterface
  145.      */
  146.     public function eraseCredentials()
  147.     {
  148.         // If you store any temporary, sensitive data on the user, clear it here
  149.         // $this->plainPassword = null;
  150.     }
  152.     public function getFirstName(): ?string
  153.     {
  154.         return $this->firstName;
  155.     }
  157.     public function setFirstName(string $firstName): self
  158.     {
  159.         $this->firstName = $firstName;
  161.         return $this;
  162.     }
  164.     public function getLastName(): ?string
  165.     {
  166.         return $this->lastName;
  167.     }
  169.     public function setLastName(string $lastName): self
  170.     {
  171.         $this->lastName = $lastName;
  173.         return $this;
  174.     }
  176.     public function getCreatedAt(): ?\DateTimeImmutable
  177.     {
  178.         return $this->createdAt;
  179.     }
  181.     public function setCreatedAt(\DateTimeImmutable $createdAt): self
  182.     {
  183.         $this->createdAt = $createdAt;
  185.         return $this;
  186.     }
  188.     /**
  189.      * @return Collection|Adress[]
  190.      */
  191.     public function getAdress(): Collection
  192.     {
  193.         return $this->adress;
  194.     }
  196.     public function addAdress(Adress $adress): self
  197.     {
  198.         if (!$this->adress->contains($adress)) {
  199.             $this->adress[] = $adress;
  200.             $adress->setAtUser($this);
  201.         }
  203.         return $this;
  204.     }
  206.     public function removeAdress(Adress $adress): self
  207.     {
  208.         if ($this->adress->removeElement($adress)) {
  209.             // set the owning side to null (unless already changed)
  210.             if ($adress->getAtUser() === $this) {
  211.                 $adress->setAtUser(null);
  212.             }
  213.         }
  215.         return $this;
  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.     /**
  231.      * @return Collection|Order[]
  232.      */
  233.     public function getOrders(): Collection
  234.     {
  235.         return $this->orders;
  236.     }
  238.     public function addOrder(Order $order): self
  239.     {
  240.         if (!$this->orders->contains($order)) {
  241.             $this->orders[] = $order;
  242.             $order->setUserOf($this);
  243.         }
  245.         return $this;
  246.     }
  248.     public function removeOrder(Order $order): self
  249.     {
  250.         if ($this->orders->removeElement($order)) {
  251.             // set the owning side to null (unless already changed)
  252.             if ($order->getUserOf() === $this) {
  253.                 $order->setUserOf(null);
  254.             }
  255.         }
  257.         return $this;
  258.     }
  260.     /**
  261.      * @return Collection|Notifications[]
  262.      */
  263.     public function getNotifications(): Collection
  264.     {
  265.         return $this->notifications;
  266.     }
  268.     public function addNotification(Notifications $notification): self
  269.     {
  270.         if (!$this->notifications->contains($notification)) {
  271.             $this->notifications[] = $notification;
  272.             $notification->setForUser($this);
  273.         }
  275.         return $this;
  276.     }
  278.     public function removeNotification(Notifications $notification): self
  279.     {
  280.         if ($this->notifications->removeElement($notification)) {
  281.             // set the owning side to null (unless already changed)
  282.             if ($notification->getForUser() === $this) {
  283.                 $notification->setForUser(null);
  284.             }
  285.         }
  287.         return $this;
  288.     }
  290.     public function getStripeUserId(): ?string
  291.     {
  292.         return $this->stripeUserId;
  293.     }
  295.     public function setStripeUserId(?string $stripeUserId): self
  296.     {
  297.         $this->stripeUserId = $stripeUserId;
  299.         return $this;
  300.     }
  302.     public function getSociete(): ?string
  303.     {
  304.         return $this->societe;
  305.     }
  307.     public function setSociete(?string $societe): self
  308.     {
  309.         $this->societe = $societe;
  311.         return $this;
  312.     }
  314.     public function getIsBanned(): ?bool
  315.     {
  316.         return $this->IsBanned;
  317.     }
  319.     public function setIsBanned(bool $IsBanned): self
  320.     {
  321.         $this->IsBanned = $IsBanned;
  323.         return $this;
  324.     }
  326.     /**
  327.      * @return Collection<int, Help>
  328.      */
  329.     public function getHelps(): Collection
  330.     {
  331.         return $this->helps;
  332.     }
  334.     public function addHelp(Help $help): self
  335.     {
  336.         if (!$this->helps->contains($help)) {
  337.             $this->helps->add($help);
  338.             $help->setUserOf($this);
  339.         }
  341.         return $this;
  342.     }
  344.     public function removeHelp(Help $help): self
  345.     {
  346.         if ($this->helps->removeElement($help)) {
  347.             // set the owning side to null (unless already changed)
  348.             if ($help->getUserOf() === $this) {
  349.                 $help->setUserOf(null);
  350.             }
  351.         }
  353.         return $this;
  354.     }
  355. }