TomCizek\ResponseRecorder\Application\ResponseRecorder

Complexity

Total Complexity

13

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	recordOn()	0	18	4
A	attachRecordingCallbackToEventbus()	0	9	1
A	getRecordingCallback()	0	10	2
A	handleCommandDispatchException()	0	11	2
A	handleShowableException()	0	11	1
A	handleFatalException()	0	12	1
A	logFatalError()	0	5	1

<?php declare(strict_types = 1);

namespace TomCizek\ResponseRecorder\Application;

use Prooph\Common\Event\ActionEvent;
use Prooph\Common\Messaging\DomainEvent;
use Prooph\ServiceBus\EventBus;
use Prooph\ServiceBus\Exception\CommandDispatchException;
use Prooph\ServiceBus\MessageBus;
use Psr\Log\LoggerInterface;
use Throwable;
use TomCizek\ResponseRecorder\Application\ResponseRecorder\BasicMutationResponse;
use TomCizek\ResponseRecorder\Application\ResponseRecorder\MutationResponse\BasicMutationResponseBuilder;
use TomCizek\ResponseRecorder\Application\ResponseRecorder\MutationResponse\ErrorCollection\GenericShowableMutationError;
use TomCizek\ResponseRecorder\DomainModel\ShowableTranslatableDomainException;

final class ResponseRecorder
{
	public const FATAL_ERROR_MESSAGE = 'fatal_error_occured_logged';

	/** @var EventBus */
	private $eventBus;

	/** @var LoggerInterface */
	private $logger;

	public function __construct(EventBus $eventBus, LoggerInterface $logger)
	{
		$this->eventBus = $eventBus;
		$this->logger = $logger;
	}

	public function recordOn($callback): BasicMutationResponse
	{
		$responseBuilder = BasicMutationResponseBuilder::create();

		$this->attachRecordingCallbackToEventbus($responseBuilder);

		try {
			$callback();
		} catch (CommandDispatchException $exception) {

The class Prooph\ServiceBus\Exception\CommandDispatchException does not exist. Did you forget a USE statement, or did you not list all dependencies?

			$this->handleCommandDispatchException($exception, $responseBuilder);
		} catch (ShowableTranslatableDomainException $exception) {
			$this->handleShowableException($exception, $responseBuilder);
		} catch (Throwable $exception) {
			$this->handleFatalException($exception, $responseBuilder);
		}

		return $responseBuilder->build();
	}

	private function attachRecordingCallbackToEventbus(
		BasicMutationResponseBuilder $responseBuilder
	): void {
		$this->eventBus->attach(
			EventBus::EVENT_DISPATCH,
			$this->getRecordingCallback($responseBuilder),
			-1000
		);
	}

	private function getRecordingCallback(BasicMutationResponseBuilder $responseBuilder): \Closure
	{
		return function (ActionEvent $actionEvent) use ($responseBuilder): void {
			$event = $actionEvent->getParam(MessageBus::EVENT_PARAM_MESSAGE);
			if (!$event instanceof DomainEvent) {

The class Prooph\Common\Messaging\DomainEvent does not exist. Did you forget a USE statement, or did you not list all dependencies?

				return;
			}
			$responseBuilder->addDomainEvent($event);
		};
	}

	private function handleCommandDispatchException(
		CommandDispatchException $exception,
		BasicMutationResponseBuilder $responseBuilder
	): void {
		$previous = $exception->getPrevious();
		if ($previous instanceof ShowableTranslatableDomainException) {
			$this->handleShowableException($previous, $responseBuilder);
		} else {
			$this->handleFatalException($exception, $responseBuilder);
		}
	}

	protected function handleShowableException(
		ShowableTranslatableDomainException $exception,
		BasicMutationResponseBuilder $responseBuilder
	): void {
		$responseBuilder->addError(
			GenericShowableMutationError::create(
				$exception->getMessage(),
				$exception->getMessageParameters()
			)
		);
	}

	protected function handleFatalException(
		Throwable $exception,
		BasicMutationResponseBuilder $responseBuilder
	): void {
		$this->logFatalError($exception);

		$responseBuilder->addError(
			GenericShowableMutationError::create(
				self::FATAL_ERROR_MESSAGE
			)
		);
	}

	private function logFatalError(
		Throwable $exception
	): void {
		$this->logger->error($exception);
	}
}