src/Entity/Whitelabel.php line 16

  1. <?php
  3. namespace App\Entity;
  5. use App\Interface\SoftDeleteInterface;
  6. use App\Repository\WhitelabelRepository;
  7. use App\Trait\SoftDeleteTrait;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\DBAL\Types\Types;
  11. use Doctrine\ORM\Mapping as ORM;
  12. use Symfony\Component\Serializer\Annotation\Groups;
  13. use Symfony\Component\Uid\Uuid;
  15. #[ORM\Entity(repositoryClass: WhitelabelRepository::class)]
  16. class Whitelabel implements SoftDeleteInterface
  17. {
  18.     use SoftDeleteTrait;
  20.     #[ORM\Id]
  21.     #[ORM\Column(type: 'uuid', unique: true)]
  22.     #[Groups(['BASE'])]
  23.     private ?string $id = null;
  25.     #[ORM\Column(length: 255)]
  26.     private ?string $name = null;
  28.     #[ORM\Column(length: 255)]
  29.     private ?string $domain = null;
  31.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  32.     private ?\DateTimeInterface $createDate = null;
  34.     #[ORM\OneToMany(mappedBy: 'whitelabel', targetEntity: Product::class, orphanRemoval: true)]
  35.     private Collection $products;
  37.     #[ORM\OneToMany(mappedBy: 'whitelabel', targetEntity: Component::class, orphanRemoval: true)]
  38.     private Collection $components;
  40.     #[ORM\OneToMany(mappedBy: 'whitelabel', targetEntity: Menu::class)]
  41.     private Collection $menus;
  43.     #[ORM\OneToMany(mappedBy: 'whitelabel', targetEntity: Property::class)]
  44.     private Collection $properties;
  46.     #[ORM\Column(length: 255, nullable: true)]
  47.     private ?string $phone = null;
  49.     #[ORM\Column(length: 2000, nullable: true)]
  50.     private ?string $address = null;
  52.     #[ORM\OneToMany(mappedBy: 'whitelabel', targetEntity: User::class, orphanRemoval: true)]
  53.     private Collection $users;
  55.     #[ORM\OneToMany(mappedBy: 'whitelabel', targetEntity: ProductCategory::class)]
  56.     private Collection $productCategories;
  58.     #[ORM\OneToMany(mappedBy: 'whitelabel', targetEntity: Allergen::class)]
  59.     private Collection $allergens;
  61.     #[ORM\OneToMany(mappedBy: 'whitelabel', targetEntity: WhitelabelDomain::class, orphanRemoval: true)]
  62.     private Collection $whitelabelDomains;
  64.     #[ORM\Column(length: 255, nullable: true)]
  65.     private ?string $template = null;
  67.     #[ORM\Column(length: 255, nullable: true)]
  68.     private ?string $oneSignalApiId = null;
  70.     #[ORM\Column(length: 255, nullable: true)]
  71.     private ?string $oneSignalApiKey = null;
  73.     public function __construct()
  74.     {
  75.         $this->id = Uuid::v4();
  76.         $this->products = new ArrayCollection();
  77.         $this->components = new ArrayCollection();
  78.         $this->menus = new ArrayCollection();
  79.         $this->properties = new ArrayCollection();
  80.         $this->users = new ArrayCollection();
  81.         $this->productCategories = new ArrayCollection();
  82.         $this->allergens = new ArrayCollection();
  83.         $this->whitelabelDomains = new ArrayCollection();
  84.     }
  86.     public function getId(): ?string
  87.     {
  88.         return $this->id;
  89.     }
  91.     public function getName(): ?string
  92.     {
  93.         return $this->name;
  94.     }
  96.     public function setName(string $name): self
  97.     {
  98.         $this->name = $name;
  100.         return $this;
  101.     }
  103.     public function getDomain(): ?string
  104.     {
  105.         return $this->domain;
  106.     }
  108.     public function setDomain(string $domain): self
  109.     {
  110.         $this->domain = $domain;
  112.         return $this;
  113.     }
  115.     public function getCreateDate(): ?\DateTimeInterface
  116.     {
  117.         return $this->createDate;
  118.     }
  120.     public function setCreateDate(\DateTimeInterface $createDate): self
  121.     {
  122.         $this->createDate = $createDate;
  124.         return $this;
  125.     }
  127.     /**
  128.      * @return Collection<int, Product>
  129.      */
  130.     public function getProducts(): Collection
  131.     {
  132.         return $this->products;
  133.     }
  135.     public function addProduct(Product $product): self
  136.     {
  137.         if (!$this->products->contains($product)) {
  138.             $this->products->add($product);
  139.             $product->setWhitelabel($this);
  140.         }
  142.         return $this;
  143.     }
  145.     public function removeProduct(Product $product): self
  146.     {
  147.         if ($this->products->removeElement($product)) {
  148.             // set the owning side to null (unless already changed)
  149.             if ($product->getWhitelabel() === $this) {
  150.                 $product->setWhitelabel(null);
  151.             }
  152.         }
  154.         return $this;
  155.     }
  157.     /**
  158.      * @return Collection<int, Component>
  159.      */
  160.     public function getComponents(): Collection
  161.     {
  162.         return $this->components;
  163.     }
  165.     public function addComponent(Component $component): self
  166.     {
  167.         if (!$this->components->contains($component)) {
  168.             $this->components->add($component);
  169.             $component->setWhitelabel($this);
  170.         }
  172.         return $this;
  173.     }
  175.     public function removeComponent(Component $component): self
  176.     {
  177.         if ($this->components->removeElement($component)) {
  178.             // set the owning side to null (unless already changed)
  179.             if ($component->getWhitelabel() === $this) {
  180.                 $component->setWhitelabel(null);
  181.             }
  182.         }
  184.         return $this;
  185.     }
  187.     /**
  188.      * @return Collection<int, Menu>
  189.      */
  190.     public function getMenus(): Collection
  191.     {
  192.         return $this->menus;
  193.     }
  195.     public function addMenu(Menu $menu): self
  196.     {
  197.         if (!$this->menus->contains($menu)) {
  198.             $this->menus->add($menu);
  199.             $menu->setWhitelabel($this);
  200.         }
  202.         return $this;
  203.     }
  205.     public function removeMenu(Menu $menu): self
  206.     {
  207.         if ($this->menus->removeElement($menu)) {
  208.             // set the owning side to null (unless already changed)
  209.             if ($menu->getWhitelabel() === $this) {
  210.                 $menu->setWhitelabel(null);
  211.             }
  212.         }
  214.         return $this;
  215.     }
  217.     /**
  218.      * @return Collection<int, Property>
  219.      */
  220.     public function getProperties(): Collection
  221.     {
  222.         return $this->properties;
  223.     }
  225.     public function addProperty(Property $property): self
  226.     {
  227.         if (!$this->properties->contains($property)) {
  228.             $this->properties->add($property);
  229.             $property->setWhitelabel($this);
  230.         }
  232.         return $this;
  233.     }
  235.     public function removeProperty(Property $property): self
  236.     {
  237.         if ($this->properties->removeElement($property)) {
  238.             // set the owning side to null (unless already changed)
  239.             if ($property->getWhitelabel() === $this) {
  240.                 $property->setWhitelabel(null);
  241.             }
  242.         }
  244.         return $this;
  245.     }
  247.     public function getPhone(): ?string
  248.     {
  249.         return $this->phone;
  250.     }
  252.     public function setPhone(?string $phone): self
  253.     {
  254.         $this->phone = $phone;
  256.         return $this;
  257.     }
  259.     public function getAddress(): ?string
  260.     {
  261.         return $this->address;
  262.     }
  264.     public function setAddress(?string $address): self
  265.     {
  266.         $this->address = $address;
  268.         return $this;
  269.     }
  271.     /**
  272.      * @return Collection<int, User>
  273.      */
  274.     public function getUsers(): Collection
  275.     {
  276.         return $this->users;
  277.     }
  279.     public function addUser(User $user): self
  280.     {
  281.         if (!$this->users->contains($user)) {
  282.             $this->users->add($user);
  283.             $user->setWhitelabel($this);
  284.         }
  286.         return $this;
  287.     }
  289.     public function removeUser(User $user): self
  290.     {
  291.         if ($this->users->removeElement($user)) {
  292.             // set the owning side to null (unless already changed)
  293.             if ($user->getWhitelabel() === $this) {
  294.                 $user->setWhitelabel(null);
  295.             }
  296.         }
  298.         return $this;
  299.     }
  301.     /**
  302.      * @return Collection<int, ProductCategory>
  303.      */
  304.     public function getProductCategories(): Collection
  305.     {
  306.         return $this->productCategories;
  307.     }
  309.     public function addProductCategory(ProductCategory $productCategory): self
  310.     {
  311.         if (!$this->productCategories->contains($productCategory)) {
  312.             $this->productCategories->add($productCategory);
  313.             $productCategory->setWhitelabel($this);
  314.         }
  316.         return $this;
  317.     }
  319.     public function removeProductCategory(ProductCategory $productCategory): self
  320.     {
  321.         if ($this->productCategories->removeElement($productCategory)) {
  322.             // set the owning side to null (unless already changed)
  323.             if ($productCategory->getWhitelabel() === $this) {
  324.                 $productCategory->setWhitelabel(null);
  325.             }
  326.         }
  328.         return $this;
  329.     }
  331.     /**
  332.      * @return Collection<int, Allergen>
  333.      */
  334.     public function getAllergens(): Collection
  335.     {
  336.         return $this->allergens;
  337.     }
  339.     public function addAllergen(Allergen $allergen): self
  340.     {
  341.         if (!$this->allergens->contains($allergen)) {
  342.             $this->allergens->add($allergen);
  343.             $allergen->setWhitelabel($this);
  344.         }
  346.         return $this;
  347.     }
  349.     public function removeAllergen(Allergen $allergen): self
  350.     {
  351.         if ($this->allergens->removeElement($allergen)) {
  352.             // set the owning side to null (unless already changed)
  353.             if ($allergen->getWhitelabel() === $this) {
  354.                 $allergen->setWhitelabel(null);
  355.             }
  356.         }
  358.         return $this;
  359.     }
  361.     /**
  362.      * @return Collection<int, WhitelabelDomain>
  363.      */
  364.     public function getWhitelabelDomains(): Collection
  365.     {
  366.         return $this->whitelabelDomains;
  367.     }
  369.     public function addWhitelabelDomain(WhitelabelDomain $whitelabelDomain): static
  370.     {
  371.         if (!$this->whitelabelDomains->contains($whitelabelDomain)) {
  372.             $this->whitelabelDomains->add($whitelabelDomain);
  373.             $whitelabelDomain->setWhitelabel($this);
  374.         }
  376.         return $this;
  377.     }
  379.     public function removeWhitelabelDomain(WhitelabelDomain $whitelabelDomain): static
  380.     {
  381.         if ($this->whitelabelDomains->removeElement($whitelabelDomain)) {
  382.             // set the owning side to null (unless already changed)
  383.             if ($whitelabelDomain->getWhitelabel() === $this) {
  384.                 $whitelabelDomain->setWhitelabel(null);
  385.             }
  386.         }
  388.         return $this;
  389.     }
  391.     public function getTemplate(): ?string
  392.     {
  393.         return $this->template;
  394.     }
  396.     public function setTemplate(?string $template): static
  397.     {
  398.         $this->template = $template;
  400.         return $this;
  401.     }
  403.     public function getOneSignalApiId(): ?string
  404.     {
  405.         return $this->oneSignalApiId;
  406.     }
  408.     public function setOneSignalApiId(?string $oneSignalApiId): static
  409.     {
  410.         $this->oneSignalApiId = $oneSignalApiId;
  412.         return $this;
  413.     }
  415.     public function getOneSignalApiKey(): ?string
  416.     {
  417.         return $this->oneSignalApiKey;
  418.     }
  420.     public function setOneSignalApiKey(?string $oneSignalApiKey): static
  421.     {
  422.         $this->oneSignalApiKey = $oneSignalApiKey;
  424.         return $this;
  425.     }
  426. }