src/Entity/Category.php line 13

  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;
  9. use Gedmo\Translatable\Translatable;
  10. use Gedmo\Mapping\Annotation as Gedmo;
  12. #[ORM\Entity(repositoryClass: CategoryRepository::class)]
  13. class Category implements Translatable
  14. {
  15.     #[ORM\Id]
  16.     #[ORM\GeneratedValue]
  17.     #[ORM\Column]
  18.     private ?int $id = null;
  20.     #[Gedmo\Translatable]
  21.     #[ORM\Column(length: 255)]
  22.     private ?string $name = null;
  24.     #[Gedmo\Locale]
  25.     private $locale;
  27.     #[ORM\Column(length: 255, nullable: true)]
  28.     private ?string $description = null;
  30.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'childCategory')]
  31.     private ?self $parentCategory = null;
  33.     #[ORM\OneToMany(mappedBy: 'parentCategory', targetEntity: self::class)]
  34.     private Collection $childCategory;
  36.     #[ORM\Column]
  37.     private ?int $level = null;
  39.     #[ORM\ManyToMany(targetEntity: CategoryMatching::class, mappedBy: 'categories')]
  40.     private Collection $categoryMatchings;
  42.     #[ORM\ManyToMany(targetEntity: Product::class, mappedBy: 'categories')]
  43.     private Collection $products;
  45.     #[ORM\Column(length: 255, nullable: true)]
  46.     private ?string $image = null;
  48.     #[ORM\Column(length: 255, nullable: true)]
  49.     private ?string $slug = null;
  53.     public function __construct()
  54.     {
  55.         $this->childCategory = new ArrayCollection();
  56.         $this->categoryMatchings = new ArrayCollection();
  57.         $this->products = new ArrayCollection();
  58.     }
  60.     public function getId(): ?int
  61.     {
  62.         return $this->id;
  63.     }
  65.     public function getName(): ?string
  66.     {
  67.         return $this->name;
  68.     }
  70.     public function setName(string $name): self
  71.     {
  72.         $this->name = $name;
  74.         return $this;
  75.     }
  77.     public function getDescription(): ?string
  78.     {
  79.         return $this->description;
  80.     }
  82.     public function setDescription(?string $description): self
  83.     {
  84.         $this->description = $description;
  86.         return $this;
  87.     }
  90.     public function getParentCategory(): ?self
  91.     {
  92.         return $this->parentCategory;
  93.     }
  95.     public function setCategory(?self $parentCategory): static
  96.     {
  97.         $this->parentCategory = $parentCategory;
  99.         return $this;
  100.     }
  102.     /**
  103.      * @return Collection<int, self>
  104.      */
  105.     public function getChildCategory(): Collection
  106.     {
  107.         return $this->childCategory;
  108.     }
  110.     public function addChildCategory(self $childCategory): static
  111.     {
  112.         if (!$this->childCategory->contains($childCategory)) {
  113.             $this->childCategory->add($childCategory);
  114.             $childCategory->setCategory($this);
  115.         }
  117.         return $this;
  118.     }
  120.     public function removeChildCategory(self $childCategory): static
  121.     {
  122.         if ($this->childCategory->removeElement($childCategory)) {
  123.             // set the owning side to null (unless already changed)
  124.             if ($childCategory->getCategory() === $this) {
  125.                 $childCategory->setCategory(null);
  126.             }
  127.         }
  129.         return $this;
  130.     }
  132.     public function getLevel(): ?int
  133.     {
  134.         return $this->level;
  135.     }
  137.     public function setLevel(int $level): static
  138.     {
  139.         $this->level = $level;
  141.         return $this;
  142.     }
  146.     public function __toString()
  147.      {
  148.         $fullCategory = $this->name."<-".$this->parentCategory;
  149.         return $fullCategory;
  150.     }
  152.     /**
  153.      * @return Collection<int, CategoryMatching>
  154.      */
  155.     public function getCategoryMatchings(): Collection
  156.     {
  157.         return $this->categoryMatchings;
  158.     }
  160.     public function addCategoryMatching(CategoryMatching $categoryMatching): static
  161.     {
  162.         if (!$this->categoryMatchings->contains($categoryMatching)) {
  163.             $this->categoryMatchings->add($categoryMatching);
  164.             $categoryMatching->addCategory($this);
  165.         }
  167.         return $this;
  168.     }
  170.     public function removeCategoryMatching(CategoryMatching $categoryMatching): static
  171.     {
  172.         if ($this->categoryMatchings->removeElement($categoryMatching)) {
  173.             $categoryMatching->removeCategory($this);
  174.         }
  176.         return $this;
  177.     }
  179.     /**
  180.      * @return Collection<int, Product>
  181.      */
  182.     public function getProducts(): Collection
  183.     {
  184.         return $this->products;
  185.     }
  187.     public function addProduct(Product $product): static
  188.     {
  189.         if (!$this->products->contains($product)) {
  190.             $this->products->add($product);
  191.             $product->addCategory($this);
  192.         }
  194.         return $this;
  195.     }
  197.     public function removeProduct(Product $product): static
  198.     {
  199.         if ($this->products->removeElement($product)) {
  200.             $product->removeCategory($this);
  201.         }
  203.         return $this;
  204.     }
  206.     public function setParentCategory(?self $parentCategory): static
  207.     {
  208.         $this->parentCategory = $parentCategory;
  210.         return $this;
  211.     }
  213.     public function getTotalProducts(): ?int
  214.     {
  215.         return count($this->products);
  216.     }
  218.     public function getImage(): ?string
  219.     {
  220.         return $this->image;
  221.     }
  223.     public function setImage(?string $image): static
  224.     {
  225.         $this->image = $image;
  227.         return $this;
  228.     }
  230.     public function setTranslatableLocale($locale)
  231.     {
  232.         $this->locale = $locale;
  233.     }
  235.     public function getSlug(): ?string
  236.     {
  237.         return $this->slug;
  238.     }
  240.     public function setSlug(?string $slug): static
  241.     {
  242.         $this->slug = $slug;
  244.         return $this;
  245.     }
  247. }