Dtc\GridBundle\Manager\GridSourceManager

Complexity

Total Complexity

30

Size/Duplication

Total Lines	170
Duplicated Lines	4.71 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	setReflectionAllowedEntities()	0	3	3
A	setRegistry()	0	4	1
A	setMongodbRegistry()	0	4	1
A	getCacheDir()	0	4	1
A	getDebug()	0	4	1
A	add()	0	4	1
B	getGridSource()	0	31	6
B	get()	8	29	11
A	all()	0	4	2
A	setEntityManager()	0	4	1
A	setDocumentManager()	0	4	1

<?php

namespace Dtc\GridBundle\Manager;

use Doctrine\Common\Annotations\Reader;
use Doctrine\Common\Persistence\AbstractManagerRegistry;
use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\ODM\MongoDB\DocumentManager;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\EntityManagerInterface;
use Dtc\GridBundle\Grid\Source\DocumentGridSource;
use Dtc\GridBundle\Grid\Source\EntityGridSource;
use Dtc\GridBundle\Grid\Source\GridSourceInterface;

class GridSourceManager
{
    protected $sourcesByClass;
    protected $sourcesByName;

    protected $reader;
    protected $cacheDir;
    protected $debug;

    /** @var AbstractManagerRegistry */
    protected $registry;

    /** @var AbstractManagerRegistry */
    protected $mongodbRegistry;

    protected $customManagerMappings;

    protected $extraGridSources;

    /**
     * @var array|null Null means all entities allowed, empty array means no entities allowed
     */
    protected $reflectionAllowedEntities;

    /**
     * GridSourceManager constructor.
     *
     * @param string $cacheDir
     * @param bool   $debug
     */
    public function __construct(Reader $reader, $cacheDir, $debug = false)
    {
        $this->cacheDir = $cacheDir;
        $this->reader = $reader;
        $this->reflectionAllowedEntities = [];
        $this->debug = $debug;
        $this->sources = array();

The property sources does not seem to exist. Did you mean sourcesByClass?

    }

    /**
     * @param array|string $allowedEntities Array of allowed entities or string '*' to allow all entities. Use empty array to specify no entities allowed for reflection.
     */
    public function setReflectionAllowedEntities($allowedEntities) {
        $this->reflectionAllowedEntities = is_array($allowedEntities) ? array_flip($allowedEntities) : ('*' === $allowedEntities ? null : []);
    }

    public function setRegistry(AbstractManagerRegistry $registry)
    {
        $this->registry = $registry;
    }

    public function setMongodbRegistry(AbstractManagerRegistry $registry)
    {
        $this->mongodbRegistry = $registry;
    }

    /**
     * @return string
     */
    protected function getCacheDir()
    {
        return $this->cacheDir;
    }

    /**
     * @return bool
     */
    protected function getDebug()
    {
        return $this->debug;
    }

    public function add($id, GridSourceInterface $gridSource)
    {
        $this->extraGridSources[$id] = $gridSource;
    }

    /**
     * @param ObjectManager $manager
     * @param $entityOrDocument
     *
     * @return DocumentGridSource|EntityGridSource|null
     */
    protected function getGridSource($manager, $entityOrDocument)
    {
        $repository = $manager->getRepository($entityOrDocument);
        if ($repository) {
            $className = $repository->getClassName();
            $classMetadata = $manager->getClassMetadata($className);
            $name = $classMetadata->getName();
            $reflectionClass = $classMetadata->getReflectionClass();
            $annotation = $this->reader->getClassAnnotation($reflectionClass, 'Dtc\GridBundle\Annotation\Grid');
            if (!$annotation && !isset($this->reflectionAllowedEntities[$entityOrDocument]) && null !== $this->reflectionAllowedEntities) {
                throw new \Exception("GridSource requested for '$entityOrDocument' but no Grid annotation found");
            }
            if ($manager instanceof EntityManagerInterface) {
                $gridSource = new EntityGridSource($manager, $name);

$manager of type object<Doctrine\ORM\EntityManagerInterface> is not a sub-type of object<Doctrine\ORM\EntityManager>. It seems like you assume a concrete implementation of the interface Doctrine\ORM\EntityManagerInterface to be always present.

            } else {
                $gridSource = new DocumentGridSource($manager, $name);

$manager of type object<Doctrine\Common\Persistence\ObjectManager> is not a sub-type of object<Doctrine\ODM\MongoDB\DocumentManager>. It seems like you assume a concrete implementation of the interface Doctrine\Common\Persistence\ObjectManager to be always present.

            }
            $gridSource->setAnnotationReader($this->reader);
            $gridSource->setCacheDir($this->cacheDir);

            $gridSource->setDebug($this->debug);
            $gridSource->autoDiscoverColumns();
            $this->sourcesByName[$name] = $gridSource;
            $this->sourcesByClass[$className] = $gridSource;
            $gridSource->setId($className);

            return $gridSource;
        }

        return null;
    }

    /**
     * Get a gridsource.
     *
     * @param string                             $id      Entity or Document

There is no parameter named $id. Was it maybe removed?

     * @param EntityManager|DocumentManager|null $manager (optional) Entity or Document manager to use (overrides default)

There is no parameter named $manager. Was it maybe removed?

     *
     * @return GridSourceInterface|null
     *
     * @throws \Exception
     */
    public function get($entityOrDocumentNameOrId)
    {
        // @Support legacy method of adding/removing grid sources
        if (isset($this->extraGridSources[$entityOrDocumentNameOrId])) {
            return $this->extraGridSources[$entityOrDocumentNameOrId];
        }

        if (isset($this->sourcesByClass[$entityOrDocumentNameOrId])) {
            return $this->sourcesByClass[$entityOrDocumentNameOrId];
        }

        if (isset($this->sourcesByName[$entityOrDocumentNameOrId])) {
            return $this->sourcesByName[$entityOrDocumentNameOrId];
        }

        try {
            if ($this->registry && ($manager = $this->registry->getManagerForClass($entityOrDocumentNameOrId)) &&

This code seems to be duplicated across your project.

                $gridSource = $this->getGridSource($manager, $entityOrDocumentNameOrId)) {
                return $gridSource;
            }
        } catch (\ReflectionException $exception) {

Consider adding a comment why this CATCH block is empty.

        }

        if ($this->mongodbRegistry && ($manager = $this->mongodbRegistry->getManagerForClass($entityOrDocumentNameOrId)) &&

This code seems to be duplicated across your project.

            $gridSource = $this->getGridSource($manager, $entityOrDocumentNameOrId)) {
            return $gridSource;
        }
        throw new \Exception("Can't find grid source for $entityOrDocumentNameOrId");
    }

    public function all()
    {
        return isset($this->sourcesByName) ? array_values($this->sourcesByName) : [];
    }

    public function setEntityManager(EntityManager $entityManager)

You have injected the EntityManager via parameter $entityManager. This is generally not recommended as it might get closed and become unusable. Instead, it is recommended to inject the ManagerRegistry and retrieve the EntityManager via getManager() each time you need it.

    {
        $this->entityManager = $entityManager;

The property entityManager does not exist. Did you maybe forget to declare it?

    }

    public function setDocumentManager(DocumentManager $documentManager)
    {
        $this->documentManager = $documentManager;

The property documentManager does not exist. Did you maybe forget to declare it?

    }
}