src/Entity/Website/Website/Website.php line 41

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\Analytics;
  12. use App\Entity\Website\Analytics\ServersUsage;
  13. use App\Entity\Website\Campaign;
  14. use App\Entity\Website\Cms\Article;
  15. use App\Entity\Website\Cms\Category;
  16. use App\Entity\Website\Cms\Page;
  17. use App\Entity\Website\Cms\Tag;
  18. use App\Entity\Website\Cost;
  19. use App\Entity\Website\CostCategory;
  20. use App\Entity\Website\Setting;
  21. use App\Entity\Website\Sms\SmsIncome;
  22. use App\Entity\Website\SubTransactions\VasetPal;
  23. use App\Entity\Website\Telegram\AgentPublicBot\Bot;
  24. use App\Entity\Website\Transaction;
  25. use App\Entity\Website\VPN\OcServ\Server;
  26. use App\Entity\Website\VPN\Service\Service;
  31. use App\Repository\Website\Website\WebsiteRepository;
  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: WebsiteRepository::class)]
  40. #[UniqueEntity(fields: ['subdomain'], message: 'این نام کاربری فروشگاه از قبل موجود می باشد')]
  41. class Website 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: 'website', targetEntity: Customer::class)]
  63.     private Collection $customers;
  69.     #[ORM\Column(length: 255, nullable: true)]
  70.     private ?string $theme = null;
  73.     #[ORM\Column(nullable: true)]
  74.     private ?array $analyticsData = null;
  76.     #[ORM\Column(nullable: true)]
  77.     private ?\DateTimeImmutable $expiredAt = null;
  81.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Transaction::class)]
  82.     private Collection $transactions;
  84.     #[ORM\Column(type: Types::BIGINT)]
  85.     private ?string $trafficUsage = null;
  89.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Domain::class)]
  90.     private Collection $domains;
  92.     #[ORM\ManyToOne(inversedBy: 'shops')]
  93.     private ?Plan $currentPlan = null;
  95.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: AddOn::class)]
  96.     private Collection $addOns;
  98.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  99.     private ?\DateTimeInterface $planStartedAt = null;
  101.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Setting::class)]
  102.     private Collection $settings;
  104.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: ServersUsage::class)]
  105.     private Collection $serversUsages;
  107.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Article::class)]
  108.     private Collection $articles;
  110.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Category::class)]
  111.     private Collection $categories;
  113.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Page::class)]
  114.     private Collection $pages;
  116.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Tag::class)]
  117.     private Collection $tags;
  119.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: \App\Entity\Website\Domains\Domain::class)]
  120.     private Collection $subPanelDomains;
  122.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: SmsIncome::class)]
  123.     private Collection $smsIncomes;
  125.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: VasetPal::class)]
  126.     private Collection $vasetPals;
  128.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Bot::class)]
  129.     private Collection $bots;
  131.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Analytics::class)]
  132.     private Collection $analytics;
  134.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Campaign::class)]
  135.     private Collection $campaigns;
  137.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Cost::class)]
  138.     private Collection $costs;
  140.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: CostCategory::class)]
  141.     private Collection $costCategories;
  143.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Transaction::class)]
  144.     private Collection $websiteTransactions;
  146.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Service::class)]
  147.     private Collection $services;
  149.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: Server::class)]
  150.     private Collection $servers;
  152.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: \App\Entity\Website\VPN\OpenVPN\Server::class)]
  153.     private Collection $openVPNServers;
  155.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: \App\Entity\Website\VPN\Service\Plan::class)]
  156.     private Collection $plans;
  158.     #[ORM\OneToMany(mappedBy: 'website', targetEntity: \App\Entity\Website\VPN\V2ray\Server::class)]
  159.     private Collection $v2rayServers;
  165.     public function subdomainAddress()
  166.     {
  167.         return $this->subdomain.'.tehranabr.org';
  168.     }
  170.     public function __construct()
  171.     {
  172.         $this->setTrafficUsage(0);
  173.         parent::__construct();
  174.         $now = new \DateTimeImmutable();
  175.         $this->setExpiredAt($now->modify("+7 days"));
  176.         $this->setPlanStartedAt($now);
  177.         $this->shopBalance = 0;
  178.         $this->customers = new ArrayCollection();
  181.         $this->pages = new ArrayCollection();
  182.         $this->articles = new ArrayCollection();
  183.         $this->categories = new ArrayCollection();
  184.         $this->tags = new ArrayCollection();
  186.         $this->transactions = new ArrayCollection();
  187.         $this->domains = new ArrayCollection();
  188.         $this->addOns = new ArrayCollection();
  189.         $this->settings = new ArrayCollection();
  190.         $this->serversUsages = new ArrayCollection();
  191.         $this->subPanelDomains = new ArrayCollection();
  192.         $this->smsIncomes = new ArrayCollection();
  193.         $this->vasetPals = new ArrayCollection();
  194.         $this->bots = new ArrayCollection();
  195.         $this->analytics = new ArrayCollection();
  196.         $this->campaigns = new ArrayCollection();
  197.         $this->costs = new ArrayCollection();
  198.         $this->costCategories = new ArrayCollection();
  199.         $this->websiteTransactions = new ArrayCollection();
  200.         $this->services = new ArrayCollection();
  201.         $this->servers = new ArrayCollection();
  202.         $this->openVPNServers = new ArrayCollection();
  203.         $this->plans = new ArrayCollection();
  204.         $this->v2rayServers = new ArrayCollection();
  206.     }
  208.     public function getId(): ?string
  209.     {
  210.         return $this->id;
  211.     }
  213.     public function getName(): ?string
  214.     {
  215.         return $this->name;
  216.     }
  218.     public function setName(string $name): static
  219.     {
  220.         $this->name = $name;
  222.         return $this;
  223.     }
  225.     public function getSubdomain(): ?string
  226.     {
  227.         return $this->subdomain;
  228.     }
  232.     public function setSubdomain(string $subdomain): static
  233.     {
  234.         $this->subdomain = $subdomain;
  236.         return $this;
  237.     }
  239.     public function getShopBalance(): ?float
  240.     {
  241.         return $this->shopBalance;
  242.     }
  244.     public function setShopBalance(float $shopBalance): static
  245.     {
  246.         $this->shopBalance = $shopBalance;
  248.         return $this;
  249.     }
  251.     public function getOwner(): ?User
  252.     {
  253.         return $this->owner;
  254.     }
  256.     public function setOwner(?User $owner): static
  257.     {
  258.         $this->owner = $owner;
  260.         return $this;
  261.     }
  263.     /**
  264.      * @return Collection<int, Customer>
  265.      */
  266.     public function getCustomers(): Collection
  267.     {
  268.         return $this->customers;
  269.     }
  271.     public function addCustomer(Customer $customer): static
  272.     {
  273.         if (!$this->customers->contains($customer)) {
  274.             $this->customers->add($customer);
  275.             $customer->setWebsite($this);
  276.         }
  278.         return $this;
  279.     }
  281.     public function removeCustomer(Customer $customer): static
  282.     {
  283.         if ($this->customers->removeElement($customer)) {
  284.             // set the owning side to null (unless already changed)
  285.             if ($customer->getWebsite() === $this) {
  286.                 $customer->setWebsite(null);
  287.             }
  288.         }
  290.         return $this;
  291.     }
  293.     public function getTheme(): ?string
  294.     {
  295.         if ($this->theme == null){
  296.             return 'default';
  297.         }
  298.         return $this->theme;
  299.     }
  301.     public function setTheme(?string $theme): static
  302.     {
  303.         $this->theme = $theme;
  305.         return $this;
  306.     }
  308.     public function getAnalyticsData(): ?array
  309.     {
  310.         return $this->analyticsData;
  311.     }
  313.     public function setAnalyticsData(?array $analyticsData): static
  314.     {
  315.         $this->analyticsData = $analyticsData;
  317.         return $this;
  318.     }
  320.     public function getExpiredAt(): ?\DateTimeImmutable
  321.     {
  322.         return $this->expiredAt;
  323.     }
  325.     public function setExpiredAt(?\DateTimeImmutable $expiredAt): static
  326.     {
  327.         $this->expiredAt = $expiredAt;
  329.         return $this;
  330.     }
  333.     /**
  334.      * @return Collection<int, Page>
  335.      */
  336.     public function getPages(): Collection
  337.     {
  338.         return $this->pages;
  339.     }
  341.     public function addPage(Page $page): static
  342.     {
  343.         if (!$this->pages->contains($page)) {
  344.             $this->pages->add($page);
  345.             $page->setWebsite($this);
  346.         }
  348.         return $this;
  349.     }
  351.     public function removePage(Page $page): static
  352.     {
  353.         if ($this->pages->removeElement($page)) {
  354.             // set the owning side to null (unless already changed)
  355.             if ($page->getWebsite() === $this) {
  356.                 $page->setWebsite(null);
  357.             }
  358.         }
  360.         return $this;
  361.     }
  363.     /**
  364.      * @return Collection<int, Article>
  365.      */
  366.     public function getArticles(): Collection
  367.     {
  368.         return $this->articles;
  369.     }
  371.     public function addArticle(Article $article): static
  372.     {
  373.         if (!$this->articles->contains($article)) {
  374.             $this->articles->add($article);
  375.             $article->setWebsite($this);
  376.         }
  378.         return $this;
  379.     }
  381.     public function removeArticle(Article $article): static
  382.     {
  383.         if ($this->articles->removeElement($article)) {
  384.             // set the owning side to null (unless already changed)
  385.             if ($article->getWebsite() === $this) {
  386.                 $article->setWebsite(null);
  387.             }
  388.         }
  390.         return $this;
  391.     }
  393.     /**
  394.      * @return Collection<int, Category>
  395.      */
  396.     public function getCategories(): Collection
  397.     {
  398.         return $this->categories;
  399.     }
  401.     public function addCategory(Category $category): static
  402.     {
  403.         if (!$this->categories->contains($category)) {
  404.             $this->categories->add($category);
  405.             $category->setWebsite($this);
  406.         }
  408.         return $this;
  409.     }
  411.     public function removeCategory(Category $category): static
  412.     {
  413.         if ($this->categories->removeElement($category)) {
  414.             // set the owning side to null (unless already changed)
  415.             if ($category->getWebsite() === $this) {
  416.                 $category->setWebsite(null);
  417.             }
  418.         }
  420.         return $this;
  421.     }
  423.     /**
  424.      * @return Collection<int, Tag>
  425.      */
  426.     public function getTags(): Collection
  427.     {
  428.         return $this->tags;
  429.     }
  431.     public function addTag(Tag $tag): static
  432.     {
  433.         if (!$this->tags->contains($tag)) {
  434.             $this->tags->add($tag);
  435.             $tag->setWebsite($this);
  436.         }
  438.         return $this;
  439.     }
  441.     public function removeTag(Tag $tag): static
  442.     {
  443.         if ($this->tags->removeElement($tag)) {
  444.             // set the owning side to null (unless already changed)
  445.             if ($tag->getWebsite() === $this) {
  446.                 $tag->setWebsite(null);
  447.             }
  448.         }
  450.         return $this;
  451.     }
  453.     /**
  454.      * @return Collection<int, Transaction>
  455.      */
  456.     public function getTransactions(): Collection
  457.     {
  458.         return $this->transactions;
  459.     }
  461.     public function addTransaction(Transaction $transaction): static
  462.     {
  463.         if (!$this->transactions->contains($transaction)) {
  464.             $this->transactions->add($transaction);
  465.             $transaction->getWebsite($this);
  466.         }
  468.         return $this;
  469.     }
  471.     public function removeTransaction(Transaction $transaction): static
  472.     {
  473.         if ($this->transactions->removeElement($transaction)) {
  474.             // set the owning side to null (unless already changed)
  475.             if ($transaction->getWebsite() === $this) {
  476.                 $transaction->setWebsite(null);
  477.             }
  478.         }
  480.         return $this;
  481.     }
  483.     public function getTrafficUsage(): ?string
  484.     {
  485.         return $this->trafficUsage;
  486.     }
  488.     public function setTrafficUsage(string $trafficUsage): static
  489.     {
  490.         $this->trafficUsage = $trafficUsage;
  492.         return $this;
  493.     }
  496.     public function getCurrentPlanString()
  497.     {
  498.         if ($this->currentPlan){
  499.            return $this->currentPlan->getTitle();
  500.         }else{
  501.             return '';
  502.         }
  503.     }
  505.     /**
  506.      * @return Collection<int, Domain>
  507.      */
  508.     public function getDomains(): Collection
  509.     {
  510.         return $this->domains;
  511.     }
  513.     public function addDomain(Domain $domain): static
  514.     {
  515.         if (!$this->domains->contains($domain)) {
  516.             $this->domains->add($domain);
  517.             $domain->setWebsite($this);
  518.         }
  520.         return $this;
  521.     }
  523.     public function removeDomain(Domain $domain): static
  524.     {
  525.         if ($this->domains->removeElement($domain)) {
  526.             // set the owning side to null (unless already changed)
  527.             if ($domain->getWebsite() === $this) {
  528.                 $domain->setWebsite(null);
  529.             }
  530.         }
  532.         return $this;
  533.     }
  535.     public function getCurrentPlan(): ?Plan
  536.     {
  537.         return $this->currentPlan;
  538.     }
  540.     public function setCurrentPlan(?Plan $currentPlan): static
  541.     {
  542.         $this->currentPlan = $currentPlan;
  544.         return $this;
  545.     }
  547.     /**
  548.      * @return Collection<int, AddOn>
  549.      */
  550.     public function getAddOns(): Collection
  551.     {
  552.         return $this->addOns;
  553.     }
  555.     public function addAddOn(AddOn $addOn): static
  556.     {
  557.         if (!$this->addOns->contains($addOn)) {
  558.             $this->addOns->add($addOn);
  559.             $addOn->setWebsite($this);
  560.         }
  562.         return $this;
  563.     }
  565.     public function removeAddOn(AddOn $addOn): static
  566.     {
  567.         if ($this->addOns->removeElement($addOn)) {
  568.             // set the owning side to null (unless already changed)
  569.             if ($addOn->getWebsite() === $this) {
  570.                 $addOn->getWebsite(null);
  571.             }
  572.         }
  574.         return $this;
  575.     }
  577.     public function getPlanStartedAt(): ?\DateTimeInterface
  578.     {
  579.         return $this->planStartedAt;
  580.     }
  582.     public function setPlanStartedAt(?\DateTimeInterface $planStartedAt): static
  583.     {
  584.         $this->planStartedAt = $planStartedAt;
  586.         return $this;
  587.     }
  589.     /**
  590.      * @return Collection<int, Setting>
  591.      */
  592.     public function getSettings(): Collection
  593.     {
  594.         return $this->settings;
  595.     }
  597.     public function addSetting(Setting $setting): static
  598.     {
  599.         if (!$this->settings->contains($setting)) {
  600.             $this->settings->add($setting);
  601.             $setting->setWebsite($this);
  602.         }
  604.         return $this;
  605.     }
  607.     public function removeSetting(Setting $setting): static
  608.     {
  609.         if ($this->settings->removeElement($setting)) {
  610.             // set the owning side to null (unless already changed)
  611.             if ($setting->getWebsite() === $this) {
  612.                 $setting->setWebsite(null);
  613.             }
  614.         }
  616.         return $this;
  617.     }
  619.     /**
  620.      * @return Collection<int, ServersUsage>
  621.      */
  622.     public function getServersUsages(): Collection
  623.     {
  624.         return $this->serversUsages;
  625.     }
  627.     public function addServersUsage(ServersUsage $serversUsage): static
  628.     {
  629.         if (!$this->serversUsages->contains($serversUsage)) {
  630.             $this->serversUsages->add($serversUsage);
  631.             $serversUsage->setWebsite($this);
  632.         }
  634.         return $this;
  635.     }
  637.     public function removeServersUsage(ServersUsage $serversUsage): static
  638.     {
  639.         if ($this->serversUsages->removeElement($serversUsage)) {
  640.             // set the owning side to null (unless already changed)
  641.             if ($serversUsage->getWebsite() === $this) {
  642.                 $serversUsage->setWebsite(null);
  643.             }
  644.         }
  646.         return $this;
  647.     }
  649.     /**
  650.      * @return Collection<int, \App\Entity\Website\Domains\Domain>
  651.      */
  652.     public function getSubPanelDomains(): Collection
  653.     {
  654.         return $this->subPanelDomains;
  655.     }
  657.     public function addSubPanelDomain(\App\Entity\Website\Domains\Domain $subPanelDomain): static
  658.     {
  659.         if (!$this->subPanelDomains->contains($subPanelDomain)) {
  660.             $this->subPanelDomains->add($subPanelDomain);
  661.             $subPanelDomain->setWebsite($this);
  662.         }
  664.         return $this;
  665.     }
  667.     public function removeSubPanelDomain(\App\Entity\Website\Domains\Domain $subPanelDomain): static
  668.     {
  669.         if ($this->subPanelDomains->removeElement($subPanelDomain)) {
  670.             // set the owning side to null (unless already changed)
  671.             if ($subPanelDomain->getWebsite() === $this) {
  672.                 $subPanelDomain->setWebsite(null);
  673.             }
  674.         }
  676.         return $this;
  677.     }
  679.     /**
  680.      * @return Collection<int, SmsIncome>
  681.      */
  682.     public function getSmsIncomes(): Collection
  683.     {
  684.         return $this->smsIncomes;
  685.     }
  687.     public function addSmsIncome(SmsIncome $smsIncome): static
  688.     {
  689.         if (!$this->smsIncomes->contains($smsIncome)) {
  690.             $this->smsIncomes->add($smsIncome);
  691.             $smsIncome->setWebsite($this);
  692.         }
  694.         return $this;
  695.     }
  697.     public function removeSmsIncome(SmsIncome $smsIncome): static
  698.     {
  699.         if ($this->smsIncomes->removeElement($smsIncome)) {
  700.             // set the owning side to null (unless already changed)
  701.             if ($smsIncome->getWebsite() === $this) {
  702.                 $smsIncome->setWebsite(null);
  703.             }
  704.         }
  706.         return $this;
  707.     }
  709.     /**
  710.      * @return Collection<int, VasetPal>
  711.      */
  712.     public function getVasetPals(): Collection
  713.     {
  714.         return $this->vasetPals;
  715.     }
  717.     public function addVasetPal(VasetPal $vasetPal): static
  718.     {
  719.         if (!$this->vasetPals->contains($vasetPal)) {
  720.             $this->vasetPals->add($vasetPal);
  721.             $vasetPal->setWebsite($this);
  722.         }
  724.         return $this;
  725.     }
  727.     public function removeVasetPal(VasetPal $vasetPal): static
  728.     {
  729.         if ($this->vasetPals->removeElement($vasetPal)) {
  730.             // set the owning side to null (unless already changed)
  731.             if ($vasetPal->getWebsite() === $this) {
  732.                 $vasetPal->setWebsite(null);
  733.             }
  734.         }
  736.         return $this;
  737.     }
  739.     /**
  740.      * @return Collection<int, Bot>
  741.      */
  742.     public function getBots(): Collection
  743.     {
  744.         return $this->bots;
  745.     }
  747.     public function addBot(Bot $bot): static
  748.     {
  749.         if (!$this->bots->contains($bot)) {
  750.             $this->bots->add($bot);
  751.             $bot->setWebsite($this);
  752.         }
  754.         return $this;
  755.     }
  757.     public function removeBot(Bot $bot): static
  758.     {
  759.         if ($this->bots->removeElement($bot)) {
  760.             // set the owning side to null (unless already changed)
  761.             if ($bot->getWebsite() === $this) {
  762.                 $bot->setWebsite(null);
  763.             }
  764.         }
  766.         return $this;
  767.     }
  769.     /**
  770.      * @return Collection<int, Analytics>
  771.      */
  772.     public function getAnalytics(): Collection
  773.     {
  774.         return $this->analytics;
  775.     }
  777.     public function addAnalytic(Analytics $analytic): static
  778.     {
  779.         if (!$this->analytics->contains($analytic)) {
  780.             $this->analytics->add($analytic);
  781.             $analytic->setWebsite($this);
  782.         }
  784.         return $this;
  785.     }
  787.     public function removeAnalytic(Analytics $analytic): static
  788.     {
  789.         if ($this->analytics->removeElement($analytic)) {
  790.             // set the owning side to null (unless already changed)
  791.             if ($analytic->getWebsite() === $this) {
  792.                 $analytic->setWebsite(null);
  793.             }
  794.         }
  796.         return $this;
  797.     }
  799.     /**
  800.      * @return Collection<int, Campaign>
  801.      */
  802.     public function getCampaigns(): Collection
  803.     {
  804.         return $this->campaigns;
  805.     }
  807.     public function addCampaign(Campaign $campaign): static
  808.     {
  809.         if (!$this->campaigns->contains($campaign)) {
  810.             $this->campaigns->add($campaign);
  811.             $campaign->setWebsite($this);
  812.         }
  814.         return $this;
  815.     }
  817.     public function removeCampaign(Campaign $campaign): static
  818.     {
  819.         if ($this->campaigns->removeElement($campaign)) {
  820.             // set the owning side to null (unless already changed)
  821.             if ($campaign->getWebsite() === $this) {
  822.                 $campaign->setWebsite(null);
  823.             }
  824.         }
  826.         return $this;
  827.     }
  829.     /**
  830.      * @return Collection<int, Cost>
  831.      */
  832.     public function getCosts(): Collection
  833.     {
  834.         return $this->costs;
  835.     }
  837.     public function addCost(Cost $cost): static
  838.     {
  839.         if (!$this->costs->contains($cost)) {
  840.             $this->costs->add($cost);
  841.             $cost->setWebsite($this);
  842.         }
  844.         return $this;
  845.     }
  847.     public function removeCost(Cost $cost): static
  848.     {
  849.         if ($this->costs->removeElement($cost)) {
  850.             // set the owning side to null (unless already changed)
  851.             if ($cost->getWebsite() === $this) {
  852.                 $cost->setWebsite(null);
  853.             }
  854.         }
  856.         return $this;
  857.     }
  859.     /**
  860.      * @return Collection<int, CostCategory>
  861.      */
  862.     public function getCostCategories(): Collection
  863.     {
  864.         return $this->costCategories;
  865.     }
  867.     public function addCostCategory(CostCategory $costCategory): static
  868.     {
  869.         if (!$this->costCategories->contains($costCategory)) {
  870.             $this->costCategories->add($costCategory);
  871.             $costCategory->setWebsite($this);
  872.         }
  874.         return $this;
  875.     }
  877.     public function removeCostCategory(CostCategory $costCategory): static
  878.     {
  879.         if ($this->costCategories->removeElement($costCategory)) {
  880.             // set the owning side to null (unless already changed)
  881.             if ($costCategory->getWebsite() === $this) {
  882.                 $costCategory->setWebsite(null);
  883.             }
  884.         }
  886.         return $this;
  887.     }
  889.     /**
  890.      * @return Collection<int, Transaction>
  891.      */
  892.     public function getWebsiteTransactions(): Collection
  893.     {
  894.         return $this->websiteTransactions;
  895.     }
  897.     public function addWebsiteTransaction(Transaction $websiteTransaction): static
  898.     {
  899.         if (!$this->websiteTransactions->contains($websiteTransaction)) {
  900.             $this->websiteTransactions->add($websiteTransaction);
  901.             $websiteTransaction->setWebsite($this);
  902.         }
  904.         return $this;
  905.     }
  907.     public function removeWebsiteTransaction(Transaction $websiteTransaction): static
  908.     {
  909.         if ($this->websiteTransactions->removeElement($websiteTransaction)) {
  910.             // set the owning side to null (unless already changed)
  911.             if ($websiteTransaction->getWebsite() === $this) {
  912.                 $websiteTransaction->setWebsite(null);
  913.             }
  914.         }
  916.         return $this;
  917.     }
  919.     /**
  920.      * @return Collection<int, Service>
  921.      */
  922.     public function getServices(): Collection
  923.     {
  924.         return $this->services;
  925.     }
  927.     public function addService(Service $service): static
  928.     {
  929.         if (!$this->services->contains($service)) {
  930.             $this->services->add($service);
  931.             $service->setWebsite($this);
  932.         }
  934.         return $this;
  935.     }
  937.     public function removeService(Service $service): static
  938.     {
  939.         if ($this->services->removeElement($service)) {
  940.             // set the owning side to null (unless already changed)
  941.             if ($service->getWebsite() === $this) {
  942.                 $service->setWebsite(null);
  943.             }
  944.         }
  946.         return $this;
  947.     }
  949.     /**
  950.      * @return Collection<int, Server>
  951.      */
  952.     public function getServers(): Collection
  953.     {
  954.         return $this->servers;
  955.     }
  957.     public function addServer(Server $server): static
  958.     {
  959.         if (!$this->servers->contains($server)) {
  960.             $this->servers->add($server);
  961.             $server->setWebsite($this);
  962.         }
  964.         return $this;
  965.     }
  967.     public function removeServer(Server $server): static
  968.     {
  969.         if ($this->servers->removeElement($server)) {
  970.             // set the owning side to null (unless already changed)
  971.             if ($server->getWebsite() === $this) {
  972.                 $server->setWebsite(null);
  973.             }
  974.         }
  976.         return $this;
  977.     }
  979.     /**
  980.      * @return Collection<int, \App\Entity\Website\VPN\OpenVPN\Server>
  981.      */
  982.     public function getOpenVPNServers(): Collection
  983.     {
  984.         return $this->openVPNServers;
  985.     }
  987.     public function addOpenVPNServer(\App\Entity\Website\VPN\OpenVPN\Server $openVPNServer): static
  988.     {
  989.         if (!$this->openVPNServers->contains($openVPNServer)) {
  990.             $this->openVPNServers->add($openVPNServer);
  991.             $openVPNServer->setWebsite($this);
  992.         }
  994.         return $this;
  995.     }
  997.     public function removeOpenVPNServer(\App\Entity\Website\VPN\OpenVPN\Server $openVPNServer): static
  998.     {
  999.         if ($this->openVPNServers->removeElement($openVPNServer)) {
  1000.             // set the owning side to null (unless already changed)
  1001.             if ($openVPNServer->getWebsite() === $this) {
  1002.                 $openVPNServer->setWebsite(null);
  1003.             }
  1004.         }
  1006.         return $this;
  1007.     }
  1009.     /**
  1010.      * @return Collection<int, \App\Entity\Website\VPN\Service\Plan>
  1011.      */
  1012.     public function getPlans(): Collection
  1013.     {
  1014.         return $this->plans;
  1015.     }
  1017.     public function addPlan(\App\Entity\Website\VPN\Service\Plan $plan): static
  1018.     {
  1019.         if (!$this->plans->contains($plan)) {
  1020.             $this->plans->add($plan);
  1021.             $plan->setWebsite($this);
  1022.         }
  1024.         return $this;
  1025.     }
  1027.     public function removePlan(\App\Entity\Website\VPN\Service\Plan $plan): static
  1028.     {
  1029.         if ($this->plans->removeElement($plan)) {
  1030.             // set the owning side to null (unless already changed)
  1031.             if ($plan->getWebsite() === $this) {
  1032.                 $plan->setWebsite(null);
  1033.             }
  1034.         }
  1036.         return $this;
  1037.     }
  1039.     /**
  1040.      * @return Collection<int, \App\Entity\Website\VPN\V2ray\Server>
  1041.      */
  1042.     public function getV2rayServers(): Collection
  1043.     {
  1044.         return $this->v2rayServers;
  1045.     }
  1047.     public function addV2rayServer(\App\Entity\Website\VPN\V2ray\Server $v2rayServer): static
  1048.     {
  1049.         if (!$this->v2rayServers->contains($v2rayServer)) {
  1050.             $this->v2rayServers->add($v2rayServer);
  1051.             $v2rayServer->setWebsite($this);
  1052.         }
  1054.         return $this;
  1055.     }
  1057.     public function removeV2rayServer(\App\Entity\Website\VPN\V2ray\Server $v2rayServer): static
  1058.     {
  1059.         if ($this->v2rayServers->removeElement($v2rayServer)) {
  1060.             // set the owning side to null (unless already changed)
  1061.             if ($v2rayServer->getWebsite() === $this) {
  1062.                 $v2rayServer->setWebsite(null);
  1063.             }
  1064.         }
  1066.         return $this;
  1067.     }
  1071. }