custom/plugins/NetzpBlog6/src/Helper/BlogHelper.php line 118

  1. <?php
  2. namespace NetzpBlog6\Helper;
  4. use NetzpBlog6\Core\Content\Blog\BlogEntity;
  5. use Shopware\Core\Content\ProductStream\Service\ProductStreamBuilderInterface;
  6. use Shopware\Core\Framework\DataAbstractionLayer\EntityCollection;
  7. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepository;
  8. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsAnyFilter;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\MultiFilter;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\NotFilter;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\RangeFilter;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Search\Grouping\FieldGrouping;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Search\Sorting\FieldSorting;
  16. use Shopware\Core\Framework\Context;
  17. use Shopware\Core\Framework\Uuid\Uuid;
  18. use Shopware\Core\System\SalesChannel\SalesChannelContext;
  19. use Symfony\Component\DependencyInjection\ContainerInterface;
  20. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  22. class BlogHelper
  23. {
  24.     public function __construct(private readonly ContainerInterface $container,
  25.                                 private readonly ProductStreamBuilderInterface $productStreamBuilder,
  26.                                 private readonly EntityRepository $productRepository)
  27.     {
  28.     }
  30.     public function getPublicBlogPosts(SalesChannelContext $salesChannelContext, Context $context, $limit = null, $offset = null,
  31.                                        $rssCategoryOnly = false)
  32.     {
  33.         $repo = $this->container->get('s_plugin_netzp_blog.repository');
  35.         $criteria = new Criteria();
  36.         $this->addBlogDateFilterAndSorting($criteria, true);
  37.         $criteria->addAssociation('category');
  38.         $criteria->addAssociation('tags');
  39.         $criteria->addAssociation('items');
  40.         $criteria->addAssociation('blogmedia');
  42.         $criteria->addFilter(new EqualsFilter('noindex', false));
  44.         $criteria->addFilter(new MultiFilter(MultiFilter::CONNECTION_OR, [
  45.             new EqualsFilter('categoryid', '00000000000000000000000000000000'),
  46.             new EqualsFilter('category.onlyloggedin', false),
  47.         ]));
  49.         $criteria->addFilter(new MultiFilter(MultiFilter::CONNECTION_OR, [
  50.             new EqualsFilter('category.saleschannelid', null),
  51.             new EqualsFilter('category.saleschannelid', '00000000000000000000000000000000'),
  52.             new EqualsFilter('category.saleschannelid', $salesChannelContext->getSalesChannel()->getId()),
  53.         ]));
  55.         if($rssCategoryOnly) {
  56.             $criteria->addFilter(new EqualsFilter('category.includeinrss', true));
  57.         }
  59.         $criteria->addSorting(new FieldSorting('items.number', FieldSorting::ASCENDING));
  60.         $criteria->addSorting(new FieldSorting('blogmedia.number', FieldSorting::ASCENDING));
  62.         if($limit) {
  63.             $criteria->setLimit($limit);
  64.         }
  65.         if($offset) {
  66.             $criteria->setOffset($offset);
  67.         }
  68.         $posts = $repo->search($criteria, $context)->getEntities();
  70.         return $posts;
  71.     }
  73.     public function isPluginActive($pluginName, Context $context)
  74.     {
  75.         $pluginRepo = $this->container->get('plugin.repository');
  76.         $pluginCriteria = new Criteria();
  77.         $pluginCriteria->addFilter(new EqualsFilter('name', $pluginName));
  78.         $plugin = $pluginRepo->search($pluginCriteria, $context)->getEntities()->first();
  80.         return $plugin && $plugin->getActive();
  81.     }
  83.     public function getBlogPosts(Criteria $criteria, SalesChannelContext $salesChannelContext,
  84.                                  ?string $categoryId, ?string $authorId, ?array $tags, ?string $sortOrder)
  85.     {
  86.         $repo = $this->container->get('s_plugin_netzp_blog.repository');
  87.         $criteria->addAssociation('netzp_blog.translations');
  88.         $criteria->addAssociation('category');
  89.         $criteria->addAssociation('categories');
  90.         $criteria->addAssociation('tags');
  92.         $this->addBlogDateFilterAndSorting($criteria, false); // without sorting
  93.         $this->addRestrictionsFilter($criteria, $salesChannelContext);
  95.         if($categoryId && $categoryId != '00000000000000000000000000000000') {
  96.             $criteria->addFilter(new MultiFilter(MultiFilter::CONNECTION_OR, [
  97.                 new EqualsFilter('categoryid', $categoryId),
  98.                 new EqualsAnyFilter('categories.id', [$categoryId]),
  99.             ]));
  100.         }
  102.         if($authorId && $authorId != '00000000000000000000000000000000') {
  103.             $criteria->addFilter(
  104.                 new EqualsFilter('authorid', $authorId)
  105.             );
  106.         }
  108.         if($tags != null && is_array($tags) && count($tags) > 0) {
  109.             $criteria->addFilter(new EqualsAnyFilter('tags.id', $tags));
  110.         }
  112.         $criteria->addSorting(new FieldSorting('sticky', FieldSorting::DESCENDING));
  113.         $criteria->addSorting(new FieldSorting(
  114.                 'postdate', $sortOrder == 'asc' ? FieldSorting::ASCENDING : FieldSorting::DESCENDING)
  115.         );
  116.         $criteria->addSorting(new FieldSorting('title', FieldSorting::ASCENDING));
  118.         $results = $repo->search($criteria, $salesChannelContext->getContext());
  120.         return $results;
  121.     }
  123.     public function getBlogPost($postId, SalesChannelContext $salesChannelContext, Context $context)
  124.     {
  125.         if( ! Uuid::isValid($postId)) {
  126.             throw new NotFoundHttpException('No valid UUID');
  127.         }
  129.         $repo = $this->container->get('s_plugin_netzp_blog.repository');
  131.         $criteria = new Criteria();
  132.         $criteria->addAssociation('products.event');
  133.         $criteria->addAssociation('category');
  134.         $criteria->addAssociation('categories');
  135.         $criteria->addAssociation('tags');
  136.         $criteria->addAssociation('items');
  137.         $criteria->getAssociation('items')->addSorting(new FieldSorting('number', FieldSorting::ASCENDING));
  138.         $criteria->addAssociation('blogmedia');
  139.         $criteria->getAssociation('blogmedia')->addSorting(new FieldSorting('number', FieldSorting::ASCENDING));
  140.         $criteria->addAssociation('blogmedia.media');
  142.         $criteria->addFilter(new EqualsFilter('id', $postId));
  144.         $this->addRestrictionsFilter($criteria, $salesChannelContext);
  145.         $this->addBlogDateFilterAndSorting($criteria);
  147.         $post = $repo->search($criteria, $context)->getEntities()->first();
  148.         if( ! $post) {
  149.             throw new NotFoundHttpException('Blog post not found');
  150.         }
  152.         $assignedProducts = [];
  153.         $tmpProducts = [];
  154.         if($post->getIsProductStream() && $post->getProductStreamId() != null) {
  155.             try {
  156.                 $tmpProducts = $this->collectByProductStream($context, $post);
  157.             }
  158.             catch(\Exception) {
  159.                 //
  160.             }
  161.         }
  162.         else {
  163.             $tmpProducts = $post->getProducts();
  164.         }
  166.         foreach ($tmpProducts as $product) {
  167.             array_push($assignedProducts, $product->getId());
  168.         }
  170.         if(count($assignedProducts) > 0) {
  171.             $productRepository = $this->container->get('sales_channel.product.repository');
  172.             $criteria2 = new Criteria($assignedProducts);
  173.             $criteria2->addAssociation('cover');
  174.             $criteria2->addAssociation('event');
  176.             $products = $productRepository->search($criteria2, $salesChannelContext)->getEntities();
  177.             $post->setProducts($products);
  178.         }
  180.         return $post;
  181.     }
  183.     public function addRestrictionsFilter(Criteria $criteria, SalesChannelContext $salesChannelContext)
  184.     {
  185.         $userLoggedIn = $salesChannelContext->getCustomer() != null;
  186.         $userCustomerGroupId = $salesChannelContext->getCurrentCustomerGroup()->getId();
  188.         $criteria->addFilter(new MultiFilter(MultiFilter::CONNECTION_OR, [
  189.             new EqualsFilter('category.saleschannelid', null),
  190.             new EqualsFilter('category.saleschannelid', '00000000000000000000000000000000'),
  191.             new EqualsFilter('category.saleschannelid', $salesChannelContext->getSalesChannel()->getId()),
  192.         ]));
  194.         $criteria->addFilter(new MultiFilter(MultiFilter::CONNECTION_OR, [
  195.             new EqualsFilter('categoryid', '00000000000000000000000000000000'),
  196.             new EqualsFilter('category.onlyloggedin', false),
  198.             new MultiFilter(MultiFilter::CONNECTION_AND, [
  199.                 new EqualsFilter('category.onlyloggedin', true),
  200.                 new EqualsFilter('category.onlyloggedin', $userLoggedIn)
  201.             ])
  202.         ]));
  204.         $criteria->addFilter(new MultiFilter(MultiFilter::CONNECTION_OR, [
  205.             new EqualsFilter('category.customergroupid', null),
  206.             new EqualsFilter('category.customergroupid', '00000000000000000000000000000000'),
  208.             new MultiFilter(MultiFilter::CONNECTION_AND, [
  209.                 new NotFilter(NotFilter::CONNECTION_AND, [
  210.                     new EqualsFilter('category.customergroupid', '00000000000000000000000000000000')
  211.                 ]),
  212.                 new EqualsFilter('category.customergroupid', $userCustomerGroupId),
  213.             ])
  214.         ]));
  215.     }
  217.     public function addBlogDateFilterAndSorting(Criteria $criteria, bool $addSorting = false)
  218.     {
  219.         $now = (new \DateTime())->format('Y-m-d');
  220.         $criteria->addFilter(
  221.             new MultiFilter(
  222.                 MultiFilter::CONNECTION_OR, [
  223.                     new RangeFilter('showfrom', ['lte' => $now]),
  224.                     new EqualsFilter('showfrom', null)
  225.                 ]
  226.             )
  227.         );
  228.         $criteria->addFilter(
  229.             new MultiFilter(
  230.                 MultiFilter::CONNECTION_OR, [
  231.                     new RangeFilter('showuntil', ['gte' => $now]),
  232.                     new EqualsFilter('showuntil', null)
  233.                 ]
  234.             )
  235.         );
  237.         if($addSorting) {
  238.             $criteria->addSorting(new FieldSorting('sticky', FieldSorting::DESCENDING));
  239.             $criteria->addSorting(new FieldSorting('postdate', 'desc'));
  240.             $criteria->addSorting(new FieldSorting('title', FieldSorting::ASCENDING));
  241.         }
  242.     }
  244.     private function collectByProductStream(Context $context, BlogEntity $blogPost): EntityCollection
  245.     {
  246.         if (!$blogPost->getIsProductStream() || $blogPost->getProductStreamId() == null) {
  247.             return new EntityCollection();
  248.         }
  250.         $filters = $this->productStreamBuilder->buildFilters($blogPost->getProductStreamId(), $context);
  252.         $criteria = new Criteria();
  253.         $criteria->addAssociation('options.group');
  254.         $criteria->addFilter(...$filters);
  256.         // Ensure storefront presentation settings of product variants, see ProductSliderCmsElementResolver
  257.         $criteria->addGroupField(new FieldGrouping('displayGroup'));
  258.         $criteria->addFilter(
  259.             new NotFilter(
  260.                 NotFilter::CONNECTION_AND,
  261.                 [new EqualsFilter('displayGroup', null)]
  262.             )
  263.         );
  265.         $criteria->addSorting(new FieldSorting('name', FieldSorting::ASCENDING));
  267.         return $this->productRepository->search($criteria, $context)->getEntities();
  268.     }
  269. }