src/Entity/User.php line 24

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Appointment\Appointment;
  6. use App\Entity\Company\Company;
  7. use App\Entity\Customer\Customer;
  8. use App\Entity\Event\EventUser;
  9. use App\Entity\Invoice\Invoice;
  10. use App\Entity\Order\Cart;
  11. use App\Entity\Order\Order;
  12. use App\Entity\UserInformation\UserInformation;
  13. use App\Entity\User\Wish;
  14. use App\Repository\UserRepository;
  15. use Doctrine\Common\Collections\ArrayCollection;
  16. use Doctrine\Common\Collections\Collection;
  17. use Doctrine\ORM\Mapping as ORM;
  18. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  19. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  20. use Symfony\Component\Security\Core\User\UserInterface;
  22. #[ORM\Entity(repositoryClass: UserRepository::class)]
  23. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  24. class User implements UserInterface, PasswordAuthenticatedUserInterface
  25. {
  26.     #[ORM\Id]
  27.     #[ORM\GeneratedValue]
  28.     #[ORM\Column]
  29.     private ?int $id = null;
  31.     #[ORM\Column(length: 180, unique: true)]
  32.     private ?string $email = null;
  34.     #[ORM\Column]
  35.     private array $roles = [];
  37.     /**
  38.      * @var string The hashed password
  39.      */
  40.     #[ORM\Column]
  41.     private ?string $password = null;
  43.     #[ORM\Column(type: 'boolean')]
  44.     private $isVerified = false;
  46.     #[ORM\Column(length: 255)]
  47.     private ?string $userName = null;
  49.     #[ORM\Column(length: 20, nullable: true)]
  50.     private ?string $telephone = null;
  52.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Comment::class)]
  53.     private Collection $comments;
  55.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Order::class)]
  56.     private Collection $orders;
  58.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: EventUser::class)]
  59.     private Collection $events;
  61.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Appointment::class)]
  62.     private Collection $appointments;
  64.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Cart::class)]
  65.     private Collection $carts;
  67.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserInformation::class)]
  68.     private Collection $userInformation;
  70.     #[ORM\ManyToMany(targetEntity: Company::class, inversedBy: 'users')]
  71.     #[ORM\JoinTable(name: 'user_company')]
  72.     private Collection $companies;
  74.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Wish::class)]
  75.     private Collection $wishes;
  77.     #[ORM\OneToOne(inversedBy: 'user')]
  78.     #[ORM\JoinColumn(nullable: true, onDelete: 'SET NULL')]
  79.     private ?Customer $customer = null;
  81.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Invoice::class)]
  82.     private Collection $invoices;
  84.     public function __toString()
  85.     {
  86.         return $this->email;
  87.     }
  89.     public function __construct()
  90.     {
  91.         $this->comments = new ArrayCollection();
  92.         $this->orders = new ArrayCollection();
  93.         $this->events = new ArrayCollection();
  94.         $this->appointments = new ArrayCollection();
  95.         $this->carts = new ArrayCollection();
  96.         $this->userInformation = new ArrayCollection();
  97.         $this->companies = new ArrayCollection();
  98.         $this->wishes = new ArrayCollection();
  99.         $this->invoices = new ArrayCollection();
  100.     }
  102.     public function getId(): ?int
  103.     {
  104.         return $this->id;
  105.     }
  107.     public function getEmail(): ?string
  108.     {
  109.         return $this->email;
  110.     }
  112.     public function setEmail(string $email): self
  113.     {
  114.         $this->email = $email;
  116.         return $this;
  117.     }
  119.     /**
  120.      * A visual identifier that represents this user.
  121.      *
  122.      * @see UserInterface
  123.      */
  124.     public function getUserIdentifier(): string
  125.     {
  126.         return (string) $this->email;
  127.     }
  129.     /**
  130.      * @see UserInterface
  131.      */
  132.     public function getRoles(): array
  133.     {
  134.         $roles = $this->roles;
  135.         // guarantee every user at least has ROLE_USER
  136.         $roles[] = 'ROLE_USER';
  138.         return array_unique($roles);
  139.     }
  141.     public function setRoles(array $roles): self
  142.     {
  143.         $this->roles = $roles;
  145.         return $this;
  146.     }
  148.     /**
  149.      * @see PasswordAuthenticatedUserInterface
  150.      */
  151.     public function getPassword(): string
  152.     {
  153.         return $this->password;
  154.     }
  156.     public function setPassword(string $password): self
  157.     {
  158.         $this->password = $password;
  160.         return $this;
  161.     }
  163.     /**
  164.      * @see UserInterface
  165.      */
  166.     public function eraseCredentials()
  167.     {
  168.         // If you store any temporary, sensitive data on the user, clear it here
  169.         // $this->plainPassword = null;
  170.     }
  172.     public function isVerified(): bool
  173.     {
  174.         return $this->isVerified;
  175.     }
  177.     public function setIsVerified(bool $isVerified): self
  178.     {
  179.         $this->isVerified = $isVerified;
  181.         return $this;
  182.     }
  186.     public function getUserName(): ?string
  187.     {
  188.         return $this->userName;
  189.     }
  191.     public function setUserName(string $userName): self
  192.     {
  193.         $this->userName = $userName;
  195.         return $this;
  196.     }
  198.     public function getTelephone(): ?string
  199.     {
  200.         return $this->telephone;
  201.     }
  203.     public function setTelephone(?string $telephone): self
  204.     {
  205.         $this->telephone = $telephone;
  207.         return $this;
  208.     }
  210.     /**
  211.      * @return Collection<int, Comment>
  212.      */
  213.     public function getComments(): Collection
  214.     {
  215.         return $this->comments;
  216.     }
  218.     public function addComment(Comment $comment): self
  219.     {
  220.         if (!$this->comments->contains($comment)) {
  221.             $this->comments->add($comment);
  222.             $comment->setUser($this);
  223.         }
  225.         return $this;
  226.     }
  228.     public function removeComment(Comment $comment): self
  229.     {
  230.         if ($this->comments->removeElement($comment)) {
  231.             // set the owning side to null (unless already changed)
  232.             if ($comment->getUser() === $this) {
  233.                 $comment->setUser(null);
  234.             }
  235.         }
  237.         return $this;
  238.     }
  240.     /**
  241.      * @return Collection<int, Order>
  242.      */
  243.     public function getOrders(): Collection
  244.     {
  245.         return $this->orders;
  246.     }
  248.     public function addOrder(Order $order): static
  249.     {
  250.         if (!$this->orders->contains($order)) {
  251.             $this->orders->add($order);
  252.             $order->setUser($this);
  253.         }
  255.         return $this;
  256.     }
  258.     public function removeOrder(Order $order): static
  259.     {
  260.         if ($this->orders->removeElement($order)) {
  261.             // set the owning side to null (unless already changed)
  262.             if ($order->getUser() === $this) {
  263.                 $order->setUser(null);
  264.             }
  265.         }
  267.         return $this;
  268.     }
  270.     /**
  271.      * @return Collection<int, EventUser>
  272.      */
  273.     public function getEvents(): Collection
  274.     {
  275.         return $this->events;
  276.     }
  278.     public function addEvent(EventUser $event): static
  279.     {
  280.         if (!$this->events->contains($event)) {
  281.             $this->events->add($event);
  282.             $event->setUser($this);
  283.         }
  285.         return $this;
  286.     }
  288.     public function removeEvent(EventUser $event): static
  289.     {
  290.         if ($this->events->removeElement($event)) {
  291.             // set the owning side to null (unless already changed)
  292.             if ($event->getUser() === $this) {
  293.                 $event->setUser(null);
  294.             }
  295.         }
  297.         return $this;
  298.     }
  300.     /**
  301.      * @return Collection<int, Appointment>
  302.      */
  303.     public function getAppointments(): Collection
  304.     {
  305.         return $this->appointments;
  306.     }
  308.     public function addAppointment(Appointment $appointment): static
  309.     {
  310.         if (!$this->appointments->contains($appointment)) {
  311.             $this->appointments->add($appointment);
  312.             $appointment->setUser($this);
  313.         }
  315.         return $this;
  316.     }
  318.     public function removeAppointment(Appointment $appointment): static
  319.     {
  320.         if ($this->appointments->removeElement($appointment)) {
  321.             // set the owning side to null (unless already changed)
  322.             if ($appointment->getUser() === $this) {
  323.                 $appointment->setUser(null);
  324.             }
  325.         }
  327.         return $this;
  328.     }
  330.     /**
  331.      * @return Collection<int, Cart>
  332.      */
  333.     public function getCarts(): Collection
  334.     {
  335.         return $this->carts;
  336.     }
  338.     public function addCart(Cart $cart): static
  339.     {
  340.         if (!$this->carts->contains($cart)) {
  341.             $this->carts->add($cart);
  342.             $cart->setUser($this);
  343.         }
  345.         return $this;
  346.     }
  348.     public function removeCart(Cart $cart): static
  349.     {
  350.         if ($this->carts->removeElement($cart)) {
  351.             // set the owning side to null (unless already changed)
  352.             if ($cart->getUser() === $this) {
  353.                 $cart->setUser(null);
  354.             }
  355.         }
  357.         return $this;
  358.     }
  360.     /**
  361.      * @return Collection<int, UserInformation>
  362.      */
  363.     public function getUserInformation(): Collection
  364.     {
  365.         return $this->userInformation;
  366.     }
  368.     public function addUserInformation(UserInformation $userInformation): static
  369.     {
  370.         if (!$this->userInformation->contains($userInformation)) {
  371.             $this->userInformation->add($userInformation);
  372.             $userInformation->setUser($this);
  373.         }
  375.         return $this;
  376.     }
  378.     public function removeUserInformation(UserInformation $userInformation): static
  379.     {
  380.         if ($this->userInformation->removeElement($userInformation)) {
  381.             // set the owning side to null (unless already changed)
  382.             if ($userInformation->getUser() === $this) {
  383.                 $userInformation->setUser(null);
  384.             }
  385.         }
  387.         return $this;
  388.     }
  390.     public function getCompanies(): Collection
  391.     {
  392.         return $this->companies;
  393.     }
  395.     public function addCompany(Company $company): self
  396.     {
  397.         if (!$this->companies->contains($company)) {
  398.             $this->companies->add($company);
  399.             $company->addUser($this);
  400.         }
  402.         return $this;
  403.     }
  405.     public function removeCompany(Company $company): self
  406.     {
  407.         if ($this->companies->removeElement($company)) {
  408.             $company->removeUser($this);
  409.         }
  411.         return $this;
  412.     }
  414.     /**
  415.      * @return Collection<int, Wish>
  416.      */
  417.     public function getWishes(): Collection
  418.     {
  419.         return $this->wishes;
  420.     }
  422.     public function addWish(Wish $wish): static
  423.     {
  424.         if (!$this->wishes->contains($wish)) {
  425.             $this->wishes->add($wish);
  426.             $wish->setUser($this);
  427.         }
  429.         return $this;
  430.     }
  432.     public function removeWish(Wish $wish): static
  433.     {
  434.         if ($this->wishes->removeElement($wish)) {
  435.             // set the owning side to null (unless already changed)
  436.             if ($wish->getUser() === $this) {
  437.                 $wish->setUser(null);
  438.             }
  439.         }
  441.         return $this;
  442.     }
  444.     public function getCustomer(): ?Customer
  445.     {
  446.         return $this->customer;
  447.     }
  449.     public function setCustomer(?Customer $customer): static
  450.     {
  451.         $this->customer = $customer;
  453.         return $this;
  454.     }
  456.     /**
  457.      * @return Collection<int, Invoice>
  458.      */
  459.     public function getInvoices(): Collection
  460.     {
  461.         return $this->invoices;
  462.     }
  464.     public function addInvoice(Invoice $invoice): static
  465.     {
  466.         if (!$this->invoices->contains($invoice)) {
  467.             $this->invoices->add($invoice);
  468.             $invoice->setUser($this);
  469.         }
  471.         return $this;
  472.     }
  474.     public function removeInvoice(Invoice $invoice): static
  475.     {
  476.         if ($this->invoices->removeElement($invoice)) {
  477.             // set the owning side to null (unless already changed)
  478.             if ($invoice->getUser() === $this) {
  479.                 $invoice->setUser(null);
  480.             }
  481.         }
  483.         return $this;
  484.     }
  485. }