src/Shop/Doctrine/Entity/Taxonomy.php line 36

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace App\Shop\Doctrine\Entity;
  7. use ApiPlatform\Core\Annotation\ApiFilter;
  8. use ApiPlatform\Core\Annotation\ApiResource;
  9. use App\Shop\Doctrine\Repository\TaxonomyRepository;
  10. use App\Shop\Filter\TaxonomyFilter;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use Doctrine\Common\Collections\Collection;
  13. use Doctrine\ORM\Mapping\Column;
  14. use Doctrine\ORM\Mapping\Entity;
  15. use Doctrine\ORM\Mapping\GeneratedValue;
  16. use Doctrine\ORM\Mapping\Id;
  17. use Doctrine\ORM\Mapping\ManyToOne;
  18. use Doctrine\ORM\Mapping\OneToMany;
  19. use Doctrine\ORM\Mapping\Table;
  20. use Gedmo\Mapping\Annotation as Gedmo;
  21. use Symfony\Component\Serializer\Annotation\Groups;
  22. use Symfony\Component\Validator\Constraints\NotBlank;
  24. /**
  25.  * @Gedmo\Tree(type="nested")
  26.  */
  27. #[ApiResource(
  28.     collectionOperations: ['get'],
  29.     itemOperations: ['get'],
  30.     attributes: ['pagination_enabled' => false],
  31.     normalizationContext: ['groups' => ['read']]
  32. )]
  33. #[ApiFilter(TaxonomyFilter::class)]
  34. #[Entity(repositoryClass: TaxonomyRepository::class)]
  35. #[Table(name: '`shop_taxonomy`')]
  36. class Taxonomy
  37. {
  38.     #[Id]
  39.     #[Column(type: 'integer')]
  40.     #[GeneratedValue]
  41.     #[Groups(['read', 'product'])]
  42.     private ?int $id = null;
  44.     #[Column]
  45.     #[NotBlank]
  46.     #[Groups(['read', 'product'])]
  47.     private string $name;
  49.     /**
  50.      * @Gedmo\TreeLevel
  51.      */
  52.     #[Column(name: 'lvl', type: 'integer')]
  53.     #[Groups('read')]
  54.     private int $level;
  56.     /**
  57.      * @Gedmo\TreeLeft
  58.      */
  59.     #[Column(name: 'lft', type: 'integer')]
  60.     private int $left;
  62.     /**
  63.      * @Gedmo\TreeRight
  64.      */
  65.     #[Column(name: 'rgt', type: 'integer')]
  66.     private int $right;
  68.     #[Groups('read')]
  69.     private int $numberOfProducts = 0;
  71.     /**
  72.      * @Gedmo\TreeParent
  73.      */
  74.     #[ManyToOne(targetEntity: Taxonomy::class, inversedBy: 'children')]
  75.     private ?Taxonomy $parent = null;
  77.     /**
  78.      * @var Collection<int, Taxonomy>
  79.      */
  80.     #[OneToMany(mappedBy: 'parent', targetEntity: Taxonomy::class)]
  81.     #[Groups('read')]
  82.     private Collection $children;
  84.     /**
  85.      * @var Collection<int, Product>
  86.      */
  87.     #[OneToMany(mappedBy: 'taxonomy', targetEntity: Product::class, fetch: 'EXTRA_LAZY')]
  88.     private Collection $products;
  90.     public function __construct()
  91.     {
  92.         $this->children = new ArrayCollection();
  93.         $this->products = new ArrayCollection();
  94.     }
  96.     public function __toString(): string
  97.     {
  98.         return $this->getName();
  99.     }
  101.     public function getId(): ?int
  102.     {
  103.         return $this->id;
  104.     }
  106.     public function getName(): string
  107.     {
  108.         return $this->name;
  109.     }
  111.     public function setName(string $name): void
  112.     {
  113.         $this->name = $name;
  114.     }
  116.     public function getLevel(): int
  117.     {
  118.         return $this->level;
  119.     }
  121.     public function setLevel(int $level): void
  122.     {
  123.         $this->level = $level;
  124.     }
  126.     public function getLeft(): int
  127.     {
  128.         return $this->left;
  129.     }
  131.     public function setLeft(int $left): void
  132.     {
  133.         $this->left = $left;
  134.     }
  136.     public function getRight(): int
  137.     {
  138.         return $this->right;
  139.     }
  141.     public function setRight(int $right): void
  142.     {
  143.         $this->right = $right;
  144.     }
  146.     public function getParent(): ?Taxonomy
  147.     {
  148.         return $this->parent;
  149.     }
  151.     public function setParent(?Taxonomy $parent): void
  152.     {
  153.         $this->parent = $parent;
  154.     }
  156.     /**
  157.      * @return Collection<int, Taxonomy>
  158.      */
  159.     public function getChildren(): Collection
  160.     {
  161.         return $this->children;
  162.     }
  164.     /**
  165.      * @return Collection<int, Product>
  166.      */
  167.     public function getProducts(): Collection
  168.     {
  169.         return $this->products;
  170.     }
  172.     /**
  173.      * @return array<int|string, array<string, int|string|null>|int|string>
  174.      */
  175.     public function getTree(): array
  176.     {
  177.         $data = [
  178.             'key' => $this->id,
  179.             'name' => $this->name,
  180.             'rootdistance' => $this->level,
  181.             'children' => $this->children->count(),
  182.         ];
  184.         if (null !== $this->parent) {
  185.             $data['parent'] = $this->parent->id;
  186.         }
  188.         return array_merge(
  189.             [$data],
  190.             ...$this->children->map(static fn (Taxonomy $taxonomy) => $taxonomy->getTree())->toArray()
  191.         );
  192.     }
  194.     public function getNumberOfProducts(): int
  195.     {
  196.         return $this->numberOfProducts;
  197.     }
  199.     public function setNumberOfProducts(int $numberOfProducts): void
  200.     {
  201.         $this->numberOfProducts = $numberOfProducts;
  202.     }
  203. }