src/Entity/Categories.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Trait\SlugTrait;
  6. use App\Repository\CategoriesRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: CategoriesRepository::class)]
  12. class Categories
  13. {
  14.     use SlugTrait;
  15.     
  16.     #[ORM\Id]
  17.     #[ORM\GeneratedValue]
  18.     #[ORM\Column(type: 'integer')]
  19.     private $id;
  21.     #[ORM\Column(type: 'string', length: 100)]
  22.     private $name;
  24.     #[ORM\Column(type: 'integer')]
  25.     private $categoryOrder;
  27.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'categories')]
  28.     #[ORM\JoinColumn(onDelete: 'CASCADE')]
  29.     private $parent;
  31.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: self::class)]
  32.     private $categories;
  34.     #[ORM\OneToMany(mappedBy: 'categories', targetEntity: Products::class)]
  35.     private $products;
  37.     #[ORM\ManyToOne(inversedBy: 'categories')]
  38.     private ?Asks $asks = null;
  40.     #[ORM\OneToMany(mappedBy: 'answer1', targetEntity: Products::class)]
  41.     private Collection $productsAnswser1;
  43.     #[ORM\OneToMany(mappedBy: 'answer2', targetEntity: Products::class)]
  44.     private Collection $productsAnswer2;
  46.     #[ORM\OneToMany(mappedBy: 'answer3', targetEntity: Products::class)]
  47.     private Collection $productsAnswer3;
  49.     #[ORM\OneToMany(mappedBy: 'answer4', targetEntity: Products::class)]
  50.     private Collection $productsAnswer4;
  52.     #[ORM\OneToMany(mappedBy: 'answer5', targetEntity: Products::class)]
  53.     private Collection $productsAnswer5;
  55.     #[ORM\OneToMany(mappedBy: 'answer6', targetEntity: Products::class)]
  56.     private Collection $productsAnswer6;
  58.     public function __construct()
  59.     {
  60.         $this->categories = new ArrayCollection();
  61.         $this->products = new ArrayCollection();
  62.         $this->productsAnswser1 = new ArrayCollection();
  63.         $this->productsAnswer2 = new ArrayCollection();
  64.         $this->productsAnswer3 = new ArrayCollection();
  65.         $this->productsAnswer4 = new ArrayCollection();
  66.         $this->productsAnswer5 = new ArrayCollection();
  67.         $this->productsAnswer6 = new ArrayCollection();
  68.     }
  70.     public function getId(): ?int
  71.     {
  72.         return $this->id;
  73.     }
  75.     public function getName(): ?string
  76.     {
  77.         return $this->name;
  78.     }
  80.     public function setName(string $name): self
  81.     {
  82.         $this->name = $name;
  84.         return $this;
  85.     }
  87.     public function getCategoryOrder(): ?int
  88.     {
  89.         return $this->categoryOrder;
  90.     }
  92.     public function setCategoryOrder(int $categoryOrder): self
  93.     {
  94.         $this->categoryOrder = $categoryOrder;
  96.         return $this;
  97.     }
  99.     public function getParent(): ?self
  100.     {
  101.         return $this->parent;
  102.     }
  104.     public function setParent(?self $parent): self
  105.     {
  106.         $this->parent = $parent;
  108.         return $this;
  109.     }
  111.     /**
  112.      * @return Collection|self[]
  113.      */
  114.     public function getCategories(): Collection
  115.     {
  116.         return $this->categories;
  117.     }
  119.     public function addCategory(self $category): self
  120.     {
  121.         if (!$this->categories->contains($category)) {
  122.             $this->categories[] = $category;
  123.             $category->setParent($this);
  124.         }
  126.         return $this;
  127.     }
  129.     public function removeCategory(self $category): self
  130.     {
  131.         if ($this->categories->removeElement($category)) {
  132.             // set the owning side to null (unless already changed)
  133.             if ($category->getParent() === $this) {
  134.                 $category->setParent(null);
  135.             }
  136.         }
  138.         return $this;
  139.     }
  141.     /**
  142.      * @return Collection|Products[]
  143.      */
  144.     public function getProducts(): Collection
  145.     {
  146.         return $this->products;
  147.     }
  149.     public function addProduct(Products $product): self
  150.     {
  151.         if (!$this->products->contains($product)) {
  152.             $this->products[] = $product;
  153.             $product->setCategories($this);
  154.         }
  156.         return $this;
  157.     }
  159.     public function removeProduct(Products $product): self
  160.     {
  161.         if ($this->products->removeElement($product)) {
  162.             // set the owning side to null (unless already changed)
  163.             if ($product->getCategories() === $this) {
  164.                 $product->setCategories(null);
  165.             }
  166.         }
  168.         return $this;
  169.     }
  171.     public function getAsks(): ?Asks
  172.     {
  173.         return $this->asks;
  174.     }
  176.     public function setAsks(?Asks $asks): static
  177.     {
  178.         $this->asks = $asks;
  180.         return $this;
  181.     }
  183.     /**
  184.      * @return Collection<int, Products>
  185.      */
  186.     public function getProductsAnswser1(): Collection
  187.     {
  188.         return $this->productsAnswser1;
  189.     }
  191.     public function addProductsAnswser1(Products $productsAnswser1): static
  192.     {
  193.         if (!$this->productsAnswser1->contains($productsAnswser1)) {
  194.             $this->productsAnswser1->add($productsAnswser1);
  195.             $productsAnswser1->setAnswer1($this);
  196.         }
  198.         return $this;
  199.     }
  201.     public function removeProductsAnswser1(Products $productsAnswser1): static
  202.     {
  203.         if ($this->productsAnswser1->removeElement($productsAnswser1)) {
  204.             // set the owning side to null (unless already changed)
  205.             if ($productsAnswser1->getAnswer1() === $this) {
  206.                 $productsAnswser1->setAnswer1(null);
  207.             }
  208.         }
  210.         return $this;
  211.     }
  213.     /**
  214.      * @return Collection<int, Products>
  215.      */
  216.     public function getProductsAnswer2(): Collection
  217.     {
  218.         return $this->productsAnswer2;
  219.     }
  221.     public function addProductsAnswer2(Products $productsAnswer2): static
  222.     {
  223.         if (!$this->productsAnswer2->contains($productsAnswer2)) {
  224.             $this->productsAnswer2->add($productsAnswer2);
  225.             $productsAnswer2->setAnswer2($this);
  226.         }
  228.         return $this;
  229.     }
  231.     public function removeProductsAnswer2(Products $productsAnswer2): static
  232.     {
  233.         if ($this->productsAnswer2->removeElement($productsAnswer2)) {
  234.             // set the owning side to null (unless already changed)
  235.             if ($productsAnswer2->getAnswer2() === $this) {
  236.                 $productsAnswer2->setAnswer2(null);
  237.             }
  238.         }
  240.         return $this;
  241.     }
  243.     /**
  244.      * @return Collection<int, Products>
  245.      */
  246.     public function getProductsAnswer3(): Collection
  247.     {
  248.         return $this->productsAnswer3;
  249.     }
  251.     public function addProductsAnswer3(Products $productsAnswer3): static
  252.     {
  253.         if (!$this->productsAnswer3->contains($productsAnswer3)) {
  254.             $this->productsAnswer3->add($productsAnswer3);
  255.             $productsAnswer3->setAnswer3($this);
  256.         }
  258.         return $this;
  259.     }
  261.     public function removeProductsAnswer3(Products $productsAnswer3): static
  262.     {
  263.         if ($this->productsAnswer3->removeElement($productsAnswer3)) {
  264.             // set the owning side to null (unless already changed)
  265.             if ($productsAnswer3->getAnswer3() === $this) {
  266.                 $productsAnswer3->setAnswer3(null);
  267.             }
  268.         }
  270.         return $this;
  271.     }
  273.     /**
  274.      * @return Collection<int, Products>
  275.      */
  276.     public function getProductsAnswer4(): Collection
  277.     {
  278.         return $this->productsAnswer4;
  279.     }
  281.     public function addProductsAnswer4(Products $productsAnswer4): static
  282.     {
  283.         if (!$this->productsAnswer4->contains($productsAnswer4)) {
  284.             $this->productsAnswer4->add($productsAnswer4);
  285.             $productsAnswer4->setAnswer4($this);
  286.         }
  288.         return $this;
  289.     }
  291.     public function removeProductsAnswer4(Products $productsAnswer4): static
  292.     {
  293.         if ($this->productsAnswer4->removeElement($productsAnswer4)) {
  294.             // set the owning side to null (unless already changed)
  295.             if ($productsAnswer4->getAnswer4() === $this) {
  296.                 $productsAnswer4->setAnswer4(null);
  297.             }
  298.         }
  300.         return $this;
  301.     }
  303.     /**
  304.      * @return Collection<int, Products>
  305.      */
  306.     public function getProductsAnswer5(): Collection
  307.     {
  308.         return $this->productsAnswer5;
  309.     }
  311.     public function addProductsAnswer5(Products $productsAnswer5): static
  312.     {
  313.         if (!$this->productsAnswer5->contains($productsAnswer5)) {
  314.             $this->productsAnswer5->add($productsAnswer5);
  315.             $productsAnswer5->setAnswer5($this);
  316.         }
  318.         return $this;
  319.     }
  321.     public function removeProductsAnswer5(Products $productsAnswer5): static
  322.     {
  323.         if ($this->productsAnswer5->removeElement($productsAnswer5)) {
  324.             // set the owning side to null (unless already changed)
  325.             if ($productsAnswer5->getAnswer5() === $this) {
  326.                 $productsAnswer5->setAnswer5(null);
  327.             }
  328.         }
  330.         return $this;
  331.     }
  333.     /**
  334.      * @return Collection<int, Products>
  335.      */
  336.     public function getProductsAnswer6(): Collection
  337.     {
  338.         return $this->productsAnswer6;
  339.     }
  341.     public function addProductsAnswer6(Products $productsAnswer6): static
  342.     {
  343.         if (!$this->productsAnswer6->contains($productsAnswer6)) {
  344.             $this->productsAnswer6->add($productsAnswer6);
  345.             $productsAnswer6->setAnswer6($this);
  346.         }
  348.         return $this;
  349.     }
  351.     public function removeProductsAnswer6(Products $productsAnswer6): static
  352.     {
  353.         if ($this->productsAnswer6->removeElement($productsAnswer6)) {
  354.             // set the owning side to null (unless already changed)
  355.             if ($productsAnswer6->getAnswer6() === $this) {
  356.                 $productsAnswer6->setAnswer6(null);
  357.             }
  358.         }
  360.         return $this;
  361.     }
  362. }