/**
* @param $serialized
* @return Envelope
*/
public function unserialize($serialized)
{
$data = json_decode($serialized, true);
$messageData = $data['message'];
$messageData['created_at'] = \DateTimeImmutable::createFromFormat('Y-m-d\\TH:i:s.u', $messageData['created_at'], new \DateTimeZone('UTC'));
$proophMessage = $this->messageFactory->createMessageFromArray($messageData['message_name'], $messageData);
$envelope = new Envelope(BernardMessage::fromProophMessage($proophMessage));
return $envelope;
}
/**
* @param Message $message
* @return Message
*/
public function createMessageFromPreviousMessage(Message $message)
{
$payloadObj = new \ArrayObject($this->defaultPayload);
$metadataObj = new \ArrayObject($this->defaultMetadata);
if (null !== $this->payloadGenerator) {
$generator = $this->payloadGenerator;
$generator($message, $payloadObj, $metadataObj);
}
return $this->messageFactory->createMessageFromArray($this->desiredMessageName, ['payload' => $payloadObj->getArrayCopy(), 'metadata' => $metadataObj->getArrayCopy()]);
}
/**
* @return Message
*/
public function current()
{
$current = $this->innerIterator->current();
$metadata = [];
foreach ($current as $key => $value) {
if (!in_array($key, $this->standardColumns)) {
$metadata[$key] = $value;
}
}
$createdAt = \DateTimeImmutable::createFromFormat('Y-m-d\\TH:i:s.u', $current['created_at'], new \DateTimeZone('UTC'));
return $this->messageFactory->createMessageFromArray($current['event_name'], ['uuid' => $current['_id'], 'version' => (int) $current['version'], 'created_at' => $createdAt, 'payload' => $current['payload'], 'metadata' => $metadata]);
}
/**
* @interitdoc
*/
public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next)
{
$eventName = $request->getAttribute(self::NAME_ATTRIBUTE);
if (null === $eventName) {
return $next($request, $response, new RuntimeException(sprintf('Event name attribute ("%s") was not found in request.', self::NAME_ATTRIBUTE), Middleware::STATUS_CODE_BAD_REQUEST));
}
try {
$event = $this->eventFactory->createMessageFromArray($eventName, ['payload' => $request->getParsedBody(), 'metadata' => $this->metadataGatherer->getFromRequest($request)]);
$this->eventBus->dispatch($event);
return $response->withStatus(Middleware::STATUS_CODE_ACCEPTED);
} catch (\Exception $e) {
return $next($request, $response, new RuntimeException(sprintf('An error occurred during dispatching of event "%s"', $eventName), Middleware::STATUS_CODE_INTERNAL_SERVER_ERROR, $e));
}
}
/**
* @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);
}
/**
* @interitdoc
*/
public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next)
{
$payload = null;
$messageName = 'UNKNOWN';
try {
$payload = $request->getParsedBody();
if (is_array($payload) && isset($payload['message_name'])) {
$messageName = $payload['message_name'];
}
MessageDataAssertion::assert($payload);
$message = $this->messageFactory->createMessageFromArray($payload['message_name'], $payload);
switch ($message->messageType()) {
case Message::TYPE_COMMAND:
$this->commandBus->dispatch($message);
return $response->withStatus(Middleware::STATUS_CODE_ACCEPTED);
case Message::TYPE_EVENT:
$this->eventBus->dispatch($message);
return $response->withStatus(Middleware::STATUS_CODE_ACCEPTED);
case Message::TYPE_QUERY:
return $this->responseStrategy->fromPromise($this->queryBus->dispatch($message));
default:
return $next($request, $response, new RuntimeException(sprintf('Invalid message type "%s" for message "%s".', $message->messageType(), $messageName), Middleware::STATUS_CODE_BAD_REQUEST));
}
} catch (\Assert\InvalidArgumentException $e) {
return $next($request, $response, new RuntimeException($e->getMessage(), Middleware::STATUS_CODE_BAD_REQUEST, $e));
} catch (\Exception $e) {
return $next($request, $response, new RuntimeException(sprintf('An error occurred during dispatching of message "%s"', $messageName), Middleware::STATUS_CODE_INTERNAL_SERVER_ERROR, $e));
}
}
/**
* @interitdoc
*/
public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next)
{
$queryName = $request->getAttribute(self::NAME_ATTRIBUTE);
if (null === $queryName) {
return $next($request, $response, new RuntimeException(sprintf('Query name attribute ("%s") was not found in request.', self::NAME_ATTRIBUTE), Middleware::STATUS_CODE_BAD_REQUEST));
}
$payload = $request->getQueryParams();
if ($request->getMethod() === 'POST') {
$payload['data'] = $request->getParsedBody();
}
try {
$query = $this->queryFactory->createMessageFromArray($queryName, ['payload' => $payload, 'metadata' => $this->metadataGatherer->getFromRequest($request)]);
return $this->responseStrategy->fromPromise($this->queryBus->dispatch($query));
} catch (\Exception $e) {
return $next($request, $response, new RuntimeException(sprintf('An error occurred during dispatching of query "%s"', $queryName), Middleware::STATUS_CODE_INTERNAL_SERVER_ERROR, $e));
}
}
/**
* @param ServerRequestInterface $request
* @param ResponseInterface $response
* @param callable $next
* @return ResponseInterface
*/
public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next)
{
$commandName = $request->getAttribute('command');
if (!$commandName) {
return $next($request, $response);
}
try {
$payload = $this->getPayloadFromRequest($request);
$command = $this->commandFactory->createMessageFromArray($commandName, ['payload' => $payload]);
$this->commandBus->dispatch($command);
return $response->withStatus(202);
} catch (MessageDispatchException $dispatchException) {
$e = $dispatchException->getFailedDispatchEvent()->getParam('exception');
return $this->populateError($response, $e);
} catch (\Exception $e) {
return $this->populateError($response, $e);
}
}
/**
* @param Envelope $envelope
* @param Queue $queue
* @return DeliveryResult
*/
public function __invoke(Envelope $envelope, Queue $queue) : DeliveryResult
{
$data = json_decode($envelope->getBody(), true);
if (!isset($data['created_at'])) {
return DeliveryResult::MSG_REJECT();
}
$data['created_at'] = DateTimeImmutable::createFromFormat('Y-m-d\\TH:i:s.u', $data['created_at'], new DateTimeZone('UTC'));
if (false === $data['created_at']) {
return DeliveryResult::MSG_REJECT();
}
try {
$command = $this->messageFactory->createMessageFromArray($envelope->getType(), $data);
$this->commandBus->dispatch($command);
} catch (\Throwable $e) {
while ($e = $e->getPrevious()) {
if ($e instanceof ConcurrencyException) {
return DeliveryResult::MSG_REJECT_REQUEUE();
}
}
return DeliveryResult::MSG_REJECT();
}
return DeliveryResult::MSG_ACK();
}
/**
* @return null|Message
*/
public function current()
{
if (false === $this->currentItem) {
return;
}
$payload = $this->payloadSerializer->unserializePayload($this->currentItem['payload']);
$metadata = [];
//Add metadata stored in table
foreach ($this->currentItem as $key => $value) {
if (!in_array($key, $this->standardColumns)) {
$metadata[$key] = $value;
}
}
$createdAt = \DateTimeImmutable::createFromFormat('Y-m-d\\TH:i:s.u', $this->currentItem['created_at'], new \DateTimeZone('UTC'));
return $this->messageFactory->createMessageFromArray($this->currentItem['event_name'], ['uuid' => $this->currentItem['event_id'], 'version' => (int) $this->currentItem['version'], 'created_at' => $createdAt, 'payload' => $payload, 'metadata' => $metadata]);
}
/**
* @param StreamName $streamName
* @param array $metadata
* @param null|int $minVersion
* @return Message[]
* @throws StreamNotFoundException
*/
public function loadEventsByMetadataFrom(StreamName $streamName, array $metadata, $minVersion = null)
{
$collection = $this->getCollection();
$query = $metadata;
if (null !== $minVersion) {
$query['version'] = ['$gte' => $minVersion];
}
$query['expire_at'] = ['$exists' => false];
$query['transaction_id'] = ['$exists' => false];
$results = $collection->find($query)->sort(['version' => $collection::ASCENDING]);
$events = [];
foreach ($results as $eventData) {
//Add metadata stored in table
foreach ($eventData as $key => $value) {
if (!in_array($key, $this->standardColumns)) {
$metadata[$key] = $value;
}
}
$createdAt = \DateTimeImmutable::createFromFormat('Y-m-d\\TH:i:s.u', $eventData['created_at'], new \DateTimeZone('UTC'));
$events[] = $this->messageFactory->createMessageFromArray($eventData['event_name'], ['uuid' => $eventData['_id'], 'version' => (int) $eventData['version'], 'created_at' => $createdAt, 'payload' => $eventData['payload'], 'metadata' => $metadata]);
}
return $events;
}
/**
* @param Document $document
*
* @return Message
*/
private function convertDocumentToEvent(Document $document)
{
$createdAt = \DateTimeImmutable::createFromFormat('Y-m-d\\TH:i:s.u', $document->created_at, new \DateTimeZone('UTC'));
return $this->messageFactory->createMessageFromArray($document->event_name, ['uuid' => $document->event_id, 'version' => (int) $document->version, 'created_at' => $createdAt, 'payload' => (array) $document->payload, 'metadata' => (array) $document->metadata]);
}
/**
* @param ChapterNumber $chapterNumber
* @param MessageFactory $messageFactory
* @return Message
* @throws Exception\Story
*/
private function getOriginalStartMessageForChapterNumber(ChapterNumber $chapterNumber, MessageFactory $messageFactory)
{
if (!isset($this->chapterNumberStartMessageMap[$chapterNumber->toString()])) {
throw Exception\Story::hasNoStartMessageLoggedForChapterNumber($chapterNumber);
}
$messageData = $this->chapterNumberStartMessageMap[$chapterNumber->toString()];
return $messageFactory->createMessageFromArray($messageData['message_name'], $messageData);
}
