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->get('no-aggregations') === true) {
  102.             $criteria->resetAggregations();
  103.         }
  105.         // switch all post filters to normal filters to reduce remaining aggregations
  106.         if ($request->get('reduce-aggregations')) {
  107.             foreach ($criteria->getPostFilters() as $filter) {
  108.                 $criteria->addFilter($filter);
  109.             }
  110.             $criteria->resetPostFilters();
  111.         }
  113.         if ($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);
  146.         $this->addCurrentFilters($event);
  148.         $currentSorting = $this->getCurrentSorting($event->getRequest());
  150.         $event->getResult()->setSorting($currentSorting);
  152.         $sortings = $this->sortingRegistry->getSortings();
  153.         /** @var BlogListingSorting $sorting */
  154.         foreach ($sortings as $sorting) {
  155.             $sorting->setActive($sorting->getKey() === $currentSorting);
  156.         }
  158.         $event->getResult()->setSortings($sortings);
  160.         $event->getResult()->setPage($this->getPage($event->getRequest()));
  162.         $event->getResult()->setLimit($this->getLimit($event->getRequest()));
  163.     }
  165.     /**
  166.      * @param Request $request
  167.      * @param Criteria $criteria
  168.      */
  169.     private function handleFilters(Request $request, Criteria $criteria): void
  170.     {
  171.         $this->handlePropertyFilter($request, $criteria);
  172.     }
  174.     /**
  175.      * @param Request $request
  176.      * @param Criteria $criteria
  177.      */
  178.     private function handlePagination(Request $request, Criteria $criteria): void
  179.     {
  180.         $limit = $this->getLimit($request);
  181.         $page = $this->getPage($request);
  183.         $criteria->setOffset(($page - 1) * $limit);
  184.         $criteria->setLimit($limit);
  185.         $criteria->setTotalCountMode(Criteria::TOTAL_COUNT_MODE_EXACT);
  186.     }
  188.     /**
  189.      * @param Request $request
  190.      * @param Criteria $criteria
  191.      */
  192.     private function handlePropertyFilter(Request $request, Criteria $criteria): void
  193.     {
  194.         $criteria->addAggregation(
  195.             new TermsAggregation('properties', 'h1webblog_blog.properties.id')
  196.         );
  197.         $criteria->addAggregation(
  198.             new TermsAggregation('options', 'h1webblog_blog.options.id')
  199.         );
  201.         $ids = $this->getPropertyIds($request);
  203.         if (empty($ids)) {
  204.             return;
  205.         }
  207.         $grouped = $this->connection->fetchAll(
  208.             'SELECT LOWER(HEX(property_group_id)) as property_group_id, LOWER(HEX(id)) as id FROM property_group_option WHERE id IN (:ids)',
  209.             ['ids' => Uuid::fromHexToBytesList($ids)],
  210.             ['ids' => Connection::PARAM_STR_ARRAY]
  211.         );
  213.         $grouped = FetchModeHelper::group($grouped);
  215.         foreach ($grouped as $options) {
  216.             $options = array_column($options, 'id');
  218.             $criteria->addPostFilter(
  219.                 new MultiFilter(
  220.                     MultiFilter::CONNECTION_OR,
  221.                     [
  222.                         new EqualsAnyFilter('h1webblog_blog.optionIds', $options),
  223.                         new EqualsAnyFilter('h1webblog_blog.propertyIds', $options),
  224.                     ]
  225.                 )
  226.             );
  227.         }
  228.     }
  230.     /**
  231.      * @param Request $request
  232.      * @param Criteria $criteria
  233.      * @param SalesChannelContext|null $context
  234.      */
  235.     private function handleSorting(Request $request, Criteria $criteria, SalesChannelContext $context = null): void
  236.     {
  237.         $currentSorting = $this->getCurrentSorting($request, $context);
  239.         if (!$currentSorting) {
  240.             return;
  241.         }
  243.         $sorting = $this->sortingRegistry->get(
  244.             $currentSorting
  245.         );
  247.         if (!$sorting) {
  248.             return;
  249.         }
  251.         foreach ($sorting->createDalSortings() as $fieldSorting) {
  252.             $criteria->addSorting($fieldSorting);
  253.         }
  254.     }
  256.     /**
  257.      * @param BlogListingResultEvent $event
  258.      * @return array
  259.      */
  260.     private function collectOptionIds(BlogListingResultEvent $event): array
  261.     {
  262.         $aggregations = $event->getResult()->getAggregations();
  264.         /** @var TermsResult|null $properties */
  265.         $properties = $aggregations->get('properties');
  267.         /** @var TermsResult|null $options */
  268.         $options = $aggregations->get('options');
  270.         $options = $options ? $options->getKeys() : [];
  271.         $properties = $properties ? $properties->getKeys() : [];
  273.         return array_unique(array_filter(array_merge($options, $properties)));
  274.     }
  276.     /**
  277.      * @param BlogListingResultEvent $event
  278.      */
  279.     private function groupOptionAggregations(BlogListingResultEvent $event): void
  280.     {
  281.         $ids = $this->collectOptionIds($event);
  283.         if (empty($ids)) {
  284.             return;
  285.         }
  287.         $criteria = new Criteria($ids);
  288.         $criteria->addAssociation('group');
  289.         $criteria->addAssociation('media');
  291.         $result = $this->optionRepository->search($criteria, $event->getContext());
  293.         /** @var PropertyGroupOptionCollection $options */
  294.         $options = $result->getEntities();
  296.         // group options by their property-group
  297.         $grouped = $options->groupByPropertyGroups();
  298.         $grouped->sortByConfig();
  300.         // remove id results to prevent wrong usages
  301.         $event->getResult()->getAggregations()->remove('properties');
  302.         $event->getResult()->getAggregations()->remove('configurators');
  303.         $event->getResult()->getAggregations()->remove('options');
  304.         $event->getResult()->getAggregations()->add(new EntityResult('properties', $grouped));
  305.     }
  307.     /**
  308.      * @param BlogListingResultEvent $event
  309.      */
  310.     private function addCurrentFilters(BlogListingResultEvent $event): void
  311.     {
  312.         $event->getResult()->addCurrentFilter('properties', $this->getPropertyIds($event->getRequest()));
  313.     }
  315.     /**
  316.      * @param Request $request
  317.      * @return string|null
  318.      */
  319.     private function getCurrentSorting(Request $request, SalesChannelContext $context = null): ?string
  320.     {
  321.         // @deprecated tag:v6.3.0 - use `order` instead
  322.         $sort = $request->get('sort', null);
  324.         if (is_string($sort) && !empty($sort)) {
  325.             $request->query->set('order', $sort);
  326.             $request->request->set('order', $sort);
  328.             $request->query->set('sort', null);
  329.             $request->request->set('sort', null);
  330.         }
  332.         $key = $request->get('order', $this->getDefaultSort($context));
  334.         if (!$key) {
  335.             return null;
  336.         }
  338.         if ($this->sortingRegistry->has($key)) {
  339.             return $key;
  340.         }
  342.         return $this->getDefaultSort($context);
  343.     }
  345.     /**
  346.      * @param Request $request
  347.      * @return array
  348.      */
  349.     private function getPropertyIds(Request $request): array
  350.     {
  351.         $ids = $request->query->get('properties', '');
  352.         if ($request->isMethod(Request::METHOD_POST)) {
  353.             $ids = $request->request->get('properties', '');
  354.         }
  356.         if (is_string($ids)) {
  357.             $ids = explode('|', $ids);
  358.         }
  360.         return array_filter($ids);
  361.     }
  363.     /**
  364.      * @param Request $request
  365.      * @return int
  366.      */
  367.     private function getLimit(Request $request): int
  368.     {
  369.         $default = $this->getDefaultPageSize();
  370.         $limit = $request->query->getInt('limit', $default);
  372.         if ($request->isMethod(Request::METHOD_POST)) {
  373.             $limit = $request->request->getInt('limit', $limit);
  374.         }
  376.         return $limit <= 0 ? $default : $limit;
  377.     }
  379.     /**
  380.      * @param Request $request
  381.      * @return int
  382.      */
  383.     private function getPage(Request $request): int
  384.     {
  385.         $page = $request->query->getInt('p', 1);
  387.         if ($request->isMethod(Request::METHOD_POST)) {
  388.             $page = $request->request->getInt('p', $page);
  389.         }
  391.         return $page <= 0 ? 1 : $page;
  392.     }
  394.     /**
  395.      * @param SalesChannelContext|null $context
  396.      * @return string|null
  397.      */
  398.     public function getDefaultSort(SalesChannelContext $context = null): ?string
  399.     {
  400.         if ($this->defaultSort === null) {
  401.             $salesChannelId = $context ? $context->getSalesChannel()->getId() : null;
  402.             $this->defaultSort = $this->configService->get('H1webBlog.config.blogDefaultSortOrder', $salesChannelId) ?: static::DEFAULT_SORT;
  403.         }
  405.         return $this->defaultSort;
  406.     }
  408.     /**
  409.      * @param SalesChannelContext|null $context
  410.      * @return int|null
  411.      */
  412.     public function getDefaultPageSize(SalesChannelContext $context = null): ?int
  413.     {
  414.         if ($this->defaultPagesize === null) {
  415.             $salesChannelId = $context ? $context->getSalesChannel()->getId() : null;
  416.             $this->defaultPagesize = $this->configService->getInt('H1webBlog.config.blogDefaultPostsPerPage', $salesChannelId) ?: static::DEFAULT_POSTS_PER_PAGE;
  417.         }
  419.         return $this->defaultPagesize;
  420.     }
  421. }