vendor/shopware/core/Content/Category/SalesChannel/NavigationRoute.php line 81

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Content\Category\SalesChannel;
  5. use Doctrine\DBAL\Connection;
  6. use Shopware\Core\Content\Category\CategoryCollection;
  7. use Shopware\Core\Content\Category\CategoryEntity;
  8. use Shopware\Core\Content\Category\Exception\CategoryNotFoundException;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Doctrine\FetchModeHelper;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Bucket\TermsAggregation;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\CountAggregation;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Bucket\TermsResult;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\ContainsFilter;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\RangeFilter;
  17. use Shopware\Core\Framework\Log\Package;
  18. use Shopware\Core\Framework\Plugin\Exception\DecorationPatternException;
  19. use Shopware\Core\Framework\Uuid\Uuid;
  20. use Shopware\Core\System\SalesChannel\Entity\SalesChannelRepository;
  21. use Shopware\Core\System\SalesChannel\SalesChannelContext;
  22. use Symfony\Component\HttpFoundation\Request;
  23. use Symfony\Component\Routing\Annotation\Route;
  25. /**
  26.  * @phpstan-type CategoryMetaInformation array{id: string, level: int, path: string}
  27.  */
  28. #[Route(defaults: ['_routeScope' => ['store-api']])]
  29. #[Package('content')]
  30. class NavigationRoute extends AbstractNavigationRoute
  31. {
  32.     /**
  33.      * @internal
  34.      */
  35.     public function __construct(
  36.         private readonly Connection $connection,
  37.         private readonly SalesChannelRepository $categoryRepository
  38.     ) {
  39.     }
  41.     public function getDecorated(): AbstractNavigationRoute
  42.     {
  43.         throw new DecorationPatternException(self::class);
  44.     }
  46.     #[Route(path: '/store-api/navigation/{activeId}/{rootId}', name: 'store-api.navigation', methods: ['GET', 'POST'], defaults: ['_entity' => 'category'])]
  47.     public function load(
  48.         string $activeId,
  49.         string $rootId,
  50.         Request $request,
  51.         SalesChannelContext $context,
  52.         Criteria $criteria
  53.     ): NavigationRouteResponse {
  54.         $depth = $request->query->getInt('depth', $request->request->getInt('depth', 2));
  56.         $metaInfo = $this->getCategoryMetaInfo($activeId, $rootId);
  58.         $active = $this->getMetaInfoById($activeId, $metaInfo);
  60.         $root = $this->getMetaInfoById($rootId, $metaInfo);
  62.         // Validate the provided category is part of the sales channel
  63.         $this->validate($activeId, $active['path'], $context);
  65.         $isChild = $this->isChildCategory($activeId, $active['path'], $rootId);
  67.         // If the provided activeId is not part of the rootId, a fallback to the rootId must be made here.
  68.         // The passed activeId is therefore part of another navigation and must therefore not be loaded.
  69.         // The availability validation has already been done in the `validate` function.
  70.         if (!$isChild) {
  71.             $activeId = $rootId;
  72.         }
  74.         $categories = new CategoryCollection();
  75.         if ($depth > 0) {
  76.             // Load the first two levels without using the activeId in the query
  77.             $categories = $this->loadLevels($rootId, (int) $root['level'], $context, clone $criteria, $depth);
  78.         }
  80.         // If the active category is part of the provided root id, we have to load the children and the parents of the active id
  81.         $categories = $this->loadChildren($activeId, $context, $rootId, $metaInfo, $categories, clone $criteria);
  83.         return new NavigationRouteResponse($categories);
  84.     }
  86.     /**
  87.      * @param string[] $ids
  88.      */
  89.     private function loadCategories(array $ids, SalesChannelContext $context, Criteria $criteria): CategoryCollection
  90.     {
  91.         $criteria->setIds($ids);
  92.         $criteria->addAssociation('media');
  93.         $criteria->setTotalCountMode(Criteria::TOTAL_COUNT_MODE_NONE);
  95.         /** @var CategoryCollection $missing */
  96.         $missing = $this->categoryRepository->search($criteria, $context)->getEntities();
  98.         return $missing;
  99.     }
  101.     private function loadLevels(string $rootId, int $rootLevel, SalesChannelContext $context, Criteria $criteria, int $depth = 2): CategoryCollection
  102.     {
  103.         $criteria->addFilter(
  104.             new ContainsFilter('path', '|' . $rootId . '|'),
  105.             new RangeFilter('level', [
  106.                 RangeFilter::GT => $rootLevel,
  107.                 RangeFilter::LTE => $rootLevel + $depth + 1,
  108.             ])
  109.         );
  111.         $criteria->addAssociation('media');
  113.         $criteria->setLimit(null);
  114.         $criteria->setTotalCountMode(Criteria::TOTAL_COUNT_MODE_NONE);
  116.         /** @var CategoryCollection $levels */
  117.         $levels = $this->categoryRepository->search($criteria, $context)->getEntities();
  119.         $this->addVisibilityCounts($rootId, $rootLevel, $depth, $levels, $context);
  121.         return $levels;
  122.     }
  124.     /**
  125.      * @return array<string, CategoryMetaInformation>
  126.      */
  127.     private function getCategoryMetaInfo(string $activeId, string $rootId): array
  128.     {
  129.         $result = $this->connection->fetchAllAssociative('
  130.             # navigation-route::meta-information
  131.             SELECT LOWER(HEX(`id`)), `path`, `level`
  132.             FROM `category`
  133.             WHERE `id` = :activeId OR `parent_id` = :activeId OR `id` = :rootId
  134.         ', ['activeId' => Uuid::fromHexToBytes($activeId), 'rootId' => Uuid::fromHexToBytes($rootId)]);
  136.         if (!$result) {
  137.             throw new CategoryNotFoundException($activeId);
  138.         }
  140.         return FetchModeHelper::groupUnique($result);
  141.     }
  143.     /**
  144.      * @param array<string, CategoryMetaInformation> $metaInfo
  145.      *
  146.      * @return CategoryMetaInformation
  147.      */
  148.     private function getMetaInfoById(string $id, array $metaInfo): array
  149.     {
  150.         if (!\array_key_exists($id, $metaInfo)) {
  151.             throw new CategoryNotFoundException($id);
  152.         }
  154.         return $metaInfo[$id];
  155.     }
  157.     /**
  158.      * @param array<string, CategoryMetaInformation> $metaInfo
  159.      */
  160.     private function loadChildren(string $activeId, SalesChannelContext $context, string $rootId, array $metaInfo, CategoryCollection $categories, Criteria $criteria): CategoryCollection
  161.     {
  162.         $active = $this->getMetaInfoById($activeId, $metaInfo);
  164.         unset($metaInfo[$rootId], $metaInfo[$activeId]);
  166.         $childIds = array_keys($metaInfo);
  168.         // Fetch all parents and first-level children of the active category, if they're not already fetched
  169.         $missing = $this->getMissingIds($activeId, $active['path'], $childIds, $categories);
  170.         if (empty($missing)) {
  171.             return $categories;
  172.         }
  174.         $categories->merge(
  175.             $this->loadCategories($missing, $context, $criteria)
  176.         );
  178.         return $categories;
  179.     }
  181.     /**
  182.      * @param array<string> $childIds
  183.      *
  184.      * @return list<string>
  185.      */
  186.     private function getMissingIds(string $activeId, ?string $path, array $childIds, CategoryCollection $alreadyLoaded): array
  187.     {
  188.         $parentIds = array_filter(explode('|', $path ?? ''));
  190.         $haveToBeIncluded = array_merge($childIds, $parentIds, [$activeId]);
  191.         $included = $alreadyLoaded->getIds();
  192.         $included = array_flip($included);
  194.         return array_values(array_diff($haveToBeIncluded, $included));
  195.     }
  197.     private function validate(string $activeId, ?string $path, SalesChannelContext $context): void
  198.     {
  199.         $ids = array_filter([
  200.             $context->getSalesChannel()->getFooterCategoryId(),
  201.             $context->getSalesChannel()->getServiceCategoryId(),
  202.             $context->getSalesChannel()->getNavigationCategoryId(),
  203.         ]);
  205.         foreach ($ids as $id) {
  206.             if ($this->isChildCategory($activeId, $path, $id)) {
  207.                 return;
  208.             }
  209.         }
  211.         throw new CategoryNotFoundException($activeId);
  212.     }
  214.     private function isChildCategory(string $activeId, ?string $path, string $rootId): bool
  215.     {
  216.         if ($rootId === $activeId) {
  217.             return true;
  218.         }
  220.         if ($path === null) {
  221.             return false;
  222.         }
  224.         if (mb_strpos($path, '|' . $rootId . '|') !== false) {
  225.             return true;
  226.         }
  228.         return false;
  229.     }
  231.     private function addVisibilityCounts(string $rootId, int $rootLevel, int $depth, CategoryCollection $levels, SalesChannelContext $context): void
  232.     {
  233.         $counts = [];
  234.         foreach ($levels as $category) {
  235.             if (!$category->getActive() || !$category->getVisible()) {
  236.                 continue;
  237.             }
  239.             $parentId = $category->getParentId();
  240.             $counts[$parentId] ??= 0;
  241.             ++$counts[$parentId];
  242.         }
  243.         foreach ($levels as $category) {
  244.             $category->setVisibleChildCount($counts[$category->getId()] ?? 0);
  245.         }
  247.         // Fetch additional level of categories for counting visible children that are NOT included in the original query
  248.         $criteria = new Criteria();
  249.         $criteria->addFilter(
  250.             new ContainsFilter('path', '|' . $rootId . '|'),
  251.             new EqualsFilter('level', $rootLevel + $depth + 1),
  252.             new EqualsFilter('active', true),
  253.             new EqualsFilter('visible', true)
  254.         );
  256.         $criteria->addAggregation(
  257.             new TermsAggregation('category-ids', 'parentId', null, null, new CountAggregation('visible-children-count', 'id'))
  258.         );
  260.         $termsResult = $this->categoryRepository
  261.             ->aggregate($criteria, $context)
  262.             ->get('category-ids');
  264.         if (!($termsResult instanceof TermsResult)) {
  265.             return;
  266.         }
  268.         foreach ($termsResult->getBuckets() as $bucket) {
  269.             $key = $bucket->getKey();
  271.             if ($key === null) {
  272.                 continue;
  273.             }
  275.             $parent = $levels->get($key);
  277.             if ($parent instanceof CategoryEntity) {
  278.                 $parent->setVisibleChildCount($bucket->getCount());
  279.             }
  280.         }
  281.     }
  282. }