Dontdrinkandroot\Repository\CrudRepository

Complexity

Total Complexity

22

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

74.23%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	persist()	0	10	2
A	flush()	0	4	1
A	detach()	0	4	1
A	findPaginatedBy()	0	24	4
A	countAll()	0	9	1
A	removeAllByIterating()	0	13	3
A	removeAllByQuery()	0	7	1
A	createBlankQueryBuilder()	0	4	1
A	merge()	0	10	2
A	removeById()	0	6	1
A	remove()	0	8	2
A	removeAll()	0	12	3

<?php

namespace Dontdrinkandroot\Repository;

use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\QueryBuilder;
use Doctrine\ORM\Tools\Pagination\Paginator;
use Dontdrinkandroot\Entity\EntityInterface;

/**
 * @author Philip Washington Sorst <philip@sorst.net>
 */
class CrudRepository extends EntityRepository implements CrudRepositoryInterface
{
    /**
     * {@inheritdoc}
     */
    public function persist(object $entity, bool $flush = true): object
    {
        $this->getEntityManager()->persist($entity);

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

        return $entity;
    }

    /**
     * {@inheritdoc}
     */
    public function merge(object $entity, bool $flush = false): object
    {
        $entity = $this->getEntityManager()->merge($entity);

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

        return $entity;
    }

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

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

    /**
     * {@inheritdoc}
     */
    public function removeById($id, bool $flush = false): void
    {
        /** @var EntityInterface $entity */
        $entity = $this->find($id);
        $this->remove($entity, $flush);
    }

    /**
     * {@inheritdoc}
     */
    public function remove(object $entity, bool $flush = false): void
    {
        $this->getEntityManager()->remove($entity);

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

    /**
     * {@inheritdoc}
     */
    public function removeAll(bool $flush = false, bool $iterate = true): void
    {
        if ($iterate) {
            $this->removeAllByIterating();
        } else {
            $this->removeAllByQuery();
        }

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

    /**
     * {@inheritdoc}
     */
    public function findPaginatedBy(
        int $page = 1,
        int $perPage = 10,
        array $criteria = [],
        array $orderBy = null
    ): Paginator {
        $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(): int
    {
        $queryBuilder = $this->getEntityManager()->createQueryBuilder();
        $queryBuilder
            ->select('count(entity)')
            ->from($this->getClassName(), 'entity');

        return $queryBuilder->getQuery()->getSingleScalarResult();
    }

    protected function removeAllByIterating(int $batchSize = 100): void
    {
        $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(): void
    {
        $queryBuilder = $this->createQueryBuilder('entity');
        $queryBuilder->delete();
        $query = $queryBuilder->getQuery();
        $query->execute();
    }

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