src/Entity/User.php line 17

  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\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  12. use Symfony\Component\Serializer\Annotation\Groups;
  13. use Symfony\Component\Uid\Uuid;
  15. #[ORM\Entity(repositoryClass: UserRepository::class)]
  16. #[ORM\Table(name: '`user`')]
  17. class User implements UserInterface, PasswordAuthenticatedUserInterface
  18. {
  19.     #[ORM\Id]
  20.     #[ORM\Column(type: 'uuid', unique: true)]
  21.     #[Groups(['BASE'])]
  22.     private ?string $id = null;
  24.     #[ORM\Column(length: 255, nullable: true)]
  25.     private ?string $name = null;
  27.     #[ORM\Column(length: 255)]
  28.     private ?string $email = null;
  30.     #[ORM\Column(length: 255)]
  31.     private ?string $password = null;
  33.     #[ORM\OneToMany(mappedBy: 'creatorUser', targetEntity: Component::class, orphanRemoval: true)]
  34.     private Collection $components;
  36.     #[ORM\OneToMany(mappedBy: 'creatorUser', targetEntity: Product::class, orphanRemoval: true)]
  37.     private Collection $products;
  39.     #[ORM\OneToMany(mappedBy: 'creatorUser', targetEntity: Menu::class, orphanRemoval: true)]
  40.     private Collection $menus;
  42.     /**
  43.      * @var string[]
  44.      */
  45.     #[ORM\Column(type: 'json')]
  46.     private $roles = [];
  48.     #[ORM\ManyToOne(inversedBy: 'users')]
  49.     #[ORM\JoinColumn(nullable: false)]
  50.     private ?Whitelabel $whitelabel = null;
  52.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  53.     private ?\DateTimeInterface $createDate = null;
  55.     #[ORM\OneToMany(mappedBy: 'creatorUser', targetEntity: ProductCategory::class)]
  56.     private Collection $productCategories;
  58.     #[ORM\OneToMany(mappedBy: 'creatorUser', targetEntity: Allergen::class)]
  59.     private Collection $allergens;
  61.     #[ORM\ManyToMany(targetEntity: Property::class, inversedBy: 'users')]
  62.     private Collection $properties;
  64.     public function __construct()
  65.     {
  66.         $this->id = Uuid::v4();
  67.         $this->components = new ArrayCollection();
  68.         $this->products = new ArrayCollection();
  69.         $this->menus = new ArrayCollection();
  70.         $this->productCategories = new ArrayCollection();
  71.         $this->allergens = new ArrayCollection();
  72.         $this->properties = new ArrayCollection();
  73.     }
  75.     public function __toString()
  76.     {
  77.         return $this->getName();
  78.     }
  80.     public function getId(): ?string
  81.     {
  82.         return $this->id;
  83.     }
  85.     public function getName(): ?string
  86.     {
  87.         return $this->name;
  88.     }
  90.     public function setName(?string $name): self
  91.     {
  92.         $this->name = $name;
  94.         return $this;
  95.     }
  97.     public function getEmail(): ?string
  98.     {
  99.         return $this->email;
  100.     }
  102.     public function setEmail(string $email): self
  103.     {
  104.         $this->email = $email;
  106.         return $this;
  107.     }
  109.     public function getPassword(): ?string
  110.     {
  111.         return $this->password;
  112.     }
  114.     public function setPassword(string $password): self
  115.     {
  116.         $this->password = $password;
  118.         return $this;
  119.     }
  121.     /**
  122.      * @return Collection<int, Component>
  123.      */
  124.     public function getComponents(): Collection
  125.     {
  126.         return $this->components;
  127.     }
  129.     public function addComponent(Component $component): self
  130.     {
  131.         if (!$this->components->contains($component)) {
  132.             $this->components->add($component);
  133.             $component->setCreatorUser($this);
  134.         }
  136.         return $this;
  137.     }
  139.     public function removeComponent(Component $component): self
  140.     {
  141.         if ($this->components->removeElement($component)) {
  142.             // set the owning side to null (unless already changed)
  143.             if ($component->getCreatorUser() === $this) {
  144.                 $component->setCreatorUser(null);
  145.             }
  146.         }
  148.         return $this;
  149.     }
  151.     /**
  152.      * @return Collection<int, Product>
  153.      */
  154.     public function getProducts(): Collection
  155.     {
  156.         return $this->products;
  157.     }
  159.     public function addProduct(Product $product): self
  160.     {
  161.         if (!$this->products->contains($product)) {
  162.             $this->products->add($product);
  163.             $product->setCreatorUser($this);
  164.         }
  166.         return $this;
  167.     }
  169.     public function removeProduct(Product $product): self
  170.     {
  171.         if ($this->products->removeElement($product)) {
  172.             // set the owning side to null (unless already changed)
  173.             if ($product->getCreatorUser() === $this) {
  174.                 $product->setCreatorUser(null);
  175.             }
  176.         }
  178.         return $this;
  179.     }
  181.     /**
  182.      * @return Collection<int, Menu>
  183.      */
  184.     public function getMenus(): Collection
  185.     {
  186.         return $this->menus;
  187.     }
  189.     public function addMenu(Menu $menu): self
  190.     {
  191.         if (!$this->menus->contains($menu)) {
  192.             $this->menus->add($menu);
  193.             $menu->setCreatorUser($this);
  194.         }
  196.         return $this;
  197.     }
  199.     public function removeMenu(Menu $menu): self
  200.     {
  201.         if ($this->menus->removeElement($menu)) {
  202.             // set the owning side to null (unless already changed)
  203.             if ($menu->getCreatorUser() === $this) {
  204.                 $menu->setCreatorUser(null);
  205.             }
  206.         }
  208.         return $this;
  209.     }
  211.     /**
  212.      * A visual identifier that represents this user.
  213.      *
  214.      * @see UserInterface
  215.      */
  216.     public function getUserIdentifier(): string
  217.     {
  218.         return (string) $this->email;
  219.     }
  221.     /**
  222.      * @see UserInterface
  223.      */
  224.     public function getRoles(): array
  225.     {
  226.         $roles = $this->roles;
  227.         // guarantee every user at least has ROLE_USER
  228.         $roles[] = 'ROLE_USER';
  230.         return array_unique($roles);
  231.     }
  233.     public function setRoles(array $roles): self
  234.     {
  235.         $this->roles = $roles;
  237.         return $this;
  238.     }
  240.     /**
  241.      * @see UserInterface
  242.      */
  243.     public function eraseCredentials()
  244.     {
  245.         // If you store any temporary, sensitive data on the user, clear it here
  246.         // $this->plainPassword = null;
  247.     }
  249.     /**
  250.      * @see UserInterface
  251.      */
  252.     public function getUsername()
  253.     {
  254.         // If you store any temporary, sensitive data on the user, clear it here
  255.         // $this->plainPassword = null;
  256.         return '';
  257.     }
  259.     public function getWhitelabel(): ?Whitelabel
  260.     {
  261.         return $this->whitelabel;
  262.     }
  264.     public function setWhitelabel(?Whitelabel $whitelabel): self
  265.     {
  266.         $this->whitelabel = $whitelabel;
  268.         return $this;
  269.     }
  271.     public function getCreateDate(): ?\DateTimeInterface
  272.     {
  273.         return $this->createDate;
  274.     }
  276.     public function setCreateDate(\DateTimeInterface $createDate): self
  277.     {
  278.         $this->createDate = $createDate;
  280.         return $this;
  281.     }
  283.     /**
  284.      * @return Collection<int, ProductCategory>
  285.      */
  286.     public function getProductCategories(): Collection
  287.     {
  288.         return $this->productCategories;
  289.     }
  291.     public function addProductCategory(ProductCategory $productCategory): self
  292.     {
  293.         if (!$this->productCategories->contains($productCategory)) {
  294.             $this->productCategories->add($productCategory);
  295.             $productCategory->setCreatorUser($this);
  296.         }
  298.         return $this;
  299.     }
  301.     public function removeProductCategory(ProductCategory $productCategory): self
  302.     {
  303.         if ($this->productCategories->removeElement($productCategory)) {
  304.             // set the owning side to null (unless already changed)
  305.             if ($productCategory->getCreatorUser() === $this) {
  306.                 $productCategory->setCreatorUser(null);
  307.             }
  308.         }
  310.         return $this;
  311.     }
  313.     /**
  314.      * @return Collection<int, Allergen>
  315.      */
  316.     public function getAllergens(): Collection
  317.     {
  318.         return $this->allergens;
  319.     }
  321.     public function addAllergen(Allergen $allergen): self
  322.     {
  323.         if (!$this->allergens->contains($allergen)) {
  324.             $this->allergens->add($allergen);
  325.             $allergen->setCreatorUser($this);
  326.         }
  328.         return $this;
  329.     }
  331.     public function removeAllergen(Allergen $allergen): self
  332.     {
  333.         if ($this->allergens->removeElement($allergen)) {
  334.             // set the owning side to null (unless already changed)
  335.             if ($allergen->getCreatorUser() === $this) {
  336.                 $allergen->setCreatorUser(null);
  337.             }
  338.         }
  340.         return $this;
  341.     }
  343.     /**
  344.      * @return Collection<int, Property>
  345.      */
  346.     public function getProperties(): Collection
  347.     {
  348.         return $this->properties;
  349.     }
  351.     public function addProperty(Property $property): static
  352.     {
  353.         if (!$this->properties->contains($property)) {
  354.             $this->properties->add($property);
  355.         }
  357.         return $this;
  358.     }
  360.     public function removeProperty(Property $property): static
  361.     {
  362.         $this->properties->removeElement($property);
  364.         return $this;
  365.     }
  366. }