src/Entity/User.php line 20

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;
  15. /**
  16.  * @ORM\Entity(repositoryClass=UserRepository::class)
  17.  * @ORM\Table(name="`user`")
  18.  * @UniqueEntity(fields={"email"}, message="There is already an account with this email")
  19.  */
  20. class User implements UserInterface, PasswordAuthenticatedUserInterface
  21. {
  22.     /**
  23.      * @ORM\Id
  24.      * @ORM\GeneratedValue
  25.      * @ORM\Column(type="integer")
  26.      */
  27.     private $id;
  29.     /**
  30.      * @ORM\Column(type="string", length=180, unique=true)
  31.      */
  32.     #[Assert\Email]
  33.     private $email;
  35.     /**
  36.      * @ORM\Column(type="json")
  37.      */
  38.     private $roles = [];
  40.     /**
  41.      * @var string The hashed password
  42.      * @ORM\Column(type="string")
  43.      */
  44.     private $password;
  47.     /**
  48.      * @ORM\ManyToOne(targetEntity=Shop::class, inversedBy="users")
  49.      * @ORM\JoinColumn(nullable=true)
  50.      */
  51.     private $shop;
  53.     /**
  54.      * @ORM\ManyToMany(targetEntity=Shop::class, inversedBy="users")
  55.      * #[JoinTable(name: 'user_shop')]
  56.      */
  57.     private Collection $shops;
  60.     /**
  61.      * @ORM\Column(type="boolean")
  62.      */
  63.     private $isVerified = false;
  65.     /**
  66.      * @ORM\OneToMany(targetEntity=Order::class, mappedBy="user")
  67.      */
  68.     private $orders;
  70.     /**
  71.      * @ORM\OneToMany(targetEntity=Address::class, mappedBy="user")
  72.      */
  73.     private $addresses;
  75.     /**
  76.      * @ORM\ManyToOne(targetEntity=Company::class, inversedBy="users")
  77.      */
  78.     private $company;
  80.     /**
  81.      * @ORM\Column(type="string", length=255, nullable=true)
  82.      */
  83.     private $firstname;
  85.     /**
  86.      * @ORM\Column(type="string", length=255, nullable=true)
  87.      */
  88.     private $lastname;
  90.     /**
  91.      * @ORM\Column(type="string", length=128, nullable=true)
  92.      * @Assert\Length(min = 10, max = 20, minMessage = "min_lenght", maxMessage = "max_lenght")
  93.      */
  94.     private $phone;
  96.     /**
  97.      * @ORM\ManyToOne(targetEntity=User::class, inversedBy="childrenUsers")
  98.      */
  99.     private $parent;
  101.     /**
  102.      * @ORM\OneToMany(targetEntity=User::class, mappedBy="parent")
  103.      */
  104.     private $childrenUsers;
  106.     /**
  107.      * @ORM\OneToMany(targetEntity=UserSetting::class, mappedBy="user", cascade={"persist"})
  108.      */
  109.     private $settings;
  111.     /**
  112.      * @ORM\Column(type="boolean", nullable=true)
  113.      */
  114.     private $active;
  116.     /**
  117.      * @ORM\OneToMany(targetEntity=Sav::class, mappedBy="user")
  118.      */
  119.     private $savs;
  121.     public function __construct()
  122.     {
  123.         $this->orders = new ArrayCollection();
  124.         $this->addresses = new ArrayCollection();
  125.         $this->childrenUsers = new ArrayCollection();
  126.         $this->settings = new ArrayCollection();
  127.         $this->shops = new ArrayCollection();
  128.         $this->savs = new ArrayCollection();
  129.     }
  131.     public function __toString()
  132.     {
  133.         return $this->getEmail();
  134.     }
  136.     public function getId(): ?int
  137.     {
  138.         return $this->id;
  139.     }
  141.     public function getEmail(): ?string
  142.     {
  143.         return $this->email;
  144.     }
  146.     public function setEmail(string $email): self
  147.     {
  148.         $this->email = $email;
  150.         return $this;
  151.     }
  153.     /**
  154.      * A visual identifier that represents this user.
  155.      *
  156.      * @see UserInterface
  157.      */
  158.     public function getUserIdentifier(): string
  159.     {
  160.         return (string)$this->email;
  161.     }
  163.     /**
  164.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  165.      */
  166.     public function getUsername(): string
  167.     {
  168.         return (string)$this->email;
  169.     }
  171.     /**
  172.      * @see UserInterface
  173.      */
  174.     public function getRoles(): array
  175.     {
  176.         $roles = $this->roles;
  177.         // guarantee every user at least has ROLE_USER
  178.         $roles[] = 'ROLE_USER';
  180.         return array_unique($roles);
  181.     }
  183.     public function setRoles(array $roles): self
  184.     {
  185.         $this->roles = $roles;
  187.         return $this;
  188.     }
  190.     /**
  191.      * @see PasswordAuthenticatedUserInterface
  192.      */
  193.     public function getPassword(): string
  194.     {
  195.         return $this->password;
  196.     }
  198.     public function setPassword(string $password): self
  199.     {
  200.         $this->password = $password;
  202.         return $this;
  203.     }
  205.     /**
  206.      * Returning a salt is only needed, if you are not using a modern
  207.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  208.      *
  209.      * @see UserInterface
  210.      */
  211.     public function getSalt(): ?string
  212.     {
  213.         return null;
  214.     }
  216.     /**
  217.      * @see UserInterface
  218.      */
  219.     public function eraseCredentials()
  220.     {
  221.         // If you store any temporary, sensitive data on the user, clear it here
  222.         // $this->plainPassword = null;
  223.     }
  226.     public function getShop(): ?Shop
  227.     {
  228.         return $this->shop;
  229.     }
  231.     public function setShop(?Shop $shop): self
  232.     {
  233.         $this->shop = $shop;
  235.         return $this;
  236.     }
  238.     public function isVerified(): bool
  239.     {
  240.         return $this->isVerified;
  241.     }
  243.     public function setIsVerified(bool $isVerified): self
  244.     {
  245.         $this->isVerified = $isVerified;
  247.         return $this;
  248.     }
  251.     /**
  252.      * @return Collection<int, Order>
  253.      */
  254.     public function getOrders(): Collection
  255.     {
  256.         return $this->orders;
  257.     }
  259.     public function addOrder(Order $order): self
  260.     {
  261.         if (!$this->orders->contains($order)) {
  262.             $this->orders[] = $order;
  263.             $order->setUser($this);
  264.         }
  266.         return $this;
  267.     }
  269.     public function removeOrder(Order $order): self
  270.     {
  271.         if ($this->orders->removeElement($order)) {
  272.             // set the owning side to null (unless already changed)
  273.             if ($order->getUser() === $this) {
  274.                 $order->setUser(null);
  275.             }
  276.         }
  278.         return $this;
  279.     }
  281.     /**
  282.      * @return Collection<int, Address>
  283.      */
  284.     public function getAddresses(): Collection
  285.     {
  286.         //
  287.         //
  288.         //echo "e";
  289.         //die();
  290.         if($this->getCompany()) {
  291.            // echo "1";
  292.             if($this->getCompany()->getAddress()) {
  293.                 if (!$this->addresses->contains($this->getCompany()->getAddress())) {
  294.                     $this->addresses[] = $this->getCompany()->getAddress();
  295.                 }
  296.             }
  297.         }
  299.         return $this->addresses;
  300.     }
  302.     public function addAddress(Address $address): self
  303.     {
  304.         if (!$this->addresses->contains($address)) {
  305.             $this->addresses[] = $address;
  306.             $address->setUser($this);
  307.         }
  309.         return $this;
  310.     }
  312.     public function removeAddress(Address $address): self
  313.     {
  314.         if ($this->addresses->removeElement($address)) {
  315.             // set the owning side to null (unless already changed)
  316.             if ($address->getUser() === $this) {
  317.                 $address->setUser(null);
  318.             }
  319.         }
  321.         return $this;
  322.     }
  324.     public function getCompany(): ?Company
  325.     {
  326.         return $this->company;
  327.     }
  329.     public function setCompany(?Company $company): self
  330.     {
  331.         $this->company = $company;
  333.         return $this;
  334.     }
  336.     public function getFirstname(): ?string
  337.     {
  338.         return $this->firstname;
  339.     }
  341.     public function setFirstname(string $firstname): self
  342.     {
  343.         $this->firstname = $firstname;
  345.         return $this;
  346.     }
  348.     public function getLastname(): ?string
  349.     {
  350.         return $this->lastname;
  351.     }
  353.     public function setLastname(string $lastname): self
  354.     {
  355.         $this->lastname = $lastname;
  357.         return $this;
  358.     }
  360.     public function getPhone(): ?string
  361.     {
  362.         return $this->phone;
  363.     }
  365.     public function setPhone(string $phone): self
  366.     {
  367.         $this->phone = $phone;
  369.         return $this;
  370.     }
  372.     public function getParent(): ?self
  373.     {
  374.         return $this->parent;
  375.     }
  377.     public function setParent(?self $parent): self
  378.     {
  379.         $this->parent = $parent;
  381.         return $this;
  382.     }
  384.     /**
  385.      * @return Collection<int, self>
  386.      */
  387.     public function getChildrenUsers(): Collection
  388.     {
  389.         return $this->childrenUsers;
  390.     }
  392.     public function addChildrenUser(self $childrenUser): self
  393.     {
  394.         if (!$this->childrenUsers->contains($childrenUser)) {
  395.             $this->childrenUsers[] = $childrenUser;
  396.             $childrenUser->setParent($this);
  397.         }
  399.         return $this;
  400.     }
  402.     public function removeChildrenUser(self $childrenUser): self
  403.     {
  404.         if ($this->childrenUsers->removeElement($childrenUser)) {
  405.             // set the owning side to null (unless already changed)
  406.             if ($childrenUser->getParent() === $this) {
  407.                 $childrenUser->setParent(null);
  408.             }
  409.         }
  411.         return $this;
  412.     }
  414.     /**
  415.      * @return Collection<int, UserSetting>
  416.      */
  417.     public function getSettings(): Collection
  418.     {
  419.         return $this->settings;
  420.     }
  423.     public function getSetting($name)
  424.     {
  426.         foreach ($this->getSettings() as $setting) {
  427.             if ($setting->getSetting()->getName() == $name) {
  428.                 if ($setting->getValue() == 'false') {
  429.                     return false;
  430.                 }
  431.                 return $setting->getValue();
  432.             }
  433.         }
  434.         return false;
  435.     }
  437.     public function addSetting(UserSetting $setting): void
  438.     {
  439.         $setting->setUser($this);
  440.         $this->settings->add($setting);
  441.         /*if (!$this->settings->contains($setting)) {
  442.             $this->settings[] = $setting;
  443.             $setting->setUser($this);
  444.         }
  446.         return $this;
  447.         */
  448.     }
  450.     public function removeSetting(UserSetting $setting): void
  451.     {
  452.         /*if ($this->settings->removeElement($setting)) {
  453.             // set the owning side to null (unless already changed)
  454.             if ($setting->getUser() === $this) {
  455.                 $setting->setUser(null);
  456.             }
  457.         }
  459.         return $this;*/
  460.     }
  462.     public function isGranted($role)
  463.     {
  464.         return in_array($role, $this->getRoles());
  465.     }
  467.     public function isIsVerified(): ?bool
  468.     {
  469.         return $this->isVerified;
  470.     }
  472.     /**
  473.      * @return Collection<int, Shop>
  474.      */
  475.     public function getShops(): Collection
  476.     {
  478.         return $this->shops;
  479.     }
  481.     public function addShop(Shop $shop): static
  482.     {
  483.         if (!$this->shops->contains($shop)) {
  484.             $this->shops->add($shop);
  485.         }
  487.         return $this;
  488.     }
  490.     public function removeShop(Shop $shop): static
  491.     {
  492.         $this->shops->removeElement($shop);
  494.         return $this;
  495.     }
  497.     public function getActive():bool
  498.     {
  499.         return $this->active;
  500.     }
  502.     public function setActive(bool $active):self
  503.     {
  504.         $this->active = $active;
  505.         return $this;
  506.     }
  508.     public function isActive(): ?bool
  509.     {
  510.         return $this->active;
  511.     }
  513.     /**
  514.      * @return Collection<int, Sav>
  515.      */
  516.     public function getSavs(): Collection
  517.     {
  518.         return $this->savs;
  519.     }
  521.     public function addSav(Sav $sav): static
  522.     {
  523.         if (!$this->savs->contains($sav)) {
  524.             $this->savs->add($sav);
  525.             $sav->setUser($this);
  526.         }
  528.         return $this;
  529.     }
  531.     public function removeSav(Sav $sav): static
  532.     {
  533.         if ($this->savs->removeElement($sav)) {
  534.             // set the owning side to null (unless already changed)
  535.             if ($sav->getUser() === $this) {
  536.                 $sav->setUser(null);
  537.             }
  538.         }
  540.         return $this;
  541.     }
  547. }