/**
* @param ActionEvent $event
*/
public function onDispatchInitialize(ActionEvent $event)
{
$bus = $event->getTarget();
if ($bus instanceof EventBus) {
$listeners = $event->getParam(EventBus::EVENT_PARAM_EVENT_LISTENERS, []);
$listeners[] = $this->messageProducer;
$event->setParam(EventBus::EVENT_PARAM_EVENT_LISTENERS, $listeners);
} else {
$event->setParam(MessageBus::EVENT_PARAM_MESSAGE_HANDLER, $this->messageProducer);
}
}
/**
* @param ActionEvent $actionEvent
*/
public function __invoke(ActionEvent $actionEvent)
{
$message = $actionEvent->getParam(MessageBus::EVENT_PARAM_MESSAGE);
if (!is_array($message)) {
return;
}
if (!array_key_exists('message_name', $message)) {
return;
}
$messageName = $message['message_name'];
unset($message['message_name']);
$message = $this->messageFactory->createMessageFromArray($messageName, $message);
$actionEvent->setParam(MessageBus::EVENT_PARAM_MESSAGE, $message);
$actionEvent->setParam(MessageBus::EVENT_PARAM_MESSAGE_NAME, $messageName);
}
/**
* @param ActionEvent $actionEvent
*/
public function onInitializeEvent(ActionEvent $actionEvent)
{
$message = $actionEvent->getParam(MessageBus::EVENT_PARAM_MESSAGE);
if (is_string($message)) {
$actionEvent->setParam(MessageBus::EVENT_PARAM_MESSAGE_NAME, $message);
}
}
public function onLocateMessageHandler(ActionEvent $actionEvent)
{
$messageHandlerAlias = $actionEvent->getParam(MessageBus::EVENT_PARAM_MESSAGE_HANDLER);
if (is_string($messageHandlerAlias) && $this->serviceLocator->has($messageHandlerAlias)) {
$actionEvent->setParam(MessageBus::EVENT_PARAM_MESSAGE_HANDLER, $this->serviceLocator->get($messageHandlerAlias));
}
}
/**
* @param ActionEvent $e
*/
public function __invoke(ActionEvent $e)
{
$message = $e->getParam(MessageBus::EVENT_PARAM_MESSAGE);
$handler = $e->getParam(MessageBus::EVENT_PARAM_MESSAGE_HANDLER);
if ($this->canInvoke($handler, $message)) {
$this->invoke($handler, $message);
$e->setParam(MessageBus::EVENT_PARAM_MESSAGE_HANDLED, true);
}
}
/**
* Add event metadata on event store appendToStream.
*
* @param ActionEvent $appendToStreamEvent
*/
public function onEventStoreAppendToStream(ActionEvent $appendToStreamEvent)
{
$streamEvents = $appendToStreamEvent->getParam('streamEvents');
if (!$streamEvents instanceof \Iterator) {
return;
}
$streamEvents = $this->handleRecordedEvents($streamEvents);
$appendToStreamEvent->setParam('streamEvents', $streamEvents);
}
/**
* @param ActionEvent $actionEvent
*/
public function __invoke(ActionEvent $actionEvent)
{
$finder = $actionEvent->getParam(QueryBus::EVENT_PARAM_MESSAGE_HANDLER);
$query = $actionEvent->getParam(QueryBus::EVENT_PARAM_MESSAGE);
$deferred = $actionEvent->getParam(QueryBus::EVENT_PARAM_DEFERRED);
if (is_object($finder)) {
$queryName = $this->determineQueryName($query);
if (method_exists($finder, $queryName)) {
$finder->{$queryName}($query, $deferred);
$actionEvent->setParam(MessageBus::EVENT_PARAM_MESSAGE_HANDLED, true);
}
}
}
/**
* @param ActionEvent $actionEvent
*/
public function onRouteMessage(ActionEvent $actionEvent)
{
$messageName = (string) $actionEvent->getParam(MessageBus::EVENT_PARAM_MESSAGE_NAME);
if (empty($messageName)) {
return;
}
$message = $actionEvent->getParam(MessageBus::EVENT_PARAM_MESSAGE);
//if the message is marked with AsyncMessage, but had not yet been sent via async then sent to async producer
if ($message instanceof AsyncMessage && !(isset($message->metadata()['handled-async']) && $message->metadata()['handled-async'] === true)) {
//apply meta data, this is need to we can identify that the message has already been send via the async producer
$message = $message->withAddedMetadata('handled-async', true);
// update ActionEvent
$actionEvent->setParam(MessageBus::EVENT_PARAM_MESSAGE, $message);
if ($actionEvent->getTarget() instanceof CommandBus || $actionEvent->getTarget() instanceof QueryBus) {
$actionEvent->setParam(MessageBus::EVENT_PARAM_MESSAGE_HANDLER, $this->asyncMessageProducer);
} else {
//Target is an event bus so we set message producer as the only listener of the message
$actionEvent->setParam(EventBus::EVENT_PARAM_EVENT_LISTENERS, [$this->asyncMessageProducer]);
}
return;
}
// pass ActionEvent to decorated router
return $this->router->onRouteMessage($actionEvent);
}
/**
* @param ActionEvent $actionEvent
* @throws UnauthorizedException
*/
public function onFinalize(ActionEvent $actionEvent)
{
$promise = $actionEvent->getParam(QueryBus::EVENT_PARAM_PROMISE);
if ($promise instanceof Promise) {
$newPromise = $promise->then(function ($result) use($actionEvent) {
if (!$this->authorizationService->isGranted($actionEvent->getParam(MessageBus::EVENT_PARAM_MESSAGE_NAME), $result)) {
$actionEvent->stopPropagation(true);
throw new UnauthorizedException();
}
});
$actionEvent->setParam(QueryBus::EVENT_PARAM_PROMISE, $newPromise);
} elseif (!$this->authorizationService->isGranted($actionEvent->getParam(MessageBus::EVENT_PARAM_MESSAGE_NAME))) {
$actionEvent->stopPropagation(true);
throw new UnauthorizedException();
}
}
/**
* @param ActionEvent $actionEvent
* @param \Exception $ex
* @throws Exception\MessageDispatchException
*/
protected function handleException(ActionEvent $actionEvent, \Exception $ex)
{
$failedPhase = $actionEvent->getName();
$actionEvent->setParam(self::EVENT_PARAM_EXCEPTION, $ex);
$this->triggerError($actionEvent);
$this->triggerFinalize($actionEvent);
//Check if a listener has removed the exception to indicate that it was able to handle it
if ($ex = $actionEvent->getParam(self::EVENT_PARAM_EXCEPTION)) {
$actionEvent->setName($failedPhase);
throw MessageDispatchException::failed($actionEvent, $ex);
}
}
/**
* @param ActionEvent $actionEvent
*/
public function onRouteEvent(ActionEvent $actionEvent)
{
$messageName = (string) $actionEvent->getParam(MessageBus::EVENT_PARAM_MESSAGE_NAME);
if (empty($messageName)) {
return;
}
if (!isset($this->eventMap[$messageName])) {
return;
}
$listeners = $actionEvent->getParam(EventBus::EVENT_PARAM_EVENT_LISTENERS, []);
$listeners = array_merge($listeners, $this->eventMap[$messageName]);
$actionEvent->setParam(EventBus::EVENT_PARAM_EVENT_LISTENERS, $listeners);
}
/**
* @param ActionEvent $actionEvent
*/
private function onRouteEvent(ActionEvent $actionEvent)
{
$messageName = (string) $actionEvent->getParam(MessageBus::EVENT_PARAM_MESSAGE_NAME);
if (empty($messageName)) {
return;
}
foreach ($this->patternMap as $map) {
list($pattern, $handler) = each($map);
if (preg_match($pattern, $messageName)) {
$listeners = $actionEvent->getParam(EventBus::EVENT_PARAM_EVENT_LISTENERS, []);
$listeners[] = $handler;
$actionEvent->setParam(EventBus::EVENT_PARAM_EVENT_LISTENERS, $listeners);
}
}
}
/**
* @param ActionEvent $actionEvent
*/
public function onRouteMessage(ActionEvent $actionEvent)
{
$messageName = (string) $actionEvent->getParam(MessageBus::EVENT_PARAM_MESSAGE_NAME);
if (empty($messageName)) {
return;
}
if (!isset($this->messageMap[$messageName])) {
return;
}
$handler = $this->messageMap[$messageName];
$actionEvent->setParam(MessageBus::EVENT_PARAM_MESSAGE_HANDLER, $handler);
}
/**
* Add event metadata on event store appendToStream
*
* @param ActionEvent $appendToStreamEvent
*/
public function onEventStoreAppendToStream(ActionEvent $appendToStreamEvent)
{
$streamEvents = $appendToStreamEvent->getParam('streamEvents');
$streamEvents = $this->handleRecordedEvents($streamEvents);
$appendToStreamEvent->setParam('streamEvents', $streamEvents);
}
