custom/plugins/NetzpBlog6/src/Resolver/BlogElementResolver.php line 176

  1. <?php
  2. namespace NetzpBlog6\Resolver;
  4. use NetzpBlog6\Controller\StoreApi\BlogListing\AbstractBlogListingRoute;
  5. use Shopware\Core\Content\Cms\Aggregate\CmsSlot\CmsSlotEntity;
  6. use Shopware\Core\Content\Cms\DataResolver\CriteriaCollection;
  7. use Shopware\Core\Content\Cms\DataResolver\Element\AbstractCmsElementResolver;
  8. use Shopware\Core\Content\Cms\DataResolver\Element\ElementDataCollection;
  9. use Shopware\Core\Content\Cms\DataResolver\ResolverContext\ResolverContext;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Metric\EntityAggregation;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsAnyFilter;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\MultiFilter;
  15. use Shopware\Core\Framework\Struct\ArrayEntity;
  16. use Shopware\Core\Framework\Uuid\Uuid;
  17. use Shopware\Core\System\SystemConfig\SystemConfigService;
  18. use Symfony\Component\HttpFoundation\Request;
  20. class BlogElementResolver extends AbstractCmsElementResolver
  21. {
  22.     final public const ELEMENT_TYPE = 'netzp-blog6';
  24.     public function getType(): string
  25.     {
  26.         return self::ELEMENT_TYPE;
  27.     }
  29.     public function __construct(private readonly SystemConfigService $systemConfig,
  30.                                 private readonly AbstractBlogListingRoute $blogListingRoute)
  31.     {
  32.     }
  34.     public function collect(CmsSlotEntity $slot, ResolverContext $resolverContext): ?CriteriaCollection
  35.     {
  36.         return null;
  37.     }
  39.     private function getPageNumber(Request $request): int
  40.     {
  41.         $pageNumber = $request->query->getInt('p', 1);
  42.         if ($request->isMethod(Request::METHOD_POST)) {
  43.             $pageNumber = $request->query->getInt('p', $pageNumber);
  44.         }
  46.         return $pageNumber <= 0 ? 1 : $pageNumber;
  47.     }
  49.     private function setPagination(Criteria $criteria, $page, $maxNumberOfPosts)
  50.     {
  51.         $criteria->setTotalCountMode(Criteria::TOTAL_COUNT_MODE_EXACT);
  52.         $criteria->setOffset(($page - 1) * $maxNumberOfPosts);
  53.         $criteria->setLimit($maxNumberOfPosts);
  54.     }
  56.     private function setCategoryFilter(Criteria $criteria, Request $request)
  57.     {
  58.         $criteria->addAggregation(
  59.             new EntityAggregation('categories', 'category.id', 's_plugin_netzp_blog_category')
  60.         );
  62.         $ids = $this->getCategoryIds($request);
  63.         if (empty($ids)) {
  64.             return;
  65.         }
  67.         $criteria->addPostFilter(
  68.             new MultiFilter(MultiFilter::CONNECTION_OR, [
  69.                 new EqualsAnyFilter('category.id', $ids),
  70.                 new EqualsAnyFilter('categories.id', $ids)
  71.             ])
  72.         );
  73.     }
  75.     private function setAuthorFilter(Criteria $criteria, Request $request)
  76.     {
  77.         $criteria->addAggregation(
  78.             new EntityAggregation('authors', 'author.id', 's_plugin_netzp_blog_author')
  79.         );
  81.         $ids = $this->getAuthorIds($request);
  82.         if (empty($ids)) {
  83.             return;
  84.         }
  86.         $criteria->addPostFilter(
  87.             new MultiFilter(MultiFilter::CONNECTION_OR, [
  88.                 new EqualsAnyFilter('author.id', $ids)
  89.             ])
  90.         );
  91.     }
  93.     private function setTagsFilter(Criteria $criteria, Request $request)
  94.     {
  95.         $criteria->addAggregation(
  96.             new EntityAggregation('tags', 'tags.id', 'tag')
  97.         );
  99.         $ids = $this->getTagIds($request);
  100.         if (empty($ids)) {
  101.             return;
  102.         }
  104.         $criteria->addPostFilter(
  105.             new MultiFilter(MultiFilter::CONNECTION_OR, [
  106.                 new EqualsAnyFilter('tags.id', $ids)
  107.             ])
  108.         );
  109.     }
  111.     private function getCategoryIds(Request $request)
  112.     {
  113.         $ids = $request->query->get('categories', '');
  114.         if ($request->isMethod(Request::METHOD_POST)) {
  115.             $ids = $request->query->get('categories', '');
  116.         }
  117.         $ids = explode('|', $ids);
  119.         return array_filter($ids);
  120.     }
  122.     private function getAuthorIds(Request $request)
  123.     {
  124.         $ids = $request->query->get('authors', '');
  125.         if ($request->isMethod(Request::METHOD_POST)) {
  126.             $ids = $request->query->get('authors', '');
  127.         }
  128.         $ids = explode('|', $ids);
  130.         return array_filter($ids);
  131.     }
  133.     private function getTagIds(Request $request)
  134.     {
  135.         $ids = $request->query->get('tags', '');
  136.         if ($request->isMethod(Request::METHOD_POST)) {
  137.             $ids = $request->query->get('tags', '');
  138.         }
  139.         $ids = explode('|', $ids);
  141.         return array_filter($ids);
  142.     }
  144.     public function enrich(CmsSlotEntity $slot, ResolverContext $resolverContext, ElementDataCollection $result): void
  145.     {
  146.         $salesChannelId = $resolverContext->getSalesChannelContext()->getSalesChannel()->getId();
  147.         $config = $slot->getFieldConfig();
  148.         $pluginConfig = $this->systemConfig->get('NetzpBlog6.config', $salesChannelId);
  150.         $criteria = new Criteria();
  151.         $criteria->setTitle('cms::netzp-blog-listing');
  153.         $categoryId = $config->has('category') ? $config->get('category')->getValue() : '00000000000000000000000000000000';
  154.         $categoryId = $categoryId != null ? $categoryId : '00000000000000000000000000000000';
  155.         $categoryId = $resolverContext->getRequest()->query->get('c', $categoryId);
  157.         $authorId = $config->has('author') ? $config->get('author')->getValue() : '00000000000000000000000000000000';
  158.         $authorId = $authorId != null ? $authorId : '00000000000000000000000000000000';
  159.         $authorId = $resolverContext->getRequest()->query->get('a', $authorId);
  161.         $tags = $config->has('tags') && $config->get('tags')->getValue() !== null ? $config->get('tags')->getValue() : [];
  162.         $sortOrder = $config->get('sortOrder')->getValue();
  164.         $maxNumberOfPosts = (int)$config->get('numberOfPosts')->getValue();
  165.         $page = $this->getPageNumber($resolverContext->getRequest());
  166.         if($maxNumberOfPosts < 1) $maxNumberOfPosts = 99999; // show "all"
  168.         $this->setPagination($criteria, $page, $maxNumberOfPosts);
  169.         $this->setCategoryFilter($criteria, $resolverContext->getRequest());
  170.         $this->setAuthorFilter($criteria, $resolverContext->getRequest());
  171.         $this->setTagsFilter($criteria, $resolverContext->getRequest());
  173.         $this->setCriteria($criteria, $categoryId, $authorId, $tags); // set criteria early so that criteriaHash in cached route is set
  175.         $blogListingResponse = $this->blogListingRoute->load(
  176.             $slot->getId(),
  177.             $criteria, $resolverContext->getSalesChannelContext(),
  178.             $categoryId, $authorId, $tags, $sortOrder);
  179.         $searchResult = $blogListingResponse->getPosts();
  181.         $data = new ArrayEntity();
  182.         $data->setUniqueIdentifier(Uuid::randomHex()); // prevent "Notice: Undefined index: id" when HTTP Cache is enabled ;-(
  183.         $slot->setData($data);
  185.         $data->set('result', $searchResult);
  186.         $data->set('pluginConfig', $pluginConfig);
  187.     }
  189.     private function setCriteria(Criteria $criteria, ?string $categoryId, ?string $authorId, array $tags)
  190.     {
  191.         if($categoryId && $categoryId != '00000000000000000000000000000000') {
  192.             $criteria->addFilter(new MultiFilter(MultiFilter::CONNECTION_OR, [
  193.                 new EqualsFilter('categoryid', $categoryId),
  194.                 new EqualsAnyFilter('categories.id', [$categoryId]),
  195.             ]));
  196.         }
  198.         if($authorId && $authorId != '00000000000000000000000000000000') {
  199.             $criteria->addFilter(
  200.                 new EqualsFilter('authorid', $authorId)
  201.             );
  202.         }
  204.         if($tags != null && is_array($tags) && count($tags) > 0) {
  205.             $criteria->addFilter(new EqualsAnyFilter('tags.id', $tags));
  206.         }
  207.     }
  208. }