Halapi\Factory\PaginationFactory

Complexity

Total Complexity

9

Size/Duplication

Total Lines	172
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
B	getRepresentation()	0	38	3
A	setPagerStrategy()	0	12	2
A	getPagerAdapter()	0	6	1
B	addPaginationParams()	0	28	1
A	getPaginatedRoute()	0	11	1

<?php

namespace Halapi\Factory;

use Doctrine\Common\Persistence\ObjectManager;
use Halapi\Representation\PaginatedRepresentation;
use Pagerfanta\Adapter\AdapterInterface;
use Pagerfanta\Pagerfanta;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

/**
 * Class PaginationFactory.
 *
 * @author Romain Richard
 */
class PaginationFactory
{
    /**
     * @var ObjectManager
     */
    public $objectManager;

    /**
     * @var UrlGeneratorInterface
     */
    public $urlGenerator;

    /**
     * @var RequestStack
     */
    private $requestStack;

    /**
     * @var string
     */
    private $pagerStrategy;

    /**
     * PaginationFactory constructor.
     *
     * @param UrlGeneratorInterface $urlGenerator
     * @param ObjectManager         $objectManager
     * @param RequestStack          $requestStack
     * @param string                $pagerStrategy
     */
    public function __construct(
        UrlGeneratorInterface $urlGenerator,
        ObjectManager $objectManager,
        RequestStack $requestStack,
        $pagerStrategy = 'ORM'
    ) {
        $this->urlGenerator = $urlGenerator;
        $this->objectManager = $objectManager;
        $this->requestStack = $requestStack;
        $this->setPagerStrategy($pagerStrategy);
    }

    /**
     * Get a paginated representation of a collection of entities.
     *
     * @param string $className
     *
     * @return PaginatedRepresentation
     */
    public function getRepresentation($className)
    {
        $shortName = (new \ReflectionClass($className))->getShortName();
        $repository = $this->objectManager->getRepository($className);
        if (!is_callable([$repository, 'findAllSorted'])) {
            throw new \BadMethodCallException(sprintf(
                "Your repository for the object %s must implement the 'findAllSorted' method
                \n
                Prototype: findAllSorted(array \$sorting, array \$filterValues, array \$filerOperators)",
                $shortName
            ));
        }

        list($page, $limit, $sorting, $filterValues, $filerOperators) = array_values($this->addPaginationParams());
        $queryBuilder = $repository->findAllSorted($sorting, $filterValues, $filerOperators);

The method findAllSorted() does not exist on Doctrine\Common\Persistence\ObjectRepository. Did you maybe mean findAll()?

        $pagerAdapter = $this->getPagerAdapter($queryBuilder);
        $pager = new Pagerfanta($pagerAdapter);
        $pager->setMaxPerPage($limit);
        $pager->setCurrentPage($page);

        return new PaginatedRepresentation(
            $page,
            $limit,
            [
                'self' => $this->getPaginatedRoute($shortName, $limit, $page, $sorting),
                'first' => $this->getPaginatedRoute($shortName, $limit, 1, $sorting),
                'next' => $this->getPaginatedRoute(
                    $shortName,
                    $limit,
                    $page < $pager->getNbPages() ? $page + 1 : $pager->getNbPages(),
                    $sorting
                ),
                'last' => $this->getPaginatedRoute($shortName, $limit, $pager->getNbPages(), $sorting),
            ],
            (array) $pager->getCurrentPageResults()
        );
    }

    /**
     * @param string $pagerStrategy
     */
    public function setPagerStrategy($pagerStrategy)
    {
        if (!class_exists('Pagerfanta\Adapter\Doctrine'.$pagerStrategy.'Adapter')) {
            throw new \InvalidArgumentException(sprintf(
                'No adapter named %s found in %s namespace',
                'Doctrine'.$pagerStrategy.'Adapter',
                'Pagerfanta\Adapter'
            ));
        }

        $this->pagerStrategy = $pagerStrategy;
    }

    /**
     * @param object $queryBuilder
     *
     * @return AdapterInterface
     */
    private function getPagerAdapter($queryBuilder)
    {
        $adapterClassName = 'Pagerfanta\Adapter\Doctrine'.$this->pagerStrategy.'Adapter';

        return new $adapterClassName($queryBuilder);
    }

    /**
     * Get the pagination parameters, filtered.
     *
     * @return array
     */
    private function addPaginationParams()
    {
        $resolver = new OptionsResolver();

        $resolver->setDefaults(array(
            'page' => '1',
            'limit' => '20',
            'sorting' => [],
            'filtervalue' => [],
            'filteroperator' => [],
        ));

        $resolver->setAllowedTypes('page', ['NULL', 'string']);
        $resolver->setAllowedTypes('limit', ['NULL', 'string']);
        $resolver->setAllowedTypes('sorting', ['NULL', 'array']);
        $resolver->setAllowedTypes('filtervalue', ['NULL', 'array']);
        $resolver->setAllowedTypes('filteroperator', ['NULL', 'array']);

        $request = $this->requestStack->getMasterRequest();

        return $resolver->resolve(array_filter([
            'page' => $request->query->get('page'),
            'limit' => $request->query->get('limit'),
            'sorting' => $request->query->get('sorting'),
            'filtervalue' => $request->query->get('filtervalue'),
            'filteroperator' => $request->query->get('filteroperator'),
        ]));
    }

    /**
     * Return the url of a resource based on the 'get_entity' route name convention.
     *
     * @param string $name
     * @param $limit
     * @param $page
     * @param $sorting
     *
     * @return string
     */
    private function getPaginatedRoute($name, $limit, $page, $sorting)
    {
        return $this->urlGenerator->generate(
            'get_'.strtolower($name).'s',
            [
                'sorting' => $sorting,
                'page' => $page,
                'limit' => $limit,
            ]
        );
    }
}