Mgid\Component\Pagination\Paginator

Complexity

Total Complexity

12

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getMapping()	0	3	1
A	paginate()	0	23	2
A	addAdapter()	0	3	1
A	addNormalizer()	0	3	1
A	__construct()	0	4	1
A	validate()	0	6	2
A	getNormalizer()	0	3	1
A	getAdapter()	0	9	3

<?php declare(strict_types=1);

namespace Mgid\Component\Pagination;

use Mgid\Component\Pagination\Mapping\Mapping;
use Symfony\Component\Validator\Validator\ValidatorInterface;
use Mgid\Component\Pagination\Mapping\MappingInterface;
use Mgid\Component\Pagination\Normalizer\ChainNormalizer;
use Symfony\Component\Validator\Exception\ValidationFailedException;
use Mgid\Component\Pagination\Normalizer\NormalizerInterface;

final class Paginator implements PaginatorInterface
{
    /**
     * @var array<string,string>
     */
    private array $adapters = [];

    /**
     * @var array<string,array<NormalizerInterface>>
     */
    private array $normalizers = [];

    /**
     * @var MappingInterface
     */
    private MappingInterface $mapping;

    /**
     * @var ValidatorInterface
     */
    private ValidatorInterface $validator;

    /**
     * @param ValidatorInterface $validator
     */
    public function __construct(ValidatorInterface $validator)
    {
        $this->mapping = new Mapping();
        $this->validator = $validator;
    }

    /**
     * {@inheritdoc}
     */
    public function getMapping(): MappingInterface
    {
        return $this->mapping;
    }

    /**
     * {@inheritdoc}
     */
    public function addAdapter(string $queryBuilderClassName, string $adapterClassName): void
    {
        $this->adapters[$queryBuilderClassName] = $adapterClassName;
    }

    /**
     * {@inheritdoc}
     */
    public function addNormalizer(string $queryBuilderClassName, NormalizerInterface $normalizer): void
    {
        $this->normalizers[$queryBuilderClassName][] = $normalizer;
    }

    /**
     * {@inheritdoc}
     */
    public function paginate(object $queryBuilder, InputInterface $input): OutputInterface
    {
        $this->validate($input);

        $adapter = $this->getAdapter($queryBuilder);
        $normalizer = $this->getNormalizer(\get_class($queryBuilder));

        $this->mapping->setRootAlias($adapter->getRootAlias());
        $this->mapping->normalize($input, $normalizer);

        $adapter->addFilters($input);

        $items = [];
        $count = $adapter->getCount();

        if ($count > 0) {
            $adapter->addOrders($input);
            $adapter->addPagination($input);

            $items = $adapter->getItems();
        }

        return new Output($count, $items);
    }

    /**
     * @param object $queryBuilder
     *
     * @return Adapter\QueryBuilderAdapterInterface
     */
    private function getAdapter(object $queryBuilder): Adapter\QueryBuilderAdapterInterface
    {
        foreach ($this->adapters as $queryBuilderClassName => $adapterClassName) {
            if ($queryBuilder instanceof $queryBuilderClassName) {
                return new $adapterClassName($queryBuilder);
            }
        }

        throw new \RuntimeException(\sprintf('No adapter found for query builder of %s', \get_class($queryBuilder)));
    }

    /**
     * @param string $queryBuilderClassName
     *
     * @return NormalizerInterface
     */
    private function getNormalizer(string $queryBuilderClassName): NormalizerInterface
    {
        return new ChainNormalizer($this->normalizers[$queryBuilderClassName] ?? []);
    }

    /**
     * @param InputInterface $input
     *
     * @throws ValidationFailedException
     */
    private function validate(InputInterface $input): void
    {
        $violations = $this->validator->validate($input);

        if ($violations->count()) {
            throw new ValidationFailedException($input, $violations);
        }
    }
}