Dontdrinkandroot\Repository\OrmEntityRepository

Complexity

Total Complexity

27

Size/Duplication

Total Lines	233
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

87.38%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	25	4
A	persist()	0	14	2
A	merge()	0	14	2
A	flush()	0	4	1
A	detach()	0	4	1
A	remove()	0	12	2
A	removeById()	0	10	1
A	removeAll()	0	16	3
A	getTransactionManager()	0	4	1
A	removeAllByIterating()	0	17	3
A	removeAllByQuery()	0	11	1
A	findPaginatedBy()	0	25	4
A	countAll()	0	15	1
A	createBlankQueryBuilder()	0	4	1

<?php

namespace Dontdrinkandroot\Repository;

use Doctrine\Common\Persistence\ManagerRegistry;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\QueryBuilder;
use Doctrine\ORM\Tools\Pagination\Paginator;
use Dontdrinkandroot\Entity\EntityInterface;

/**
 * @author Philip Washington Sorst <philip@sorst.net>
 */
class OrmEntityRepository extends EntityRepository implements EntityRepositoryInterface
{
    protected $transactionManager;

    /**
     * OrmEntityRepository constructor.
     *
     * @param ManagerRegistry|EntityManagerInterface $registryOrManager
     * @param string|ClassMetadata                   $classNameOrMetadata
     * @param TransactionManager|null                $transactionManager
     */
    public function __construct(
        $registryOrManager,
        $classNameOrMetadata,
        ?TransactionManager $transactionManager = null
    ) {
        if ($registryOrManager instanceof ManagerRegistry) {
            $manager = $registryOrManager->getManagerForClass($classNameOrMetadata);

It seems like $classNameOrMetadata defined by parameter $classNameOrMetadata on line 29 can also be of type object<Doctrine\ORM\Mapping\ClassMetadata>; however, Doctrine\Common\Persistence\ManagerRegistry::getManagerForClass() does only seem to accept string, maybe add an additional type check?

        } else {
            $manager = $registryOrManager;
        }

        if ($classNameOrMetadata instanceof ClassMetadata) {
            $classMetadata = $classNameOrMetadata;
        } else {
            $classMetadata = $manager->getClassMetadata($classNameOrMetadata);
        }

        parent::__construct($manager, $classMetadata);

$manager is of type object<Doctrine\Common\Persistence\ObjectManager>|null, but the function expects a object<Doctrine\ORM\EntityManagerInterface>.

        if (null === $transactionManager) {
            $this->transactionManager = new TransactionManager($manager);

$manager is of type object<Doctrine\Common\Persistence\ObjectManager>|null, but the function expects a object<Doctrine\ORM\EntityManagerInterface>.

        } else {
            $this->transactionManager = $transactionManager;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function persist($entity, $flush = true)
    {
        return $this->transactionManager->transactional(
            function () use ($entity, $flush) {
                $this->getEntityManager()->persist($entity);

                if ($flush) {
                    $this->getEntityManager()->flush($entity);
                }

                return $entity;
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function merge($entity, $flush = false)
    {
        return $this->transactionManager->transactional(
            function () use ($entity, $flush) {
                $entity = $this->getEntityManager()->merge($entity);

Consider using a different name than the imported variable $entity, or did you forget to import by reference?

                if ($flush) {
                    $this->getEntityManager()->flush($entity);
                }

                return $entity;
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function flush($entity = null)
    {
        $this->getEntityManager()->flush($entity);
    }

    /**
     * {@inheritdoc}
     */
    public function detach($entity)
    {
        $this->getEntityManager()->detach($entity);
    }

    /**
     * {@inheritdoc}
     */
    public function remove($entity, $flush = false)
    {
        return $this->transactionManager->transactional(
            function () use ($entity, $flush) {
                $this->getEntityManager()->remove($entity);

                if ($flush) {
                    $this->getEntityManager()->flush($entity);
                }
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function removeById($id, $flush = false)
    {
        return $this->transactionManager->transactional(
            function () use ($id, $flush) {
                /** @var EntityInterface $entity */
                $entity = $this->find($id);
                $this->remove($entity, $flush);
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function removeAll($flush = false, $iterate = true)
    {
        return $this->transactionManager->transactional(
            function () use ($flush, $iterate) {
                if ($iterate) {
                    $this->removeAllByIterating();
                } else {
                    $this->removeAllByQuery();
                }

                if ($flush) {
                    $this->getEntityManager()->flush();
                }
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function getTransactionManager()
    {
        return $this->transactionManager;
    }

    protected function removeAllByIterating($batchSize = 100)
    {
        return $this->transactionManager->transactional(
            function () use ($batchSize) {
                $entities = $this->findAll();
                $count = 0;
                foreach ($entities as $entity) {
                    $this->remove($entity, false);
                    $count++;
                    if ($count >= $batchSize) {
                        $this->getEntityManager()->flush();
                        $count = 0;
                    }
                }
            }
        );
    }

    protected function removeAllByQuery()
    {
        return $this->transactionManager->transactional(
            function () {
                $queryBuilder = $this->createQueryBuilder('entity');
                $queryBuilder->delete();
                $query = $queryBuilder->getQuery();
                $query->execute();
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function findPaginatedBy($page = 1, $perPage = 10, array $criteria = [], array $orderBy = null)
    {
        return $this->transactionManager->transactional(
            function () use ($page, $perPage, $criteria, $orderBy) {

                $queryBuilder = $this->createQueryBuilder('entity');

                foreach ($criteria as $field => $value) {
                    $queryBuilder->andWhere('entity.' . $field . ' = :' . $field);
                    $queryBuilder->setParameter($field, $value);
                }

                if (null !== $orderBy) {
                    foreach ($orderBy as $field => $order) {
                        $queryBuilder->addOrderBy('entity.' . $field, $order);
                    }
                }

                $queryBuilder->setFirstResult(($page - 1) * $perPage);
                $queryBuilder->setMaxResults($perPage);

                return new Paginator($queryBuilder);
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function countAll()
    {
        return $this->transactionManager->transactional(
            function () {
                $queryBuilder = $this->getEntityManager()->createQueryBuilder();
                $queryBuilder
                    ->select('count(entity)')
                    ->from($this->getClassName(), 'entity');

                $result = $queryBuilder->getQuery()->getSingleScalarResult();

                return $result;
            }
        );
    }

    /**
     * @return QueryBuilder
     */
    protected function createBlankQueryBuilder()
    {
        return $this->getEntityManager()->createQueryBuilder();
    }
}