vendor/store.shopware.com/h1webblog/src/Blog/Listing/BlogListingFeaturesSubscriber.php line 96

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. namespace H1web\Blog\Blog\Listing;
  5. use Doctrine\DBAL\Connection;
  6. use H1web\Blog\Blog\Events\BlogListingCriteriaEvent;
  7. use H1web\Blog\Blog\Events\BlogListingResultEvent;
  8. use Shopware\Core\Content\Property\Aggregate\PropertyGroupOption\PropertyGroupOptionCollection;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Doctrine\FetchModeHelper;
  10. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepositoryInterface;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Bucket\TermsAggregation;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Bucket\TermsResult;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Search\AggregationResult\Metric\EntityResult;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsAnyFilter;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\MultiFilter;
  17. use Shopware\Core\Framework\Uuid\Uuid;
  18. use Shopware\Core\System\SalesChannel\SalesChannelContext;
  19. use Shopware\Core\System\SystemConfig\SystemConfigService;
  20. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  21. use Symfony\Component\HttpFoundation\Request;
  23. class BlogListingFeaturesSubscriber implements EventSubscriberInterface
  24. {
  25.     public const DEFAULT_SORT = 'publishedAt--desc';
  26.     public const DEFAULT_SEARCH_SORT = 'score';
  28.     public const DEFAULT_POSTS_PER_PAGE = 24;
  30.     /**
  31.      * @var EntityRepositoryInterface
  32.      */
  33.     private $optionRepository;
  35.     /**
  36.      * @var BlogListingSortingRegistry
  37.      */
  38.     private $sortingRegistry;
  40.     /**
  41.      * @var Connection
  42.      */
  43.     private $connection;
  45.     /**
  46.      * @var SystemConfigService
  47.      */
  48.     private $configService;
  50.     /**
  51.      * @var string
  52.      */
  53.     private $defaultSort;
  55.     /**
  56.      * @var int
  57.      */
  58.     private $defaultPagesize;
  60.     /**
  61.      * BlogListingFeaturesSubscriber constructor.
  62.      * @param Connection $connection
  63.      * @param EntityRepositoryInterface $optionRepository
  64.      * @param BlogListingSortingRegistry $sortingRegistry
  65.      */
  66.     public function __construct(
  67.         Connection $connection,
  68.         EntityRepositoryInterface $optionRepository,
  69.         BlogListingSortingRegistry $sortingRegistry,
  70.         SystemConfigService $configService
  71.     )
  72.     {
  73.         $this->optionRepository = $optionRepository;
  74.         $this->connection = $connection;
  75.         $this->sortingRegistry = $sortingRegistry;
  76.         $this->configService = $configService;
  77.     }
  79.     /**
  80.      * @return array
  81.      */
  82.     public static function getSubscribedEvents()
  83.     {
  84.         return [
  85.             BlogListingCriteriaEvent::class => [
  86.                 ['handleListingRequest', 100],
  87.                 ['switchFilter', -100],
  88.             ],
  89.             BlogListingResultEvent::class => 'handleResult',
  90.         ];
  91.     }
  93.     /**
  94.      * @param BlogListingCriteriaEvent $event
  95.      */
  96.     public function switchFilter(BlogListingCriteriaEvent $event): void
  97.     {
  98.         $request = $event->getRequest();
  99.         $criteria = $event->getCriteria();
  101.         if ($request->request->get('no-aggregations') === true) {
  102.             $criteria->resetAggregations();
  103.         }
  105.         // switch all post filters to normal filters to reduce remaining aggregations
  106.         if ($request->request->get('reduce-aggregations')) {
  107.             foreach ($criteria->getPostFilters() as $filter) {
  108.                 $criteria->addFilter($filter);
  109.             }
  110.             $criteria->resetPostFilters();
  111.         }
  113.         if ($request->request->get('only-aggregations') === true) {
  114.             // set limit to zero to fetch no blogs.
  115.             $criteria->setLimit(0);
  117.             // no total count required
  118.             $criteria->setTotalCountMode(Criteria::TOTAL_COUNT_MODE_NONE);
  120.             // sorting and association are only required for the blog data
  121.             $criteria->resetSorting();
  122.             $criteria->resetAssociations();
  123.         }
  124.     }
  126.     /**
  127.      * @param BlogListingCriteriaEvent $event
  128.      */
  129.     public function handleListingRequest(BlogListingCriteriaEvent $event): void
  130.     {
  131.         $request = $event->getRequest();
  132.         $criteria = $event->getCriteria();
  134.         $this->handlePagination($request, $criteria);
  135.         $this->handleFilters($request, $criteria);
  136.         $this->handleSorting($request, $criteria, $event->getSalesChannelContext());
  137.     }
  139.     /**
  140.      * @param BlogListingResultEvent $event
  141.      */
  142.     public function handleResult(BlogListingResultEvent $event): void
  143.     {
  144.         $this->groupOptionAggregations($event);
  145.         $event->getResult()->setPage($this->getPage($event->getRequest()));
  146.         $event->getResult()->setLimit($this->getLimit($event->getRequest()));
  147.     }
  149.     /**
  150.      * @param Request $request
  151.      * @param Criteria $criteria
  152.      */
  153.     private function handleFilters(Request $request, Criteria $criteria): void
  154.     {
  155.         $this->handlePropertyFilter($request, $criteria);
  156.     }
  158.     /**
  159.      * @param Request $request
  160.      * @param Criteria $criteria
  161.      */
  162.     private function handlePagination(Request $request, Criteria $criteria): void
  163.     {
  164.         $limit = $this->getLimit($request);
  165.         $page = $this->getPage($request);
  167.         $criteria->setOffset(($page - 1) * $limit);
  168.         $criteria->setLimit($limit);
  169.         $criteria->setTotalCountMode(Criteria::TOTAL_COUNT_MODE_EXACT);
  170.     }
  172.     /**
  173.      * @param Request $request
  174.      * @param Criteria $criteria
  175.      */
  176.     private function handlePropertyFilter(Request $request, Criteria $criteria): void
  177.     {
  178.         $criteria->addAggregation(
  179.             new TermsAggregation('properties', 'h1webblog_blog.properties.id')
  180.         );
  181.         $criteria->addAggregation(
  182.             new TermsAggregation('options', 'h1webblog_blog.options.id')
  183.         );
  185.         $ids = $this->getPropertyIds($request);
  187.         if (empty($ids)) {
  188.             return;
  189.         }
  191.         $grouped = $this->connection->fetchAll(
  192.             'SELECT LOWER(HEX(property_group_id)) as property_group_id, LOWER(HEX(id)) as id FROM property_group_option WHERE id IN (:ids)',
  193.             ['ids' => Uuid::fromHexToBytesList($ids)],
  194.             ['ids' => Connection::PARAM_STR_ARRAY]
  195.         );
  197.         $grouped = FetchModeHelper::group($grouped);
  199.         foreach ($grouped as $options) {
  200.             $options = array_column($options, 'id');
  202.             $criteria->addPostFilter(
  203.                 new MultiFilter(
  204.                     MultiFilter::CONNECTION_OR,
  205.                     [
  206.                         new EqualsAnyFilter('h1webblog_blog.optionIds', $options),
  207.                         new EqualsAnyFilter('h1webblog_blog.propertyIds', $options),
  208.                     ]
  209.                 )
  210.             );
  211.         }
  212.     }
  214.     /**
  215.      * @param Request $request
  216.      * @param Criteria $criteria
  217.      * @param SalesChannelContext|null $context
  218.      */
  219.     private function handleSorting(Request $request, Criteria $criteria, SalesChannelContext $context = null): void
  220.     {
  221.         $currentSorting = $this->getCurrentSorting($request, $context);
  223.         if (!$currentSorting) {
  224.             return;
  225.         }
  227.         $sorting = $this->sortingRegistry->get(
  228.             $currentSorting
  229.         );
  231.         if (!$sorting) {
  232.             return;
  233.         }
  235.         foreach ($sorting->createDalSortings() as $fieldSorting) {
  236.             $criteria->addSorting($fieldSorting);
  237.         }
  238.     }
  240.     /**
  241.      * @param BlogListingResultEvent $event
  242.      * @return array
  243.      */
  244.     private function collectOptionIds(BlogListingResultEvent $event): array
  245.     {
  246.         $aggregations = $event->getResult()->getAggregations();
  248.         /** @var TermsResult|null $properties */
  249.         $properties = $aggregations->get('properties');
  251.         /** @var TermsResult|null $options */
  252.         $options = $aggregations->get('options');
  254.         $options = $options ? $options->getKeys() : [];
  255.         $properties = $properties ? $properties->getKeys() : [];
  257.         return array_unique(array_filter(array_merge($options, $properties)));
  258.     }
  260.     /**
  261.      * @param BlogListingResultEvent $event
  262.      */
  263.     private function groupOptionAggregations(BlogListingResultEvent $event): void
  264.     {
  265.         $ids = $this->collectOptionIds($event);
  267.         if (empty($ids)) {
  268.             return;
  269.         }
  271.         $criteria = new Criteria($ids);
  272.         $criteria->addAssociation('group');
  273.         $criteria->addAssociation('media');
  275.         $result = $this->optionRepository->search($criteria, $event->getContext());
  277.         /** @var PropertyGroupOptionCollection $options */
  278.         $options = $result->getEntities();
  280.         // group options by their property-group
  281.         $grouped = $options->groupByPropertyGroups();
  282.         $grouped->sortByConfig();
  284.         // remove id results to prevent wrong usages
  285.         $event->getResult()->getAggregations()->remove('properties');
  286.         $event->getResult()->getAggregations()->remove('configurators');
  287.         $event->getResult()->getAggregations()->remove('options');
  288.         $event->getResult()->getAggregations()->add(new EntityResult('properties', $grouped));
  289.     }
  292.     /**
  293.      * @param Request $request
  294.      * @return string|null
  295.      */
  296.     private function getCurrentSorting(Request $request, SalesChannelContext $context = null): ?string
  297.     {
  298.         // @deprecated tag:v6.3.0 - use `order` instead
  299.         $sort = $request->request->get('sort', null);
  301.         if (is_string($sort) && !empty($sort)) {
  302.             $request->query->set('order', $sort);
  303.             $request->request->set('order', $sort);
  305.             $request->query->set('sort', null);
  306.             $request->request->set('sort', null);
  307.         }
  309.         $key = $request->request->get('order', $this->getDefaultSort($context));
  311.         if (!$key) {
  312.             return null;
  313.         }
  315.         if ($this->sortingRegistry->has($key)) {
  316.             return $key;
  317.         }
  319.         return $this->getDefaultSort($context);
  320.     }
  322.     /**
  323.      * @param Request $request
  324.      * @return array
  325.      */
  326.     private function getPropertyIds(Request $request): array
  327.     {
  328.         $ids = $request->query->get('properties', '');
  329.         if ($request->isMethod(Request::METHOD_POST)) {
  330.             $ids = $request->request->get('properties', '');
  331.         }
  333.         if (is_string($ids)) {
  334.             $ids = explode('|', $ids);
  335.         }
  337.         return array_filter($ids);
  338.     }
  340.     /**
  341.      * @param Request $request
  342.      * @return int
  343.      */
  344.     private function getLimit(Request $request): int
  345.     {
  346.         $default = $this->getDefaultPageSize();
  347.         $limit = $request->query->getInt('limit', $default);
  349.         if ($request->isMethod(Request::METHOD_POST)) {
  350.             $limit = $request->request->getInt('limit', $limit);
  351.         }
  353.         return $limit <= 0 ? $default : $limit;
  354.     }
  356.     /**
  357.      * @param Request $request
  358.      * @return int
  359.      */
  360.     private function getPage(Request $request): int
  361.     {
  362.         $page = $request->query->getInt('p', 1);
  364.         if ($request->isMethod(Request::METHOD_POST)) {
  365.             $page = $request->request->getInt('p', $page);
  366.         }
  368.         return $page <= 0 ? 1 : $page;
  369.     }
  371.     /**
  372.      * @param SalesChannelContext|null $context
  373.      * @return string|null
  374.      */
  375.     public function getDefaultSort(SalesChannelContext $context = null): ?string
  376.     {
  377.         if ($this->defaultSort === null) {
  378.             $salesChannelId = $context ? $context->getSalesChannel()->getId() : null;
  379.             $this->defaultSort = $this->configService->get('H1webBlog.config.blogDefaultSortOrder', $salesChannelId) ?: static::DEFAULT_SORT;
  380.         }
  382.         return $this->defaultSort;
  383.     }
  385.     /**
  386.      * @param SalesChannelContext|null $context
  387.      * @return int|null
  388.      */
  389.     public function getDefaultPageSize(SalesChannelContext $context = null): ?int
  390.     {
  391.         if ($this->defaultPagesize === null) {
  392.             $salesChannelId = $context ? $context->getSalesChannel()->getId() : null;
  393.             $this->defaultPagesize = $this->configService->getInt('H1webBlog.config.blogDefaultPostsPerPage', $salesChannelId) ?: static::DEFAULT_POSTS_PER_PAGE;
  394.         }
  396.         return $this->defaultPagesize;
  397.     }
  398. }