src/Entity/Category.php line 49

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use App\Repository\CategoryRepository;
  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 ApiPlatform\Metadata\ApiFilter;
  12. use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
  13. use Symfony\Component\Serializer\Annotation\Groups;
  14. use ApiPlatform\Core\Annotation\ApiProperty;
  15. use Symfony\Component\Serializer\Annotation\MaxDepth;
  16. use ApiPlatform\Serializer\Filter\GroupFilter;
  22. #[ORM\Entity(repositoryClass: CategoryRepository::class)]
  23. #[ApiResource(
  24.     normalizationContext: ['groups' => ['cat:read']],
  25.     denormalizationContext: ['groups' => ['cat:write']],
  26.     order: ['sort' => 'ASC', 'name' => 'ASC'],
  27.     paginationPartial: false
  28. )]
  29. #[ApiFilter(SearchFilter::class, properties: [
  30.     'name' => 'ipartial', 
  31.     'status' => 'exact',  
  32.     'categories.status' => 'exact', 
  33.     'parent' => 'exact', 
  34.     'main' => 'exact', 
  35.     'type' => 'exact', 
  36.     'slug' => 'exact', 
  37.     'products.show' => 'exact',
  38.     'products.id' => 'exact',
  39.     'attributes.id' => 'exact',
  40.     'faqs.id' => 'exact',
  41.     'news.id' => 'exact',
  42.     'pages.id' => 'exact', 
  43.     'projects.id' => 'exact', 
  44.     'siteProducts.id' => 'exact', 
  45.     'objects.id' => 'exact', 
  46.     'language' => 'exact', 
  47.     'active' => 'exact', 
  48.     'categories.status' => 'exact', 
  49. ])]
  50. #[ApiFilter(GroupFilter::class, arguments: ['parameterName' => 'g', 'overrideDefaultGroups' => true])]
  52. class Category
  53. { 
  54.     #[ORM\Id]
  55.     #[ORM\GeneratedValue]
  56.     #[ORM\Column]
  57.     #[Groups(['cat:read', 'cat:write', 'prod:medium',  'attributes:read', 'attributes_items:read', 'coupon:read', 'read', 'write', 'news:read', 'news:write', 'site_product:read', 'product:read', 'objects:read', 'faq:read', 'projects:read'])]
  58.     private ?int $id = null;
  60.     #[Groups(['cat:read'])]
  61.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  62.     private ?\DateTimeInterface $date_entered = null;
  64.     #[Groups(['cat:read'])]
  65.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  66.     private ?\DateTimeInterface $date_modified = null;
  68.     #[ORM\Column(nullable: true)]
  69.     private ?int $created_by = null;
  71.     #[ORM\Column(nullable: true)]
  72.     private ?int $modified_user_id = null;
  74.     #[Groups(['cat:read', 'cat:write', 'prod:medium', 'attributes:read', 'attributes_items:read', 'coupon:read', 'read', 'write',  'news:read', 'news:write', 'site_product:read', 'product:read', 'objects:read' , 'faq:read' , 'projects:read' ])]
  75.     #[ORM\Column(length: 255)]
  76.     private ?string $name = null;
  78.     #[Groups(['cat:parent', 'cat:write'])]
  79.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'categories', cascade:['persist'])]
  80.     private ?self $parent = null;
  82.     #[Groups(['cat:categories', 'cat:write'])]
  83.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: self::class, cascade:['persist', 'remove'])]
  84.     #[MaxDepth(1)]
  85.     #[ApiProperty(writable: true)]
  86.     private Collection $categories;
  88.     #[Groups(['cat:read', 'cat:write', 'attributes:read', 'read', 'write', 'news:read', 'news:write', 'site_product:read', 'product:read', 'faq:read', 'projects:read'])]
  89.     #[ORM\Column(length: 100, nullable: true)]
  90.     private ?string $slug = null;
  92.     #[Groups(['cat:read', 'cat:write', 'read', 'write', 'news:read', 'news:write', 'site_product:read'])]
  93.     #[ORM\Column(length: 100, nullable: true)]
  94.     private ?string $status = null;
  96.     #[Groups(['cat:read', 'cat:write', 'read', 'write','news:read', 'news:write', 'site_product:read'])]
  97.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  98.     private ?string $description = null;
  100.     #[Groups(['cat:read', 'cat:write', 'read', 'write', 'news:read', 'news:write', 'site_product:read'])]
  101.     #[ORM\Column(nullable: true)]
  102.     private ?bool $main = null;
  104.     #[Groups(['cat:read', 'cat:write', 'read', 'write', 'news:read', 'news:write', 'site_product:read', 'product:read', 'faq:read'])]
  105.     #[ORM\Column(length: 20, nullable: true)]
  106.     private ?string $type = null;
  108.     #[ApiProperty(writable: true)]
  109.     #[Groups(['cat:products', 'cat:write'])]
  110.     #[ORM\ManyToMany(targetEntity: Products::class, mappedBy: 'category', cascade:['persist'])]
  111.     #[MaxDepth(1)]
  112.     private Collection $products;
  114.     #[Groups(['cat:attributes', 'cat:write'])]
  115.     #[ORM\ManyToMany(targetEntity: Attributes::class, mappedBy: 'category', cascade:['persist'])]
  116.     private Collection $attributes;
  118.     #[ORM\ManyToMany(targetEntity: AttributeItems::class, mappedBy: 'categories', cascade:['persist'])]
  119.     private Collection $attributeItems;
  121.     #[ORM\ManyToMany(targetEntity: Coupons::class, mappedBy: 'category', cascade:['persist'])]
  122.     private Collection $coupons;
  124.     #[ORM\ManyToMany(targetEntity: Faq::class, mappedBy: 'category')]
  125.     private Collection $faqs;
  126.     
  127.     #[Groups(['cat:pages', 'cat:write'])]
  128.     #[ORM\ManyToMany(targetEntity: Pages::class, mappedBy: 'categories',  cascade:['persist'])]
  129.     private Collection $pages;
  131.     #[Groups(['cat:news', 'cat:write'])]
  132.     #[ORM\ManyToMany(targetEntity: News::class, inversedBy: 'categories',  cascade:['persist'])]
  133.     private Collection $news;
  135.     #[Groups(['cat:siteProducts', 'cat:write'])]
  136.     #[ORM\ManyToMany(targetEntity: SiteProducts::class, mappedBy: 'category')]
  137.     private Collection $siteProducts;
  139.     #[Groups(['cat:read', 'cat:write'])]
  140.     #[ORM\Column(nullable: true, options: ["default" => 0])]
  141.     private ?int $productCnt = null;
  143.     #[Groups(['cat:read', 'cat:write'])]
  144.     #[ORM\Column(nullable: true,  options: ["default" => 0])]
  145.     private ?int $SiteProductCnt = null;
  147.     #[Groups(['cat:media', 'cat:write'])]
  148.     #[ORM\ManyToOne(inversedBy: 'categories')]
  149.     private ?MediaObject $media = null;
  151.     #[Groups(['cat:read', 'cat:write', 'read', 'write', 'news:read', 'news:write', 'site_product:read'])]
  152.     #[ORM\Column(nullable: true)]
  153.     private ?int $sort = null;
  155.     #[Groups(['cat:objects', 'cat:write'])]
  156.     #[ORM\ManyToMany(targetEntity: Objects::class, mappedBy: 'category')]
  157.     private Collection $objects;
  159.     #[Groups(['cat:projects', 'cat:write'])]
  160.     #[ORM\ManyToMany(targetEntity: Projects::class, mappedBy: 'category')]
  161.     private Collection $projects;
  163.     #[Groups(['cat:read', 'cat:write'])]
  164.     #[ORM\ManyToOne(inversedBy: 'categories')]
  165.     private ?Languages $language = null;
  167.     #[Groups(['cat:read', 'cat:write'])]
  168.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'translations')]
  169.     private ?self $translation = null;
  171.     #[Groups(['cat:read', 'cat:write', ])]
  172.     #[ORM\OneToMany(mappedBy: 'translation', targetEntity: self::class)]
  173.     private Collection $translations;
  175.     public function __construct()
  176.     {
  177.         $this->categories = new ArrayCollection();
  178.         $this->products = new ArrayCollection();
  179.         $this->attributes = new ArrayCollection();
  180.         $this->attributeItems = new ArrayCollection();
  181.         $this->coupons = new ArrayCollection();
  182.         $this->faqs = new ArrayCollection();
  183.         $this->pages = new ArrayCollection();
  184.         $this->news = new ArrayCollection();
  185.         $this->siteProducts = new ArrayCollection();
  186.         $this->objects = new ArrayCollection();
  187.         $this->projects = new ArrayCollection();
  188.         $this->translations = new ArrayCollection();
  189.     }
  191.     public function getId(): ?int
  192.     {
  193.         return $this->id;
  194.     }
  196.     public function getDateEntered(): ?\DateTimeInterface
  197.     {
  198.         return $this->date_entered;
  199.     }
  201.     public function setDateEntered(?\DateTimeInterface $date_entered): self
  202.     {
  203.         $this->date_entered = $date_entered;
  205.         return $this;
  206.     }
  208.     public function getDateModified(): ?\DateTimeInterface
  209.     {
  210.         return $this->date_modified;
  211.     }
  213.     public function setDateModified(?\DateTimeInterface $date_modified): self
  214.     {
  215.         $this->date_modified = $date_modified;
  217.         return $this;
  218.     }
  220.     public function getCreatedBy(): ?int
  221.     {
  222.         return $this->created_by;
  223.     }
  225.     public function setCreatedBy(?int $created_by): self
  226.     {
  227.         $this->created_by = $created_by;
  229.         return $this;
  230.     }
  232.     public function getModifiedUserId(): ?int
  233.     {
  234.         return $this->modified_user_id;
  235.     }
  237.     public function setModifiedUserId(?int $modified_user_id): self
  238.     {
  239.         $this->modified_user_id = $modified_user_id;
  241.         return $this; 
  242.     }
  244.     public function getName(): ?string
  245.     {
  246.         return $this->name;
  247.     }
  249.     public function setName(string $name): self
  250.     {
  251.         $this->name = $name;
  253.         return $this;
  254.     }
  256.     public function getParent(): ?self
  257.     {
  258.         return $this->parent;
  259.     }
  261.     public function setParent(?self $parent): self
  262.     {
  263.         $this->parent = $parent;
  265.         return $this;
  266.     }
  268.     /**
  269.      * @return Collection<int, self>
  270.      */
  271.     public function getCategories(): Collection
  272.     {
  273.         return $this->categories;
  274.     }
  276.     public function addCategory(self $category): self
  277.     {
  278.         if (!$this->categories->contains($category)) {
  279.             $this->categories->add($category);
  280.             $category->setParent($this);
  281.         }
  283.         return $this;
  284.     }
  286.     public function removeCategory(self $category): self
  287.     {
  288.         if ($this->categories->removeElement($category)) {
  289.             // set the owning side to null (unless already changed)
  290.             if ($category->getParent() === $this) {
  291.                 $category->setParent(null);
  292.             }
  293.         }
  295.         return $this;
  296.     }
  298.     public function getSlug(): ?string
  299.     {
  300.         return $this->slug;
  301.     }
  303.     public function setSlug(?string $slug): self
  304.     {
  305.         $this->slug = mb_strtolower( $slug );
  307.         return $this;
  308.     }
  310.     public function getStatus(): ?string
  311.     {
  312.         return $this->status;
  313.     }
  315.     public function setStatus(?string $status): self
  316.     {
  317.         $this->status = $status;
  319.         return $this;
  320.     }
  322.     public function getDescription(): ?string
  323.     {
  324.         return $this->description;
  325.     }
  327.     public function setDescription(?string $description): self
  328.     {
  329.         $this->description = $description;
  331.         return $this;
  332.     }
  333.     
  334.     public function isMain(): ?bool
  335.     {
  336.         return $this->main;
  337.     }
  339.     public function setMain(?bool $main): self
  340.     {
  341.         $this->main = $main;
  343.         return $this;
  344.     }
  346.     public function getType(): ?string
  347.     {
  348.         return $this->type;
  349.     }
  351.     public function setType(?string $type): self
  352.     {
  353.         $this->type = $type;
  355.         return $this;
  356.     }
  358.     /**
  359.      * @return Collection<int, Products>
  360.      */
  361.     public function getProducts(): Collection
  362.     {
  363.         return $this->products;
  364.     }
  366.     public function addProduct(Products $product): self
  367.     {
  368.         if (!$this->products->contains($product)) {
  369.             $this->products->add($product);
  370.             $product->addCategory($this);
  371.         }
  373.         return $this;
  374.     }
  376.     public function removeProduct(Products $product): self
  377.     {
  378.         if ($this->products->removeElement($product)) {
  379.             $product->removeCategory($this);
  380.         }
  382.         return $this;
  383.     }
  385.     /**
  386.      * @return Collection<int, Attributes>
  387.      */
  388.     public function getAttributes(): Collection
  389.     {
  390.         return $this->attributes;
  391.     }
  393.     public function addAttribute(Attributes $attribute): self
  394.     {
  395.         if (!$this->attributes->contains($attribute)) {
  396.             $this->attributes->add($attribute);
  397.             $attribute->addCategory($this);
  398.         }
  400.         return $this;
  401.     }
  403.     public function removeAttribute(Attributes $attribute): self
  404.     {
  405.         if ($this->attributes->removeElement($attribute)) {
  406.             $attribute->removeCategory($this);
  407.         }
  409.         return $this;
  410.     }
  412.     /**
  413.      * @return Collection<int, AttributeItems>
  414.      */
  415.     public function getAttributeItems(): Collection
  416.     {
  417.         return $this->attributeItems;
  418.     }
  420.     public function addAttributeItem(AttributeItems $attributeItem): self
  421.     {
  422.         if (!$this->attributeItems->contains($attributeItem)) {
  423.             $this->attributeItems->add($attributeItem);
  424.             $attributeItem->addCategory($this);
  425.         }
  427.         return $this;
  428.     }
  430.     public function removeAttributeItem(AttributeItems $attributeItem): self
  431.     {
  432.         if ($this->attributeItems->removeElement($attributeItem)) {
  433.             $attributeItem->removeCategory($this);
  434.         }
  436.         return $this;
  437.     }
  439.     /**
  440.      * @return Collection<int, Coupons>
  441.      */
  442.     public function getCoupons(): Collection
  443.     {
  444.         return $this->coupons;
  445.     }
  447.     public function addCoupon(Coupons $coupon): self
  448.     {
  449.         if (!$this->coupons->contains($coupon)) {
  450.             $this->coupons->add($coupon);
  451.             $coupon->addCategory($this);
  452.         }
  454.         return $this;
  455.     }
  457.     public function removeCoupon(Coupons $coupon): self
  458.     {
  459.         if ($this->coupons->removeElement($coupon)) {
  460.             $coupon->removeCategory($this);
  461.         }
  463.         return $this;
  464.     }
  466.     /**
  467.      * @return Collection<int, Faq>
  468.      */
  469.     public function getFaqs(): Collection
  470.     {
  471.         return $this->faqs;
  472.     }
  474.     public function addFaq(Faq $faq): static
  475.     {
  476.         if (!$this->faqs->contains($faq)) {
  477.             $this->faqs->add($faq);
  478.             $faq->addCategory($this);
  479.         }
  480.         return $this;
  481.     }
  482.     /**
  483.      * @return Collection<int, Pages>
  484.      */
  485.     public function getPages(): Collection
  486.     {
  487.         return $this->pages;
  488.     }
  490.     public function addPage(Pages $page): static
  491.     {
  492.         if (!$this->pages->contains($page)) {
  493.             $this->pages->add($page);
  494.         }
  496.         return $this;
  497.     }
  500.     public function removeFaq(Faq $faq): static
  501.     {
  502.         if ($this->faqs->removeElement($faq)) {
  503.             $faq->removeCategory($this);
  504.         }
  506.         return $this;
  507.     }
  509.     public function removePage(Pages $page): static
  510.     {
  511.         $this->pages->removeElement($page);
  513.         return $this;
  514.     }
  516.     /**
  517.      * @return Collection<int, News>
  518.      */
  519.     public function getNews(): Collection
  520.     {
  521.         return $this->news;
  522.     }
  524.     public function addNews(News $news): static
  525.     {
  526.         if (!$this->news->contains($news)) {
  527.             $this->news->add($news);
  528.         }
  530.         return $this;
  531.     }
  534.     public function removeNews(News $news): static
  535.     {
  536.         $this->news->removeElement($news);
  538.         return $this;
  539.     }
  541.     /**
  542.      * @return Collection<int, SiteProducts>
  543.      */
  544.     public function getSiteProducts(): Collection
  545.     {
  546.         return $this->siteProducts;
  547.     }
  549.     public function addSiteProduct(SiteProducts $siteProduct): static
  550.     {
  551.         if (!$this->siteProducts->contains($siteProduct)) {
  552.             $this->siteProducts->add($siteProduct);
  553.             $siteProduct->addCategory($this);
  554.         }
  555.         return $this;
  556.     }
  557.     
  558.     public function getLanguage(): ?Languages
  559.     {
  560.         return $this->language;
  561.     }
  563.     public function setLanguage(?Languages $language): static
  564.     {
  565.         $this->language = $language;
  567.         return $this;
  568.     }
  570.     public function removeSiteProduct(SiteProducts $siteProduct): static
  571.     {
  572.         if ($this->siteProducts->removeElement($siteProduct)) {
  573.             $siteProduct->removeCategory($this);
  574.         }
  576.         return $this;
  577.     }
  579.     public function getProductCnt(): ?int
  580.     {
  581.         return $this->productCnt;
  582.     }
  584.     public function setProductCnt(?int $productCnt): static
  585.     {
  586.         $this->productCnt = $productCnt;
  588.         return $this;
  589.     }
  591.     public function getSiteProductCnt(): ?int
  592.     {
  593.         return $this->SiteProductCnt;
  594.     }
  596.     public function setSiteProductCnt(?int $SiteProductCnt): static
  597.     {
  598.         $this->SiteProductCnt = $SiteProductCnt;
  600.         return $this;
  601.     }
  603.     public function getMedia(): ?MediaObject
  604.     {
  605.         return $this->media;
  606.     }
  608.     public function setMedia(?MediaObject $media): static
  609.     {
  610.         $this->media = $media;
  612.         return $this;
  613.     }
  615.     public function getSort(): ?int
  616.     {
  617.         return $this->sort;
  618.     }
  620.     public function setSort(?int $sort): static
  621.     {
  622.         $this->sort = $sort;
  623.         return $this;
  624.     }
  626.     
  627.     public function getTranslation(): ?self
  628.     {
  629.         return $this->translation;
  630.     }
  632.     public function setTranslation(?self $translation): static
  633.     {
  634.         $this->translation = $translation;
  636.         return $this;
  637.     }
  639.     /**
  640.      * @return Collection<int, Objects>
  641.      */
  642.     public function getObjects(): Collection
  643.     {
  644.         return $this->objects;
  645.     }
  647.     public function addObject(Objects $object): static
  648.     {
  649.         if (!$this->objects->contains($object)) {
  650.             $this->objects->add($object);
  651.             $object->addCategory($this);
  652.         }
  654.         return $this;
  655.     }
  657.     
  658.     /**
  659.      *  @return Collection<int, self>
  660.      */
  661.     public function getTranslations(): Collection
  662.     {
  663.         return $this->translations;
  664.     }
  666.     public function addTranslation(self $translation): static
  667.     {
  668.         if (!$this->translations->contains($translation)) {
  669.             $this->translations->add($translation);
  670.             $translation->setTranslation($this);
  671.         }
  673.         return $this;
  674.     }
  676.     public function removeObject(Objects $object): static
  677.     {
  678.         if ($this->objects->removeElement($object)) {
  679.             $object->removeCategory($this);
  680.         }
  682.         return $this;
  683.     }
  685.     /**
  686.      * @return Collection<int, Projects>
  687.      */
  688.     public function getProjects(): Collection
  689.     {
  690.         return $this->projects;
  691.     }
  693.     public function addProject(Projects $project): static
  694.     {
  695.         if (!$this->projects->contains($project)) {
  696.             $this->projects->add($project);
  697.             $project->addCategory($this);
  698.         }
  700.         return $this;
  701.     }
  703.     public function removeProject(Projects $project): static
  704.     {
  705.         if ($this->projects->removeElement($project)) {
  706.             $project->removeCategory($this);
  707.         }
  709.         return $this;
  710.     }
  712.     public function removeTranslation(self $translation): static
  713.     {
  714.         if ($this->translations->removeElement($translation)) {
  715.             // set the owning side to null (unless already changed)
  716.             if ($translation->getTranslation() === $this) {
  717.                 $translation->setTranslation(null);
  718.             }
  719.         }
  721.         return $this;
  722.     }
  723. }