vendor/shopware/core/Content/Flow/Dispatching/StorableFlow.php line 66

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Content\Flow\Dispatching;
  5. use Shopware\Core\Content\Flow\FlowException;
  6. use Shopware\Core\Framework\Context;
  7. use Shopware\Core\Framework\Event\FlowEvent;
  8. use Shopware\Core\Framework\Event\FlowEventAware;
  9. use Shopware\Core\Framework\Feature;
  11. /**
  12.  * @internal
  13.  */
  14. class StorableFlow
  15. {
  16.     protected ?FlowState $state = null;
  18.     /**
  19.      * @var array<string, mixed>
  20.      */
  21.     protected array $config = [];
  23.     protected string $name;
  25.     protected Context $context;
  27.     /**
  28.      * @var array<string, mixed>
  29.      */
  30.     protected array $store = [];
  32.     /**
  33.      * @var array<string, mixed>
  34.      */
  35.     protected array $data = [];
  37.     /**
  38.      * @deprecated tag:v6.5.0 Will be removed
  39.      */
  40.     private ?FlowEventAware $originalEvent = null;
  42.     /**
  43.      * @deprecated tag:v6.5.0 Will be removed
  44.      */
  45.     private ?FlowEvent $flowEvent = null;
  47.     /**
  48.      * @param array<string, mixed> $store
  49.      * @param array<string, mixed> $data
  50.      */
  51.     public function __construct(
  52.         string $name,
  53.         Context $context,
  54.         array $store = [],
  55.         array $data = []
  56.     ) {
  57.         $this->name = $name;
  58.         $this->context = $context;
  59.         $this->data = $data;
  60.         $this->store = $store;
  61.     }
  63.     /**
  64.      * @deprecated tag:v6.5.0 Will be removed
  65.      */
  66.     public function setOriginalEvent(FlowEventAware $event): void
  67.     {
  68.         Feature::triggerDeprecationOrThrow(
  69.             'v6.5.0.0',
  70.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0')
  71.         );
  73.         $this->originalEvent = $event;
  74.     }
  76.     /**
  77.      * @deprecated tag:v6.5.0 Will be removed
  78.      */
  79.     public function getOriginalEvent(): ?FlowEventAware
  80.     {
  81.         Feature::triggerDeprecationOrThrow(
  82.             'v6.5.0.0',
  83.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0')
  84.         );
  86.         return $this->originalEvent;
  87.     }
  89.     /**
  90.      * @deprecated tag:v6.5.0 Will be removed
  91.      */
  92.     public function setFlowEvent(FlowEvent $event): void
  93.     {
  94.         Feature::triggerDeprecationOrThrow(
  95.             'v6.5.0.0',
  96.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0')
  97.         );
  99.         $this->flowEvent = $event;
  100.     }
  102.     /**
  103.      * @deprecated tag:v6.5.0 Will be removed
  104.      */
  105.     public function getFlowEvent(): ?FlowEvent
  106.     {
  107.         Feature::triggerDeprecationOrThrow(
  108.             'v6.5.0.0',
  109.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0')
  110.         );
  112.         return $this->flowEvent;
  113.     }
  115.     public function getName(): string
  116.     {
  117.         return $this->name;
  118.     }
  120.     public function getContext(): Context
  121.     {
  122.         return $this->context;
  123.     }
  125.     /**
  126.      * @param mixed $value
  127.      */
  128.     public function setStore(string $key, $value): void
  129.     {
  130.         $this->store[$key] = $value;
  131.     }
  133.     public function hasStore(string $key): bool
  134.     {
  135.         return \array_key_exists($key, $this->store);
  136.     }
  138.     /**
  139.      * @param mixed $default
  140.      *
  141.      * @return mixed
  142.      */
  143.     public function getStore(string $key, $default = null)
  144.     {
  145.         return $this->store[$key] ?? $default;
  146.     }
  148.     /**
  149.      * @return array<string, mixed>
  150.      */
  151.     public function stored(): array
  152.     {
  153.         return $this->store;
  154.     }
  156.     /**
  157.      * @param mixed $value
  158.      */
  159.     public function setData(string $key, $value): void
  160.     {
  161.         $this->data[$key] = $value;
  162.     }
  164.     public function hasData(string $key): bool
  165.     {
  166.         return \array_key_exists($key, $this->data);
  167.     }
  169.     /**
  170.      * @param mixed $default
  171.      *
  172.      * @return mixed
  173.      */
  174.     public function getData(string $key, $default = null)
  175.     {
  176.         $value = $this->data[$key] ?? $default;
  178.         if (\is_callable($value)) {
  179.             $this->data[$key] = $value($this);
  180.         }
  182.         return $this->data[$key] ?? $default;
  183.     }
  185.     /**
  186.      * @return array<string, mixed>
  187.      */
  188.     public function data(): array
  189.     {
  190.         foreach ($this->data as $key => $data) {
  191.             $this->getData($key);
  192.         }
  194.         return $this->data;
  195.     }
  197.     /**
  198.      * @param array<int, mixed> $args
  199.      */
  200.     public function lazy(string $key, callable $closure, array $args): void
  201.     {
  202.         $this->data[$key] = $closure($args);
  203.     }
  205.     /**
  206.      * @param array<string, mixed> $config
  207.      */
  208.     public function setConfig(array $config): void
  209.     {
  210.         $this->config = $config;
  211.     }
  213.     /**
  214.      * @return array<string, mixed>
  215.      */
  216.     public function getConfig(): array
  217.     {
  218.         return $this->config;
  219.     }
  221.     public function setFlowState(FlowState $state): void
  222.     {
  223.         $this->state = $state;
  224.     }
  226.     public function getFlowState(): FlowState
  227.     {
  228.         if (!$this->state) {
  229.             throw FlowException::methodNotCompatible('getFlowState()', self::class);
  230.         }
  232.         return $this->state;
  233.     }
  235.     public function stop(): void
  236.     {
  237.         if (!$this->state) {
  238.             throw FlowException::methodNotCompatible('stop()', self::class);
  239.         }
  241.         $this->state->stop = true;
  242.     }
  243. }