vendor/shopware/core/Content/Product/SalesChannel/Listing/ProductListingFeaturesSubscriber.php line 84

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Content\Product\SalesChannel\Listing;
  5. use Doctrine\DBAL\Connection;
  6. use Shopware\Core\Content\Product\Events\ProductListingCollectFilterEvent;
  7. use Shopware\Core\Content\Product\Events\ProductListingCriteriaEvent;
  8. use Shopware\Core\Content\Product\Events\ProductListingResultEvent;
  9. use Shopware\Core\Content\Product\Events\ProductSearchCriteriaEvent;
  10. use Shopware\Core\Content\Product\Events\ProductSearchResultEvent;
  11. use Shopware\Core\Content\Product\Events\ProductSuggestCriteriaEvent;
  12. use Shopware\Core\Content\Product\SalesChannel\Exception\ProductSortingNotFoundException;
  13. use Shopware\Core\Content\Product\SalesChannel\Sorting\ProductSortingCollection;
  14. use Shopware\Core\Content\Product\SalesChannel\Sorting\ProductSortingEntity;
  15. use Shopware\Core\Content\Property\Aggregate\PropertyGroupOption\PropertyGroupOptionCollection;
  16. use Shopware\Core\Framework\Context;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Dbal\Common\RepositoryIterator;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Doctrine\FetchModeHelper;
  19. use Shopware\Core\Framework\DataAbstractionLayer\Entity;
  20. use Shopware\Core\Framework\DataAbstractionLayer\EntityCollection;
  21. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepository;
  22. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Aggregation;
  23. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Bucket\FilterAggregation;
  24. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Bucket\TermsAggregation;
  25. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\EntityAggregation;
  26. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\MaxAggregation;
  27. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\StatsAggregation;
  28. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Bucket\TermsResult;
  29. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Metric\EntityResult;
  30. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  31. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsAnyFilter;
  32. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  33. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\MultiFilter;
  34. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\RangeFilter;
  35. use Shopware\Core\Framework\DataAbstractionLayer\Search\Sorting\FieldSorting;
  36. use Shopware\Core\Framework\Log\Package;
  37. use Shopware\Core\Framework\Uuid\Uuid;
  38. use Shopware\Core\Profiling\Profiler;
  39. use Shopware\Core\System\SalesChannel\SalesChannelContext;
  40. use Shopware\Core\System\SystemConfig\SystemConfigService;
  41. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  42. use Symfony\Component\HttpFoundation\Request;
  43. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  45. /**
  46.  * @internal
  47.  */
  48. #[Package('inventory')]
  49. class ProductListingFeaturesSubscriber implements EventSubscriberInterface
  50. {
  51.     final public const DEFAULT_SEARCH_SORT = 'score';
  53.     final public const PROPERTY_GROUP_IDS_REQUEST_PARAM = 'property-whitelist';
  55.     /**
  56.      * @internal
  57.      */
  58.     public function __construct(private readonly Connection $connection, private readonly EntityRepository $optionRepository, private readonly EntityRepository $sortingRepository, private readonly SystemConfigService $systemConfigService, private readonly EventDispatcherInterface $dispatcher)
  59.     {
  60.     }
  62.     public static function getSubscribedEvents(): array
  63.     {
  64.         return [
  65.             ProductListingCriteriaEvent::class => [
  66.                 ['handleListingRequest', 100],
  67.                 ['handleFlags', -100],
  68.             ],
  69.             ProductSuggestCriteriaEvent::class => [
  70.                 ['handleFlags', -100],
  71.             ],
  72.             ProductSearchCriteriaEvent::class => [
  73.                 ['handleSearchRequest', 100],
  74.                 ['handleFlags', -100],
  75.             ],
  76.             ProductListingResultEvent::class => [
  77.                 ['handleResult', 100],
  78.                 ['removeScoreSorting', -100],
  79.             ],
  80.             ProductSearchResultEvent::class => 'handleResult',
  81.         ];
  82.     }
  84.     public function handleFlags(ProductListingCriteriaEvent $event): void
  85.     {
  86.         $request = $event->getRequest();
  87.         $criteria = $event->getCriteria();
  89.         if ($request->get('no-aggregations')) {
  90.             $criteria->resetAggregations();
  91.         }
  93.         if ($request->get('only-aggregations')) {
  94.             // set limit to zero to fetch no products.
  95.             $criteria->setLimit(0);
  97.             // no total count required
  98.             $criteria->setTotalCountMode(Criteria::TOTAL_COUNT_MODE_NONE);
  100.             // sorting and association are only required for the product data
  101.             $criteria->resetSorting();
  102.             $criteria->resetAssociations();
  103.         }
  104.     }
  106.     public function handleListingRequest(ProductListingCriteriaEvent $event): void
  107.     {
  108.         $request = $event->getRequest();
  109.         $criteria = $event->getCriteria();
  110.         $context = $event->getSalesChannelContext();
  112.         if (!$request->get('order')) {
  113.             $request->request->set('order', $this->getSystemDefaultSorting($context));
  114.         }
  116.         $criteria->addAssociation('options');
  118.         $this->handlePagination($request, $criteria, $event->getSalesChannelContext());
  120.         $this->handleFilters($request, $criteria, $context);
  122.         $this->handleSorting($request, $criteria, $context);
  123.     }
  125.     public function handleSearchRequest(ProductSearchCriteriaEvent $event): void
  126.     {
  127.         $request = $event->getRequest();
  128.         $criteria = $event->getCriteria();
  129.         $context = $event->getSalesChannelContext();
  131.         if (!$request->get('order')) {
  132.             $request->request->set('order', self::DEFAULT_SEARCH_SORT);
  133.         }
  135.         $this->handlePagination($request, $criteria, $event->getSalesChannelContext());
  137.         $this->handleFilters($request, $criteria, $context);
  139.         $this->handleSorting($request, $criteria, $context);
  140.     }
  142.     public function handleResult(ProductListingResultEvent $event): void
  143.     {
  144.         Profiler::trace('product-listing::feature-subscriber', function () use ($event): void {
  145.             $this->groupOptionAggregations($event);
  147.             $this->addCurrentFilters($event);
  149.             $result = $event->getResult();
  151.             /** @var ProductSortingCollection $sortings */
  152.             $sortings = $result->getCriteria()->getExtension('sortings');
  153.             $currentSortingKey = $this->getCurrentSorting($sortings, $event->getRequest())->getKey();
  155.             $result->setSorting($currentSortingKey);
  157.             $result->setAvailableSortings($sortings);
  159.             $result->setPage($this->getPage($event->getRequest()));
  161.             $result->setLimit($this->getLimit($event->getRequest(), $event->getSalesChannelContext()));
  162.         });
  163.     }
  165.     public function removeScoreSorting(ProductListingResultEvent $event): void
  166.     {
  167.         $sortings = $event->getResult()->getAvailableSortings();
  169.         $defaultSorting = $sortings->getByKey(self::DEFAULT_SEARCH_SORT);
  170.         if ($defaultSorting !== null) {
  171.             $sortings->remove($defaultSorting->getId());
  172.         }
  174.         $event->getResult()->setAvailableSortings($sortings);
  175.     }
  177.     private function handleFilters(Request $request, Criteria $criteria, SalesChannelContext $context): void
  178.     {
  179.         $criteria->addAssociation('manufacturer');
  181.         $filters = $this->getFilters($request, $context);
  183.         $aggregations = $this->getAggregations($request, $filters);
  185.         foreach ($aggregations as $aggregation) {
  186.             $criteria->addAggregation($aggregation);
  187.         }
  189.         foreach ($filters as $filter) {
  190.             if ($filter->isFiltered()) {
  191.                 $criteria->addPostFilter($filter->getFilter());
  192.             }
  193.         }
  195.         $criteria->addExtension('filters', $filters);
  196.     }
  198.     /**
  199.      * @return array<Aggregation>
  200.      */
  201.     private function getAggregations(Request $request, FilterCollection $filters): array
  202.     {
  203.         $aggregations = [];
  205.         if ($request->get('reduce-aggregations') === null) {
  206.             foreach ($filters as $filter) {
  207.                 $aggregations = array_merge($aggregations, $filter->getAggregations());
  208.             }
  210.             return $aggregations;
  211.         }
  213.         foreach ($filters as $filter) {
  214.             $excluded = $filters->filtered();
  216.             if ($filter->exclude()) {
  217.                 $excluded = $excluded->blacklist($filter->getName());
  218.             }
  220.             foreach ($filter->getAggregations() as $aggregation) {
  221.                 if ($aggregation instanceof FilterAggregation) {
  222.                     $aggregation->addFilters($excluded->getFilters());
  224.                     $aggregations[] = $aggregation;
  226.                     continue;
  227.                 }
  229.                 $aggregation = new FilterAggregation(
  230.                     $aggregation->getName(),
  231.                     $aggregation,
  232.                     $excluded->getFilters()
  233.                 );
  235.                 $aggregations[] = $aggregation;
  236.             }
  237.         }
  239.         return $aggregations;
  240.     }
  242.     private function handlePagination(Request $request, Criteria $criteria, SalesChannelContext $context): void
  243.     {
  244.         $limit = $this->getLimit($request, $context);
  246.         $page = $this->getPage($request);
  248.         $criteria->setOffset(($page - 1) * $limit);
  249.         $criteria->setLimit($limit);
  250.         $criteria->setTotalCountMode(Criteria::TOTAL_COUNT_MODE_EXACT);
  251.     }
  253.     private function handleSorting(Request $request, Criteria $criteria, SalesChannelContext $context): void
  254.     {
  255.         /** @var ProductSortingCollection $sortings */
  256.         $sortings = $criteria->getExtension('sortings') ?? new ProductSortingCollection();
  257.         $sortings->merge($this->getAvailableSortings($request, $context->getContext()));
  259.         $currentSorting = $this->getCurrentSorting($sortings, $request);
  261.         $criteria->addSorting(
  262.             ...$currentSorting->createDalSorting()
  263.         );
  265.         $criteria->addExtension('sortings', $sortings);
  266.     }
  268.     private function getCurrentSorting(ProductSortingCollection $sortings, Request $request): ProductSortingEntity
  269.     {
  270.         $key = $request->get('order');
  272.         $sorting = $sortings->getByKey($key);
  273.         if ($sorting !== null) {
  274.             return $sorting;
  275.         }
  277.         throw new ProductSortingNotFoundException($key);
  278.     }
  280.     private function getAvailableSortings(Request $request, Context $context): ProductSortingCollection
  281.     {
  282.         $criteria = new Criteria();
  283.         $criteria->setTitle('product-listing::load-sortings');
  284.         $availableSortings = $request->get('availableSortings');
  285.         $availableSortingsFilter = [];
  287.         if ($availableSortings) {
  288.             arsort($availableSortings, \SORT_DESC | \SORT_NUMERIC);
  289.             $availableSortingsFilter = array_keys($availableSortings);
  291.             $criteria->addFilter(new EqualsAnyFilter('key', $availableSortingsFilter));
  292.         }
  294.         $criteria
  295.             ->addFilter(new EqualsFilter('active', true))
  296.             ->addSorting(new FieldSorting('priority', 'DESC'));
  298.         /** @var ProductSortingCollection $sortings */
  299.         $sortings = $this->sortingRepository->search($criteria, $context)->getEntities();
  301.         if ($availableSortings) {
  302.             $sortings->sortByKeyArray($availableSortingsFilter);
  303.         }
  305.         return $sortings;
  306.     }
  308.     private function getSystemDefaultSorting(SalesChannelContext $context): string
  309.     {
  310.         return $this->systemConfigService->getString(
  311.             'core.listing.defaultSorting',
  312.             $context->getSalesChannel()->getId()
  313.         );
  314.     }
  316.     /**
  317.      * @return array<int, non-falsy-string>
  318.      */
  319.     private function collectOptionIds(ProductListingResultEvent $event): array
  320.     {
  321.         $aggregations = $event->getResult()->getAggregations();
  323.         /** @var TermsResult|null $properties */
  324.         $properties = $aggregations->get('properties');
  326.         /** @var TermsResult|null $options */
  327.         $options = $aggregations->get('options');
  329.         $options = $options ? $options->getKeys() : [];
  330.         $properties = $properties ? $properties->getKeys() : [];
  332.         return array_unique(array_filter([...$options, ...$properties]));
  333.     }
  335.     private function groupOptionAggregations(ProductListingResultEvent $event): void
  336.     {
  337.         $ids = $this->collectOptionIds($event);
  339.         if (empty($ids)) {
  340.             return;
  341.         }
  343.         $criteria = new Criteria($ids);
  344.         $criteria->setLimit(500);
  345.         $criteria->addAssociation('group');
  346.         $criteria->addAssociation('media');
  347.         $criteria->addFilter(new EqualsFilter('group.filterable', true));
  348.         $criteria->setTitle('product-listing::property-filter');
  349.         $criteria->addSorting(new FieldSorting('id', FieldSorting::ASCENDING));
  351.         $mergedOptions = new PropertyGroupOptionCollection();
  353.         $repositoryIterator = new RepositoryIterator($this->optionRepository, $event->getContext(), $criteria);
  354.         while (($result = $repositoryIterator->fetch()) !== null) {
  355.             /** @var PropertyGroupOptionCollection $entities */
  356.             $entities = $result->getEntities();
  358.             $mergedOptions->merge($entities);
  359.         }
  361.         // group options by their property-group
  362.         $grouped = $mergedOptions->groupByPropertyGroups();
  363.         $grouped->sortByPositions();
  364.         $grouped->sortByConfig();
  366.         $aggregations = $event->getResult()->getAggregations();
  368.         // remove id results to prevent wrong usages
  369.         $aggregations->remove('properties');
  370.         $aggregations->remove('configurators');
  371.         $aggregations->remove('options');
  372.         /** @var EntityCollection<Entity> $grouped */
  373.         $aggregations->add(new EntityResult('properties', $grouped));
  374.     }
  376.     private function addCurrentFilters(ProductListingResultEvent $event): void
  377.     {
  378.         $result = $event->getResult();
  380.         $filters = $result->getCriteria()->getExtension('filters');
  381.         if (!$filters instanceof FilterCollection) {
  382.             return;
  383.         }
  385.         foreach ($filters as $filter) {
  386.             $result->addCurrentFilter($filter->getName(), $filter->getValues());
  387.         }
  388.     }
  390.     /**
  391.      * @return list<string>
  392.      */
  393.     private function getManufacturerIds(Request $request): array
  394.     {
  395.         $ids = $request->query->get('manufacturer', '');
  396.         if ($request->isMethod(Request::METHOD_POST)) {
  397.             $ids = $request->request->get('manufacturer', '');
  398.         }
  400.         if (\is_string($ids)) {
  401.             $ids = explode('|', $ids);
  402.         }
  404.         /** @var list<string> $ids */
  405.         $ids = array_filter((array) $ids);
  407.         return $ids;
  408.     }
  410.     /**
  411.      * @return list<string>
  412.      */
  413.     private function getPropertyIds(Request $request): array
  414.     {
  415.         $ids = $request->query->get('properties', '');
  416.         if ($request->isMethod(Request::METHOD_POST)) {
  417.             $ids = $request->request->get('properties', '');
  418.         }
  420.         if (\is_string($ids)) {
  421.             $ids = explode('|', $ids);
  422.         }
  424.         /** @var list<string> $ids */
  425.         $ids = array_filter((array) $ids);
  427.         return $ids;
  428.     }
  430.     private function getLimit(Request $request, SalesChannelContext $context): int
  431.     {
  432.         $limit = $request->query->getInt('limit', 0);
  434.         if ($request->isMethod(Request::METHOD_POST)) {
  435.             $limit = $request->request->getInt('limit', $limit);
  436.         }
  438.         $limit = $limit > 0 ? $limit : $this->systemConfigService->getInt('core.listing.productsPerPage', $context->getSalesChannel()->getId());
  440.         return $limit <= 0 ? 24 : $limit;
  441.     }
  443.     private function getPage(Request $request): int
  444.     {
  445.         $page = $request->query->getInt('p', 1);
  447.         if ($request->isMethod(Request::METHOD_POST)) {
  448.             $page = $request->request->getInt('p', $page);
  449.         }
  451.         return $page <= 0 ? 1 : $page;
  452.     }
  454.     private function getFilters(Request $request, SalesChannelContext $context): FilterCollection
  455.     {
  456.         $filters = new FilterCollection();
  458.         $filters->add($this->getManufacturerFilter($request));
  459.         $filters->add($this->getPriceFilter($request));
  460.         $filters->add($this->getRatingFilter($request));
  461.         $filters->add($this->getShippingFreeFilter($request));
  462.         $filters->add($this->getPropertyFilter($request));
  464.         if (!$request->request->get('manufacturer-filter', true)) {
  465.             $filters->remove('manufacturer');
  466.         }
  468.         if (!$request->request->get('price-filter', true)) {
  469.             $filters->remove('price');
  470.         }
  472.         if (!$request->request->get('rating-filter', true)) {
  473.             $filters->remove('rating');
  474.         }
  476.         if (!$request->request->get('shipping-free-filter', true)) {
  477.             $filters->remove('shipping-free');
  478.         }
  480.         if (!$request->request->get('property-filter', true)) {
  481.             $filters->remove('properties');
  483.             if (\count($propertyWhitelist = $request->request->all(self::PROPERTY_GROUP_IDS_REQUEST_PARAM))) {
  484.                 $filters->add($this->getPropertyFilter($request, $propertyWhitelist));
  485.             }
  486.         }
  488.         $event = new ProductListingCollectFilterEvent($request, $filters, $context);
  489.         $this->dispatcher->dispatch($event);
  491.         return $filters;
  492.     }
  494.     private function getManufacturerFilter(Request $request): Filter
  495.     {
  496.         $ids = $this->getManufacturerIds($request);
  498.         return new Filter(
  499.             'manufacturer',
  500.             !empty($ids),
  501.             [new EntityAggregation('manufacturer', 'product.manufacturerId', 'product_manufacturer')],
  502.             new EqualsAnyFilter('product.manufacturerId', $ids),
  503.             $ids
  504.         );
  505.     }
  507.     /**
  508.      * @param array<string>|null $groupIds
  509.      */
  510.     private function getPropertyFilter(Request $request, ?array $groupIds = null): Filter
  511.     {
  512.         $ids = $this->getPropertyIds($request);
  514.         $propertyAggregation = new TermsAggregation('properties', 'product.properties.id');
  516.         $optionAggregation = new TermsAggregation('options', 'product.options.id');
  518.         if ($groupIds) {
  519.             $propertyAggregation = new FilterAggregation(
  520.                 'properties-filter',
  521.                 $propertyAggregation,
  522.                 [new EqualsAnyFilter('product.properties.groupId', $groupIds)]
  523.             );
  525.             $optionAggregation = new FilterAggregation(
  526.                 'options-filter',
  527.                 $optionAggregation,
  528.                 [new EqualsAnyFilter('product.options.groupId', $groupIds)]
  529.             );
  530.         }
  532.         if (empty($ids)) {
  533.             return new Filter(
  534.                 'properties',
  535.                 false,
  536.                 [$propertyAggregation, $optionAggregation],
  537.                 new MultiFilter(MultiFilter::CONNECTION_OR, []),
  538.                 [],
  539.                 false
  540.             );
  541.         }
  543.         $grouped = $this->connection->fetchAllAssociative(
  544.             'SELECT LOWER(HEX(property_group_id)) as property_group_id, LOWER(HEX(id)) as id
  545.              FROM property_group_option
  546.              WHERE id IN (:ids)',
  547.             ['ids' => Uuid::fromHexToBytesList($ids)],
  548.             ['ids' => Connection::PARAM_STR_ARRAY]
  549.         );
  551.         $grouped = FetchModeHelper::group($grouped);
  553.         $filters = [];
  554.         foreach ($grouped as $options) {
  555.             $options = array_column($options, 'id');
  557.             $filters[] = new MultiFilter(
  558.                 MultiFilter::CONNECTION_OR,
  559.                 [
  560.                     new EqualsAnyFilter('product.optionIds', $options),
  561.                     new EqualsAnyFilter('product.propertyIds', $options),
  562.                 ]
  563.             );
  564.         }
  566.         return new Filter(
  567.             'properties',
  568.             true,
  569.             [$propertyAggregation, $optionAggregation],
  570.             new MultiFilter(MultiFilter::CONNECTION_AND, $filters),
  571.             $ids,
  572.             false
  573.         );
  574.     }
  576.     private function getPriceFilter(Request $request): Filter
  577.     {
  578.         $min = $request->get('min-price');
  579.         $max = $request->get('max-price');
  581.         $range = [];
  582.         if ($min !== null && $min >= 0) {
  583.             $range[RangeFilter::GTE] = $min;
  584.         }
  585.         if ($max !== null && $max >= 0) {
  586.             $range[RangeFilter::LTE] = $max;
  587.         }
  589.         return new Filter(
  590.             'price',
  591.             !empty($range),
  592.             [new StatsAggregation('price', 'product.cheapestPrice', true, true, false, false)],
  593.             new RangeFilter('product.cheapestPrice', $range),
  594.             [
  595.                 'min' => (float) $request->get('min-price'),
  596.                 'max' => (float) $request->get('max-price'),
  597.             ]
  598.         );
  599.     }
  601.     private function getRatingFilter(Request $request): Filter
  602.     {
  603.         $filtered = $request->get('rating');
  605.         return new Filter(
  606.             'rating',
  607.             $filtered !== null,
  608.             [
  609.                 new FilterAggregation(
  610.                     'rating-exists',
  611.                     new MaxAggregation('rating', 'product.ratingAverage'),
  612.                     [new RangeFilter('product.ratingAverage', [RangeFilter::GTE => 0])]
  613.                 ),
  614.             ],
  615.             new RangeFilter('product.ratingAverage', [
  616.                 RangeFilter::GTE => (int) $filtered,
  617.             ]),
  618.             $filtered
  619.         );
  620.     }
  622.     private function getShippingFreeFilter(Request $request): Filter
  623.     {
  624.         $filtered = (bool) $request->get('shipping-free', false);
  626.         return new Filter(
  627.             'shipping-free',
  628.             $filtered === true,
  629.             [
  630.                 new FilterAggregation(
  631.                     'shipping-free-filter',
  632.                     new MaxAggregation('shipping-free', 'product.shippingFree'),
  633.                     [new EqualsFilter('product.shippingFree', true)]
  634.                 ),
  635.             ],
  636.             new EqualsFilter('product.shippingFree', true),
  637.             $filtered
  638.         );
  639.     }
  640. }