/**
* @inheritdoc
*/
public function createBody(DomainMessage $domainMessage)
{
$this->guardSerializable($domainMessage->getMetadata());
$this->guardSerializable($domainMessage->getPayload());
$data = ['id' => $domainMessage->getId(), 'playhead' => $domainMessage->getPlayhead(), 'metadata' => $domainMessage->getMetadata()->serialize(), 'payload' => $domainMessage->getPayload()->serialize(), 'recorded_on' => $domainMessage->getRecordedOn()->toString()];
return json_encode($data);
}
/**
* @param DomainMessage $domainMessage
*/
private function publishWithAMQP(DomainMessage $domainMessage)
{
$payload = $domainMessage->getPayload();
$eventClass = get_class($payload);
$this->logger->info("publishing message with event type {$eventClass} to exchange {$this->exchange}");
$this->channel->basic_publish($this->messageFactory->createAMQPMessage($domainMessage), $this->exchange);
}
/**
* @inheritdoc
*/
public function isSatisfiedBy(DomainMessage $domainMessage)
{
$payload = $domainMessage->getPayload();
$payloadClass = get_class($payload);
$this->logger->info("expected: {$this->typeName}, actual: {$payloadClass}");
$satisfied = is_a($payload, $this->typeName) || is_subclass_of($payload, $this->typeName);
$this->logger->info('satisfied: ' . ($satisfied ? 'yes' : 'no'));
return $satisfied;
}
public function handle(DomainMessage $domainMessage, SensitiveData $data = null)
{
$event = $domainMessage->getPayload();
$method = $this->getHandleMethod($event);
if (!method_exists($this, $method)) {
return;
}
$this->{$method}($event, $domainMessage, $data);
}
/**
* @param DomainMessage $domainMessage
*/
public function handle(DomainMessage $domainMessage)
{
$event = $domainMessage->getPayload();
$method = $this->methodNameInflector->inflect($event);
if (!method_exists($this, $method)) {
return;
}
$this->{$method}($event, $domainMessage);
}
/**
* {@inheritdoc}
*/
public function normalize(DomainMessage $domainMessage)
{
$payloadType = get_class($domainMessage->getPayload());
if (isset($this->normalizers[$payloadType])) {
/* @var DomainMessageNormalizerInterface $normalizer */
$normalizer = $this->normalizers[$payloadType];
return $normalizer->normalize($domainMessage);
}
return new DomainEventStream(array($domainMessage));
}
/**
* @param DomainMessage $domainMessage
* @return void
*/
public function handle(DomainMessage $domainMessage)
{
$event = $domainMessage->getPayload();
$eventName = $this->nameExtractor->extract($event);
$eventHandlers = $this->handlerLocator->getHandlersForEvent($eventName);
foreach ($eventHandlers as $handler) {
$methodName = $this->methodNameInflector->inflect($event, $handler);
// is_callable is used here instead of method_exists, as method_exists
// will fail when given a handler that relies on __call.
if (!is_callable([$handler, $methodName])) {
throw CanNotInvokeHandlerException::forEvent($event, sprintf("Method '%s' does not exist on handler", is_object($methodName) ? get_class($methodName) : gettype($methodName)));
}
$handler->{$methodName}($event, $domainMessage);
}
}
/**
* Handles the event by delegating it to Saga('s) related to the event.
*/
public function handle(DomainMessage $domainMessage)
{
$event = $domainMessage->getPayload();
foreach ($this->sagas as $sagaType => $saga) {
$metadata = $this->metadataFactory->create($saga);
if (!$metadata->handles($event)) {
continue;
}
$state = $this->stateManager->findOneBy($metadata->criteria($event), $sagaType);
if (null === $state) {
continue;
}
$this->eventDispatcher->dispatch(SagaManagerInterface::EVENT_PRE_HANDLE, array($sagaType, $state->getId()));
$newState = $saga->handle($event, $state);
$this->eventDispatcher->dispatch(SagaManagerInterface::EVENT_POST_HANDLE, array($sagaType, $state->getId()));
$this->repository->save($newState, $sagaType);
}
}
/**
* Handle an event.
*
* @param DomainMessage $message
*
* @return void
*/
public function handle(DomainMessage $message)
{
$event = $message->getPayload();
$context = self::getContext($message);
$this->handler->handle($event, $context);
}
/**
* Appends an event to the event store
*/
private function appendEvent(DomainMessage $event)
{
$this->connection->table($this->table)->insert(['uuid' => (string) $event->getId(), 'playhead' => (int) $event->getPlayhead(), 'metadata' => $this->serialize($event->getMetadata()), 'payload' => $this->serialize($event->getPayload()), 'recorded_on' => $event->getRecordedOn()->toString(), 'type' => $event->getType()]);
}
private function insertMessage(Connection $connection, DomainMessage $domainMessage)
{
$data = array('uuid' => $this->convertIdentifierToStorageValue((string) $domainMessage->getId()), 'playhead' => $domainMessage->getPlayhead(), 'metadata' => json_encode($this->metadataSerializer->serialize($domainMessage->getMetadata())), 'payload' => json_encode($this->payloadSerializer->serialize($domainMessage->getPayload())), 'recorded_on' => $domainMessage->getRecordedOn()->toString(), 'type' => $domainMessage->getType());
$connection->insert($this->tableName, $data);
}
/**
* Turns a DomainMessage into array using broadway's serializers.
*
* @param DomainMessage $message The domain message.
* @throws SerializationException When the serializers cannot perform.
* @return array An array representation of the message.
*/
private function convertDomainMessage(DomainMessage $message)
{
$metadata = $this->metadataSerializer->serialize($message->getMetadata());
$payload = $this->payloadSerializer->serialize($message->getPayload());
return ['uuid' => (string) $message->getId(), 'playhead' => $message->getPlayhead(), 'metadata' => json_encode($metadata), 'payload' => json_encode($payload), 'recorded_on' => $message->getRecordedOn()->toString(), 'type' => $message->getType()];
}
/**
* @inheritdoc
*/
public function isSatisfiedBy(DomainMessage $domainMessage)
{
$payload = $domainMessage->getPayload();
return 0 === stripos(get_class($payload), $this->namespace);
}
/**
* @inheritDoc
*/
public function handle(DomainMessage $domainMessage)
{
$this->emitter->emit($domainMessage->getPayload());
}
/**
* @param DomainMessage $domainMessage
* @return array
*/
public function createProperties(DomainMessage $domainMessage)
{
$payloadClassName = get_class($domainMessage->getPayload());
$contentType = $this->contentTypeLookup->getContentType($payloadClassName);
return ['content_type' => $contentType];
}
/**
* @inheritdoc
*/
public function createBody(DomainMessage $domainMessage)
{
$this->guardSerializable($domainMessage->getPayload());
return json_encode($domainMessage->getPayload()->serialize());
}
/**
* @param DomainMessage $object
* @return array
*/
public function serialize(DomainMessage $object)
{
return ['id' => $object->getId(), 'playhead' => $object->getPlayhead(), 'metadata' => $this->metadataSerializer->serialize($object->getMetadata()), 'payload' => $this->payloadSerializer->serialize($object->getPayload()), 'recordedOn' => $object->getRecordedOn()->toString()];
}
