src/Core/Content/Flow/Dispatching/FlowDispatcher.php line 44

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Content\Flow\Dispatching;
  5. use Psr\EventDispatcher\StoppableEventInterface;
  6. use Psr\Log\LoggerInterface;
  7. use Shopware\Core\Content\Flow\Dispatching\Struct\Flow;
  8. use Shopware\Core\Content\Flow\Exception\ExecuteSequenceException;
  9. use Shopware\Core\Framework\Context;
  10. use Shopware\Core\Framework\Event\FlowEventAware;
  11. use Shopware\Core\Framework\Event\FlowLogEvent;
  12. use Shopware\Core\Framework\Log\Package;
  13. use Symfony\Component\DependencyInjection\ContainerInterface;
  14. use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
  15. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  16. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  18. /**
  19.  * @internal not intended for decoration or replacement
  20.  */
  21. #[Package('business-ops')]
  22. class FlowDispatcher implements EventDispatcherInterface
  23. {
  24.     private ContainerInterface $container;
  26.     public function __construct(private readonly EventDispatcherInterface $dispatcher, private readonly LoggerInterface $logger, private readonly FlowFactory $flowFactory)
  27.     {
  28.     }
  30.     public function setContainer(ContainerInterface $container): void
  31.     {
  32.         $this->container = $container;
  33.     }
  35.     /**
  36.      * @template TEvent of object
  37.      *
  38.      * @param TEvent $event
  39.      *
  40.      * @return TEvent
  41.      */
  42.     public function dispatch($event, ?string $eventName = null): object
  43.     {
  44.         $event = $this->dispatcher->dispatch($event, $eventName);
  46.         if (!$event instanceof FlowEventAware) {
  47.             return $event;
  48.         }
  50.         $flowLogEvent = new FlowLogEvent(FlowLogEvent::NAME, $event);
  51.         $this->dispatcher->dispatch($flowLogEvent, $flowLogEvent->getName());
  53.         if (($event instanceof StoppableEventInterface && $event->isPropagationStopped())
  54.             || $event->getContext()->hasState(Context::SKIP_TRIGGER_FLOW)
  55.         ) {
  56.             return $event;
  57.         }
  59.         $storableFlow = $this->flowFactory->create($event);
  60.         $this->callFlowExecutor($storableFlow);
  62.         return $event;
  63.     }
  65.     /**
  66.      * @param callable $listener
  67.      */
  68.     public function addListener(string $eventName, $listener, int $priority = 0): void
  69.     {
  70.         $this->dispatcher->addListener($eventName, $listener, $priority);
  71.     }
  73.     public function addSubscriber(EventSubscriberInterface $subscriber): void
  74.     {
  75.         $this->dispatcher->addSubscriber($subscriber);
  76.     }
  78.     /**
  79.      * @param callable $listener
  80.      */
  81.     public function removeListener(string $eventName, $listener): void
  82.     {
  83.         $this->dispatcher->removeListener($eventName, $listener);
  84.     }
  86.     public function removeSubscriber(EventSubscriberInterface $subscriber): void
  87.     {
  88.         $this->dispatcher->removeSubscriber($subscriber);
  89.     }
  91.     public function getListeners(?string $eventName = null): array
  92.     {
  93.         return $this->dispatcher->getListeners($eventName);
  94.     }
  96.     /**
  97.      * @param callable $listener
  98.      */
  99.     public function getListenerPriority(string $eventName, $listener): ?int
  100.     {
  101.         return $this->dispatcher->getListenerPriority($eventName, $listener);
  102.     }
  104.     public function hasListeners(?string $eventName = null): bool
  105.     {
  106.         return $this->dispatcher->hasListeners($eventName);
  107.     }
  109.     private function callFlowExecutor(StorableFlow $event): void
  110.     {
  111.         $flows = $this->getFlows($event->getName());
  113.         if (empty($flows)) {
  114.             return;
  115.         }
  117.         /** @var FlowExecutor|null $flowExecutor */
  118.         $flowExecutor = $this->container->get(FlowExecutor::class);
  120.         if ($flowExecutor === null) {
  121.             throw new ServiceNotFoundException(FlowExecutor::class);
  122.         }
  124.         foreach ($flows as $flow) {
  125.             try {
  126.                 /** @var Flow $payload */
  127.                 $payload = $flow['payload'];
  128.                 $flowExecutor->execute($payload, $event);
  129.             } catch (ExecuteSequenceException $e) {
  130.                 $this->logger->error(
  131.                     "Could not execute flow with error message:\n"
  132.                     . 'Flow name: ' . $flow['name'] . "\n"
  133.                     . 'Flow id: ' . $flow['id'] . "\n"
  134.                     . 'Sequence id: ' . $e->getSequenceId() . "\n"
  135.                     . $e->getMessage() . "\n"
  136.                     . 'Error Code: ' . $e->getCode() . "\n"
  137.                 );
  138.             } catch (\Throwable $e) {
  139.                 $this->logger->error(
  140.                     "Could not execute flow with error message:\n"
  141.                     . 'Flow name: ' . $flow['name'] . "\n"
  142.                     . 'Flow id: ' . $flow['id'] . "\n"
  143.                     . $e->getMessage() . "\n"
  144.                     . 'Error Code: ' . $e->getCode() . "\n"
  145.                 );
  146.             }
  147.         }
  148.     }
  150.     /**
  151.      * @return array<string, mixed>
  152.      */
  153.     private function getFlows(string $eventName): array
  154.     {
  155.         /** @var AbstractFlowLoader|null $flowLoader */
  156.         $flowLoader = $this->container->get(FlowLoader::class);
  158.         if ($flowLoader === null) {
  159.             throw new ServiceNotFoundException(FlowExecutor::class);
  160.         }
  162.         $flows = $flowLoader->load();
  164.         $result = [];
  165.         if (\array_key_exists($eventName, $flows)) {
  166.             $result = $flows[$eventName];
  167.         }
  169.         return $result;
  170.     }
  171. }