Dsantang\DomainEventsDoctrine\Outbox\EventsHandler

Complexity

Total Complexity

10

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Test Coverage

Coverage

75.76%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	persist()	0	10	2
A	convert()	0	25	5
A	getEventAwareEntities()	0	10	1
A	getDomainsEvents()	0	16	2

<?php

declare(strict_types=1);

namespace Dsantang\DomainEventsDoctrine\Outbox;

use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Event\OnFlushEventArgs;
use Doctrine\ORM\UnitOfWork;
use Dsantang\DomainEvents\Counter;
use Dsantang\DomainEvents\DomainEvent;
use Dsantang\DomainEvents\EventAware;
use function array_filter;
use function array_merge;
use function class_exists;
use function get_class;
use function ksort;

abstract class EventsHandler
{
    /**
     * @return DomainEvent[]
     */
    protected function getDomainsEvents(OnFlushEventArgs $eventArgs) : array
    {
        $unitOfWork = $eventArgs->getEntityManager()
            ->getUnitOfWork();

        $events = [];

        foreach (self::getEventAwareEntities($unitOfWork) as $entity) {
            $events += $entity->expelRecordedEvents();
        }

        ksort($events);

        Counter::reset();

        return $events;
    }

    /**
     * @param string[]      $conversionMap
     * @param DomainEvent[] $domainEvents
     *
     * @return array
     */
    protected function convert(array $conversionMap, DomainEvent ...$domainEvents) : array
    {
        $outboxEntries = [];

        foreach ($domainEvents as $domainEvent) {
            $domainEventClassName = get_class($domainEvent);

            if (! isset($conversionMap[$domainEventClassName])) {
                continue;
            }

            if (! class_exists($conversionMap[$domainEventClassName])) {
                continue;
            }

            $outboxEvent = new $conversionMap[$domainEventClassName]($domainEvent);

            if (! $outboxEvent instanceof OutboxEntry) {
                continue;
            }

            $outboxEntries[] = $outboxEvent;
        }

        return $outboxEntries;
    }

    protected function persist(
        EntityManagerInterface $entityManager,
        OutboxMappedSuperclass $outboxMappedSuperclass,
        OutboxEntry ...$outboxEntries
    ) : void {
        foreach ($outboxEntries as $outboxEntry) {
            $entityManager->persist($outboxMappedSuperclass->withOutboxEntry($outboxEntry));
        }

        $entityManager->getUnitOfWork()->computeChangeSets();
    }

    abstract function onFlush(OnFlushEventArgs $eventArgs) : void;

It is generally recommended to explicitly declare the visibility for methods.

    /**
     * @return EventAware[]
     */
    private static function getEventAwareEntities(UnitOfWork $unitOfWork) : array
    {
        $entities = array_merge(
            $unitOfWork->getScheduledEntityInsertions(),
            $unitOfWork->getScheduledEntityUpdates(),
            $unitOfWork->getScheduledEntityDeletions()
        );

        return array_filter($entities, static function ($entity) {
            return $entity instanceof EventAware;
        });
    }
}