src/Entity/Server/Hetzner/ServerType.php line 15

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Server\Hetzner;
  5. use App\Entity\BaseEntity;
  6. use App\Repository\Server\Hetzner\ServerTypeRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Bridge\Doctrine\IdGenerator\UuidGenerator;
  13. #[ORM\Entity(repositoryClass: ServerTypeRepository::class)]
  14. #[ORM\Table(name: '`hetzner_sell_server_server_type`')]
  15. class ServerType extends BaseEntity
  16. {
  17.     #[ORM\Id]
  18.     #[ORM\Column(type: 'guid', unique: true)]
  19.     #[ORM\GeneratedValue(strategy: 'CUSTOM')]
  20.     #[ORM\CustomIdGenerator(class: UuidGenerator::class)]
  21.     private $id;
  23.     #[ORM\Column(length: 255, nullable: true)]
  24.     private ?string $systemId = null;
  26.     #[ORM\Column(length: 255, nullable: true)]
  27.     private ?string $name = null;
  29.     #[ORM\Column(length: 255, nullable: true)]
  30.     private ?string $description = null;
  32.     #[ORM\Column]
  33.     private ?int $cores = null;
  35.     #[ORM\Column]
  36.     private ?float $memory = null;
  38.     #[ORM\Column]
  39.     private ?float $disk = null;
  41.     #[ORM\Column]
  42.     private ?bool $isDeprecated = null;
  44.     public string $hourlyPrice;
  45.     public string $monthlyPrice;
  47.     #[ORM\Column(length: 255, nullable: true)]
  48.     private ?string $storageType = null;
  50.     #[ORM\Column(length: 255, nullable: true)]
  51.     private ?string $cpuType = null;
  53.     #[ORM\Column(length: 255, nullable: true)]
  54.     private ?string $architecture = null;
  56.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  57.     private ?\DateTimeInterface $deprecation = null;
  59.     #[ORM\OneToMany(mappedBy: 'serverType', targetEntity: ServerTypePrice::class)]
  60.     private Collection $serverTypePrices;
  64.     #[ORM\OneToMany(mappedBy: 'serverType', targetEntity: Server::class)]
  65.     private Collection $servers;
  67.     #[ORM\OneToMany(mappedBy: 'serverType', targetEntity: DataCenterSupportedServerTypes::class)]
  68.     private Collection $dataCenterSupportedServerTypes;
  70.     public function __construct()
  71.     {
  72.         parent::__construct();
  73.         $this->serverTypePrices = new ArrayCollection();
  74.         $this->servers = new ArrayCollection();
  75.         $this->dataCenterSupportedServerTypes = new ArrayCollection();
  76.     }
  78.     public function __toString()
  79.     {
  80.         return
  81.             'Cpu : '.$this->cpuType
  82.             . ' - '
  83.             .'Core : ' . $this->getCores()
  84.             . ' - '
  85.             .'Memory : '.$this->getMemory();
  86.     }
  88.     public function getId(): ?string
  89.     {
  90.         return $this->id;
  91.     }
  93.     public function getSystemId(): ?string
  94.     {
  95.         return $this->systemId;
  96.     }
  98.     public function setSystemId(?string $systemId): static
  99.     {
  100.         $this->systemId = $systemId;
  102.         return $this;
  103.     }
  105.     public function getName(): ?string
  106.     {
  107.         return $this->name;
  108.     }
  110.     public function setName(?string $name): static
  111.     {
  112.         $this->name = $name;
  114.         return $this;
  115.     }
  117.     public function getDescription(): ?string
  118.     {
  119.         return $this->description;
  120.     }
  122.     public function setDescription(?string $description): static
  123.     {
  124.         $this->description = $description;
  126.         return $this;
  127.     }
  129.     public function getCores(): ?int
  130.     {
  131.         return $this->cores;
  132.     }
  134.     public function setCores(int $cores): static
  135.     {
  136.         $this->cores = $cores;
  138.         return $this;
  139.     }
  141.     public function getMemory(): ?float
  142.     {
  143.         return $this->memory;
  144.     }
  146.     public function setMemory(float $memory): static
  147.     {
  148.         $this->memory = $memory;
  150.         return $this;
  151.     }
  153.     public function getDisk(): ?float
  154.     {
  155.         return $this->disk;
  156.     }
  158.     public function setDisk(float $disk): static
  159.     {
  160.         $this->disk = $disk;
  162.         return $this;
  163.     }
  165.     public function isIsDeprecated(): ?bool
  166.     {
  167.         return $this->isDeprecated;
  168.     }
  170.     public function setIsDeprecated(bool $isDeprecated): static
  171.     {
  172.         $this->isDeprecated = $isDeprecated;
  174.         return $this;
  175.     }
  177.     public function getStorageType(): ?string
  178.     {
  179.         return $this->storageType;
  180.     }
  182.     public function setStorageType(?string $storageType): static
  183.     {
  184.         $this->storageType = $storageType;
  186.         return $this;
  187.     }
  189.     public function getCpuType(): ?string
  190.     {
  191.         return $this->cpuType;
  192.     }
  194.     public function setCpuType(?string $cpuType): static
  195.     {
  196.         $this->cpuType = $cpuType;
  198.         return $this;
  199.     }
  201.     public function getArchitecture(): ?string
  202.     {
  203.         return $this->architecture;
  204.     }
  206.     public function setArchitecture(?string $architecture): static
  207.     {
  208.         $this->architecture = $architecture;
  210.         return $this;
  211.     }
  213.     public function getDeprecation(): ?\DateTimeInterface
  214.     {
  215.         return $this->deprecation;
  216.     }
  218.     public function setDeprecation(?\DateTimeInterface $deprecation): static
  219.     {
  220.         $this->deprecation = $deprecation;
  222.         return $this;
  223.     }
  225.     /**
  226.      * @return Collection<int, ServerTypePrice>
  227.      */
  228.     public function getServerTypePrices(): Collection
  229.     {
  230.         return $this->serverTypePrices;
  231.     }
  233.     public function addServerTypePrice(ServerTypePrice $serverTypePrice): static
  234.     {
  235.         if (!$this->serverTypePrices->contains($serverTypePrice)) {
  236.             $this->serverTypePrices->add($serverTypePrice);
  237.             $serverTypePrice->setServerType($this);
  238.         }
  240.         return $this;
  241.     }
  243.     public function removeServerTypePrice(ServerTypePrice $serverTypePrice): static
  244.     {
  245.         if ($this->serverTypePrices->removeElement($serverTypePrice)) {
  246.             // set the owning side to null (unless already changed)
  247.             if ($serverTypePrice->getServerType() === $this) {
  248.                 $serverTypePrice->setServerType(null);
  249.             }
  250.         }
  252.         return $this;
  253.     }
  255.     /**
  256.      * @return Collection<int, Server>
  257.      */
  258.     public function getServers(): Collection
  259.     {
  260.         return $this->servers;
  261.     }
  263.     public function addServer(Server $server): static
  264.     {
  265.         if (!$this->servers->contains($server)) {
  266.             $this->servers->add($server);
  267.             $server->setServerType($this);
  268.         }
  270.         return $this;
  271.     }
  273.     public function removeServer(Server $server): static
  274.     {
  275.         if ($this->servers->removeElement($server)) {
  276.             // set the owning side to null (unless already changed)
  277.             if ($server->getServerType() === $this) {
  278.                 $server->setServerType(null);
  279.             }
  280.         }
  282.         return $this;
  283.     }
  285.     /**
  286.      * @return Collection<int, DataCenterSupportedServerTypes>
  287.      */
  288.     public function getDataCenterSupportedServerTypes(): Collection
  289.     {
  290.         return $this->dataCenterSupportedServerTypes;
  291.     }
  293.     public function addDataCenterSupportedServerType(DataCenterSupportedServerTypes $dataCenterSupportedServerType): static
  294.     {
  295.         if (!$this->dataCenterSupportedServerTypes->contains($dataCenterSupportedServerType)) {
  296.             $this->dataCenterSupportedServerTypes->add($dataCenterSupportedServerType);
  297.             $dataCenterSupportedServerType->setServerType($this);
  298.         }
  300.         return $this;
  301.     }
  303.     public function removeDataCenterSupportedServerType(DataCenterSupportedServerTypes $dataCenterSupportedServerType): static
  304.     {
  305.         if ($this->dataCenterSupportedServerTypes->removeElement($dataCenterSupportedServerType)) {
  306.             // set the owning side to null (unless already changed)
  307.             if ($dataCenterSupportedServerType->getServerType() === $this) {
  308.                 $dataCenterSupportedServerType->setServerType(null);
  309.             }
  310.         }
  312.         return $this;
  313.     }
  315.     public function getMonthlyPrice(): string
  316.     {
  317.         return $this->monthlyPrice;
  318.     }
  320.     public function setMonthlyPrice(string $monthlyPrice): void
  321.     {
  322.         $this->monthlyPrice = $monthlyPrice;
  323.     }
  325.     public function getHourlyPrice(): string
  326.     {
  327.         return $this->hourlyPrice;
  328.     }
  330.     public function setHourlyPrice(string $hourlyPrice): void
  331.     {
  332.         $this->hourlyPrice = $hourlyPrice;
  333.     }
  334. }