Arp\LaminasDoctrine\Service\EntityManager\EntityManagerProvider

Complexity

Total Complexity

20

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	setEntityManagers()	0	7	3
A	getEntityManager()	0	22	6
A	setEntityManager()	0	3	1
A	refresh()	0	14	3
A	setEntityManagerConfig()	0	3	1
A	hasEntityManager()	0	3	2
A	__construct()	0	6	1
A	create()	0	18	3

<?php

declare(strict_types=1);

namespace Arp\LaminasDoctrine\Service\EntityManager;

use Arp\LaminasDoctrine\Config\DoctrineConfig;
use Arp\LaminasDoctrine\Factory\Service\EntityManagerFactory;
use Arp\LaminasDoctrine\Service\EntityManager\Exception\EntityManagerProviderException;
use Doctrine\ORM\EntityManagerInterface;
use Psr\Container\ContainerExceptionInterface;

/**
 * @author  Alex Patterson <alex.patterson.webdev@gmail.com>
 * @package Arp\LaminasDoctrine\Service\EntityManager
 */
final class EntityManagerProvider implements EntityManagerProviderInterface
{
    /**
     * @var DoctrineConfig
     */
    private DoctrineConfig $config;

    /**
     * @var ContainerInterface
     */
    private ContainerInterface $container;

    /**
     * @param DoctrineConfig     $config
     * @param ContainerInterface $container
     * @param array              $entityManagers
     */
    public function __construct(DoctrineConfig $config, ContainerInterface $container, array $entityManagers = [])
    {
        $this->config = $config;
        $this->container = $container;

        $this->setEntityManagers($entityManagers);
    }

    /**
     * @param string $name
     *
     * @return EntityManagerInterface
     *
     * @throws EntityManagerProviderException
     */
    public function getEntityManager(string $name): EntityManagerInterface
    {
        try {
            if (!$this->container->has($name) && $this->config->hasEntityManagerConfig($name)) {
                $this->container->setService($name, $this->create($name, $this->config->getEntityManagerConfig($name)));
            }

            if ($this->container->has($name)) {
                return $this->container->get($name);
            }
        } catch (EntityManagerProviderException $e) {
            throw $e;
        } catch (ContainerExceptionInterface $e) {
            throw new EntityManagerProviderException(
                sprintf('Failed retrieve entity manager \'%s\': %s', $name, $e->getMessage()),

The method getMessage() does not exist on Psr\Container\ContainerExceptionInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Psr\Container\NotFoundExceptionInterface or Interop\Container\Exception\ContainerException or Interop\Container\Exception\NotFoundException or Interop\Container\Exception\NotFoundException or Laminas\ServiceManager\Exception\ExceptionInterface. Are you sure you never get one of those?

                $e->getCode(),

The method getCode() does not exist on Psr\Container\ContainerExceptionInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Psr\Container\NotFoundExceptionInterface or Interop\Container\Exception\ContainerException or Interop\Container\Exception\NotFoundException or Interop\Container\Exception\NotFoundException or Laminas\ServiceManager\Exception\ExceptionInterface. Are you sure you never get one of those?

                $e
            );
        }

        throw new EntityManagerProviderException(
            sprintf('Unable to find entity manager \'%s\'', $name)
        );
    }

    /**
     * @param string $name
     *
     * @return EntityManagerInterface
     *
     * @throws EntityManagerProviderException
     */
    public function refresh(string $name): EntityManagerInterface
    {
        $entityManager = $this->getEntityManager($name);

        if ($this->container->has($name)) {
            if ($entityManager->isOpen()) {
                $entityManager->close();
            }

            $entityManager = $this->create($name, $this->config->getEntityManagerConfig($name));
            $this->container->setService($name, $entityManager);
        }

        return $entityManager;
    }

    /**
     * Set the configuration options for a single entity manager with the provided $name
     *
     * @param string $name
     * @param array  $config
     */
    public function setEntityManagerConfig(string $name, array $config): void
    {
        $this->config->setEntityManagerConfig($name, $config);
    }

    /**
     * Check if the entity manager is registered with the provider
     *
     * @param string $name The name of the entity manager to check
     *
     * @return bool
     */
    public function hasEntityManager(string $name): bool
    {
        return $this->container->has($name) || $this->config->hasEntityManagerConfig($name);
    }

    /**
     * @param string                 $name
     * @param EntityManagerInterface $entityManager
     */
    public function setEntityManager(string $name, EntityManagerInterface $entityManager): void
    {
        $this->container->setService($name, $entityManager);
    }

    /**
     * @param array $entityManagers
     */
    public function setEntityManagers(array $entityManagers): void
    {
        foreach ($entityManagers as $name => $entityManager) {
            if (is_array($entityManager)) {
                $this->setEntityManagerConfig($name, $entityManager);
            } else {
                $this->setEntityManager($name, $entityManager);
            }
        }
    }

    /**
     * @param string      $name
     * @param array       $config
     * @param string|null $factoryClassName
     *
     * @return EntityManagerInterface
     *
     * @throws EntityManagerProviderException
     */
    private function create(string $name, array $config, string $factoryClassName = null): EntityManagerInterface
    {
        // We must exclude calls from refresh() so we need to check
        if (!$this->container->has($name)) {
            /**
             * There is no manual entry for this entity manager. We can manually add it so we do not need
             * to explicitly define it each time with the 'entity_manager_container'
             */
            $this->container->setFactory($name, $factoryClassName ?? EntityManagerFactory::class);
        }

        try {
            return $this->container->build($name, $config);
        } catch (ContainerExceptionInterface $e) {
            throw new EntityManagerProviderException(
                sprintf('Failed to create entity manager \'%s\' from configuration: %s', $name, $e->getMessage()),
                $e->getCode(),
                $e
            );
        }
    }
}