custom/plugins/MaxiaVariantsTable6/src/Storefront/Subscriber/VariantsTableFilterSubscriber.php line 76

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. namespace Maxia\MaxiaVariantsTable6\Storefront\Subscriber;
  5. use Doctrine\DBAL\Connection;
  6. use Maxia\MaxiaVariantsTable6\Core\Content\VariantsTable\Column\DataMapping\ProductOptionMapping;
  7. use Maxia\MaxiaVariantsTable6\Core\Content\VariantsTable\Column\DataMapping\ProductOptionsMapping;
  8. use Maxia\MaxiaVariantsTable6\Core\Content\VariantsTable\Column\DataMapping\ProductPropertiesMapping;
  9. use Maxia\MaxiaVariantsTable6\Core\Content\VariantsTable\Column\DataMapping\ProductPropertyMapping;
  10. use Maxia\MaxiaVariantsTable6\Core\Content\VariantsTable\Events\VariantsTableCollectFilterEvent;
  11. use Maxia\MaxiaVariantsTable6\Core\Content\VariantsTable\Events\VariantsTableSearchCriteriaEvent;
  12. use Maxia\MaxiaVariantsTable6\Core\Content\VariantsTable\VariantsTableEntity;
  13. use Maxia\MaxiaVariantsTable6\Storefront\Pagelet\VariantsTable\Events\VariantsTablePageletLoadedEvent;
  14. use Maxia\MaxiaVariantsTable6\Storefront\Pagelet\VariantsTable\VariantsTablePagelet;
  15. use Shopware\Core\Content\Product\ProductEntity;
  16. use Shopware\Core\Content\Product\SalesChannel\Listing\Filter;
  17. use Shopware\Core\Content\Product\SalesChannel\Listing\FilterCollection;
  18. use Shopware\Core\Content\Product\SalesChannel\Listing\ProductListingFeaturesSubscriber;
  19. use Shopware\Core\Content\Property\Aggregate\PropertyGroupOption\PropertyGroupOptionCollection;
  20. use Shopware\Core\Content\Property\Aggregate\PropertyGroupOption\PropertyGroupOptionEntity;
  21. use Shopware\Core\Content\Property\PropertyGroupEntity;
  22. use Shopware\Core\Framework\DataAbstractionLayer\Dbal\Common\RepositoryIterator;
  23. use Shopware\Core\Framework\DataAbstractionLayer\Doctrine\FetchModeHelper;
  24. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepositoryInterface;
  25. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Bucket\FilterAggregation;
  26. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Bucket\TermsAggregation;
  27. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\MaxAggregation;
  28. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\MinAggregation;
  29. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Bucket\TermsResult;
  30. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Metric\EntityResult;
  31. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  32. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsAnyFilter;
  33. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  34. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\MultiFilter;
  35. use Shopware\Core\Framework\DataAbstractionLayer\Search\Sorting\FieldSorting;
  36. use Shopware\Core\Framework\Uuid\Uuid;
  37. use Shopware\Core\PlatformRequest;
  38. use Shopware\Core\System\SalesChannel\SalesChannelContext;
  39. use Shopware\Core\System\SystemConfig\SystemConfigService;
  40. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  41. use Symfony\Component\HttpFoundation\Request;
  42. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  44. /**
  45.  * Extends the search criteria and loads filter values
  46.  *
  47.  * @package Maxia\MaxiaVariantsTable6\Subscriber
  48.  */
  49. class VariantsTableFilterSubscriber implements EventSubscriberInterface
  50. {
  51.     public static function getSubscribedEvents(): array
  52.     {
  53.         return [
  54.             VariantsTableSearchCriteriaEvent::class => 'handleSearchCriteria',
  55.             VariantsTablePageletLoadedEvent::class => 'handleResult'
  56.         ];
  57.     }
  59.     private SystemConfigService $systemConfig;
  60.     private EntityRepositoryInterface $optionRepository;
  61.     private Connection $connection;
  62.     private EventDispatcherInterface $dispatcher;
  64.     public function __construct(
  65.         SystemConfigService $systemConfig,
  66.         EntityRepositoryInterface $optionRepository,
  67.         Connection $connection,
  68.         EventDispatcherInterface $dispatcher)
  69.     {
  70.         $this->systemConfig = $systemConfig;
  71.         $this->optionRepository = $optionRepository;
  72.         $this->connection = $connection;
  73.         $this->dispatcher = $dispatcher;
  74.     }
  76.     public function handleSearchCriteria(VariantsTableSearchCriteriaEvent $event): void
  77.     {
  78.         $request = $event->getRequest();
  79.         $criteria = $event->getCriteria();
  80.         $context = $event->getSalesChannelContext();
  82.         $criteria->addAssociation('options');
  84.         $this->handleFilters($request, $event->getVariantsTableEntity(), $criteria, $context);
  85.     }
  87.     public function handleResult(VariantsTablePageletLoadedEvent $event): void
  88.     {
  89.         if (!$event->getPagelet()->getConfig()->isShowFilters()) {
  90.             return;
  91.         }
  93.         $this->addCurrentFilters($event);
  95.         if ($event->getRequest()->attributes->get('_route') === 'frontend.plugins.maxia-variants-table.ajax') {
  96.             return;
  97.         }
  99.         $this->groupOptionAggregations($event);
  100.     }
  102.     private function handleFilters(Request $request, VariantsTableEntity $variantsTable, Criteria $criteria, SalesChannelContext $context): void
  103.     {
  104.         $filters = $this->getFilters($request, $variantsTable, $context);
  106.         $aggregations = $this->getAggregations($request, $filters);
  108.         foreach ($aggregations as $aggregation) {
  109.             $criteria->addAggregation($aggregation);
  110.         }
  112.         foreach ($filters as $filter) {
  113.             if ($filter->isFiltered()) {
  114.                 $criteria->addFilter($filter->getFilter());
  115.             }
  116.         }
  118.         $criteria->addExtension('filters', $filters);
  119.     }
  121.     private function getAggregations(Request $request, FilterCollection $filters): array
  122.     {
  123.         $aggregations = [];
  125.         if ($request->get('reduce-aggregations') === null) {
  126.             foreach ($filters as $filter) {
  127.                 $aggregations = array_merge($aggregations, $filter->getAggregations());
  128.             }
  130.             return $aggregations;
  131.         }
  133.         foreach ($filters as $filter) {
  134.             $excluded = $filters->filtered();
  136.             if ($filter->exclude()) {
  137.                 $excluded = $excluded->blacklist($filter->getName());
  138.             }
  140.             foreach ($filter->getAggregations() as $aggregation) {
  141.                 if ($aggregation instanceof FilterAggregation) {
  142.                     $aggregation->addFilters($excluded->getFilters());
  144.                     $aggregations[] = $aggregation;
  146.                     continue;
  147.                 }
  149.                 $aggregation = new FilterAggregation(
  150.                     $aggregation->getName(),
  151.                     $aggregation,
  152.                     $excluded->getFilters()
  153.                 );
  155.                 $aggregations[] = $aggregation;
  156.             }
  157.         }
  159.         return $aggregations;
  160.     }
  162.     private function collectOptionIds(VariantsTablePageletLoadedEvent $event): array
  163.     {
  164.         $aggregations = $event->getPagelet()->getSearchResult()->getAggregations();
  166.         /** @var TermsResult|null $properties */
  167.         $properties = $aggregations->get('properties');
  169.         /** @var TermsResult|null $options */
  170.         $options = $aggregations->get('options');
  172.         $options = $options ? $options->getKeys() : [];
  173.         $properties = $properties ? $properties->getKeys() : [];
  175.         return array_unique(array_filter(array_merge($options, $properties)));
  176.     }
  178.     /**
  179.      * Returns option IDs mapped by property_group IDs for all variant options of the product.
  180.      *
  181.      * @param ProductEntity $parentProduct
  182.      * @return array
  183.      * @throws \Doctrine\DBAL\Exception
  184.      */
  185.     private function getVariantPropertyIds(ProductEntity $parentProduct)
  186.     {
  187.         $results = $this->connection->fetchAllAssociative("
  188.             SELECT 
  189.                 `property`.property_group_id, `property`.id
  190.             FROM 
  191.                 `product`
  192.             LEFT JOIN 
  193.                 `product_option` AS `option` ON `option`.product_id = `product`.id
  194.             LEFT JOIN 
  195.                 `property_group_option` `property` ON `property`.id = `option`.property_group_option_id
  196.             WHERE 
  197.                 `product`.parent_id = :parentId
  198.                 AND `option`.product_version_id = :versionId
  199.             GROUP BY `property`.id
  200.         ",
  201.             [
  202.                 'parentId' => Uuid::fromHexToBytes($parentProduct->getId()),
  203.                 'versionId' => Uuid::fromHexToBytes($parentProduct->getVersionId())
  204.             ],
  205.         );
  207.         $options = [];
  209.         foreach ($results as $result) {
  210.             $groupId = Uuid::fromBytesToHex($result['property_group_id']);
  211.             $optionId = Uuid::fromBytesToHex($result['id']);
  213.             if (!isset($options[$groupId])) {
  214.                 $options[$groupId] = [];
  215.             }
  217.             $options[$groupId][] = $optionId;
  218.         }
  220.         return $options;
  221.     }
  223.     private function groupOptionAggregations(VariantsTablePageletLoadedEvent $event): void
  224.     {
  225.         $ids = $this->collectOptionIds($event);
  227.         if (empty($ids)) {
  228.             return;
  229.         }
  231.         $criteria = new Criteria($ids);
  232.         $criteria->setLimit(500);
  233.         $criteria->addAssociation('group');
  234.         $criteria->addAssociation('media');
  235.         $criteria->setTitle('product-listing::property-filter');
  236.         $criteria->addSorting(new FieldSorting('id', FieldSorting::ASCENDING));
  238.         $filterGroupIds = $this->getFilterablePropertyGroupIds($event->getPagelet());
  240.         if ($filterGroupIds) {
  241.             $criteria->addFilter(new EqualsAnyFilter('group.id', $filterGroupIds));
  242.         }
  244.         $mergedOptions = new PropertyGroupOptionCollection();
  246.         $repositoryIterator = new RepositoryIterator($this->optionRepository, $event->getContext(), $criteria);
  247.         while (($result = $repositoryIterator->fetch()) !== null) {
  248.             $mergedOptions->merge($result->getEntities());
  249.         }
  251.         // filter out options that are not associated with any variant, if setting 'mergeVariantOptions' is disabled
  252.         $filterConfig = $event->getPagelet()->getConfig()->getFilterConfig();
  254.         if ($filterConfig && isset($filterConfig['mergeVariantOptions']) && !$filterConfig['mergeVariantOptions']) {
  255.             $variantOptions = $this->getVariantPropertyIds($event->getPagelet()->getParentProduct());
  257.             $mergedOptions = $mergedOptions->filter(function (PropertyGroupOptionEntity $property) use ($variantOptions) {
  258.                 if (!isset($variantOptions[$property->getGroupId()])) {
  259.                     return false;
  260.                 }
  262.                 return in_array($property->getId(), $variantOptions[$property->getGroupId()]);
  263.             });
  264.         }
  266.         // group options by their property-group
  267.         $grouped = $mergedOptions->groupByPropertyGroups();
  268.         $grouped->sortByPositions();
  269.         $grouped->sortByConfig();
  271.         $aggregations = $event->getPagelet()->getSearchResult()->getAggregations();
  273.         // remove id results to prevent wrong usages
  274.         $aggregations->remove('properties');
  275.         $aggregations->remove('configurators');
  276.         $aggregations->remove('options');
  277.         $aggregations->add(new EntityResult('properties', $grouped));
  278.     }
  280.     private function addCurrentFilters(VariantsTablePageletLoadedEvent $event): void
  281.     {
  282.         $result = $event->getPagelet()->getSearchResult();
  284.         $filters = $result->getCriteria()->getExtension('filters');
  285.         if (!$filters instanceof FilterCollection) {
  286.             return;
  287.         }
  289.         foreach ($filters as $filter) {
  290.             $event->getPagelet()->getSearchResult()->addCurrentFilter($filter->getName(), $filter->getValues());
  291.         }
  292.     }
  294.     private function getPropertyIdsFromRequest(Request $request): array
  295.     {
  296.         $ids = $request->query->get('properties', '');
  297.         if ($request->isMethod(Request::METHOD_POST)) {
  298.             $ids = $request->request->get('properties', '');
  299.         }
  301.         if (\is_string($ids)) {
  302.             $ids = explode('|', $ids);
  303.         }
  305.         return array_filter((array) $ids);
  306.     }
  308.     protected function getFilters(Request $request, VariantsTableEntity $variantsTable, SalesChannelContext $context): FilterCollection
  309.     {
  310.         $filters = new FilterCollection();
  312.         $filters->add($this->getAvailableFilter($request, $variantsTable));
  314.         if ($variantsTable->isShowFilters()) {
  315.             $filters->add($this->getPropertyFilter($request));
  317.             if (!$request->request->get('available-filter', true)) {
  318.                 $filters->remove('available-free');
  319.             }
  321.             if (!$request->request->get('property-filter', true)) {
  322.                 $filters->remove('properties');
  324.                 if (\count($propertyWhitelist = $request->request->all(ProductListingFeaturesSubscriber::PROPERTY_GROUP_IDS_REQUEST_PARAM))) {
  325.                     $filters->add($this->getPropertyFilter($request, $propertyWhitelist));
  326.                 }
  327.             }
  328.         }
  330.         $event = new VariantsTableCollectFilterEvent($request, $filters, $context);
  331.         $this->dispatcher->dispatch($event);
  333.         return $filters;
  334.     }
  336.     protected function getPropertyFilter(Request $request, ?array $groupIds = null): Filter
  337.     {
  338.         $ids = $this->getPropertyIdsFromRequest($request);
  340.         $propertyAggregation = new TermsAggregation('properties', 'product.properties.id');
  342.         $optionAggregation = new TermsAggregation('options', 'product.options.id');
  344.         if ($groupIds) {
  345.             $optionAggregation = new FilterAggregation(
  346.                 'options-filter',
  347.                 $optionAggregation,
  348.                 [new EqualsAnyFilter('product.options.groupId', $groupIds)]
  349.             );
  351.             $propertyAggregation = new FilterAggregation(
  352.                 'properties-filter',
  353.                 $propertyAggregation,
  354.                 [new EqualsAnyFilter('product.properties.groupId', $groupIds)]
  355.             );
  356.         }
  358.         if (empty($ids)) {
  359.             return new Filter(
  360.                 'properties',
  361.                 false,
  362.                 [$propertyAggregation, $optionAggregation],
  363.                 new MultiFilter(MultiFilter::CONNECTION_OR, []),
  364.                 [],
  365.                 false
  366.             );
  367.         }
  369.         $grouped = $this->connection->fetchAll(
  370.             'SELECT LOWER(HEX(property_group_id)) as property_group_id, LOWER(HEX(id)) as id
  371.              FROM property_group_option
  372.              WHERE id IN (:ids)',
  373.             ['ids' => Uuid::fromHexToBytesList($ids)],
  374.             ['ids' => Connection::PARAM_STR_ARRAY]
  375.         );
  377.         $grouped = FetchModeHelper::group($grouped);
  379.         $filters = [];
  380.         foreach ($grouped as $options) {
  381.             $options = array_column($options, 'id');
  383.             $filters[] = new MultiFilter(
  384.                 MultiFilter::CONNECTION_OR,
  385.                 [
  386.                     new EqualsAnyFilter('product.optionIds', $options),
  387.                     new EqualsAnyFilter('product.propertyIds', $options),
  388.                 ]
  389.             );
  390.         }
  392.         return new Filter(
  393.             'properties',
  394.             true,
  395.             [$propertyAggregation, $optionAggregation],
  396.             new MultiFilter(MultiFilter::CONNECTION_AND, $filters),
  397.             $ids,
  398.             false
  399.         );
  400.     }
  402.     protected function getAvailableFilter(Request $request, VariantsTableEntity $variantsTableEntity): Filter
  403.     {
  404.         /** @var SalesChannelContext $context */
  405.         $salesChannelContext = $request->get(PlatformRequest::ATTRIBUTE_SALES_CHANNEL_CONTEXT_OBJECT);
  407.         $availableField = 'product.available';
  409.         if ($this->systemConfig->get('DvsnStoreStock.config.status', $salesChannelContext->getSalesChannelId())) {
  410.             $translated = $salesChannelContext->getSalesChannel()->getTranslated();
  412.             if (isset($translated['customFields'])
  413.                 && isset($translated['customFields']['dvsn_store_stock_sales_channel_status'])
  414.                 && $translated['customFields']['dvsn_store_stock_sales_channel_status'])
  415.             {
  416.                 $storeId = $translated['customFields']['dvsn_store_stock_sales_channel_status_store'];
  417.                 $availableField = 'customFields.dvsn_store_stock."' . $storeId . '".available';
  418.             }
  419.         }
  421.         return $this->createAvailableFilter($request, $variantsTableEntity, $availableField);
  422.     }
  424.     /**
  425.      * Creates the show or hide unavailable products filter, depending on the plugin setting "isShowUnavailable"
  426.      *
  427.      * @param Request $request
  428.      * @param VariantsTableEntity $variantsTableEntity
  429.      * @param string $field
  430.      * @return Filter
  431.      */
  432.     protected function createAvailableFilter(
  433.         Request $request,
  434.         VariantsTableEntity $variantsTableEntity,
  435.         string $field = 'product.available'
  436.     ) {
  437.         $checked = (bool) $request->get('available', false);
  439.         if ($variantsTableEntity->isShowUnavailable()) {
  440.             return new Filter(
  441.                 'available',
  442.                 $checked,
  443.                 [
  444.                     new FilterAggregation(
  445.                         'available-filter',
  446.                         new MaxAggregation('available', $field),
  447.                         [new EqualsFilter($field, true)]
  448.                     ),
  449.                 ],
  450.                 new EqualsFilter($field, true),
  451.                 $checked
  452.             );
  454.         } else {
  455.             return new Filter(
  456.                 'available',
  457.                 !$checked,
  458.                 [
  459.                     new FilterAggregation(
  460.                         'available-filter',
  461.                         new MinAggregation('available', $field),
  462.                         [new EqualsFilter($field, false)]
  463.                     ),
  464.                 ],
  465.                 new EqualsFilter($field, true),
  466.                 $checked
  467.             );
  468.         }
  469.     }
  471.     /**
  472.      * Returns filterable property group ids by reading the filter config
  473.      *
  474.      * @param VariantsTablePagelet $pagelet
  475.      * @return array
  476.      */
  477.     protected function getFilterablePropertyGroupIds(VariantsTablePagelet $pagelet)
  478.     {
  479.         $filterGroupIds = [];
  480.         $filterConfig = $pagelet->getConfig()->getFilterConfig();
  482.         if ($filterConfig['displayMode'] === 'selected-properties') {
  483.             if ($filterConfig['selectedProperties']) {
  484.                 $filterGroupIds = $filterConfig['selectedProperties'];
  485.             } else {
  486.                 $filterConfig['displayMode'] = 'auto';
  487.                 $pagelet->getConfig()->setFilterConfig($filterConfig);
  488.             }
  489.         }
  491.         if ($filterConfig['displayMode'] === 'auto') {
  492.             $filterGroupIds = $this->getPropertyGroupIdsFromTableColumns($pagelet);
  494.             if (!$filterGroupIds) {
  495.                 $filterConfig['displayMode'] = 'all';
  496.                 $pagelet->getConfig()->setFilterConfig($filterConfig);
  497.             }
  498.         }
  500.         return $filterGroupIds;
  501.     }
  503.     /**
  504.      * Returns property group ids for all columns in the table
  505.      *
  506.      * @param VariantsTablePagelet $pagelet
  507.      * @return array
  508.      */
  509.     protected function getPropertyGroupIdsFromTableColumns(VariantsTablePagelet $pagelet)
  510.     {
  511.         $groupIds = [];
  513.         foreach ($pagelet->getConfig()->getColumns() as $column) {
  514.             if ($column->getDataMappingClass() === ProductOptionMapping::class) {
  515.                 if ($column->getConfig() && $column->getConfig()['groupId']) {
  516.                     $groupIds[] = $column->getConfig()['groupId'];
  517.                 }
  519.             } else if ($column->getDataMappingClass() == ProductPropertyMapping::class) {
  520.                 if ($column->getConfig() && $column->getConfig()['propertyGroupId']) {
  521.                     $groupIds[] = $column->getConfig()['propertyGroupId'];
  522.                 }
  524.             } else if ($column->getDataMappingClass() === ProductOptionsMapping::class) {
  525.                 $ids = $pagelet->getParentProduct()->getOptions()->map(function (PropertyGroupOptionEntity $entity) {
  526.                     return $entity->getGroupId();
  527.                 });
  529.                 $groupIds = array_merge($groupIds, array_unique($ids));
  531.             } else if ($column->getDataMappingClass() === ProductPropertiesMapping::class) {
  532.                 $ids = $pagelet->getParentProduct()->getSortedProperties()->map(function (PropertyGroupEntity $entity) {
  533.                     return $entity->getId();
  534.                 });
  536.                 $groupIds = array_merge($groupIds, array_unique($ids));
  537.             }
  538.         }
  540.         return array_unique($groupIds);
  541.     }
  542. }