SwitchableEntityManager::__construct() - Code Metrics - Inspection of "wip" - st-universe/core - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — dev ( 6bf3a3...19aaea )

by Janko
created 2024-12-20 23:20 UTC
SwitchableEntityManager::__construct() A

↳ Parent: SwitchableEntityManager
Complexity

Conditions	1
Paths	1
Size

Total Lines	11
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	4
c	1
b	0
f	0
nc	1
nop	4
dl	0
loc	11
rs	10
<?php

namespace Stu\Orm\Transaction;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\DBAL\Connection;
use Doctrine\ORM\Configuration;
use Doctrine\ORM\Decorator\EntityManagerDecorator;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use Override;
filter:
    dependency_paths: ["lib/*"]
use RuntimeException;
use Stu\Module\Logging\LoggerTypeEnum;
filter:
    dependency_paths: ["lib/*"]
use Stu\Module\Logging\LoggerUtilFactoryInterface;
use Stu\Module\Logging\RotatingLoggerInterface;
filter:
    dependency_paths: ["lib/*"]
use Stu\Orm\Transaction\EntityManagerFactoryInterface;

class SwitchableEntityManager extends EntityManagerDecorator implements SwitchableEntityManagerInterface
{
    /** @var ArrayCollection<string, EntityManagerInterface> */
    private Collection $entityManagers;

    private EntityManagerTypeEnum $currentType;
filter:
    dependency_paths: ["lib/*"]
    private EntityManagerTypeEnum $lastType;
    private RotatingLoggerInterface $logger;

    public function __construct(
        private EntityManagerFactoryInterface $entityManagerFactory,
        private Configuration $configuration,
        EntityManagerInterface $sessionEntityManager,
        LoggerUtilFactoryInterface $loggerUtilFactory
    ) {
        parent::__construct($sessionEntityManager);

        $this->entityManagers = new ArrayCollection([EntityManagerTypeEnum::SESSION->value => $sessionEntityManager]);
        $this->currentType = EntityManagerTypeEnum::SESSION;
        $this->logger = $loggerUtilFactory->getRotatingLogger(LoggerTypeEnum::EVENT_AND_ENTITY_LOCK);
        $this->logger = $loggerUtilFactory->getRotatingLogger(LoggerTypeEnum::EVENT_AND_ENTITY_LOCK);
    }

    public function switchType(EntityManagerTypeEnum $type): SwitchableEntityManager
    {
        if ($this->currentType === $type) {
            return $this;
        }

        $this->lastType = $this->currentType;
        $this->currentType =  $type;

        $key = $type->value;
        $entityManager = $this->entityManagers->get($key);
        if ($entityManager === null) {
            $entityManager = $this->setNewEntityManger($key);
        }

        $this->logger->log(sprintf(
            'SWITCH_TYPE: %s(%d)->%s(%d)',
            $this->lastType->value,
            $this->wrapped->getConnection()->getTransactionNestingLevel(),
            $key,
            $entityManager->getConnection()->getTransactionNestingLevel()
        ));

        $this->wrapped = $entityManager;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        return $this;
    }

    public function resetLastType(): SwitchableEntityManager
    {
        $this->switchType($this->lastType);

        return $this;
    }

    private function setNewEntityManger(string $key, ?Connection $connection = null): EntityManagerInterface
    {
        $newManager = $this->entityManagerFactory->createEntityManager($connection);
        $this->entityManagers->set($key, $newManager);

        return $newManager;
    }

    /**
     * Executes a function in a transaction.
     *
     * The function gets passed this EntityManager instance as an (optional) parameter.
     *
     * {@link flush} is invoked prior to transaction commit.
     *
     * If an exception occurs during execution of the function or flushing or transaction commit,
     * the transaction is rolled back, the EntityManager closed and the exception re-thrown.
     *
     * @psalm-param callable(self): T $func The function to execute transactionally.
     *
     * @return mixed The value returned from the closure.
     * @psalm-return T
     *
     * @template T
     */
    #[Override]
    public function wrapInTransaction(callable $func): mixed
    {
        if (!$this->wrapped->isOpen()) {
            $this->renewManager();
        }

        return $this->wrapped->wrapInTransaction(function (EntityManagerInterface $entityManager) use ($func) {

            return $func($entityManager);
        });
    }

    private function renewManager(EntityManagerInterface $entityManager = null): SwitchableEntityManager
    {
        // remove old manager
        $oldManager = $entityManager ?? $this->wrapped;
        /** @var string|false */
        $key = $this->entityManagers->indexOf($oldManager);
        if (!$key) {
            throw new RuntimeException(sprintf('no entity manager of type "%s" registered', $key));
            throw new RuntimeException(sprintf('no entity manager of type "%s" registered', /** @scrutinizer ignore-type */ $key));
        }
        $this->entityManagers->remove($key);
        $this->entityManagers->remove(/** @scrutinizer ignore-type */ $key);

        // create and register new manager
        $this->wrapped = $this->setNewEntityManger($key, $oldManager->getConnection());
        $this->wrapped = $this->setNewEntityManger(/** @scrutinizer ignore-type */ $key, $oldManager->getConnection());

        return $this;
    }

    public function isUninitializedObject(mixed $obj): bool
    {
        return $this->wrapped->isUninitializedObject($obj);
    }

    #[Override]
    public function getRepository(string $className): EntityRepository
    {
        return $this
            ->configuration
            ->getRepositoryFactory()
            ->getRepository($this, $className);
    }

    public function beginTransaction(): void
    {
        $this->logger->logf('%s::BEGIN_TRANSACTION', $this->currentType->value);
        $this->wrapped->beginTransaction();
    }

    public function flush(): void
    {
        if ($this->wrapped->isOpen()) {
            $this->wrapped->flush();
        } else {
            throw new TransactionException(sprintf('entity manager is closed. wrong type? (%s)', $this->currentType->value));
        }
    }

    #[Override]
    public function commit(): void
    {
        $this->logger->logf('%s::COMMIT_TRANSACTION', $this->currentType->value);

        if ($this->wrapped->getConnection()->isTransactionActive()) {
            $this->wrapped->commit();
        } else {
            throw new TransactionException(sprintf('no active transaction. wrong type? (%s)', $this->currentType->value));
        }
    }
}

st-universe / core

Push — dev ( 6bf3a3...19aaea )

SwitchableEntityManager::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
