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\Server\Hetzner\Ip;
  10. use App\Entity\Server\Hetzner\Server;
  11. use App\Entity\Server\Ticket\Ticket;
  12. use App\Entity\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;
  215.     public function __construct()
  216.     {
  217.         parent::__construct();
  218.         $this->setIsVerified(false);
  219.         $this->setInterestRate(100);
  220.         $this->setSubUserCount(0);
  221.         $this->transactions = new ArrayCollection();
  222.         $this->users = new ArrayCollection();
  223.         $this->madeTransactions = new ArrayCollection();
  224.         $this->advertisedUsers = new ArrayCollection();
  225.         $this->domains = new ArrayCollection();
  226.         $this->setIsTelegramContactChecked(0);
  227.         $this->bots = new ArrayCollection();
  228.         $this->ideas = new ArrayCollection();
  229.         $this->setCardNumberToCharge('');
  230.         $this->arzDigitals = new ArrayCollection();
  231.         $this->streamMasters = new ArrayCollection();
  232.         $this->donateKons = new ArrayCollection();
  233.         $this->tickets = new ArrayCollection();
  234.         $this->ticketMessages = new ArrayCollection();
  235.     }
  238.     #[Pure] public function __toString(): string
  239.     {
  240.         if ($this->getFirstName() && $this->getLastName()) {
  241.             return $this->getFirstName() . ' ' . $this->getLastName();
  242.         }
  243.         return $this->getEmail();
  244.     }
  246.     public function getFirstName(): ?string
  247.     {
  248.         return $this->firstName;
  249.     }
  251.     public function setFirstName(?string $firstName): self
  252.     {
  253.         $this->firstName = $firstName;
  255.         return $this;
  256.     }
  258.     public function getLastName(): ?string
  259.     {
  260.         return $this->lastName;
  261.     }
  263.     public function setLastName(?string $lastName): self
  264.     {
  265.         $this->lastName = $lastName;
  267.         return $this;
  268.     }
  270.     public function getEmail(): ?string
  271.     {
  272.         return $this->email;
  273.     }
  275.     public function setEmail(string $email): self
  276.     {
  277.         $this->email = $email;
  279.         return $this;
  280.     }
  282.     public function hasRole($role): bool
  283.     {
  284.         return in_array($role, $this->getRoles());
  285.     }
  287.     /**
  288.      * @see UserInterface
  289.      */
  290.     public function getRoles(): array
  291.     {
  292.         $roles = $this->roles;
  293.         // guarantee every user at least has ROLE_USER
  294.         $roles[] = 'ROLE_USER';
  296.         return array_unique($roles);
  297.     }
  299.     public function setRoles(array $roles): self
  300.     {
  301.         $this->roles = $roles;
  303.         return $this;
  304.     }
  306.     public function getId(): ?string
  307.     {
  308.         return $this->id;
  309.     }
  311.     #[Pure] public function hasAccess($access): bool
  312.     {
  313.         return in_array($access, $this->getAccess());
  314.     }
  316.     public function getAccess(): ?array
  317.     {
  318.         if ($this->access) {
  319.             return $this->access;
  320.         }
  321.         return [];
  322.     }
  324.     public function setAccess(array $access): self
  325.     {
  326.         $this->access = $access;
  328.         return $this;
  329.     }
  331.     /**
  332.      * A visual identifier that represents this user.
  333.      *
  334.      * @see UserInterface
  335.      */
  336.     public function getUserIdentifier(): string
  337.     {
  338.         return (string)$this->email;
  339.     }
  341.     /**
  342.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  343.      */
  344.     public function getUsername(): string
  345.     {
  346.         return (string)$this->email;
  347.     }
  349.     /**
  350.      * @see PasswordAuthenticatedUserInterface
  351.      */
  352.     public function getPassword(): string
  353.     {
  354.         return $this->password;
  355.     }
  357.     public function setPassword(string $password): self
  358.     {
  359.         $this->password = $password;
  361.         return $this;
  362.     }
  364.     /**
  365.      * Returning a salt is only needed, if you are not using a modern
  366.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  367.      *
  368.      * @see UserInterface
  369.      */
  370.     public function getSalt(): ?string
  371.     {
  372.         return null;
  373.     }
  375.     /**
  376.      * @see UserInterface
  377.      */
  378.     public function eraseCredentials()
  379.     {
  380.         // If you store any temporary, sensitive data on the user, clear it here
  381.         // $this->plainPassword = null;
  382.     }
  384.     public function getImage(): ?string
  385.     {
  386.         return $this->image;
  387.     }
  389.     public function setImage(?string $image): self
  390.     {
  391.         $this->image = $image;
  393.         return $this;
  394.     }
  396.     public function getWallet(): ?string
  397.     {
  398.         return $this->wallet;
  399.     }
  401.     public function setWallet(string $wallet): self
  402.     {
  403.         $this->wallet = $wallet;
  405.         return $this;
  406.     }
  408.     public function getMobile(): ?string
  409.     {
  410.         return $this->mobile;
  411.     }
  413.     public function setMobile( $mobile): self
  414.     {
  415.         $this->mobile = $mobile;
  417.         return $this;
  418.     }
  422.     public function getMobileColoredItem(): ?string
  423.     {
  424.         if ($this->getMobile()){
  425.             return $this->getMobile();
  426.         }else{
  427.             return  'ندارد';
  428.         }
  429.     }
  431.     /**
  432.      * @return Collection<int, Transaction>
  433.      */
  434.     public function getTransactions(): Collection
  435.     {
  436.         return $this->transactions;
  437.     }
  439.     public function addTransaction(Transaction $transaction): self
  440.     {
  441.         if (!$this->transactions->contains($transaction)) {
  442.             $this->transactions->add($transaction);
  443.             $transaction->setOwner($this);
  444.         }
  446.         return $this;
  447.     }
  449.     public function removeTransaction(Transaction $transaction): self
  450.     {
  451.         if ($this->transactions->removeElement($transaction)) {
  452.             // set the owning side to null (unless already changed)
  453.             if ($transaction->getOwner() === $this) {
  454.                 $transaction->setOwner(null);
  455.             }
  456.         }
  458.         return $this;
  459.     }
  464.     public function getLastLogin(): ?DateTimeInterface
  465.     {
  466.         return $this->lastLogin;
  467.     }
  469.     public function setLastLogin(?DateTimeInterface $lastLogin): self
  470.     {
  471.         $this->lastLogin = $lastLogin;
  473.         return $this;
  474.     }
  476.     /**
  477.      * @return Collection<int, self>
  478.      */
  479.     public function getUsers(): Collection
  480.     {
  481.         return $this->users;
  482.     }
  484.     public function addUser(self $user): self
  485.     {
  486.         if (!$this->users->contains($user)) {
  487.             $this->users->add($user);
  488.             $user->setPresenter($this);
  489.         }
  491.         return $this;
  492.     }
  494.     public function removeUser(self $user): self
  495.     {
  496.         if ($this->users->removeElement($user)) {
  497.             // set the owning side to null (unless already changed)
  498.             if ($user->getPresenter() === $this) {
  499.                 $user->setPresenter(null);
  500.             }
  501.         }
  503.         return $this;
  504.     }
  506.     public function getPresenter(): ?self
  507.     {
  508.         return $this->presenter;
  509.     }
  511.     public function setPresenter(?self $presenter): self
  512.     {
  513.         $this->presenter = $presenter;
  515.         return $this;
  516.     }
  518.     public function getUniquePresenterCode(): ?int
  519.     {
  520.         return $this->uniquePresenterCode;
  521.     }
  523.     public function setUniquePresenterCode(?int $uniquePresenterCode): self
  524.     {
  525.         $this->uniquePresenterCode = $uniquePresenterCode;
  527.         return $this;
  528.     }
  530.     public function getLastBuy(): ?\DateTimeInterface
  531.     {
  532.         return $this->lastBuy;
  533.     }
  535.     public function setLastBuy(?\DateTimeInterface $lastBuy): self
  536.     {
  537.         $this->lastBuy = $lastBuy;
  539.         return $this;
  540.     }
  542.     public function getSubUserCount(): ?int
  543.     {
  544.         return $this->subUserCount;
  545.     }
  547.     public function setSubUserCount(int $subUserCount): self
  548.     {
  549.         $this->subUserCount = $subUserCount;
  551.         return $this;
  552.     }
  560.     public function getInterestRate(): ?int
  561.     {
  562.         return $this->interestRate;
  563.     }
  565.     public function setInterestRate(?int $interestRate): self
  566.     {
  567.         $this->interestRate = $interestRate;
  569.         return $this;
  570.     }
  572.     public function getTelegramChannel(): ?string
  573.     {
  574.         return $this->telegramChannel;
  575.     }
  577.     public function setTelegramChannel(?string $telegramChannel): self
  578.     {
  579.         $this->telegramChannel = $telegramChannel;
  581.         return $this;
  582.     }
  584.     public function getCustomerText(): ?string
  585.     {
  586.         return $this->customerText;
  587.     }
  589.     public function setCustomerText(?string $customerText): self
  590.     {
  591.         $this->customerText = $customerText;
  593.         return $this;
  594.     }
  597.     public function getThisMonthCharge(): ?int
  598.     {
  599.         return $this->thisMonthCharge;
  600.     }
  602.     public function setThisMonthCharge(?int $thisMonthCharge): self
  603.     {
  604.         $this->thisMonthCharge = $thisMonthCharge;
  606.         return $this;
  607.     }
  613.     /**
  614.      * @return Collection<int, Transaction>
  615.      */
  616.     public function getMadeTransactions(): Collection
  617.     {
  618.         return $this->madeTransactions;
  619.     }
  621.     public function addMadeTransaction(Transaction $madeTransaction): self
  622.     {
  623.         if (!$this->madeTransactions->contains($madeTransaction)) {
  624.             $this->madeTransactions->add($madeTransaction);
  625.             $madeTransaction->setAuthor($this);
  626.         }
  628.         return $this;
  629.     }
  631.     public function removeMadeTransaction(Transaction $madeTransaction): self
  632.     {
  633.         if ($this->madeTransactions->removeElement($madeTransaction)) {
  634.             // set the owning side to null (unless already changed)
  635.             if ($madeTransaction->getAuthor() === $this) {
  636.                 $madeTransaction->setAuthor(null);
  637.             }
  638.         }
  640.         return $this;
  641.     }
  643.     public function getAdvertiser(): ?self
  644.     {
  645.         return $this->advertiser;
  646.     }
  648.     public function setAdvertiser(?self $advertiser): self
  649.     {
  650.         $this->advertiser = $advertiser;
  652.         return $this;
  653.     }
  655.     /**
  656.      * @return Collection<int, self>
  657.      */
  658.     public function getAdvertisedUsers(): Collection
  659.     {
  660.         return $this->advertisedUsers;
  661.     }
  663.     public function addAdvertisedUser(self $advertisedUser): self
  664.     {
  665.         if (!$this->advertisedUsers->contains($advertisedUser)) {
  666.             $this->advertisedUsers->add($advertisedUser);
  667.             $advertisedUser->setAdvertiser($this);
  668.         }
  670.         return $this;
  671.     }
  673.     public function removeAdvertisedUser(self $advertisedUser): self
  674.     {
  675.         if ($this->advertisedUsers->removeElement($advertisedUser)) {
  676.             // set the owning side to null (unless already changed)
  677.             if ($advertisedUser->getAdvertiser() === $this) {
  678.                 $advertisedUser->setAdvertiser(null);
  679.             }
  680.         }
  682.         return $this;
  683.     }
  688.     /**
  689.      * @return array|null
  690.      */
  691.     public function getUserTrace(): ?array
  692.     {
  693.         return json_decode($this->userTrace , true);
  694.     }
  696.     /**
  697.      * @param array|null $userTrace
  698.      */
  699.     public function setUserTrace(?array $userTrace): void
  700.     {
  701.         $this->userTrace = json_encode($userTrace);
  702.     }
  710.     public function getCampaign(): ?Campaign
  711.     {
  712.         return $this->campaign;
  713.     }
  715.     public function setCampaign(?Campaign $campaign): static
  716.     {
  717.         $this->campaign = $campaign;
  719.         return $this;
  720.     }
  722.     /**
  723.      * @return Collection<int, Domain>
  724.      */
  725.     public function getDomains(): Collection
  726.     {
  727.         return $this->domains;
  728.     }
  730.     public function addDomain(Domain $domain): static
  731.     {
  732.         if (!$this->domains->contains($domain)) {
  733.             $this->domains->add($domain);
  734.             $domain->setOwner($this);
  735.         }
  737.         return $this;
  738.     }
  740.     public function removeDomain(Domain $domain): static
  741.     {
  742.         if ($this->domains->removeElement($domain)) {
  743.             // set the owning side to null (unless already changed)
  744.             if ($domain->getOwner() === $this) {
  745.                 $domain->setOwner(null);
  746.             }
  747.         }
  749.         return $this;
  750.     }
  753.     public function isVerified(): bool
  754.     {
  755.         return $this->isVerified;
  756.     }
  758.     public function setIsVerified(bool $isVerified): void
  759.     {
  760.         $this->isVerified = $isVerified;
  761.     }
  766.     public function isIsTelegramContact(): ?bool
  767.     {
  768.         return $this->isTelegramContact;
  769.     }
  771.     public function setIsTelegramContact(?bool $isTelegramContact): static
  772.     {
  773.         $this->isTelegramContact = $isTelegramContact;
  775.         return $this;
  776.     }
  778.     public function isIsTelegramContactChecked(): ?bool
  779.     {
  780.         return $this->isTelegramContactChecked;
  781.     }
  783.     public function setIsTelegramContactChecked(?bool $isTelegramContactChecked): static
  784.     {
  785.         $this->isTelegramContactChecked = $isTelegramContactChecked;
  787.         return $this;
  788.     }
  795.     /**
  796.      * @return Collection<int, Bot>
  797.      */
  798.     public function getBots(): Collection
  799.     {
  800.         return $this->bots;
  801.     }
  803.     public function addBot(Bot $bot): static
  804.     {
  805.         if (!$this->bots->contains($bot)) {
  806.             $this->bots->add($bot);
  807.             $bot->setOwner($this);
  808.         }
  810.         return $this;
  811.     }
  813.     public function removeBot(Bot $bot): static
  814.     {
  815.         if ($this->bots->removeElement($bot)) {
  816.             // set the owning side to null (unless already changed)
  817.             if ($bot->getOwner() === $this) {
  818.                 $bot->setOwner(null);
  819.             }
  820.         }
  822.         return $this;
  823.     }
  827.     /**
  828.      * @return Collection<int, Idea>
  829.      */
  830.     public function getIdeas(): Collection
  831.     {
  832.         return $this->ideas;
  833.     }
  835.     public function addIdea(Idea $idea): static
  836.     {
  837.         if (!$this->ideas->contains($idea)) {
  838.             $this->ideas->add($idea);
  839.             $idea->setAuthor($this);
  840.         }
  842.         return $this;
  843.     }
  845.     public function removeIdea(Idea $idea): static
  846.     {
  847.         if ($this->ideas->removeElement($idea)) {
  848.             // set the owning side to null (unless already changed)
  849.             if ($idea->getAuthor() === $this) {
  850.                 $idea->setAuthor(null);
  851.             }
  852.         }
  854.         return $this;
  855.     }
  859.     public function getCardNumberToCharge(): ?string
  860.     {
  861.         return $this->cardNumberToCharge;
  862.     }
  864.     public function setCardNumberToCharge(?string $cardNumberToCharge): static
  865.     {
  866.         $this->cardNumberToCharge = $cardNumberToCharge;
  868.         return $this;
  869.     }
  874.     public function getTheme(): ?string
  875.     {
  876. //        if ($this->hasRole('ROLE_ADMIN')){
  877.             return 'neon';
  878. //        }
  879. //        return 'default';
  880. //        return $this->theme?:'default';
  881.     }
  883.     public function setTheme(?string $theme): static
  884.     {
  885.         $this->theme = $theme;
  887.         return $this;
  888.     }
  895.     public function getAdvertiserMonthlyIncome(): ?string
  896.     {
  897.         return $this->advertiserMonthlyIncome;
  898.     }
  900.     public function setAdvertiserMonthlyIncome(?string $advertiserMonthlyIncome): static
  901.     {
  902.         $this->advertiserMonthlyIncome = $advertiserMonthlyIncome;
  904.         return $this;
  905.     }
  908.     public function getConnectedTelegramUserId(): ?array
  909.     {
  910.         return json_decode($this->connectedTelegramUserId , true);
  911.     }
  913.     public function setConnectedTelegramUserId(?array $connectedTelegramUserId): static
  914.     {
  915.         $this->connectedTelegramUserId = json_encode($connectedTelegramUserId);
  917.         return $this;
  918.     }
  920.     /**
  921.      * @return Collection<int, ArzDigital>
  922.      */
  923.     public function getArzDigitals(): Collection
  924.     {
  925.         return $this->arzDigitals;
  926.     }
  928.     public function addArzDigital(ArzDigital $arzDigital): static
  929.     {
  930.         if (!$this->arzDigitals->contains($arzDigital)) {
  931.             $this->arzDigitals->add($arzDigital);
  932.             $arzDigital->setPanelOwner($this);
  933.         }
  935.         return $this;
  936.     }
  938.     public function removeArzDigital(ArzDigital $arzDigital): static
  939.     {
  940.         if ($this->arzDigitals->removeElement($arzDigital)) {
  941.             // set the owning side to null (unless already changed)
  942.             if ($arzDigital->getPanelOwner() === $this) {
  943.                 $arzDigital->setPanelOwner(null);
  944.             }
  945.         }
  947.         return $this;
  948.     }
  950.     public function getVpnServicesCount(): ?int
  951.     {
  952.         return $this->VpnServicesCount;
  953.     }
  955.     public function setVpnServicesCount(?int $VpnServicesCount): static
  956.     {
  957.         $this->VpnServicesCount = $VpnServicesCount;
  959.         return $this;
  960.     }
  962.     public function getGiftWallet(): ?string
  963.     {
  964.         return $this->giftWallet;
  965.     }
  967.     public function setGiftWallet(?string $giftWallet): static
  968.     {
  969.         $this->giftWallet = $giftWallet;
  971.         return $this;
  972.     }
  974.     /**
  975.      * @return Collection<int, Ip>
  976.      */
  977.     public function getHetznerIps(): Collection
  978.     {
  979.         return $this->hetznerIps;
  980.     }
  982.     public function addHetznerIp(Ip $hetznerIp): static
  983.     {
  984.         if (!$this->hetznerIps->contains($hetznerIp)) {
  985.             $this->hetznerIps->add($hetznerIp);
  986.             $hetznerIp->setOwner($this);
  987.         }
  989.         return $this;
  990.     }
  992.     public function removeHetznerIp(Ip $hetznerIp): static
  993.     {
  994.         if ($this->hetznerIps->removeElement($hetznerIp)) {
  995.             // set the owning side to null (unless already changed)
  996.             if ($hetznerIp->getOwner() === $this) {
  997.                 $hetznerIp->setOwner(null);
  998.             }
  999.         }
  1001.         return $this;
  1002.     }
  1004.     /**
  1005.      * @return Collection<int, Server>
  1006.      */
  1007.     public function getHetznerServers(): Collection
  1008.     {
  1009.         return $this->hetznerServers;
  1010.     }
  1012.     public function addHetznerServer(Server $hetznerServer): static
  1013.     {
  1014.         if (!$this->hetznerServers->contains($hetznerServer)) {
  1015.             $this->hetznerServers->add($hetznerServer);
  1016.             $hetznerServer->setOwner($this);
  1017.         }
  1019.         return $this;
  1020.     }
  1022.     public function removeHetznerServer(Server $hetznerServer): static
  1023.     {
  1024.         if ($this->hetznerServers->removeElement($hetznerServer)) {
  1025.             // set the owning side to null (unless already changed)
  1026.             if ($hetznerServer->getOwner() === $this) {
  1027.                 $hetznerServer->setOwner(null);
  1028.             }
  1029.         }
  1031.         return $this;
  1032.     }
  1034.     /**
  1035.      * @return Collection<int, StreamMasters>
  1036.      */
  1037.     public function getStreamMasters(): Collection
  1038.     {
  1039.         return $this->streamMasters;
  1040.     }
  1042.     public function addStreamMaster(StreamMasters $streamMaster): static
  1043.     {
  1044.         if (!$this->streamMasters->contains($streamMaster)) {
  1045.             $this->streamMasters->add($streamMaster);
  1046.             $streamMaster->setOwner($this);
  1047.         }
  1049.         return $this;
  1050.     }
  1052.     public function removeStreamMaster(StreamMasters $streamMaster): static
  1053.     {
  1054.         if ($this->streamMasters->removeElement($streamMaster)) {
  1055.             // set the owning side to null (unless already changed)
  1056.             if ($streamMaster->getOwner() === $this) {
  1057.                 $streamMaster->setOwner(null);
  1058.             }
  1059.         }
  1061.         return $this;
  1062.     }
  1064.     /**
  1065.      * @return Collection<int, DonateKon>
  1066.      */
  1067.     public function getDonateKons(): Collection
  1068.     {
  1069.         return $this->donateKons;
  1070.     }
  1072.     public function addDonateKon(DonateKon $donateKon): static
  1073.     {
  1074.         if (!$this->donateKons->contains($donateKon)) {
  1075.             $this->donateKons->add($donateKon);
  1076.             $donateKon->setOwner($this);
  1077.         }
  1079.         return $this;
  1080.     }
  1082.     public function removeDonateKon(DonateKon $donateKon): static
  1083.     {
  1084.         if ($this->donateKons->removeElement($donateKon)) {
  1085.             // set the owning side to null (unless already changed)
  1086.             if ($donateKon->getOwner() === $this) {
  1087.                 $donateKon->setOwner(null);
  1088.             }
  1089.         }
  1091.         return $this;
  1092.     }
  1094.     /**
  1095.      * @return Collection<int, Ticket>
  1096.      */
  1097.     public function getTickets(): Collection
  1098.     {
  1099.         return $this->tickets;
  1100.     }
  1102.     public function addTicket(Ticket $ticket): static
  1103.     {
  1104.         if (!$this->tickets->contains($ticket)) {
  1105.             $this->tickets->add($ticket);
  1106.             $ticket->setCreator($this);
  1107.         }
  1109.         return $this;
  1110.     }
  1112.     public function removeTicket(Ticket $ticket): static
  1113.     {
  1114.         if ($this->tickets->removeElement($ticket)) {
  1115.             // set the owning side to null (unless already changed)
  1116.             if ($ticket->getCreator() === $this) {
  1117.                 $ticket->setCreator(null);
  1118.             }
  1119.         }
  1121.         return $this;
  1122.     }
  1124.     /**
  1125.      * @return Collection<int, TicketMessage>
  1126.      */
  1127.     public function getTicketMessages(): Collection
  1128.     {
  1129.         return $this->ticketMessages;
  1130.     }
  1132.     public function addTicketMessage(TicketMessage $ticketMessage): static
  1133.     {
  1134.         if (!$this->ticketMessages->contains($ticketMessage)) {
  1135.             $this->ticketMessages->add($ticketMessage);
  1136.             $ticketMessage->setAuthor($this);
  1137.         }
  1139.         return $this;
  1140.     }
  1142.     public function removeTicketMessage(TicketMessage $ticketMessage): static
  1143.     {
  1144.         if ($this->ticketMessages->removeElement($ticketMessage)) {
  1145.             // set the owning side to null (unless already changed)
  1146.             if ($ticketMessage->getAuthor() === $this) {
  1147.                 $ticketMessage->setAuthor(null);
  1148.             }
  1149.         }
  1151.         return $this;
  1152.     }
  1158. }