src/Entity/Category.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\CategoryRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. /**
  11.  * @ORM\Entity(repositoryClass=CategoryRepository::class)
  12.  */
  13. class Category
  14. {
  15.     /**
  16.      * @ORM\Id
  17.      * @ORM\GeneratedValue
  18.      * @ORM\Column(type="integer")
  19.      */
  20.     private $id;
  22.     /**
  23.      * @ORM\Column(type="string", length=128)
  24.      */
  25.     private $name;
  27.     /**
  28.      * @ORM\Column(type="integer")
  29.      */
  30.     private $wttId;
  32.     /**
  33.      * @ORM\OneToMany(targetEntity=Model::class, mappedBy="category")
  34.      */
  35.     private $models;
  37.     /**
  38.      * @ORM\Column(type="string", length=16)
  39.      */
  40.     private $type;
  43.     /**
  44.      * @ORM\OneToMany(targetEntity=CategorySetting::class, mappedBy="category", cascade={"persist"})
  45.      */
  46.     private $settings;
  49.     /**
  50.      * @ORM\OneToMany(targetEntity=Option::class, mappedBy="category", cascade={"persist"})
  51.      */
  52.     private $options;
  54.     /**
  55.      * @ORM\ManyToMany(targetEntity=Shop::class, mappedBy="categories", cascade={"persist"})
  56.      */
  57.     private $shops;
  59.     public function __construct()
  60.     {
  61.         $this->models = new ArrayCollection();
  62.         $this->settings = new ArrayCollection();
  63.         $this->options = new ArrayCollection();
  64.         $this->shops = new ArrayCollection();
  65.     }
  67.     public function __toString()
  68.     {
  69.         return $this->getName();
  70.     }
  72.     public function getId(): ?int
  73.     {
  74.         return $this->id;
  75.     }
  77.     public function getName(): ?string
  78.     {
  79.         return $this->name;
  80.     }
  82.     public function setName(string $name): self
  83.     {
  84.         $this->name = $name;
  86.         return $this;
  87.     }
  89.     public function getWttId(): ?int
  90.     {
  91.         return $this->wttId;
  92.     }
  94.     public function setWttId(int $wttId): self
  95.     {
  96.         $this->wttId = $wttId;
  98.         return $this;
  99.     }
  101.     /**
  102.      * @return Collection<int, Model>
  103.      */
  104.     public function getModels(): Collection
  105.     {
  106.         return $this->models;
  107.     }
  109.     public function addModel(Model $model): self
  110.     {
  111.         if (!$this->models->contains($model)) {
  112.             $this->models[] = $model;
  113.             $model->setCategory($this);
  114.         }
  116.         return $this;
  117.     }
  119.     public function removeModel(Model $model): self
  120.     {
  121.         if ($this->models->removeElement($model)) {
  122.             // set the owning side to null (unless already changed)
  123.             if ($model->getCategory() === $this) {
  124.                 $model->setCategory(null);
  125.             }
  126.         }
  128.         return $this;
  129.     }
  131.     public function getType(): ?string
  132.     {
  133.         return $this->type;
  134.     }
  136.     public function setType(string $type): self
  137.     {
  138.         $this->type = $type;
  140.         return $this;
  141.     }
  143.     /**
  144.      * @return Collection<int, ShopSetting>
  145.      */
  146.     public function getSettings(): Collection
  147.     {
  148.         return $this->settings;
  149.     }
  151.     public function addSetting(ShopSetting $setting): static
  152.     {
  153.         if (!$this->settings->contains($setting)) {
  154.             $this->settings->add($setting);
  155.             $setting->setCategory($this);
  156.         }
  158.         return $this;
  159.     }
  161.     public function removeSetting(ShopSetting $setting): static
  162.     {
  163.         if ($this->settings->removeElement($setting)) {
  164.             // set the owning side to null (unless already changed)
  165.             if ($setting->getCategory() === $this) {
  166.                 $setting->setCategory(null);
  167.             }
  168.         }
  170.         return $this;
  171.     }
  174.     /**
  175.      * @return Collection<int, Option>
  176.      */
  177.     public function getOptions(): Collection
  178.     {
  179.         return $this->options;
  180.     }
  182.     public function addOption(Option $option): static
  183.     {
  184.         if (!$this->options->contains($option)) {
  185.             $this->options->add($option);
  187.         }
  189.         return $this;
  190.     }
  192.     public function removeOption(Option $option): static
  193.     {
  194.         $this->options->removeElement($option);
  195.         return $this;
  196.     }
  200.     /**
  201.      * @return Collection<int, Shop>
  202.      */
  203.     public function getShops(): Collection
  204.     {
  205.         return $this->shops;
  206.     }
  208.     public function addShop(Shop $shop): static
  209.     {
  210.         if (!$this->shops->contains($shop)) {
  211.             $this->shops->add($shop);
  212.             $shop->addCategory($this);
  213.         }
  215.         return $this;
  216.     }
  218.     public function removeShop(Shop $shop): static
  219.     {
  220.         if ($this->shops->removeElement($shop)) {
  221.             $shop->removeCategory($this);
  222.         }
  224.         return $this;
  225.     }
  226. }