src/Entity/Website/Website/Website.php line 27

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Website\Website;
  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\Website\Setting;
  12. use App\Entity\Website\Transaction;
  17. use App\Repository\Website\Website\WebsiteRepository;
  18. use Doctrine\Common\Collections\ArrayCollection;
  19. use Doctrine\Common\Collections\Collection;
  20. use Doctrine\DBAL\Types\Types;
  21. use Doctrine\ORM\Mapping as ORM;
  22. use Symfony\Bridge\Doctrine\IdGenerator\UuidGenerator;
  23. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  25. #[ORM\Entity(repositoryClass: WebsiteRepository::class)]
  26. #[UniqueEntity(fields: ['subdomain'], message: 'این نام کاربری فروشگاه از قبل موجود می باشد')]
  27. class Website extends BaseEntity
  28. {
  29.     #[ORM\Id]
  30.     #[ORM\Column(type: 'guid', unique: true)]
  31.     #[ORM\GeneratedValue(strategy: 'CUSTOM')]
  32.     #[ORM\CustomIdGenerator(class: UuidGenerator::class)]
  33.     private ?string $id;
  35.     #[ORM\Column(length: 255)]
  36.     private ?string $name = null;
  38.     #[ORM\Column(length: 255, unique: true)]
  39.     private ?string $subdomain = null;
  41.     #[ORM\Column]
  42.     private ?float $shopBalance = null;
  44.     #[ORM\ManyToOne(inversedBy: 'shops')]
  45.     #[ORM\JoinColumn(nullable: false)]
  46.     private ?User $owner = null;
  48.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Customer::class)]
  49.     private Collection $customers;
  55.     #[ORM\Column(length: 255, nullable: true)]
  56.     private ?string $theme = null;
  59.     #[ORM\Column(nullable: true)]
  60.     private ?array $analyticsData = null;
  62.     #[ORM\Column(nullable: true)]
  63.     private ?\DateTimeImmutable $expiredAt = null;
  67.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Transaction::class)]
  68.     private Collection $transactions;
  70.     #[ORM\Column(type: Types::BIGINT)]
  71.     private ?string $trafficUsage = null;
  75.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Domain::class)]
  76.     private Collection $domains;
  78.     #[ORM\ManyToOne(inversedBy: 'shops')]
  79.     private ?Plan $currentPlan = null;
  81.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: AddOn::class)]
  82.     private Collection $addOns;
  84.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  85.     private ?\DateTimeInterface $planStartedAt = null;
  87.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Setting::class)]
  88.     private Collection $settings;
  94.     public function subdomainAddress()
  95.     {
  96.         return $this->subdomain.'.tehranabr.org';
  97.     }
  99.     public function __construct()
  100.     {
  101.         $this->setTrafficUsage(0);
  102.         parent::__construct();
  103.         $now = new \DateTimeImmutable();
  104.         $this->setExpiredAt($now->modify("+7 days"));
  105.         $this->setPlanStartedAt($now);
  106.         $this->shopBalance = 0;
  107.         $this->customers = new ArrayCollection();
  108.         $this->products = new ArrayCollection();
  109.         $this->productAttributes = new ArrayCollection();
  110.         $this->productAttributeValues = new ArrayCollection();
  111.         $this->discounts = new ArrayCollection();
  112.         $this->carts = new ArrayCollection();
  113.         $this->cartItems = new ArrayCollection();
  114.         $this->cartItemAttributes = new ArrayCollection();
  115.         $this->coupons = new ArrayCollection();
  116.         $this->orders = new ArrayCollection();
  117.         $this->shippingMethods = new ArrayCollection();
  118.         $this->productCategories = new ArrayCollection();
  119.         $this->postTypes = new ArrayCollection();
  120.         $this->menus = new ArrayCollection();
  122.         $this->pages = new ArrayCollection();
  123.         $this->articles = new ArrayCollection();
  124.         $this->categories = new ArrayCollection();
  125.         $this->tags = new ArrayCollection();
  126.         $this->tickets = new ArrayCollection();
  127.         $this->transactions = new ArrayCollection();
  128.         $this->domains = new ArrayCollection();
  129.         $this->addOns = new ArrayCollection();
  130.         $this->smsTemplates = new ArrayCollection();
  131.         $this->settings = new ArrayCollection();
  133.     }
  135.     public function getId(): ?string
  136.     {
  137.         return $this->id;
  138.     }
  140.     public function getName(): ?string
  141.     {
  142.         return $this->name;
  143.     }
  145.     public function setName(string $name): static
  146.     {
  147.         $this->name = $name;
  149.         return $this;
  150.     }
  152.     public function getSubdomain(): ?string
  153.     {
  154.         return $this->subdomain;
  155.     }
  159.     public function setSubdomain(string $subdomain): static
  160.     {
  161.         $this->subdomain = $subdomain;
  163.         return $this;
  164.     }
  166.     public function getShopBalance(): ?float
  167.     {
  168.         return $this->shopBalance;
  169.     }
  171.     public function setShopBalance(float $shopBalance): static
  172.     {
  173.         $this->shopBalance = $shopBalance;
  175.         return $this;
  176.     }
  178.     public function getOwner(): ?User
  179.     {
  180.         return $this->owner;
  181.     }
  183.     public function setOwner(?User $owner): static
  184.     {
  185.         $this->owner = $owner;
  187.         return $this;
  188.     }
  190.     /**
  191.      * @return Collection<int, Customer>
  192.      */
  193.     public function getCustomers(): Collection
  194.     {
  195.         return $this->customers;
  196.     }
  198.     public function addCustomer(Customer $customer): static
  199.     {
  200.         if (!$this->customers->contains($customer)) {
  201.             $this->customers->add($customer);
  202.             $customer->setWebsite($this);
  203.         }
  205.         return $this;
  206.     }
  208.     public function removeCustomer(Customer $customer): static
  209.     {
  210.         if ($this->customers->removeElement($customer)) {
  211.             // set the owning side to null (unless already changed)
  212.             if ($customer->getWebsite() === $this) {
  213.                 $customer->setWebsite(null);
  214.             }
  215.         }
  217.         return $this;
  218.     }
  220.     /**
  221.      * @return Collection<int, Product>
  222.      */
  223.     public function getProducts(): Collection
  224.     {
  225.         return $this->products;
  226.     }
  228.     public function addProduct(Product $product): static
  229.     {
  230.         if (!$this->products->contains($product)) {
  231.             $this->products->add($product);
  232.             $product->setWebsite($this);
  233.         }
  235.         return $this;
  236.     }
  238.     public function removeProduct(Product $product): static
  239.     {
  240.         if ($this->products->removeElement($product)) {
  241.             // set the owning side to null (unless already changed)
  242.             if ($product->getWebsite() === $this) {
  243.                 $product->setWebsite(null);
  244.             }
  245.         }
  247.         return $this;
  248.     }
  250.     /**
  251.      * @return Collection<int, ProductAttribute>
  252.      */
  253.     public function getProductAttributes(): Collection
  254.     {
  255.         return $this->productAttributes;
  256.     }
  258.     public function addProductAttribute(ProductAttribute $productAttribute): static
  259.     {
  260.         if (!$this->productAttributes->contains($productAttribute)) {
  261.             $this->productAttributes->add($productAttribute);
  262.             $productAttribute->setWebsite($this);
  263.         }
  265.         return $this;
  266.     }
  268.     public function removeProductAttribute(ProductAttribute $productAttribute): static
  269.     {
  270.         if ($this->productAttributes->removeElement($productAttribute)) {
  271.             // set the owning side to null (unless already changed)
  272.             if ($productAttribute->getWebsite() === $this) {
  273.                 $productAttribute->setWebsite(null);
  274.             }
  275.         }
  277.         return $this;
  278.     }
  280.     /**
  281.      * @return Collection<int, ProductAttributeValue>
  282.      */
  283.     public function getProductAttributeValues(): Collection
  284.     {
  285.         return $this->productAttributeValues;
  286.     }
  288.     public function addProductAttributeValue(ProductAttributeValue $productAttributeValue): static
  289.     {
  290.         if (!$this->productAttributeValues->contains($productAttributeValue)) {
  291.             $this->productAttributeValues->add($productAttributeValue);
  292.             $productAttributeValue->setWebsite($this);
  293.         }
  295.         return $this;
  296.     }
  298.     public function removeProductAttributeValue(ProductAttributeValue $productAttributeValue): static
  299.     {
  300.         if ($this->productAttributeValues->removeElement($productAttributeValue)) {
  301.             // set the owning side to null (unless already changed)
  302.             if ($productAttributeValue->getWebsite() === $this) {
  303.                 $productAttributeValue->setWebsite(null);
  304.             }
  305.         }
  307.         return $this;
  308.     }
  310.     /**
  311.      * @return Collection<int, Discount>
  312.      */
  313.     public function getDiscounts(): Collection
  314.     {
  315.         return $this->discounts;
  316.     }
  318.     public function addDiscount(Discount $discount): static
  319.     {
  320.         if (!$this->discounts->contains($discount)) {
  321.             $this->discounts->add($discount);
  322.             $discount->setWebsite($this);
  323.         }
  325.         return $this;
  326.     }
  328.     public function removeDiscount(Discount $discount): static
  329.     {
  330.         if ($this->discounts->removeElement($discount)) {
  331.             // set the owning side to null (unless already changed)
  332.             if ($discount->getWebsite() === $this) {
  333.                 $discount->setWebsite(null);
  334.             }
  335.         }
  337.         return $this;
  338.     }
  340.     /**
  341.      * @return Collection<int, Cart>
  342.      */
  343.     public function getCarts(): Collection
  344.     {
  345.         return $this->carts;
  346.     }
  348.     public function addCart(Cart $cart): static
  349.     {
  350.         if (!$this->carts->contains($cart)) {
  351.             $this->carts->add($cart);
  352.             $cart->setWebsite($this);
  353.         }
  355.         return $this;
  356.     }
  358.     public function removeCart(Cart $cart): static
  359.     {
  360.         if ($this->carts->removeElement($cart)) {
  361.             // set the owning side to null (unless already changed)
  362.             if ($cart->getWebsite() === $this) {
  363.                 $cart->setWebsite(null);
  364.             }
  365.         }
  367.         return $this;
  368.     }
  370.     /**
  371.      * @return Collection<int, CartItem>
  372.      */
  373.     public function getCartItems(): Collection
  374.     {
  375.         return $this->cartItems;
  376.     }
  378.     public function addCartItem(CartItem $cartItem): static
  379.     {
  380.         if (!$this->cartItems->contains($cartItem)) {
  381.             $this->cartItems->add($cartItem);
  382.             $cartItem->setWebsite($this);
  383.         }
  385.         return $this;
  386.     }
  388.     public function removeCartItem(CartItem $cartItem): static
  389.     {
  390.         if ($this->cartItems->removeElement($cartItem)) {
  391.             // set the owning side to null (unless already changed)
  392.             if ($cartItem->getWebsite() === $this) {
  393.                 $cartItem->setWebsite(null);
  394.             }
  395.         }
  397.         return $this;
  398.     }
  400.     /**
  401.      * @return Collection<int, CartItemAttribute>
  402.      */
  403.     public function getCartItemAttributes(): Collection
  404.     {
  405.         return $this->cartItemAttributes;
  406.     }
  408.     public function addCartItemAttribute(CartItemAttribute $cartItemAttribute): static
  409.     {
  410.         if (!$this->cartItemAttributes->contains($cartItemAttribute)) {
  411.             $this->cartItemAttributes->add($cartItemAttribute);
  412.             $cartItemAttribute->setWebsite($this);
  413.         }
  415.         return $this;
  416.     }
  418.     public function removeCartItemAttribute(CartItemAttribute $cartItemAttribute): static
  419.     {
  420.         if ($this->cartItemAttributes->removeElement($cartItemAttribute)) {
  421.             // set the owning side to null (unless already changed)
  422.             if ($cartItemAttribute->getWebsite() === $this) {
  423.                 $cartItemAttribute->setWebsite(null);
  424.             }
  425.         }
  427.         return $this;
  428.     }
  430.     /**
  431.      * @return Collection<int, Coupon>
  432.      */
  433.     public function getCoupons(): Collection
  434.     {
  435.         return $this->coupons;
  436.     }
  438.     public function addCoupon(Coupon $coupon): static
  439.     {
  440.         if (!$this->coupons->contains($coupon)) {
  441.             $this->coupons->add($coupon);
  442.             $coupon->setWebsite($this);
  443.         }
  445.         return $this;
  446.     }
  448.     public function removeCoupon(Coupon $coupon): static
  449.     {
  450.         if ($this->coupons->removeElement($coupon)) {
  451.             // set the owning side to null (unless already changed)
  452.             if ($coupon->getWebsite() === $this) {
  453.                 $coupon->setWebsite(null);
  454.             }
  455.         }
  457.         return $this;
  458.     }
  460.     /**
  461.      * @return Collection<int, Order>
  462.      */
  463.     public function getOrders(): Collection
  464.     {
  465.         return $this->orders;
  466.     }
  468.     public function addOrder(Order $order): static
  469.     {
  470.         if (!$this->orders->contains($order)) {
  471.             $this->orders->add($order);
  472.             $order->setWebsite($this);
  473.         }
  475.         return $this;
  476.     }
  478.     public function removeOrder(Order $order): static
  479.     {
  480.         if ($this->orders->removeElement($order)) {
  481.             // set the owning side to null (unless already changed)
  482.             if ($order->getWebsite() === $this) {
  483.                 $order->setWebsite(null);
  484.             }
  485.         }
  487.         return $this;
  488.     }
  490.     /**
  491.      * @return Collection<int, ShippingMethod>
  492.      */
  493.     public function getShippingMethods(): Collection
  494.     {
  495.         return $this->shippingMethods;
  496.     }
  498.     public function addShippingMethod(ShippingMethod $shippingMethod): static
  499.     {
  500.         if (!$this->shippingMethods->contains($shippingMethod)) {
  501.             $this->shippingMethods->add($shippingMethod);
  502.             $shippingMethod->setWebsite($this);
  503.         }
  505.         return $this;
  506.     }
  508.     public function removeShippingMethod(ShippingMethod $shippingMethod): static
  509.     {
  510.         if ($this->shippingMethods->removeElement($shippingMethod)) {
  511.             // set the owning side to null (unless already changed)
  512.             if ($shippingMethod->getWebsite() === $this) {
  513.                 $shippingMethod->setWebsite(null);
  514.             }
  515.         }
  517.         return $this;
  518.     }
  520.     public function getTheme(): ?string
  521.     {
  522.         if ($this->theme == null){
  523.             return 'default';
  524.         }
  525.         return $this->theme;
  526.     }
  528.     public function setTheme(?string $theme): static
  529.     {
  530.         $this->theme = $theme;
  532.         return $this;
  533.     }
  535.     /**
  536.      * @return Collection<int, ProductCategory>
  537.      */
  538.     public function getProductCategories(): Collection
  539.     {
  540.         return $this->productCategories;
  541.     }
  543.     public function addProductCategory(ProductCategory $productCategory): static
  544.     {
  545.         if (!$this->productCategories->contains($productCategory)) {
  546.             $this->productCategories->add($productCategory);
  547.             $productCategory->setWebsite($this);
  548.         }
  550.         return $this;
  551.     }
  553.     public function removeProductCategory(ProductCategory $productCategory): static
  554.     {
  555.         if ($this->productCategories->removeElement($productCategory)) {
  556.             // set the owning side to null (unless already changed)
  557.             if ($productCategory->getWebsite() === $this) {
  558.                 $productCategory->setWebsite(null);
  559.             }
  560.         }
  562.         return $this;
  563.     }
  565.     public function getAnalyticsData(): ?array
  566.     {
  567.         return $this->analyticsData;
  568.     }
  570.     public function setAnalyticsData(?array $analyticsData): static
  571.     {
  572.         $this->analyticsData = $analyticsData;
  574.         return $this;
  575.     }
  577.     public function getExpiredAt(): ?\DateTimeImmutable
  578.     {
  579.         return $this->expiredAt;
  580.     }
  582.     public function setExpiredAt(?\DateTimeImmutable $expiredAt): static
  583.     {
  584.         $this->expiredAt = $expiredAt;
  586.         return $this;
  587.     }
  589.     /**
  590.      * @return Collection<int, PostType>
  591.      */
  592.     public function getPostTypes(): Collection
  593.     {
  594.         return $this->postTypes;
  595.     }
  597.     public function addPostType(PostType $postType): static
  598.     {
  599.         if (!$this->postTypes->contains($postType)) {
  600.             $this->postTypes->add($postType);
  601.             $postType->setWebsite($this);
  602.         }
  604.         return $this;
  605.     }
  607.     public function removePostType(PostType $postType): static
  608.     {
  609.         if ($this->postTypes->removeElement($postType)) {
  610.             // set the owning side to null (unless already changed)
  611.             if ($postType->getWebsite() === $this) {
  612.                 $postType->setWebsite(null);
  613.             }
  614.         }
  616.         return $this;
  617.     }
  619.     /**
  620.      * @return Collection<int, Menu>
  621.      */
  622.     public function getMenus(): Collection
  623.     {
  624.         return $this->menus;
  625.     }
  627.     public function addMenu(Menu $menu): static
  628.     {
  629.         if (!$this->menus->contains($menu)) {
  630.             $this->menus->add($menu);
  631.             $menu->setWebsite($this);
  632.         }
  634.         return $this;
  635.     }
  637.     public function removeMenu(Menu $menu): static
  638.     {
  639.         if ($this->menus->removeElement($menu)) {
  640.             // set the owning side to null (unless already changed)
  641.             if ($menu->getWebsite() === $this) {
  642.                 $menu->setWebsite(null);
  643.             }
  644.         }
  646.         return $this;
  647.     }
  650.     /**
  651.      * @return Collection<int, Page>
  652.      */
  653.     public function getPages(): Collection
  654.     {
  655.         return $this->pages;
  656.     }
  658.     public function addPage(Page $page): static
  659.     {
  660.         if (!$this->pages->contains($page)) {
  661.             $this->pages->add($page);
  662.             $page->setWebsite($this);
  663.         }
  665.         return $this;
  666.     }
  668.     public function removePage(Page $page): static
  669.     {
  670.         if ($this->pages->removeElement($page)) {
  671.             // set the owning side to null (unless already changed)
  672.             if ($page->getWebsite() === $this) {
  673.                 $page->setWebsite(null);
  674.             }
  675.         }
  677.         return $this;
  678.     }
  680.     /**
  681.      * @return Collection<int, Article>
  682.      */
  683.     public function getArticles(): Collection
  684.     {
  685.         return $this->articles;
  686.     }
  688.     public function addArticle(Article $article): static
  689.     {
  690.         if (!$this->articles->contains($article)) {
  691.             $this->articles->add($article);
  692.             $article->setWebsite($this);
  693.         }
  695.         return $this;
  696.     }
  698.     public function removeArticle(Article $article): static
  699.     {
  700.         if ($this->articles->removeElement($article)) {
  701.             // set the owning side to null (unless already changed)
  702.             if ($article->getWebsite() === $this) {
  703.                 $article->setWebsite(null);
  704.             }
  705.         }
  707.         return $this;
  708.     }
  710.     /**
  711.      * @return Collection<int, Category>
  712.      */
  713.     public function getCategories(): Collection
  714.     {
  715.         return $this->categories;
  716.     }
  718.     public function addCategory(Category $category): static
  719.     {
  720.         if (!$this->categories->contains($category)) {
  721.             $this->categories->add($category);
  722.             $category->setWebsite($this);
  723.         }
  725.         return $this;
  726.     }
  728.     public function removeCategory(Category $category): static
  729.     {
  730.         if ($this->categories->removeElement($category)) {
  731.             // set the owning side to null (unless already changed)
  732.             if ($category->getWebsite() === $this) {
  733.                 $category->setWebsite(null);
  734.             }
  735.         }
  737.         return $this;
  738.     }
  740.     /**
  741.      * @return Collection<int, Tag>
  742.      */
  743.     public function getTags(): Collection
  744.     {
  745.         return $this->tags;
  746.     }
  748.     public function addTag(Tag $tag): static
  749.     {
  750.         if (!$this->tags->contains($tag)) {
  751.             $this->tags->add($tag);
  752.             $tag->setWebsite($this);
  753.         }
  755.         return $this;
  756.     }
  758.     public function removeTag(Tag $tag): static
  759.     {
  760.         if ($this->tags->removeElement($tag)) {
  761.             // set the owning side to null (unless already changed)
  762.             if ($tag->getWebsite() === $this) {
  763.                 $tag->setWebsite(null);
  764.             }
  765.         }
  767.         return $this;
  768.     }
  770.     /**
  771.      * @return Collection<int, Ticket>
  772.      */
  773.     public function getTickets(): Collection
  774.     {
  775.         return $this->tickets;
  776.     }
  778.     public function addTicket(Ticket $ticket): static
  779.     {
  780.         if (!$this->tickets->contains($ticket)) {
  781.             $this->tickets->add($ticket);
  782.             $ticket->setWebsite($this);
  783.         }
  785.         return $this;
  786.     }
  788.     public function removeTicket(Ticket $ticket): static
  789.     {
  790.         if ($this->tickets->removeElement($ticket)) {
  791.             // set the owning side to null (unless already changed)
  792.             if ($ticket->getWebsite() === $this) {
  793.                 $ticket->setWebsite(null);
  794.             }
  795.         }
  797.         return $this;
  798.     }
  800.     /**
  801.      * @return Collection<int, Transaction>
  802.      */
  803.     public function getTransactions(): Collection
  804.     {
  805.         return $this->transactions;
  806.     }
  808.     public function addTransaction(Transaction $transaction): static
  809.     {
  810.         if (!$this->transactions->contains($transaction)) {
  811.             $this->transactions->add($transaction);
  812.             $transaction->getWebsite($this);
  813.         }
  815.         return $this;
  816.     }
  818.     public function removeTransaction(Transaction $transaction): static
  819.     {
  820.         if ($this->transactions->removeElement($transaction)) {
  821.             // set the owning side to null (unless already changed)
  822.             if ($transaction->getWebsite() === $this) {
  823.                 $transaction->setWebsite(null);
  824.             }
  825.         }
  827.         return $this;
  828.     }
  830.     public function getTrafficUsage(): ?string
  831.     {
  832.         return $this->trafficUsage;
  833.     }
  835.     public function setTrafficUsage(string $trafficUsage): static
  836.     {
  837.         $this->trafficUsage = $trafficUsage;
  839.         return $this;
  840.     }
  843.     public function getCurrentPlanString()
  844.     {
  845.         if ($this->currentPlan){
  846.            return $this->currentPlan->getTitle();
  847.         }else{
  848.             return '';
  849.         }
  850.     }
  852.     /**
  853.      * @return Collection<int, Domain>
  854.      */
  855.     public function getDomains(): Collection
  856.     {
  857.         return $this->domains;
  858.     }
  860.     public function addDomain(Domain $domain): static
  861.     {
  862.         if (!$this->domains->contains($domain)) {
  863.             $this->domains->add($domain);
  864.             $domain->setWebsite($this);
  865.         }
  867.         return $this;
  868.     }
  870.     public function removeDomain(Domain $domain): static
  871.     {
  872.         if ($this->domains->removeElement($domain)) {
  873.             // set the owning side to null (unless already changed)
  874.             if ($domain->getWebsite() === $this) {
  875.                 $domain->setWebsite(null);
  876.             }
  877.         }
  879.         return $this;
  880.     }
  882.     public function getCurrentPlan(): ?Plan
  883.     {
  884.         return $this->currentPlan;
  885.     }
  887.     public function setCurrentPlan(?Plan $currentPlan): static
  888.     {
  889.         $this->currentPlan = $currentPlan;
  891.         return $this;
  892.     }
  894.     /**
  895.      * @return Collection<int, AddOn>
  896.      */
  897.     public function getAddOns(): Collection
  898.     {
  899.         return $this->addOns;
  900.     }
  902.     public function addAddOn(AddOn $addOn): static
  903.     {
  904.         if (!$this->addOns->contains($addOn)) {
  905.             $this->addOns->add($addOn);
  906.             $addOn->setWebsite($this);
  907.         }
  909.         return $this;
  910.     }
  912.     public function removeAddOn(AddOn $addOn): static
  913.     {
  914.         if ($this->addOns->removeElement($addOn)) {
  915.             // set the owning side to null (unless already changed)
  916.             if ($addOn->getWebsite() === $this) {
  917.                 $addOn->getWebsite(null);
  918.             }
  919.         }
  921.         return $this;
  922.     }
  924.     public function getPlanStartedAt(): ?\DateTimeInterface
  925.     {
  926.         return $this->planStartedAt;
  927.     }
  929.     public function setPlanStartedAt(?\DateTimeInterface $planStartedAt): static
  930.     {
  931.         $this->planStartedAt = $planStartedAt;
  933.         return $this;
  934.     }
  936.     /**
  937.      * @return Collection<int, SmsTemplate>
  938.      */
  939.     public function getSmsTemplates(): Collection
  940.     {
  941.         return $this->smsTemplates;
  942.     }
  944.     public function addSmsTemplate(SmsTemplate $smsTemplate): static
  945.     {
  946.         if (!$this->smsTemplates->contains($smsTemplate)) {
  947.             $this->smsTemplates->add($smsTemplate);
  948.             $smsTemplate->setWebsite($this);
  949.         }
  951.         return $this;
  952.     }
  954.     public function removeSmsTemplate(SmsTemplate $smsTemplate): static
  955.     {
  956.         if ($this->smsTemplates->removeElement($smsTemplate)) {
  957.             // set the owning side to null (unless already changed)
  958.             if ($smsTemplate->getWebsite() === $this) {
  959.                 $smsTemplate->setWebsite(null);
  960.             }
  961.         }
  963.         return $this;
  964.     }
  966.     /**
  967.      * @return Collection<int, Setting>
  968.      */
  969.     public function getSettings(): Collection
  970.     {
  971.         return $this->settings;
  972.     }
  974.     public function addSetting(Setting $setting): static
  975.     {
  976.         if (!$this->settings->contains($setting)) {
  977.             $this->settings->add($setting);
  978.             $setting->setWebsite($this);
  979.         }
  981.         return $this;
  982.     }
  984.     public function removeSetting(Setting $setting): static
  985.     {
  986.         if ($this->settings->removeElement($setting)) {
  987.             // set the owning side to null (unless already changed)
  988.             if ($setting->getWebsite() === $this) {
  989.                 $setting->setWebsite(null);
  990.             }
  991.         }
  993.         return $this;
  994.     }
  998. }