|
1
|
|
|
<?php |
|
2
|
|
|
|
|
3
|
|
|
declare(strict_types=1); |
|
4
|
|
|
|
|
5
|
|
|
namespace Spiral\Core; |
|
6
|
|
|
|
|
7
|
|
|
use Psr\EventDispatcher\EventDispatcherInterface; |
|
8
|
|
|
use Spiral\Core\Event\InterceptorCalling; |
|
9
|
|
|
use Spiral\Core\Exception\InterceptorException; |
|
10
|
|
|
use Spiral\Interceptors\Context\CallContext; |
|
11
|
|
|
use Spiral\Interceptors\Context\Target; |
|
12
|
|
|
use Spiral\Interceptors\HandlerInterface; |
|
13
|
|
|
use Spiral\Interceptors\InterceptorInterface; |
|
14
|
|
|
|
|
15
|
|
|
/** |
|
16
|
|
|
* Provides the ability to modify the call to the domain core on it's way to the action. |
|
17
|
|
|
* |
|
18
|
|
|
* @deprecated use {@see \Spiral\Interceptors\Handler\InterceptorPipeline} instead |
|
19
|
|
|
*/ |
|
20
|
|
|
final class InterceptorPipeline implements CoreInterface, HandlerInterface |
|
|
|
|
|
|
21
|
|
|
{ |
|
22
|
|
|
private ?CoreInterface $core = null; |
|
23
|
|
|
private ?HandlerInterface $handler = null; |
|
24
|
|
|
|
|
25
|
|
|
/** @var list<CoreInterceptorInterface|InterceptorInterface> */ |
|
|
|
|
|
|
26
|
|
|
private array $interceptors = []; |
|
27
|
|
|
|
|
28
|
|
|
private int $position = 0; |
|
29
|
|
|
private ?CallContext $context = null; |
|
30
|
|
|
|
|
31
|
|
|
public function __construct( |
|
32
|
|
|
private readonly ?EventDispatcherInterface $dispatcher = null |
|
33
|
|
|
) { |
|
34
|
|
|
} |
|
35
|
|
|
|
|
36
|
|
|
public function addInterceptor(CoreInterceptorInterface|InterceptorInterface $interceptor): void |
|
37
|
|
|
{ |
|
38
|
|
|
$this->interceptors[] = $interceptor; |
|
39
|
|
|
} |
|
40
|
|
|
|
|
41
|
|
|
public function withCore(CoreInterface $core): self |
|
42
|
|
|
{ |
|
43
|
|
|
$pipeline = clone $this; |
|
44
|
|
|
$pipeline->core = $core; |
|
45
|
|
|
$pipeline->handler = null; |
|
46
|
|
|
return $pipeline; |
|
47
|
|
|
} |
|
48
|
|
|
|
|
49
|
|
|
public function withHandler(HandlerInterface $handler): self |
|
50
|
|
|
{ |
|
51
|
|
|
$pipeline = clone $this; |
|
52
|
|
|
$pipeline->handler = $handler; |
|
53
|
|
|
$pipeline->core = null; |
|
54
|
|
|
return $pipeline; |
|
55
|
|
|
} |
|
56
|
|
|
|
|
57
|
|
|
/** |
|
58
|
|
|
* @throws \Throwable |
|
59
|
|
|
*/ |
|
60
|
|
|
public function callAction(string $controller, string $action, array $parameters = []): mixed |
|
61
|
|
|
{ |
|
62
|
|
|
if ($this->context === null) { |
|
63
|
|
|
return $this->handle( |
|
64
|
|
|
new CallContext(Target::fromPathArray([$controller, $action]), $parameters), |
|
65
|
|
|
); |
|
66
|
|
|
} |
|
67
|
|
|
|
|
68
|
|
|
if ($this->context->getTarget()->getPath() === [$controller, $action]) { |
|
69
|
|
|
return $this->handle($this->context->withArguments($parameters)); |
|
70
|
|
|
} |
|
71
|
|
|
|
|
72
|
|
|
return $this->handle( |
|
73
|
|
|
$this->context->withTarget( |
|
74
|
|
|
Target::fromPathArray([$controller, $action]), |
|
75
|
|
|
)->withArguments($parameters) |
|
76
|
|
|
); |
|
77
|
|
|
} |
|
78
|
|
|
|
|
79
|
|
|
/** |
|
80
|
|
|
* @throws \Throwable |
|
81
|
|
|
*/ |
|
82
|
|
|
public function handle(CallContext $context): mixed |
|
83
|
|
|
{ |
|
84
|
|
|
if ($this->core === null && $this->handler === null) { |
|
85
|
|
|
throw new InterceptorException('Unable to invoke pipeline without last handler.'); |
|
|
|
|
|
|
86
|
|
|
} |
|
87
|
|
|
|
|
88
|
|
|
$path = $context->getTarget()->getPath(); |
|
89
|
|
|
|
|
90
|
|
|
if (isset($this->interceptors[$this->position])) { |
|
91
|
|
|
$interceptor = $this->interceptors[$this->position]; |
|
92
|
|
|
$handler = $this->nextWithContext($context); |
|
93
|
|
|
|
|
94
|
|
|
$this->dispatcher?->dispatch( |
|
95
|
|
|
new InterceptorCalling( |
|
|
|
|
|
|
96
|
|
|
controller: $path[0] ?? '', |
|
97
|
|
|
action: $path[1] ?? '', |
|
98
|
|
|
parameters: $context->getArguments(), |
|
99
|
|
|
interceptor: $interceptor, |
|
100
|
|
|
) |
|
101
|
|
|
); |
|
102
|
|
|
|
|
103
|
|
|
return $interceptor instanceof CoreInterceptorInterface |
|
104
|
|
|
? $interceptor->process($path[0] ?? '', $path[1] ?? '', $context->getArguments(), $handler) |
|
105
|
|
|
: $interceptor->intercept($context, $handler); |
|
106
|
|
|
} |
|
107
|
|
|
|
|
108
|
|
|
return $this->core === null |
|
109
|
|
|
? $this->handler->handle($context) |
|
|
|
|
|
|
110
|
|
|
: $this->core->callAction($path[0] ?? '', $path[1] ?? '', $context->getArguments()); |
|
111
|
|
|
} |
|
112
|
|
|
|
|
113
|
|
|
private function nextWithContext(CallContext $context): self |
|
114
|
|
|
{ |
|
115
|
|
|
$pipeline = clone $this; |
|
116
|
|
|
$pipeline->context = $context; |
|
117
|
|
|
++$pipeline->position; |
|
118
|
|
|
return $pipeline; |
|
119
|
|
|
} |
|
120
|
|
|
} |
|
121
|
|
|
|
spiral /
framework
Loading history...
This interface has been deprecated. The supplier of the interface has supplied an explanatory message.
The explanatory message should give you some clue as to whether and when the interface will be removed and what other interface to use instead.