custom/plugins/SasBlogModule/src/Subscriber/BlogCacheInvalidSubscriber.php line 150

  1. <?php declare(strict_types=1);
  3. namespace Sas\BlogModule\Subscriber;
  5. use Sas\BlogModule\Content\Blog\BlogSeoUrlRoute;
  6. use Sas\BlogModule\Controller\CachedBlogController;
  7. use Sas\BlogModule\Controller\CachedBlogRssController;
  8. use Sas\BlogModule\Controller\CachedBlogSearchController;
  9. use Sas\BlogModule\Core\Content\Cms\BlogAssignment\CacheProductBlogAssignmentRoute;
  10. use Shopware\Core\Content\Category\SalesChannel\CachedCategoryRoute;
  11. use Shopware\Core\Content\Cms\CmsPageEvents;
  12. use Shopware\Core\Content\Seo\Event\SeoEvents;
  13. use Shopware\Core\Content\Seo\SeoUrlUpdater;
  14. use Shopware\Core\Framework\Adapter\Cache\CacheInvalidator;
  15. use Shopware\Core\Framework\Context;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Cache\EntityCacheKeyGenerator;
  17. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepository;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityDeletedEvent;
  19. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityWrittenEvent;
  20. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  21. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsAnyFilter;
  22. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  23. use Shopware\Core\System\SystemConfig\SystemConfigService;
  24. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  26. /**
  27.  * After you change the SEO Template within the SEO settings, we need to re-generate all existing URLs.
  28.  * All old URL's should match the new saved SEO Template pattern.
  29.  */
  30. class BlogCacheInvalidSubscriber implements EventSubscriberInterface
  31. {
  32.     private SeoUrlUpdater $seoUrlUpdater;
  34.     private EntityRepository $categoryRepository;
  36.     private EntityRepository $blogRepository;
  38.     private EntityRepository $productRepository;
  40.     private CacheInvalidator $cacheInvalidator;
  42.     private SystemConfigService $systemConfigService;
  44.     public function __construct(
  45.         SeoUrlUpdater $seoUrlUpdater,
  46.         EntityRepository $categoryRepository,
  47.         EntityRepository $blogRepository,
  48.         CacheInvalidator $cacheInvalidator,
  49.         SystemConfigService $systemConfigService,
  50.         EntityRepository $productRepository
  51.     ) {
  52.         $this->seoUrlUpdater = $seoUrlUpdater;
  53.         $this->categoryRepository = $categoryRepository;
  54.         $this->blogRepository = $blogRepository;
  55.         $this->cacheInvalidator = $cacheInvalidator;
  56.         $this->systemConfigService = $systemConfigService;
  57.         $this->productRepository = $productRepository;
  58.     }
  60.     public static function getSubscribedEvents(): array
  61.     {
  62.         return [
  63.             CmsPageEvents::PAGE_WRITTEN_EVENT => [
  64.                 ['onUpdateSeoUrlCmsPage', 10],
  65.                 ['onUpdateInvalidateCacheCmsPage', 11],
  66.                 ['invalidBlogDetailCmsPage', 12],
  67.             ],
  68.             'sas_blog_entries.written' => [
  69.                 ['onUpdateSeoUrl', 10],
  70.                 ['onUpdateInvalidateCache', 11],
  71.             ],
  72.             'sas_blog_entries.deleted' => [
  73.                 ['onDeleteSeoUrl', 10],
  74.                 ['onDeleteInvalidateCache', 11],
  75.             ],
  76.             SeoEvents::SEO_URL_TEMPLATE_WRITTEN_EVENT => [
  77.                 ['updateSeoUrlForAllArticles', 10],
  78.             ],
  79.         ];
  80.     }
  82.     public function invalidBlogDetailCmsPage(EntityWrittenEvent $event): void
  83.     {
  84.         $cmsPageIds = $event->getIds();
  85.         $cmsBlogDetailPageId = $this->systemConfigService->get('SasBlogModule.config.cmsBlogDetailPage');
  86.         if (!\is_string($cmsBlogDetailPageId) || !\in_array($cmsBlogDetailPageId, $cmsPageIds, true)) {
  87.             return;
  88.         }
  90.         $this->cacheInvalidator->invalidate(
  91.             array_map([EntityCacheKeyGenerator::class, 'buildCmsTag'], [$cmsBlogDetailPageId])
  92.         );
  93.     }
  95.     public function onUpdateSeoUrlCmsPage(EntityWrittenEvent $event): void
  96.     {
  97.         $blogIds = $this->getBlogIds($event);
  98.         if (empty($blogIds)) {
  99.             return;
  100.         }
  102.         $this->seoUrlUpdater->update(BlogSeoUrlRoute::ROUTE_NAME, $blogIds);
  103.     }
  105.     public function onUpdateInvalidateCacheCmsPage(EntityWrittenEvent $event): void
  106.     {
  107.         $blogIds = $this->getBlogIds($event);
  108.         if (empty($blogIds)) {
  109.             return;
  110.         }
  112.         $this->invalidateCache($blogIds);
  114.         $this->invalidateCacheCategory($event->getContext());
  116.         $this->invalidateCacheProductBlogAssignment($blogIds, $event->getContext());
  117.     }
  119.     /**
  120.      * When a blog article created or updated we will generate the SeoUrl for it
  121.      */
  122.     public function onUpdateSeoUrl(EntityWrittenEvent $event): void
  123.     {
  124.         $this->seoUrlUpdater->update(BlogSeoUrlRoute::ROUTE_NAME, $event->getIds());
  125.     }
  127.     /**
  128.      * When a blog article deleted we will mark as deleted the SeoUrl
  129.      */
  130.     public function onDeleteSeoUrl(EntityDeletedEvent $event): void
  131.     {
  132.         $this->seoUrlUpdater->update(BlogSeoUrlRoute::ROUTE_NAME, $event->getIds());
  133.     }
  135.     /**
  136.      * Invalidate blog cms cache when create or update
  137.      */
  138.     public function onUpdateInvalidateCache(EntityWrittenEvent $event): void
  139.     {
  140.         $this->invalidateCache($event->getIds());
  142.         $this->invalidateCacheCategory($event->getContext());
  144.         $this->invalidateCacheProductBlogAssignment($event->getIds(), $event->getContext());
  145.     }
  147.     /**
  148.      * Invalidate blog cms cache when delete article
  149.      */
  150.     public function onDeleteInvalidateCache(EntityDeletedEvent $event): void
  151.     {
  152.         $this->invalidateCache($event->getIds());
  154.         $this->invalidateCacheCategory($event->getContext());
  156.         $this->invalidateCacheProductBlogAssignment($event->getIds(), $event->getContext());
  157.     }
  159.     /**
  160.      * When update SEO template in the settings, we will update all SEO URLs for the blog articles
  161.      */
  162.     public function updateSeoUrlForAllArticles(): void
  163.     {
  164.         $this->seoUrlUpdater->update(BlogSeoUrlRoute::ROUTE_NAME, []);
  165.     }
  167.     private function invalidateCacheProductBlogAssignment(array $blogIds, Context $context): void
  168.     {
  169.         $productIds = $this->getBlogProductIds($blogIds, $context);
  170.         $this->cacheInvalidator->invalidate(
  171.             array_map([CacheProductBlogAssignmentRoute::class, 'buildName'], $productIds)
  172.         );
  173.     }
  175.     private function getBlogProductIds(array $blogIds, Context $context): array
  176.     {
  177.         $criteria = new Criteria();
  178.         $criteria->addFilter(new EqualsAnyFilter('assignedBlogs.id', $blogIds));
  180.         return $this->productRepository->searchIds($criteria, $context)->getIds();
  181.     }
  183.     /**
  184.      * Invalidate blog category cache
  185.      */
  186.     private function invalidateCacheCategory(Context $context): void
  187.     {
  188.         $catIds = $this->getBlogCategoryIds($context);
  190.         // invalidates the category route cache when a category changed
  191.         $this->cacheInvalidator->invalidate(
  192.             array_map([CachedCategoryRoute::class, 'buildName'], $catIds)
  193.         );
  194.     }
  196.     private function getBlogCategoryIds(Context $context): array
  197.     {
  198.         $criteria = new Criteria();
  199.         $criteria->addFilter(new EqualsFilter('active', true));
  200.         $criteria->addFilter(new EqualsFilter('cmsPage.sections.blocks.type', 'blog-listing'));
  201.         $criteria->addAssociation('cmsPage.sections.blocks');
  203.         return $this->categoryRepository->search($criteria, $context)->getIds();
  204.     }
  206.     /**
  207.      * Invalidate cache
  208.      */
  209.     private function invalidateCache(array $articleIds): void
  210.     {
  211.         $this->cacheInvalidator->invalidate(
  212.             array_map([CachedBlogController::class, 'buildName'], $articleIds)
  213.         );
  215.         $this->cacheInvalidator->invalidate([
  216.             'product-suggest-route',
  217.             'product-search-route',
  218.             CachedBlogSearchController::SEARCH_TAG,
  219.             CachedBlogRssController::RSS_TAG,
  220.         ]);
  222.         $cmsBlogDetailPageId = $this->systemConfigService->get('SasBlogModule.config.cmsBlogDetailPage');
  223.         if (!\is_string($cmsBlogDetailPageId)) {
  224.             return;
  225.         }
  227.         $this->cacheInvalidator->invalidate(
  228.             array_map([EntityCacheKeyGenerator::class, 'buildCmsTag'], [$cmsBlogDetailPageId])
  229.         );
  230.     }
  232.     private function getBlogIds(EntityWrittenEvent $event): array
  233.     {
  234.         return $this->blogRepository->searchIds(
  235.             (new Criteria())->addFilter(new EqualsAnyFilter('cmsPageId', $event->getIds())),
  236.             $event->getContext()
  237.         )->getIds();
  238.     }
  239. }