src/Entity/Shop/Shop/Shop.php line 41

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Shop\Shop;
  5. use App\Entity\BaseEntity;
  6. use App\Entity\BaseSite\Domain;
  7. use App\Entity\BaseSite\Plan\AddOn;
  8. use App\Entity\BaseSite\Plan\Plan;
  9. use App\Entity\Generic\Customer\Customer;
  10. use App\Entity\Generic\User;
  11. use App\Entity\Shop\Accounting\Transaction;
  12. use App\Entity\Shop\Blog\Article;
  13. use App\Entity\Shop\Blog\Category;
  14. use App\Entity\Shop\Blog\Tag;
  15. use App\Entity\Shop\Cart\Cart;
  16. use App\Entity\Shop\Cart\CartItem;
  17. use App\Entity\Shop\Cart\CartItemAttribute;
  18. use App\Entity\Shop\Menu\Menu;
  19. use App\Entity\Shop\Order\Coupon;
  20. use App\Entity\Shop\Order\Discount;
  21. use App\Entity\Shop\Order\Order;
  22. use App\Entity\Shop\Order\ShippingMethod;
  23. use App\Entity\Shop\Page\Page;
  24. use App\Entity\Shop\PostType\PostType;
  25. use App\Entity\Shop\Product\Product;
  26. use App\Entity\Shop\Product\ProductAttribute;
  27. use App\Entity\Shop\Product\ProductAttributeValue;
  28. use App\Entity\Shop\Product\ProductCategory;
  29. use App\Entity\Shop\Setting;
  30. use App\Entity\Shop\Ticket\Ticket;
  31. use App\Repository\Shop\Shop\ShopRepository;
  32. use Doctrine\Common\Collections\ArrayCollection;
  33. use Doctrine\Common\Collections\Collection;
  34. use Doctrine\DBAL\Types\Types;
  35. use Doctrine\ORM\Mapping as ORM;
  36. use Symfony\Bridge\Doctrine\IdGenerator\UuidGenerator;
  37. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  39. #[ORM\Entity(repositoryClass: ShopRepository::class)]
  40. #[UniqueEntity(fields: ['subdomain'], message: 'این نام کاربری فروشگاه از قبل موجود می باشد')]
  41. class Shop extends BaseEntity
  42. {
  43.     #[ORM\Id]
  44.     #[ORM\Column(type: 'guid', unique: true)]
  45.     #[ORM\GeneratedValue(strategy: 'CUSTOM')]
  46.     #[ORM\CustomIdGenerator(class: UuidGenerator::class)]
  47.     private ?string $id;
  49.     #[ORM\Column(length: 255)]
  50.     private ?string $name = null;
  52.     #[ORM\Column(length: 255, unique: true)]
  53.     private ?string $subdomain = null;
  55.     #[ORM\Column]
  56.     private ?float $shopBalance = null;
  58.     #[ORM\ManyToOne(inversedBy: 'shops')]
  59.     #[ORM\JoinColumn(nullable: false)]
  60.     private ?User $owner = null;
  62.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Customer::class)]
  63.     private Collection $customers;
  65.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Product::class)]
  66.     private Collection $products;
  68.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: ProductAttribute::class)]
  69.     private Collection $productAttributes;
  71.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: ProductAttributeValue::class)]
  72.     private Collection $productAttributeValues;
  74.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Discount::class)]
  75.     private Collection $discounts;
  77.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Cart::class)]
  78.     private Collection $carts;
  80.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: CartItem::class)]
  81.     private Collection $cartItems;
  83.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: CartItemAttribute::class)]
  84.     private Collection $cartItemAttributes;
  86.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Coupon::class)]
  87.     private Collection $coupons;
  89.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Order::class)]
  90.     private Collection $orders;
  92.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: ShippingMethod::class)]
  93.     private Collection $shippingMethods;
  95.     #[ORM\Column(length: 255, nullable: true)]
  96.     private ?string $theme = null;
  98.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: ProductCategory::class)]
  99.     private Collection $productCategories;
  101.     #[ORM\Column(nullable: true)]
  102.     private ?array $analyticsData = null;
  104.     #[ORM\Column(nullable: true)]
  105.     private ?\DateTimeImmutable $expiredAt = null;
  107.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: PostType::class)]
  108.     private Collection $postTypes;
  110.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Menu::class)]
  111.     private Collection $menus;
  113.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Setting::class)]
  114.     private Collection $settings;
  116.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Page::class)]
  117.     private Collection $pages;
  119.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Article::class)]
  120.     private Collection $articles;
  122.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Category::class)]
  123.     private Collection $categories;
  125.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Tag::class)]
  126.     private Collection $tags;
  128.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Ticket::class)]
  129.     private Collection $tickets;
  131.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Transaction::class)]
  132.     private Collection $transactions;
  134.     #[ORM\Column(type: Types::BIGINT)]
  135.     private ?string $trafficUsage = null;
  139.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: Domain::class)]
  140.     private Collection $domains;
  142.     #[ORM\ManyToOne(inversedBy: 'shops')]
  143.     private ?Plan $currentPlan = null;
  145.     #[ORM\OneToMany(mappedBy: 'shop', targetEntity: AddOn::class)]
  146.     private Collection $addOns;
  148.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  149.     private ?\DateTimeInterface $planStartedAt = null;
  153.     public function subdomainAddress()
  154.     {
  155.         return $this->subdomain.'.poooshe.com';
  156.     }
  158.     public function __construct()
  159.     {
  160.         $this->setTrafficUsage(0);
  161.         parent::__construct();
  162.         $now = new \DateTimeImmutable();
  163.         $this->setExpiredAt($now->modify("+7 days"));
  164.         $this->setPlanStartedAt($now);
  165.         $this->shopBalance = 0;
  166.         $this->customers = new ArrayCollection();
  167.         $this->products = new ArrayCollection();
  168.         $this->productAttributes = new ArrayCollection();
  169.         $this->productAttributeValues = new ArrayCollection();
  170.         $this->discounts = new ArrayCollection();
  171.         $this->carts = new ArrayCollection();
  172.         $this->cartItems = new ArrayCollection();
  173.         $this->cartItemAttributes = new ArrayCollection();
  174.         $this->coupons = new ArrayCollection();
  175.         $this->orders = new ArrayCollection();
  176.         $this->shippingMethods = new ArrayCollection();
  177.         $this->productCategories = new ArrayCollection();
  178.         $this->postTypes = new ArrayCollection();
  179.         $this->menus = new ArrayCollection();
  180.         $this->settings = new ArrayCollection();
  181.         $this->pages = new ArrayCollection();
  182.         $this->articles = new ArrayCollection();
  183.         $this->categories = new ArrayCollection();
  184.         $this->tags = new ArrayCollection();
  185.         $this->tickets = new ArrayCollection();
  186.         $this->transactions = new ArrayCollection();
  187.         $this->domains = new ArrayCollection();
  188.         $this->addOns = new ArrayCollection();
  189.     }
  191.     public function getId(): ?string
  192.     {
  193.         return $this->id;
  194.     }
  196.     public function getName(): ?string
  197.     {
  198.         return $this->name;
  199.     }
  201.     public function setName(string $name): static
  202.     {
  203.         $this->name = $name;
  205.         return $this;
  206.     }
  208.     public function getSubdomain(): ?string
  209.     {
  210.         return $this->subdomain;
  211.     }
  215.     public function setSubdomain(string $subdomain): static
  216.     {
  217.         $this->subdomain = $subdomain;
  219.         return $this;
  220.     }
  222.     public function getShopBalance(): ?float
  223.     {
  224.         return $this->shopBalance;
  225.     }
  227.     public function setShopBalance(float $shopBalance): static
  228.     {
  229.         $this->shopBalance = $shopBalance;
  231.         return $this;
  232.     }
  234.     public function getOwner(): ?User
  235.     {
  236.         return $this->owner;
  237.     }
  239.     public function setOwner(?User $owner): static
  240.     {
  241.         $this->owner = $owner;
  243.         return $this;
  244.     }
  246.     /**
  247.      * @return Collection<int, Customer>
  248.      */
  249.     public function getCustomers(): Collection
  250.     {
  251.         return $this->customers;
  252.     }
  254.     public function addCustomer(Customer $customer): static
  255.     {
  256.         if (!$this->customers->contains($customer)) {
  257.             $this->customers->add($customer);
  258.             $customer->setShop($this);
  259.         }
  261.         return $this;
  262.     }
  264.     public function removeCustomer(Customer $customer): static
  265.     {
  266.         if ($this->customers->removeElement($customer)) {
  267.             // set the owning side to null (unless already changed)
  268.             if ($customer->getShop() === $this) {
  269.                 $customer->setShop(null);
  270.             }
  271.         }
  273.         return $this;
  274.     }
  276.     /**
  277.      * @return Collection<int, Product>
  278.      */
  279.     public function getProducts(): Collection
  280.     {
  281.         return $this->products;
  282.     }
  284.     public function addProduct(Product $product): static
  285.     {
  286.         if (!$this->products->contains($product)) {
  287.             $this->products->add($product);
  288.             $product->setShop($this);
  289.         }
  291.         return $this;
  292.     }
  294.     public function removeProduct(Product $product): static
  295.     {
  296.         if ($this->products->removeElement($product)) {
  297.             // set the owning side to null (unless already changed)
  298.             if ($product->getShop() === $this) {
  299.                 $product->setShop(null);
  300.             }
  301.         }
  303.         return $this;
  304.     }
  306.     /**
  307.      * @return Collection<int, ProductAttribute>
  308.      */
  309.     public function getProductAttributes(): Collection
  310.     {
  311.         return $this->productAttributes;
  312.     }
  314.     public function addProductAttribute(ProductAttribute $productAttribute): static
  315.     {
  316.         if (!$this->productAttributes->contains($productAttribute)) {
  317.             $this->productAttributes->add($productAttribute);
  318.             $productAttribute->setShop($this);
  319.         }
  321.         return $this;
  322.     }
  324.     public function removeProductAttribute(ProductAttribute $productAttribute): static
  325.     {
  326.         if ($this->productAttributes->removeElement($productAttribute)) {
  327.             // set the owning side to null (unless already changed)
  328.             if ($productAttribute->getShop() === $this) {
  329.                 $productAttribute->setShop(null);
  330.             }
  331.         }
  333.         return $this;
  334.     }
  336.     /**
  337.      * @return Collection<int, ProductAttributeValue>
  338.      */
  339.     public function getProductAttributeValues(): Collection
  340.     {
  341.         return $this->productAttributeValues;
  342.     }
  344.     public function addProductAttributeValue(ProductAttributeValue $productAttributeValue): static
  345.     {
  346.         if (!$this->productAttributeValues->contains($productAttributeValue)) {
  347.             $this->productAttributeValues->add($productAttributeValue);
  348.             $productAttributeValue->setShop($this);
  349.         }
  351.         return $this;
  352.     }
  354.     public function removeProductAttributeValue(ProductAttributeValue $productAttributeValue): static
  355.     {
  356.         if ($this->productAttributeValues->removeElement($productAttributeValue)) {
  357.             // set the owning side to null (unless already changed)
  358.             if ($productAttributeValue->getShop() === $this) {
  359.                 $productAttributeValue->setShop(null);
  360.             }
  361.         }
  363.         return $this;
  364.     }
  366.     /**
  367.      * @return Collection<int, Discount>
  368.      */
  369.     public function getDiscounts(): Collection
  370.     {
  371.         return $this->discounts;
  372.     }
  374.     public function addDiscount(Discount $discount): static
  375.     {
  376.         if (!$this->discounts->contains($discount)) {
  377.             $this->discounts->add($discount);
  378.             $discount->setShop($this);
  379.         }
  381.         return $this;
  382.     }
  384.     public function removeDiscount(Discount $discount): static
  385.     {
  386.         if ($this->discounts->removeElement($discount)) {
  387.             // set the owning side to null (unless already changed)
  388.             if ($discount->getShop() === $this) {
  389.                 $discount->setShop(null);
  390.             }
  391.         }
  393.         return $this;
  394.     }
  396.     /**
  397.      * @return Collection<int, Cart>
  398.      */
  399.     public function getCarts(): Collection
  400.     {
  401.         return $this->carts;
  402.     }
  404.     public function addCart(Cart $cart): static
  405.     {
  406.         if (!$this->carts->contains($cart)) {
  407.             $this->carts->add($cart);
  408.             $cart->setShop($this);
  409.         }
  411.         return $this;
  412.     }
  414.     public function removeCart(Cart $cart): static
  415.     {
  416.         if ($this->carts->removeElement($cart)) {
  417.             // set the owning side to null (unless already changed)
  418.             if ($cart->getShop() === $this) {
  419.                 $cart->setShop(null);
  420.             }
  421.         }
  423.         return $this;
  424.     }
  426.     /**
  427.      * @return Collection<int, CartItem>
  428.      */
  429.     public function getCartItems(): Collection
  430.     {
  431.         return $this->cartItems;
  432.     }
  434.     public function addCartItem(CartItem $cartItem): static
  435.     {
  436.         if (!$this->cartItems->contains($cartItem)) {
  437.             $this->cartItems->add($cartItem);
  438.             $cartItem->setShop($this);
  439.         }
  441.         return $this;
  442.     }
  444.     public function removeCartItem(CartItem $cartItem): static
  445.     {
  446.         if ($this->cartItems->removeElement($cartItem)) {
  447.             // set the owning side to null (unless already changed)
  448.             if ($cartItem->getShop() === $this) {
  449.                 $cartItem->setShop(null);
  450.             }
  451.         }
  453.         return $this;
  454.     }
  456.     /**
  457.      * @return Collection<int, CartItemAttribute>
  458.      */
  459.     public function getCartItemAttributes(): Collection
  460.     {
  461.         return $this->cartItemAttributes;
  462.     }
  464.     public function addCartItemAttribute(CartItemAttribute $cartItemAttribute): static
  465.     {
  466.         if (!$this->cartItemAttributes->contains($cartItemAttribute)) {
  467.             $this->cartItemAttributes->add($cartItemAttribute);
  468.             $cartItemAttribute->setShop($this);
  469.         }
  471.         return $this;
  472.     }
  474.     public function removeCartItemAttribute(CartItemAttribute $cartItemAttribute): static
  475.     {
  476.         if ($this->cartItemAttributes->removeElement($cartItemAttribute)) {
  477.             // set the owning side to null (unless already changed)
  478.             if ($cartItemAttribute->getShop() === $this) {
  479.                 $cartItemAttribute->setShop(null);
  480.             }
  481.         }
  483.         return $this;
  484.     }
  486.     /**
  487.      * @return Collection<int, Coupon>
  488.      */
  489.     public function getCoupons(): Collection
  490.     {
  491.         return $this->coupons;
  492.     }
  494.     public function addCoupon(Coupon $coupon): static
  495.     {
  496.         if (!$this->coupons->contains($coupon)) {
  497.             $this->coupons->add($coupon);
  498.             $coupon->setShop($this);
  499.         }
  501.         return $this;
  502.     }
  504.     public function removeCoupon(Coupon $coupon): static
  505.     {
  506.         if ($this->coupons->removeElement($coupon)) {
  507.             // set the owning side to null (unless already changed)
  508.             if ($coupon->getShop() === $this) {
  509.                 $coupon->setShop(null);
  510.             }
  511.         }
  513.         return $this;
  514.     }
  516.     /**
  517.      * @return Collection<int, Order>
  518.      */
  519.     public function getOrders(): Collection
  520.     {
  521.         return $this->orders;
  522.     }
  524.     public function addOrder(Order $order): static
  525.     {
  526.         if (!$this->orders->contains($order)) {
  527.             $this->orders->add($order);
  528.             $order->setShop($this);
  529.         }
  531.         return $this;
  532.     }
  534.     public function removeOrder(Order $order): static
  535.     {
  536.         if ($this->orders->removeElement($order)) {
  537.             // set the owning side to null (unless already changed)
  538.             if ($order->getShop() === $this) {
  539.                 $order->setShop(null);
  540.             }
  541.         }
  543.         return $this;
  544.     }
  546.     /**
  547.      * @return Collection<int, ShippingMethod>
  548.      */
  549.     public function getShippingMethods(): Collection
  550.     {
  551.         return $this->shippingMethods;
  552.     }
  554.     public function addShippingMethod(ShippingMethod $shippingMethod): static
  555.     {
  556.         if (!$this->shippingMethods->contains($shippingMethod)) {
  557.             $this->shippingMethods->add($shippingMethod);
  558.             $shippingMethod->setShop($this);
  559.         }
  561.         return $this;
  562.     }
  564.     public function removeShippingMethod(ShippingMethod $shippingMethod): static
  565.     {
  566.         if ($this->shippingMethods->removeElement($shippingMethod)) {
  567.             // set the owning side to null (unless already changed)
  568.             if ($shippingMethod->getShop() === $this) {
  569.                 $shippingMethod->setShop(null);
  570.             }
  571.         }
  573.         return $this;
  574.     }
  576.     public function getTheme(): ?string
  577.     {
  578.         if ($this->theme == null){
  579.             return 'default';
  580.         }
  581.         return $this->theme;
  582.     }
  584.     public function setTheme(?string $theme): static
  585.     {
  586.         $this->theme = $theme;
  588.         return $this;
  589.     }
  591.     /**
  592.      * @return Collection<int, ProductCategory>
  593.      */
  594.     public function getProductCategories(): Collection
  595.     {
  596.         return $this->productCategories;
  597.     }
  599.     public function addProductCategory(ProductCategory $productCategory): static
  600.     {
  601.         if (!$this->productCategories->contains($productCategory)) {
  602.             $this->productCategories->add($productCategory);
  603.             $productCategory->setShop($this);
  604.         }
  606.         return $this;
  607.     }
  609.     public function removeProductCategory(ProductCategory $productCategory): static
  610.     {
  611.         if ($this->productCategories->removeElement($productCategory)) {
  612.             // set the owning side to null (unless already changed)
  613.             if ($productCategory->getShop() === $this) {
  614.                 $productCategory->setShop(null);
  615.             }
  616.         }
  618.         return $this;
  619.     }
  621.     public function getAnalyticsData(): ?array
  622.     {
  623.         return $this->analyticsData;
  624.     }
  626.     public function setAnalyticsData(?array $analyticsData): static
  627.     {
  628.         $this->analyticsData = $analyticsData;
  630.         return $this;
  631.     }
  633.     public function getExpiredAt(): ?\DateTimeImmutable
  634.     {
  635.         return $this->expiredAt;
  636.     }
  638.     public function setExpiredAt(?\DateTimeImmutable $expiredAt): static
  639.     {
  640.         $this->expiredAt = $expiredAt;
  642.         return $this;
  643.     }
  645.     /**
  646.      * @return Collection<int, PostType>
  647.      */
  648.     public function getPostTypes(): Collection
  649.     {
  650.         return $this->postTypes;
  651.     }
  653.     public function addPostType(PostType $postType): static
  654.     {
  655.         if (!$this->postTypes->contains($postType)) {
  656.             $this->postTypes->add($postType);
  657.             $postType->setShop($this);
  658.         }
  660.         return $this;
  661.     }
  663.     public function removePostType(PostType $postType): static
  664.     {
  665.         if ($this->postTypes->removeElement($postType)) {
  666.             // set the owning side to null (unless already changed)
  667.             if ($postType->getShop() === $this) {
  668.                 $postType->setShop(null);
  669.             }
  670.         }
  672.         return $this;
  673.     }
  675.     /**
  676.      * @return Collection<int, Menu>
  677.      */
  678.     public function getMenus(): Collection
  679.     {
  680.         return $this->menus;
  681.     }
  683.     public function addMenu(Menu $menu): static
  684.     {
  685.         if (!$this->menus->contains($menu)) {
  686.             $this->menus->add($menu);
  687.             $menu->setShop($this);
  688.         }
  690.         return $this;
  691.     }
  693.     public function removeMenu(Menu $menu): static
  694.     {
  695.         if ($this->menus->removeElement($menu)) {
  696.             // set the owning side to null (unless already changed)
  697.             if ($menu->getShop() === $this) {
  698.                 $menu->setShop(null);
  699.             }
  700.         }
  702.         return $this;
  703.     }
  705.     /**
  706.      * @return Collection<int, Setting>
  707.      */
  708.     public function getSettings(): Collection
  709.     {
  710.         return $this->settings;
  711.     }
  713.     public function addSetting(Setting $setting): static
  714.     {
  715.         if (!$this->settings->contains($setting)) {
  716.             $this->settings->add($setting);
  717.             $setting->setShop($this);
  718.         }
  720.         return $this;
  721.     }
  723.     public function removeSetting(Setting $setting): static
  724.     {
  725.         if ($this->settings->removeElement($setting)) {
  726.             // set the owning side to null (unless already changed)
  727.             if ($setting->getShop() === $this) {
  728.                 $setting->setShop(null);
  729.             }
  730.         }
  732.         return $this;
  733.     }
  735.     /**
  736.      * @return Collection<int, Page>
  737.      */
  738.     public function getPages(): Collection
  739.     {
  740.         return $this->pages;
  741.     }
  743.     public function addPage(Page $page): static
  744.     {
  745.         if (!$this->pages->contains($page)) {
  746.             $this->pages->add($page);
  747.             $page->setShop($this);
  748.         }
  750.         return $this;
  751.     }
  753.     public function removePage(Page $page): static
  754.     {
  755.         if ($this->pages->removeElement($page)) {
  756.             // set the owning side to null (unless already changed)
  757.             if ($page->getShop() === $this) {
  758.                 $page->setShop(null);
  759.             }
  760.         }
  762.         return $this;
  763.     }
  765.     /**
  766.      * @return Collection<int, Article>
  767.      */
  768.     public function getArticles(): Collection
  769.     {
  770.         return $this->articles;
  771.     }
  773.     public function addArticle(Article $article): static
  774.     {
  775.         if (!$this->articles->contains($article)) {
  776.             $this->articles->add($article);
  777.             $article->setShop($this);
  778.         }
  780.         return $this;
  781.     }
  783.     public function removeArticle(Article $article): static
  784.     {
  785.         if ($this->articles->removeElement($article)) {
  786.             // set the owning side to null (unless already changed)
  787.             if ($article->getShop() === $this) {
  788.                 $article->setShop(null);
  789.             }
  790.         }
  792.         return $this;
  793.     }
  795.     /**
  796.      * @return Collection<int, Category>
  797.      */
  798.     public function getCategories(): Collection
  799.     {
  800.         return $this->categories;
  801.     }
  803.     public function addCategory(Category $category): static
  804.     {
  805.         if (!$this->categories->contains($category)) {
  806.             $this->categories->add($category);
  807.             $category->setShop($this);
  808.         }
  810.         return $this;
  811.     }
  813.     public function removeCategory(Category $category): static
  814.     {
  815.         if ($this->categories->removeElement($category)) {
  816.             // set the owning side to null (unless already changed)
  817.             if ($category->getShop() === $this) {
  818.                 $category->setShop(null);
  819.             }
  820.         }
  822.         return $this;
  823.     }
  825.     /**
  826.      * @return Collection<int, Tag>
  827.      */
  828.     public function getTags(): Collection
  829.     {
  830.         return $this->tags;
  831.     }
  833.     public function addTag(Tag $tag): static
  834.     {
  835.         if (!$this->tags->contains($tag)) {
  836.             $this->tags->add($tag);
  837.             $tag->setShop($this);
  838.         }
  840.         return $this;
  841.     }
  843.     public function removeTag(Tag $tag): static
  844.     {
  845.         if ($this->tags->removeElement($tag)) {
  846.             // set the owning side to null (unless already changed)
  847.             if ($tag->getShop() === $this) {
  848.                 $tag->setShop(null);
  849.             }
  850.         }
  852.         return $this;
  853.     }
  855.     /**
  856.      * @return Collection<int, Ticket>
  857.      */
  858.     public function getTickets(): Collection
  859.     {
  860.         return $this->tickets;
  861.     }
  863.     public function addTicket(Ticket $ticket): static
  864.     {
  865.         if (!$this->tickets->contains($ticket)) {
  866.             $this->tickets->add($ticket);
  867.             $ticket->setShop($this);
  868.         }
  870.         return $this;
  871.     }
  873.     public function removeTicket(Ticket $ticket): static
  874.     {
  875.         if ($this->tickets->removeElement($ticket)) {
  876.             // set the owning side to null (unless already changed)
  877.             if ($ticket->getShop() === $this) {
  878.                 $ticket->setShop(null);
  879.             }
  880.         }
  882.         return $this;
  883.     }
  885.     /**
  886.      * @return Collection<int, Transaction>
  887.      */
  888.     public function getTransactions(): Collection
  889.     {
  890.         return $this->transactions;
  891.     }
  893.     public function addTransaction(Transaction $transaction): static
  894.     {
  895.         if (!$this->transactions->contains($transaction)) {
  896.             $this->transactions->add($transaction);
  897.             $transaction->setShop($this);
  898.         }
  900.         return $this;
  901.     }
  903.     public function removeTransaction(Transaction $transaction): static
  904.     {
  905.         if ($this->transactions->removeElement($transaction)) {
  906.             // set the owning side to null (unless already changed)
  907.             if ($transaction->getShop() === $this) {
  908.                 $transaction->setShop(null);
  909.             }
  910.         }
  912.         return $this;
  913.     }
  915.     public function getTrafficUsage(): ?string
  916.     {
  917.         return $this->trafficUsage;
  918.     }
  920.     public function setTrafficUsage(string $trafficUsage): static
  921.     {
  922.         $this->trafficUsage = $trafficUsage;
  924.         return $this;
  925.     }
  928.     public function getCurrentPlanString()
  929.     {
  930.         if ($this->currentPlan){
  931.            return $this->currentPlan->getTitle();
  932.         }else{
  933.             return '';
  934.         }
  935.     }
  937.     /**
  938.      * @return Collection<int, Domain>
  939.      */
  940.     public function getDomains(): Collection
  941.     {
  942.         return $this->domains;
  943.     }
  945.     public function addDomain(Domain $domain): static
  946.     {
  947.         if (!$this->domains->contains($domain)) {
  948.             $this->domains->add($domain);
  949.             $domain->setShop($this);
  950.         }
  952.         return $this;
  953.     }
  955.     public function removeDomain(Domain $domain): static
  956.     {
  957.         if ($this->domains->removeElement($domain)) {
  958.             // set the owning side to null (unless already changed)
  959.             if ($domain->getShop() === $this) {
  960.                 $domain->setShop(null);
  961.             }
  962.         }
  964.         return $this;
  965.     }
  967.     public function getCurrentPlan(): ?Plan
  968.     {
  969.         return $this->currentPlan;
  970.     }
  972.     public function setCurrentPlan(?Plan $currentPlan): static
  973.     {
  974.         $this->currentPlan = $currentPlan;
  976.         return $this;
  977.     }
  979.     /**
  980.      * @return Collection<int, AddOn>
  981.      */
  982.     public function getAddOns(): Collection
  983.     {
  984.         return $this->addOns;
  985.     }
  987.     public function addAddOn(AddOn $addOn): static
  988.     {
  989.         if (!$this->addOns->contains($addOn)) {
  990.             $this->addOns->add($addOn);
  991.             $addOn->setShop($this);
  992.         }
  994.         return $this;
  995.     }
  997.     public function removeAddOn(AddOn $addOn): static
  998.     {
  999.         if ($this->addOns->removeElement($addOn)) {
  1000.             // set the owning side to null (unless already changed)
  1001.             if ($addOn->getShop() === $this) {
  1002.                 $addOn->setShop(null);
  1003.             }
  1004.         }
  1006.         return $this;
  1007.     }
  1009.     public function getPlanStartedAt(): ?\DateTimeInterface
  1010.     {
  1011.         return $this->planStartedAt;
  1012.     }
  1014.     public function setPlanStartedAt(?\DateTimeInterface $planStartedAt): static
  1015.     {
  1016.         $this->planStartedAt = $planStartedAt;
  1018.         return $this;
  1019.     }
  1022. }