src/Entity/Generic/User.php line 36

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Generic;
  5. use App\Entity\BaseEntity;
  6. use App\Entity\Campaign;
  7. use App\Entity\Domains\Domain;
  8. use App\Entity\Idea;
  9. use App\Entity\SAAS\Server\Hetzner\Ip;
  10. use App\Entity\SAAS\Server\Hetzner\Server;
  11. use App\Entity\SAAS\Server\Ticket\Ticket;
  12. use App\Entity\SAAS\Server\Ticket\TicketMessage;
  13. use App\Entity\SubTransactions\ArzDigital;
  14. use App\Entity\SubTransactions\DonateKon;
  15. use App\Entity\SubTransactions\StreamMasters;
  16. use App\Entity\Telegram\AgentPublicBot\Bot;
  17. use App\Entity\Transaction;
  18. use App\Entity\VPN\Service\Service;
  19. use App\Repository\Generic\UserRepository;
  20. use DateTimeInterface;
  21. use Doctrine\Common\Collections\ArrayCollection;
  22. use Doctrine\Common\Collections\Collection;
  23. use Doctrine\DBAL\Types\Types;
  24. use Doctrine\ORM\Mapping as ORM;
  25. use JetBrains\PhpStorm\Pure;
  26. use Symfony\Bridge\Doctrine\IdGenerator\UuidGenerator;
  27. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  28. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  29. use Symfony\Component\Security\Core\User\UserInterface;
  30. use Symfony\Component\Validator\Constraints as Assert;
  32. #[ORM\Entity(repositoryClass: UserRepository::class)]
  33. #[ORM\Table(name: '`user`')]
  34. #[UniqueEntity(fields: ['email'], message: 'این پست الکترونیک از قبل موجود می باشد')]
  35. #[UniqueEntity(fields: ['mobile'], message: 'این شماره موبایل از قبل موجود می باشد')]
  36. class User extends BaseEntity implements UserInterface, PasswordAuthenticatedUserInterface
  37. {
  38.     #[ORM\Id]
  39.     #[ORM\Column(type: 'guid', unique: true)]
  40.     #[ORM\GeneratedValue(strategy: 'CUSTOM')]
  41.     #[ORM\CustomIdGenerator(class: UuidGenerator::class)]
  42.     private $id;
  44.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  45.     private $email;
  47.     #[ORM\Column(type: 'json')]
  48.     private $roles = [];
  50.     #[ORM\Column(type: 'string')]
  51.     private $password;
  53.     #[ORM\Column(type: 'boolean')]
  54.     private $isVerified = false;
  58.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  59.     private $firstName;
  61.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  62.     private $lastName;
  64.     #[ORM\Column(type: 'json')]
  65.     private $access = [];
  67.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  68.     private $image;
  70.     #[ORM\Column(type: 'bigint')]
  71.     private $wallet = 0;
  75.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  76.     private ?string $mobile;
  81.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Transaction::class)]
  82.     private Collection $transactions;
  86.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  87.     private ?DateTimeInterface $lastLogin = null;
  89.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'users')]
  90.     private ?self $presenter = null;
  92.     #[ORM\OneToMany(mappedBy: 'presenter', targetEntity: self::class)]
  93.     private Collection $users;
  95.     #[ORM\Column(nullable: true)]
  96.     private ?int $uniquePresenterCode = null;
  98.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  99.     private ?\DateTimeInterface $lastBuy = null;
  101.     #[ORM\Column]
  102.     private ?int $subUserCount = null;
  104.     /**
  105.      * @var Collection<int, Service>
  106.      */
  107.     #[ORM\OneToMany(targetEntity: Service::class, mappedBy: 'owner')]
  108.     private Collection $services;
  110.     #[ORM\Column(nullable: true)]
  111.     #[Assert\Range(
  112.         notInRangeMessage: '
  113.         درصد سود باید بین 
  114.         {{ min }}
  115.         و 
  116.         {{ max }}
  117.         باشد',
  118.         min: 0,
  119.         max: 1000,
  120.     )]
  121.     private ?int $interestRate = null;
  123.     #[ORM\Column(length: 255, nullable: true)]
  124.     private ?string $telegramChannel = null;
  126.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  127.     private ?string $customerText = null;
  130.     #[ORM\Column(nullable: true)]
  131.     private ?int $thisMonthCharge = null;
  137.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Transaction::class)]
  138.     private Collection $madeTransactions;
  142.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'advertisedUsers')]
  143.     private ?self $advertiser = null;
  145.     #[ORM\OneToMany(mappedBy: 'advertiser', targetEntity: self::class)]
  146.     private Collection $advertisedUsers;
  151.     #[ORM\Column(length: 255, nullable: true)]
  152.     private ?string $userTrace = null;
  157.     #[ORM\ManyToOne(inversedBy: 'users')]
  158.     private ?Campaign $campaign = null;
  159.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Domain::class)]
  160.     private Collection $domains;
  161.     #[ORM\Column(nullable: true)]
  162.     private ?bool $isTelegramContact = null;
  163.     #[ORM\Column(nullable: true)]
  164.     private ?bool $isTelegramContactChecked = null;
  165.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Bot::class)]
  166.     private Collection $bots;
  168.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Idea::class)]
  169.     private Collection $ideas;
  173.     #[ORM\Column(length: 255, nullable: true)]
  174.     private ?string $cardNumberToCharge = null;
  177.     #[ORM\Column(type: Types::BIGINT, nullable: true)]
  178.     private ?string $advertiserMonthlyIncome = null;
  182.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  183.     private ?string $connectedTelegramUserId = null;
  185.     #[ORM\OneToMany(mappedBy: 'panelOwner', targetEntity: ArzDigital::class)]
  186.     private Collection $arzDigitals;
  188.     #[ORM\Column(nullable: true)]
  189.     private ?int $VpnServicesCount = null;
  191.     #[ORM\Column(type: Types::BIGINT, nullable: true)]
  192.     private ?string $giftWallet = null;
  195.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Ip::class)]
  196.     private Collection $hetznerIps;
  198.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Server::class)]
  199.     private Collection $hetznerServers;
  201.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: StreamMasters::class)]
  202.     private Collection $streamMasters;
  204.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: DonateKon::class)]
  205.     private Collection $donateKons;
  207.     #[ORM\OneToMany(mappedBy: 'creator', targetEntity: Ticket::class)]
  208.     private Collection $tickets;
  210.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: TicketMessage::class)]
  211.     private Collection $ticketMessages;
  213.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: \App\Entity\SAAS\Domain\Domain::class)]
  214.     private Collection $boughtDomains;
  218.     public function __construct()
  219.     {
  220.         parent::__construct();
  221.         $this->setIsVerified(false);
  222.         $this->setInterestRate(100);
  223.         $this->setSubUserCount(0);
  224.         $this->transactions = new ArrayCollection();
  225.         $this->users = new ArrayCollection();
  226.         $this->madeTransactions = new ArrayCollection();
  227.         $this->advertisedUsers = new ArrayCollection();
  228.         $this->domains = new ArrayCollection();
  229.         $this->setIsTelegramContactChecked(0);
  230.         $this->bots = new ArrayCollection();
  231.         $this->ideas = new ArrayCollection();
  232.         $this->setCardNumberToCharge('');
  233.         $this->arzDigitals = new ArrayCollection();
  234.         $this->streamMasters = new ArrayCollection();
  235.         $this->donateKons = new ArrayCollection();
  236.         $this->tickets = new ArrayCollection();
  237.         $this->ticketMessages = new ArrayCollection();
  238.         $this->boughtDomains = new ArrayCollection();
  239.     }
  242.     #[Pure] public function __toString(): string
  243.     {
  244.         if ($this->getFirstName() && $this->getLastName()) {
  245.             return $this->getFirstName() . ' ' . $this->getLastName();
  246.         }
  247.         return $this->getEmail();
  248.     }
  250.     public function getFirstName(): ?string
  251.     {
  252.         return $this->firstName;
  253.     }
  255.     public function setFirstName(?string $firstName): self
  256.     {
  257.         $this->firstName = $firstName;
  259.         return $this;
  260.     }
  262.     public function getLastName(): ?string
  263.     {
  264.         return $this->lastName;
  265.     }
  267.     public function setLastName(?string $lastName): self
  268.     {
  269.         $this->lastName = $lastName;
  271.         return $this;
  272.     }
  274.     public function getEmail(): ?string
  275.     {
  276.         return $this->email;
  277.     }
  279.     public function setEmail(string $email): self
  280.     {
  281.         $this->email = $email;
  283.         return $this;
  284.     }
  286.     public function hasRole($role): bool
  287.     {
  288.         return in_array($role, $this->getRoles());
  289.     }
  291.     /**
  292.      * @see UserInterface
  293.      */
  294.     public function getRoles(): array
  295.     {
  296.         $roles = $this->roles;
  297.         // guarantee every user at least has ROLE_USER
  298.         $roles[] = 'ROLE_USER';
  300.         return array_unique($roles);
  301.     }
  303.     public function setRoles(array $roles): self
  304.     {
  305.         $this->roles = $roles;
  307.         return $this;
  308.     }
  310.     public function getId(): ?string
  311.     {
  312.         return $this->id;
  313.     }
  315.     #[Pure] public function hasAccess($access): bool
  316.     {
  317.         return in_array($access, $this->getAccess());
  318.     }
  320.     public function getAccess(): ?array
  321.     {
  322.         if ($this->access) {
  323.             return $this->access;
  324.         }
  325.         return [];
  326.     }
  328.     public function setAccess(array $access): self
  329.     {
  330.         $this->access = $access;
  332.         return $this;
  333.     }
  335.     /**
  336.      * A visual identifier that represents this user.
  337.      *
  338.      * @see UserInterface
  339.      */
  340.     public function getUserIdentifier(): string
  341.     {
  342.         return (string)$this->email;
  343.     }
  345.     /**
  346.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  347.      */
  348.     public function getUsername(): string
  349.     {
  350.         return (string)$this->email;
  351.     }
  353.     /**
  354.      * @see PasswordAuthenticatedUserInterface
  355.      */
  356.     public function getPassword(): string
  357.     {
  358.         return $this->password;
  359.     }
  361.     public function setPassword(string $password): self
  362.     {
  363.         $this->password = $password;
  365.         return $this;
  366.     }
  368.     /**
  369.      * Returning a salt is only needed, if you are not using a modern
  370.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  371.      *
  372.      * @see UserInterface
  373.      */
  374.     public function getSalt(): ?string
  375.     {
  376.         return null;
  377.     }
  379.     /**
  380.      * @see UserInterface
  381.      */
  382.     public function eraseCredentials()
  383.     {
  384.         // If you store any temporary, sensitive data on the user, clear it here
  385.         // $this->plainPassword = null;
  386.     }
  388.     public function getImage(): ?string
  389.     {
  390.         return $this->image;
  391.     }
  393.     public function setImage(?string $image): self
  394.     {
  395.         $this->image = $image;
  397.         return $this;
  398.     }
  400.     public function getWallet(): ?string
  401.     {
  402.         return $this->wallet;
  403.     }
  405.     public function setWallet(string $wallet): self
  406.     {
  407.         $this->wallet = $wallet;
  409.         return $this;
  410.     }
  412.     public function getMobile(): ?string
  413.     {
  414.         return $this->mobile;
  415.     }
  417.     public function setMobile( $mobile): self
  418.     {
  419.         $this->mobile = $mobile;
  421.         return $this;
  422.     }
  426.     public function getMobileColoredItem(): ?string
  427.     {
  428.         if ($this->getMobile()){
  429.             return $this->getMobile();
  430.         }else{
  431.             return  'ندارد';
  432.         }
  433.     }
  435.     /**
  436.      * @return Collection<int, Transaction>
  437.      */
  438.     public function getTransactions(): Collection
  439.     {
  440.         return $this->transactions;
  441.     }
  443.     public function addTransaction(Transaction $transaction): self
  444.     {
  445.         if (!$this->transactions->contains($transaction)) {
  446.             $this->transactions->add($transaction);
  447.             $transaction->setOwner($this);
  448.         }
  450.         return $this;
  451.     }
  453.     public function removeTransaction(Transaction $transaction): self
  454.     {
  455.         if ($this->transactions->removeElement($transaction)) {
  456.             // set the owning side to null (unless already changed)
  457.             if ($transaction->getOwner() === $this) {
  458.                 $transaction->setOwner(null);
  459.             }
  460.         }
  462.         return $this;
  463.     }
  468.     public function getLastLogin(): ?DateTimeInterface
  469.     {
  470.         return $this->lastLogin;
  471.     }
  473.     public function setLastLogin(?DateTimeInterface $lastLogin): self
  474.     {
  475.         $this->lastLogin = $lastLogin;
  477.         return $this;
  478.     }
  480.     /**
  481.      * @return Collection<int, self>
  482.      */
  483.     public function getUsers(): Collection
  484.     {
  485.         return $this->users;
  486.     }
  488.     public function addUser(self $user): self
  489.     {
  490.         if (!$this->users->contains($user)) {
  491.             $this->users->add($user);
  492.             $user->setPresenter($this);
  493.         }
  495.         return $this;
  496.     }
  498.     public function removeUser(self $user): self
  499.     {
  500.         if ($this->users->removeElement($user)) {
  501.             // set the owning side to null (unless already changed)
  502.             if ($user->getPresenter() === $this) {
  503.                 $user->setPresenter(null);
  504.             }
  505.         }
  507.         return $this;
  508.     }
  510.     public function getPresenter(): ?self
  511.     {
  512.         return $this->presenter;
  513.     }
  515.     public function setPresenter(?self $presenter): self
  516.     {
  517.         $this->presenter = $presenter;
  519.         return $this;
  520.     }
  522.     public function getUniquePresenterCode(): ?int
  523.     {
  524.         return $this->uniquePresenterCode;
  525.     }
  527.     public function setUniquePresenterCode(?int $uniquePresenterCode): self
  528.     {
  529.         $this->uniquePresenterCode = $uniquePresenterCode;
  531.         return $this;
  532.     }
  534.     public function getLastBuy(): ?\DateTimeInterface
  535.     {
  536.         return $this->lastBuy;
  537.     }
  539.     public function setLastBuy(?\DateTimeInterface $lastBuy): self
  540.     {
  541.         $this->lastBuy = $lastBuy;
  543.         return $this;
  544.     }
  546.     public function getSubUserCount(): ?int
  547.     {
  548.         return $this->subUserCount;
  549.     }
  551.     public function setSubUserCount(int $subUserCount): self
  552.     {
  553.         $this->subUserCount = $subUserCount;
  555.         return $this;
  556.     }
  564.     public function getInterestRate(): ?int
  565.     {
  566.         return $this->interestRate;
  567.     }
  569.     public function setInterestRate(?int $interestRate): self
  570.     {
  571.         $this->interestRate = $interestRate;
  573.         return $this;
  574.     }
  576.     public function getTelegramChannel(): ?string
  577.     {
  578.         return $this->telegramChannel;
  579.     }
  581.     public function setTelegramChannel(?string $telegramChannel): self
  582.     {
  583.         $this->telegramChannel = $telegramChannel;
  585.         return $this;
  586.     }
  588.     public function getCustomerText(): ?string
  589.     {
  590.         return $this->customerText;
  591.     }
  593.     public function setCustomerText(?string $customerText): self
  594.     {
  595.         $this->customerText = $customerText;
  597.         return $this;
  598.     }
  601.     public function getThisMonthCharge(): ?int
  602.     {
  603.         return $this->thisMonthCharge;
  604.     }
  606.     public function setThisMonthCharge(?int $thisMonthCharge): self
  607.     {
  608.         $this->thisMonthCharge = $thisMonthCharge;
  610.         return $this;
  611.     }
  617.     /**
  618.      * @return Collection<int, Transaction>
  619.      */
  620.     public function getMadeTransactions(): Collection
  621.     {
  622.         return $this->madeTransactions;
  623.     }
  625.     public function addMadeTransaction(Transaction $madeTransaction): self
  626.     {
  627.         if (!$this->madeTransactions->contains($madeTransaction)) {
  628.             $this->madeTransactions->add($madeTransaction);
  629.             $madeTransaction->setAuthor($this);
  630.         }
  632.         return $this;
  633.     }
  635.     public function removeMadeTransaction(Transaction $madeTransaction): self
  636.     {
  637.         if ($this->madeTransactions->removeElement($madeTransaction)) {
  638.             // set the owning side to null (unless already changed)
  639.             if ($madeTransaction->getAuthor() === $this) {
  640.                 $madeTransaction->setAuthor(null);
  641.             }
  642.         }
  644.         return $this;
  645.     }
  647.     public function getAdvertiser(): ?self
  648.     {
  649.         return $this->advertiser;
  650.     }
  652.     public function setAdvertiser(?self $advertiser): self
  653.     {
  654.         $this->advertiser = $advertiser;
  656.         return $this;
  657.     }
  659.     /**
  660.      * @return Collection<int, self>
  661.      */
  662.     public function getAdvertisedUsers(): Collection
  663.     {
  664.         return $this->advertisedUsers;
  665.     }
  667.     public function addAdvertisedUser(self $advertisedUser): self
  668.     {
  669.         if (!$this->advertisedUsers->contains($advertisedUser)) {
  670.             $this->advertisedUsers->add($advertisedUser);
  671.             $advertisedUser->setAdvertiser($this);
  672.         }
  674.         return $this;
  675.     }
  677.     public function removeAdvertisedUser(self $advertisedUser): self
  678.     {
  679.         if ($this->advertisedUsers->removeElement($advertisedUser)) {
  680.             // set the owning side to null (unless already changed)
  681.             if ($advertisedUser->getAdvertiser() === $this) {
  682.                 $advertisedUser->setAdvertiser(null);
  683.             }
  684.         }
  686.         return $this;
  687.     }
  692.     /**
  693.      * @return array|null
  694.      */
  695.     public function getUserTrace(): ?array
  696.     {
  697.         return json_decode($this->userTrace , true);
  698.     }
  700.     /**
  701.      * @param array|null $userTrace
  702.      */
  703.     public function setUserTrace(?array $userTrace): void
  704.     {
  705.         $this->userTrace = json_encode($userTrace);
  706.     }
  714.     public function getCampaign(): ?Campaign
  715.     {
  716.         return $this->campaign;
  717.     }
  719.     public function setCampaign(?Campaign $campaign): static
  720.     {
  721.         $this->campaign = $campaign;
  723.         return $this;
  724.     }
  726.     /**
  727.      * @return Collection<int, Domain>
  728.      */
  729.     public function getDomains(): Collection
  730.     {
  731.         return $this->domains;
  732.     }
  734.     public function addDomain(Domain $domain): static
  735.     {
  736.         if (!$this->domains->contains($domain)) {
  737.             $this->domains->add($domain);
  738.             $domain->setOwner($this);
  739.         }
  741.         return $this;
  742.     }
  744.     public function removeDomain(Domain $domain): static
  745.     {
  746.         if ($this->domains->removeElement($domain)) {
  747.             // set the owning side to null (unless already changed)
  748.             if ($domain->getOwner() === $this) {
  749.                 $domain->setOwner(null);
  750.             }
  751.         }
  753.         return $this;
  754.     }
  757.     public function isVerified(): bool
  758.     {
  759.         return $this->isVerified;
  760.     }
  762.     public function setIsVerified(bool $isVerified): void
  763.     {
  764.         $this->isVerified = $isVerified;
  765.     }
  770.     public function isIsTelegramContact(): ?bool
  771.     {
  772.         return $this->isTelegramContact;
  773.     }
  775.     public function setIsTelegramContact(?bool $isTelegramContact): static
  776.     {
  777.         $this->isTelegramContact = $isTelegramContact;
  779.         return $this;
  780.     }
  782.     public function isIsTelegramContactChecked(): ?bool
  783.     {
  784.         return $this->isTelegramContactChecked;
  785.     }
  787.     public function setIsTelegramContactChecked(?bool $isTelegramContactChecked): static
  788.     {
  789.         $this->isTelegramContactChecked = $isTelegramContactChecked;
  791.         return $this;
  792.     }
  799.     /**
  800.      * @return Collection<int, Bot>
  801.      */
  802.     public function getBots(): Collection
  803.     {
  804.         return $this->bots;
  805.     }
  807.     public function addBot(Bot $bot): static
  808.     {
  809.         if (!$this->bots->contains($bot)) {
  810.             $this->bots->add($bot);
  811.             $bot->setOwner($this);
  812.         }
  814.         return $this;
  815.     }
  817.     public function removeBot(Bot $bot): static
  818.     {
  819.         if ($this->bots->removeElement($bot)) {
  820.             // set the owning side to null (unless already changed)
  821.             if ($bot->getOwner() === $this) {
  822.                 $bot->setOwner(null);
  823.             }
  824.         }
  826.         return $this;
  827.     }
  831.     /**
  832.      * @return Collection<int, Idea>
  833.      */
  834.     public function getIdeas(): Collection
  835.     {
  836.         return $this->ideas;
  837.     }
  839.     public function addIdea(Idea $idea): static
  840.     {
  841.         if (!$this->ideas->contains($idea)) {
  842.             $this->ideas->add($idea);
  843.             $idea->setAuthor($this);
  844.         }
  846.         return $this;
  847.     }
  849.     public function removeIdea(Idea $idea): static
  850.     {
  851.         if ($this->ideas->removeElement($idea)) {
  852.             // set the owning side to null (unless already changed)
  853.             if ($idea->getAuthor() === $this) {
  854.                 $idea->setAuthor(null);
  855.             }
  856.         }
  858.         return $this;
  859.     }
  863.     public function getCardNumberToCharge(): ?string
  864.     {
  865.         return $this->cardNumberToCharge;
  866.     }
  868.     public function setCardNumberToCharge(?string $cardNumberToCharge): static
  869.     {
  870.         $this->cardNumberToCharge = $cardNumberToCharge;
  872.         return $this;
  873.     }
  878.     public function getTheme(): ?string
  879.     {
  880. //        if ($this->hasRole('ROLE_ADMIN')){
  881.             return 'neon';
  882. //        }
  883. //        return 'default';
  884. //        return $this->theme?:'default';
  885.     }
  887.     public function setTheme(?string $theme): static
  888.     {
  889.         $this->theme = $theme;
  891.         return $this;
  892.     }
  899.     public function getAdvertiserMonthlyIncome(): ?string
  900.     {
  901.         return $this->advertiserMonthlyIncome;
  902.     }
  904.     public function setAdvertiserMonthlyIncome(?string $advertiserMonthlyIncome): static
  905.     {
  906.         $this->advertiserMonthlyIncome = $advertiserMonthlyIncome;
  908.         return $this;
  909.     }
  912.     public function getConnectedTelegramUserId(): ?array
  913.     {
  914.         return json_decode($this->connectedTelegramUserId , true);
  915.     }
  917.     public function setConnectedTelegramUserId(?array $connectedTelegramUserId): static
  918.     {
  919.         $this->connectedTelegramUserId = json_encode($connectedTelegramUserId);
  921.         return $this;
  922.     }
  924.     /**
  925.      * @return Collection<int, ArzDigital>
  926.      */
  927.     public function getArzDigitals(): Collection
  928.     {
  929.         return $this->arzDigitals;
  930.     }
  932.     public function addArzDigital(ArzDigital $arzDigital): static
  933.     {
  934.         if (!$this->arzDigitals->contains($arzDigital)) {
  935.             $this->arzDigitals->add($arzDigital);
  936.             $arzDigital->setPanelOwner($this);
  937.         }
  939.         return $this;
  940.     }
  942.     public function removeArzDigital(ArzDigital $arzDigital): static
  943.     {
  944.         if ($this->arzDigitals->removeElement($arzDigital)) {
  945.             // set the owning side to null (unless already changed)
  946.             if ($arzDigital->getPanelOwner() === $this) {
  947.                 $arzDigital->setPanelOwner(null);
  948.             }
  949.         }
  951.         return $this;
  952.     }
  954.     public function getVpnServicesCount(): ?int
  955.     {
  956.         return $this->VpnServicesCount;
  957.     }
  959.     public function setVpnServicesCount(?int $VpnServicesCount): static
  960.     {
  961.         $this->VpnServicesCount = $VpnServicesCount;
  963.         return $this;
  964.     }
  966.     public function getGiftWallet(): ?string
  967.     {
  968.         return $this->giftWallet;
  969.     }
  971.     public function setGiftWallet(?string $giftWallet): static
  972.     {
  973.         $this->giftWallet = $giftWallet;
  975.         return $this;
  976.     }
  978.     /**
  979.      * @return Collection<int, Ip>
  980.      */
  981.     public function getHetznerIps(): Collection
  982.     {
  983.         return $this->hetznerIps;
  984.     }
  986.     public function addHetznerIp(Ip $hetznerIp): static
  987.     {
  988.         if (!$this->hetznerIps->contains($hetznerIp)) {
  989.             $this->hetznerIps->add($hetznerIp);
  990.             $hetznerIp->setOwner($this);
  991.         }
  993.         return $this;
  994.     }
  996.     public function removeHetznerIp(Ip $hetznerIp): static
  997.     {
  998.         if ($this->hetznerIps->removeElement($hetznerIp)) {
  999.             // set the owning side to null (unless already changed)
  1000.             if ($hetznerIp->getOwner() === $this) {
  1001.                 $hetznerIp->setOwner(null);
  1002.             }
  1003.         }
  1005.         return $this;
  1006.     }
  1008.     /**
  1009.      * @return Collection<int, Server>
  1010.      */
  1011.     public function getHetznerServers(): Collection
  1012.     {
  1013.         return $this->hetznerServers;
  1014.     }
  1016.     public function addHetznerServer(Server $hetznerServer): static
  1017.     {
  1018.         if (!$this->hetznerServers->contains($hetznerServer)) {
  1019.             $this->hetznerServers->add($hetznerServer);
  1020.             $hetznerServer->setOwner($this);
  1021.         }
  1023.         return $this;
  1024.     }
  1026.     public function removeHetznerServer(Server $hetznerServer): static
  1027.     {
  1028.         if ($this->hetznerServers->removeElement($hetznerServer)) {
  1029.             // set the owning side to null (unless already changed)
  1030.             if ($hetznerServer->getOwner() === $this) {
  1031.                 $hetznerServer->setOwner(null);
  1032.             }
  1033.         }
  1035.         return $this;
  1036.     }
  1038.     /**
  1039.      * @return Collection<int, StreamMasters>
  1040.      */
  1041.     public function getStreamMasters(): Collection
  1042.     {
  1043.         return $this->streamMasters;
  1044.     }
  1046.     public function addStreamMaster(StreamMasters $streamMaster): static
  1047.     {
  1048.         if (!$this->streamMasters->contains($streamMaster)) {
  1049.             $this->streamMasters->add($streamMaster);
  1050.             $streamMaster->setOwner($this);
  1051.         }
  1053.         return $this;
  1054.     }
  1056.     public function removeStreamMaster(StreamMasters $streamMaster): static
  1057.     {
  1058.         if ($this->streamMasters->removeElement($streamMaster)) {
  1059.             // set the owning side to null (unless already changed)
  1060.             if ($streamMaster->getOwner() === $this) {
  1061.                 $streamMaster->setOwner(null);
  1062.             }
  1063.         }
  1065.         return $this;
  1066.     }
  1068.     /**
  1069.      * @return Collection<int, DonateKon>
  1070.      */
  1071.     public function getDonateKons(): Collection
  1072.     {
  1073.         return $this->donateKons;
  1074.     }
  1076.     public function addDonateKon(DonateKon $donateKon): static
  1077.     {
  1078.         if (!$this->donateKons->contains($donateKon)) {
  1079.             $this->donateKons->add($donateKon);
  1080.             $donateKon->setOwner($this);
  1081.         }
  1083.         return $this;
  1084.     }
  1086.     public function removeDonateKon(DonateKon $donateKon): static
  1087.     {
  1088.         if ($this->donateKons->removeElement($donateKon)) {
  1089.             // set the owning side to null (unless already changed)
  1090.             if ($donateKon->getOwner() === $this) {
  1091.                 $donateKon->setOwner(null);
  1092.             }
  1093.         }
  1095.         return $this;
  1096.     }
  1098.     /**
  1099.      * @return Collection<int, Ticket>
  1100.      */
  1101.     public function getTickets(): Collection
  1102.     {
  1103.         return $this->tickets;
  1104.     }
  1106.     public function addTicket(Ticket $ticket): static
  1107.     {
  1108.         if (!$this->tickets->contains($ticket)) {
  1109.             $this->tickets->add($ticket);
  1110.             $ticket->setCreator($this);
  1111.         }
  1113.         return $this;
  1114.     }
  1116.     public function removeTicket(Ticket $ticket): static
  1117.     {
  1118.         if ($this->tickets->removeElement($ticket)) {
  1119.             // set the owning side to null (unless already changed)
  1120.             if ($ticket->getCreator() === $this) {
  1121.                 $ticket->setCreator(null);
  1122.             }
  1123.         }
  1125.         return $this;
  1126.     }
  1128.     /**
  1129.      * @return Collection<int, TicketMessage>
  1130.      */
  1131.     public function getTicketMessages(): Collection
  1132.     {
  1133.         return $this->ticketMessages;
  1134.     }
  1136.     public function addTicketMessage(TicketMessage $ticketMessage): static
  1137.     {
  1138.         if (!$this->ticketMessages->contains($ticketMessage)) {
  1139.             $this->ticketMessages->add($ticketMessage);
  1140.             $ticketMessage->setAuthor($this);
  1141.         }
  1143.         return $this;
  1144.     }
  1146.     public function removeTicketMessage(TicketMessage $ticketMessage): static
  1147.     {
  1148.         if ($this->ticketMessages->removeElement($ticketMessage)) {
  1149.             // set the owning side to null (unless already changed)
  1150.             if ($ticketMessage->getAuthor() === $this) {
  1151.                 $ticketMessage->setAuthor(null);
  1152.             }
  1153.         }
  1155.         return $this;
  1156.     }
  1158.     /**
  1159.      * @return Collection<int, \App\Entity\SAAS\Domain\Domain>
  1160.      */
  1161.     public function getBoughtDomains(): Collection
  1162.     {
  1163.         return $this->boughtDomains;
  1164.     }
  1166.     public function addBoughtDomain(\App\Entity\SAAS\Domain\Domain $boughtDomain): static
  1167.     {
  1168.         if (!$this->boughtDomains->contains($boughtDomain)) {
  1169.             $this->boughtDomains->add($boughtDomain);
  1170.             $boughtDomain->setOwner($this);
  1171.         }
  1173.         return $this;
  1174.     }
  1176.     public function removeBoughtDomain(\App\Entity\SAAS\Domain\Domain $boughtDomain): static
  1177.     {
  1178.         if ($this->boughtDomains->removeElement($boughtDomain)) {
  1179.             // set the owning side to null (unless already changed)
  1180.             if ($boughtDomain->getOwner() === $this) {
  1181.                 $boughtDomain->setOwner(null);
  1182.             }
  1183.         }
  1185.         return $this;
  1186.     }
  1192. }