vendor/easycorp/easyadmin-bundle/src/Orm/EntityPaginator.php line 35

Open in your IDE?
  1. <?php
  3. namespace EasyCorp\Bundle\EasyAdminBundle\Orm;
  5. use Doctrine\ORM\Query;
  6. use Doctrine\ORM\QueryBuilder;
  7. use Doctrine\ORM\Tools\Pagination\CountWalker;
  8. use Doctrine\ORM\Tools\Pagination\Paginator;
  9. use EasyCorp\Bundle\EasyAdminBundle\Config\Option\EA;
  10. use EasyCorp\Bundle\EasyAdminBundle\Contracts\Orm\EntityPaginatorInterface;
  11. use EasyCorp\Bundle\EasyAdminBundle\Dto\PaginatorDto;
  12. use EasyCorp\Bundle\EasyAdminBundle\Factory\EntityFactory;
  13. use EasyCorp\Bundle\EasyAdminBundle\Router\AdminUrlGenerator;
  15. /**
  16.  * @author Javier Eguiluz <javier.eguiluz@gmail.com>
  17.  */
  18. final class EntityPaginator implements EntityPaginatorInterface
  19. {
  20.     private $adminUrlGenerator;
  21.     private $entityFactory;
  22.     private $currentPage;
  23.     private $pageSize;
  24.     private $rangeSize;
  25.     private $rangeEdgeSize;
  26.     private $results;
  27.     private $numResults;
  29.     public function __construct(AdminUrlGenerator $adminUrlGenerator, EntityFactory $entityFactory)
  30.     {
  31.         $this->adminUrlGenerator = $adminUrlGenerator;
  32.         $this->entityFactory = $entityFactory;
  33.     }
  35.     public function paginate(PaginatorDto $paginatorDto, QueryBuilder $queryBuilder): EntityPaginatorInterface
  36.     {
  37.         $this->pageSize = $paginatorDto->getPageSize();
  38.         $this->rangeSize = $paginatorDto->getRangeSize();
  39.         $this->rangeEdgeSize = $paginatorDto->getRangeEdgeSize();
  40.         $this->currentPage = max(1, $paginatorDto->getPageNumber());
  41.         $firstResult = ($this->currentPage - 1) * $this->pageSize;
  43.         /** @var Query $query */
  44.         $query = $queryBuilder
  45.             ->setFirstResult($firstResult)
  46.             ->setMaxResults($this->pageSize)
  47.             ->getQuery();
  49.         if (0 === \count($queryBuilder->getDQLPart('join'))) {
  50.             $query->setHint(CountWalker::HINT_DISTINCT, false);
  51.         }
  53.         $paginator = new Paginator($query, $paginatorDto->fetchJoinCollection());
  55.         if (null === $useOutputWalkers = $paginatorDto->useOutputWalkers()) {
  56.             $havingPart = $queryBuilder->getDQLPart('having');
  57.             if (\is_array($havingPart)) {
  58.                 $useOutputWalkers = \count($havingPart) > 0;
  59.             } else {
  60.                 $useOutputWalkers = null !== $havingPart;
  61.             }
  62.         }
  63.         $paginator->setUseOutputWalkers($useOutputWalkers);
  65.         $this->results = $paginator->getIterator();
  66.         $this->numResults = $paginator->count();
  68.         return $this;
  69.     }
  71.     public function generateUrlForPage(int $page): string
  72.     {
  73.         return $this->adminUrlGenerator->set(EA::PAGE, $page)->includeReferrer()->generateUrl();
  74.     }
  76.     public function getCurrentPage(): int
  77.     {
  78.         return $this->currentPage;
  79.     }
  81.     public function getLastPage(): int
  82.     {
  83.         return (int) ceil($this->numResults / $this->pageSize);
  84.     }
  86.     /**
  87.      * It returns the closest available pages around the current page.
  88.      * E.g. a paginator with 35 pages, if current page = 1, returns [1, 2, 3, 4, null, 35]
  89.      *      if current page = 18, returns [1, null, 15, 16, 17, 18, 19, 20, 21, null, 35]
  90.      * NULL values mean a gap in the pagination (they can be represented as ellipsis in the templates).
  91.      *
  92.      * This code was inspired by https://github.com/django/django/blob/55fabc53373a8c7ef31d8c4cffd2a07be0a88c2e/django/core/paginator.py#L134
  93.      * (c) Django Project
  94.      *
  95.      * @return int[]
  96.      */
  97.     public function getPageRange(int $pagesOnEachSide = null, int $pagesOnEdges = null): iterable
  98.     {
  99.         $pagesOnEachSide = $pagesOnEachSide ?? $this->rangeSize;
  100.         $pagesOnEdges = $pagesOnEdges ?? $this->rangeEdgeSize;
  102.         if (0 === $pagesOnEachSide) {
  103.             return null;
  104.         }
  106.         if ($this->getLastPage() <= ($pagesOnEachSide + $pagesOnEdges) * 2) {
  107.             return yield from range(1, $this->getLastPage());
  108.         }
  110.         if ($this->getCurrentPage() > ($pagesOnEachSide + $pagesOnEdges + 1)) {
  111.             yield from range(1, $pagesOnEdges);
  112.             yield null;
  113.             yield from range($this->getCurrentPage() - $pagesOnEachSide, $this->getCurrentPage());
  114.         } else {
  115.             yield from range(1, $this->getCurrentPage());
  116.         }
  118.         if ($this->getCurrentPage() < ($this->getLastPage() - $pagesOnEachSide - $pagesOnEdges - 1)) {
  119.             yield from range($this->getCurrentPage() + 1, $this->getCurrentPage() + $pagesOnEachSide);
  120.             yield null;
  121.             yield from range($this->getLastPage() - $pagesOnEdges + 1, $this->getLastPage());
  122.         } elseif ($this->getCurrentPage() + 1 <= $this->getLastPage()) {
  123.             yield from range($this->getCurrentPage() + 1, $this->getLastPage());
  124.         }
  125.     }
  127.     public function getPageSize(): int
  128.     {
  129.         return $this->pageSize;
  130.     }
  132.     public function hasPreviousPage(): bool
  133.     {
  134.         return $this->currentPage > 1;
  135.     }
  137.     public function getPreviousPage(): int
  138.     {
  139.         return max(1, $this->currentPage - 1);
  140.     }
  142.     public function hasNextPage(): bool
  143.     {
  144.         return $this->currentPage < $this->getLastPage();
  145.     }
  147.     public function getNextPage(): int
  148.     {
  149.         return min($this->getLastPage(), $this->currentPage + 1);
  150.     }
  152.     public function hasToPaginate(): bool
  153.     {
  154.         return $this->numResults > $this->pageSize;
  155.     }
  157.     public function isOutOfRange(): bool
  158.     {
  159.         if (1 === $this->currentPage) {
  160.             return false;
  161.         }
  163.         return $this->currentPage < 1 || $this->currentPage > $this->getLastPage();
  164.     }
  166.     public function getNumResults(): int
  167.     {
  168.         return $this->numResults;
  169.     }
  171.     public function getResults(): ?iterable
  172.     {
  173.         return $this->results;
  174.     }
  176.     public function getResultsAsJson(): string
  177.     {
  178.         foreach ($this->getResults() ?? [] as $entityInstance) {
  179.             $entityDto = $this->entityFactory->createForEntityInstance($entityInstance);
  181.             $jsonResult['results'][] = [
  182.                 EA::ENTITY_ID => $entityDto->getPrimaryKeyValueAsString(),
  183.                 'entityAsString' => $entityDto->toString(),
  184.             ];
  185.         }
  187.         $nextPageUrl = !$this->hasNextPage() ? null : $this->adminUrlGenerator->set(EA::PAGE, $this->getNextPage())->removeReferrer()->generateUrl();
  188.         $jsonResult['next_page'] = $nextPageUrl;
  190.         return json_encode($jsonResult);
  191.     }
  192. }