custom/plugins/theme/src/Subscriber/DynamicAccessSubscriber.php line 46

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. namespace DonCarneTheme\Subscriber;
  5. use Shopware\Core\Content\Category\Exception\CategoryNotFoundException;
  6. use Shopware\Core\Content\Product\Exception\ProductNotFoundException;
  7. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepositoryInterface;
  8. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  10. use Shopware\Core\System\SalesChannel\SalesChannelContext;
  11. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  12. use Symfony\Component\HttpFoundation\RedirectResponse;
  13. use Symfony\Component\HttpKernel\Event\ExceptionEvent;
  14. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  15. use Symfony\Component\HttpKernel\KernelEvents;
  16. use Symfony\Component\Routing\RouterInterface;
  18. class DynamicAccessSubscriber implements EventSubscriberInterface
  19. {
  20.     private EntityRepositoryInterface $categoryRepository;
  21.     private EntityRepositoryInterface $productRepository;
  22.     private RouterInterface $router;
  24.     /**
  25.      * The URL for the Beef Club login page
  26.      */
  27.     private const BEEF_CLUB_URL = 'https://doncarne.de/c/beef-club/';
  29.     public function __construct(
  30.         EntityRepositoryInterface $categoryRepository,
  31.         EntityRepositoryInterface $productRepository,
  32.         RouterInterface $router
  33.     ) {
  34.         $this->categoryRepository = $categoryRepository;
  35.         $this->productRepository = $productRepository;
  36.         $this->router = $router;
  37.     }
  39.     public static function getSubscribedEvents(): array
  40.     {
  41.         return [
  42.             KernelEvents::EXCEPTION => ['onKernelException', 0]
  43.         ];
  44.     }
  46.     public function onKernelException(ExceptionEvent $event): void
  47.     {
  48.         $exception = $event->getThrowable();
  49.         $request = $event->getRequest();
  50.         
  51.         // Check if we have a sales channel context and a logged-in user
  52.         if (!$request->attributes->has('sw-sales-channel-context')) {
  53.             return;
  54.         }
  55.         
  56.         /** @var SalesChannelContext $context */
  57.         $context = $request->attributes->get('sw-sales-channel-context');
  58.         
  59.         // Only handle 404 exceptions, CategoryNotFoundException, and ProductNotFoundException
  60.         if (!($exception instanceof NotFoundHttpException) && 
  61.             !($exception instanceof CategoryNotFoundException) &&
  62.             !($exception instanceof ProductNotFoundException)) {
  63.             return;
  64.         }
  65.         
  66.         // Check for typical URL patterns that might be restricted by Dynamic Access
  67.         $pathInfo = $request->getPathInfo();
  68.         
  69.         // Handle category not found exceptions - check if category actually exists
  70.         if (($exception instanceof CategoryNotFoundException) || $this->isCategoryPath($pathInfo)) {
  71.             $categoryId = $this->extractCategoryIdFromPath($pathInfo);
  72.             if ($categoryId && $this->categoryExists($categoryId, $context)) {
  73.                 // Category exists but user doesn't have access, redirect to Beef Club
  74.                 $response = new RedirectResponse(self::BEEF_CLUB_URL);
  75.                 $event->setResponse($response);
  76.                 return;
  77.             }
  78.         }
  79.         
  80.         // Handle product not found exceptions - check if product actually exists
  81.         if (($exception instanceof ProductNotFoundException) || $this->isProductPath($pathInfo)) {
  82.             $productId = $this->extractProductIdFromPath($pathInfo);
  83.             if ($productId && $this->productExists($productId, $context)) {
  84.                 // Product exists but user doesn't have access, redirect to Beef Club
  85.                 $response = new RedirectResponse(self::BEEF_CLUB_URL);
  86.                 $event->setResponse($response);
  87.                 return;
  88.             }
  89.         }
  90.     }
  91.     
  92.     /**
  93.      * Determine if the path looks like a category page
  94.      */
  95.     private function isCategoryPath(string $pathInfo): bool
  96.     {
  97.         // Category paths typically don't have extensions and don't contain /detail/ or /checkout/
  98.         return !preg_match('/(\.[\w\d]+$|\/detail\/|\/checkout\/)/', $pathInfo);
  99.     }
  100.     
  101.     /**
  102.      * Determine if the path looks like a product detail page
  103.      */
  104.     private function isProductPath(string $pathInfo): bool
  105.     {
  106.         // Product paths typically contain /detail/ 
  107.         return strpos($pathInfo, '/detail/') !== false;
  108.     }
  109.     
  110.     /**
  111.      * Extract a potential category ID from a URL path
  112.      */
  113.     private function extractCategoryIdFromPath(string $pathInfo): ?string
  114.     {
  115.         // Extract the last segment of the URL which should be the category ID
  116.         if (preg_match('/\/([a-f0-9]{32})(?:\/|$)/', $pathInfo, $matches)) {
  117.             return $matches[1];
  118.         }
  119.         
  120.         return null;
  121.     }
  122.     
  123.     /**
  124.      * Extract a potential product ID from a URL path
  125.      */
  126.     private function extractProductIdFromPath(string $pathInfo): ?string
  127.     {
  128.         // Extract the ID from a path like '/detail/a1b2c3.../'
  129.         if (preg_match('/\/detail\/([a-f0-9]{32})(?:\/|$)/', $pathInfo, $matches)) {
  130.             return $matches[1];
  131.         }
  132.         
  133.         return null;
  134.     }
  135.     
  136.     /**
  137.      * Check if a category exists in the database without applying customer group filters
  138.      */
  139.     private function categoryExists(string $categoryId, SalesChannelContext $context): bool
  140.     {
  141.         $criteria = new Criteria([$categoryId]);
  142.         $criteria->addFilter(new EqualsFilter('active', true));
  143.         $criteria->addAssociation('type');
  144.         
  145.         // Query directly against the repository to bypass sales channel filters
  146.         $result = $this->categoryRepository->search($criteria, $context->getContext());
  147.         
  148.         return $result->getTotal() > 0;
  149.     }
  150.     
  151.     /**
  152.      * Check if a product exists in the database without applying customer group filters
  153.      */
  154.     private function productExists(string $productId, SalesChannelContext $context): bool
  155.     {
  156.         $criteria = new Criteria([$productId]);
  157.         $criteria->addFilter(new EqualsFilter('active', true));
  158.         
  159.         // Query directly against the repository to bypass sales channel filters
  160.         $result = $this->productRepository->search($criteria, $context->getContext());
  161.         
  162.         return $result->getTotal() > 0;
  163.     }
  164. }