Dontdrinkandroot\Repository\TransactionManager

Complexity

Total Complexity

14

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

80.48%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	beginTransaction()	0	4	1
A	commitTransaction()	0	21	4
A	rollbackTransaction()	0	14	3
A	isInTransaction()	0	4	1
A	transactional()	0	20	3
A	setLogger()	0	4	1

<?php

namespace Dontdrinkandroot\Repository;

use Doctrine\ORM\EntityManagerInterface;
use Exception;
use InvalidArgumentException;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

/**
 * @author Philip Washington Sorst <philip@sorst.net>
 */
class TransactionManager
{
    /** @var LoggerInterface */
    private $logger;

    /** @var EntityManagerInterface */
    private $entityManager;

    public function __construct(EntityManagerInterface $entityManager)
    {
        $this->entityManager = $entityManager;
        $this->logger = new NullLogger();
    }

    public function beginTransaction(): void
    {
        $this->entityManager->beginTransaction();
    }

    public function commitTransaction(bool $forceFlush = false): bool
    {
        $nestingLevel = $this->entityManager->getConnection()->getTransactionNestingLevel();

        /* No active transaction */
        if (!$this->isInTransaction()) {
            $this->logger->warning('No active Transaction for commit');

            return false;
        }

        $flushed = false;
        /* Topmost transaction, flush */
        if (1 === $nestingLevel || $forceFlush) {
            $flushed = true;
            $this->entityManager->flush();
        }
        $this->entityManager->commit();

        return $flushed;
    }

    public function rollbackTransaction(bool $closeEmOnException = true): void
    {
        /* No active transaction */
        if (!$this->isInTransaction()) {
            $this->logger->warning('No active Transaction for commit');

            return;
        }

        if ($closeEmOnException) {
            $this->entityManager->close();
        }
        $this->entityManager->rollback();
    }

    public function isInTransaction(): bool
    {
        return 0 !== $this->entityManager->getConnection()->getTransactionNestingLevel();
    }

    public function transactional(Callable $func, bool $forceFlush = false, bool $closeEmOnException = true)
    {
        if (!is_callable($func)) {
            throw new InvalidArgumentException('Expected argument of type "callable", got "' . gettype($func) . '"');
        }

        $this->beginTransaction();

        try {
            $return = call_user_func($func, $this);

            $this->commitTransaction($forceFlush);

            return $return;
        } catch (Exception $e) {
            $this->rollbackTransaction($closeEmOnException);

            throw $e;
        }
    }

    public function setLogger(LoggerInterface $logger): void
    {
        $this->logger = $logger;
    }
}