vendor/knplabs/knp-components/src/Knp/Component/Pager/Paginator.php line 55

  1. <?php
  3. namespace Knp\Component\Pager;
  5. use Knp\Component\Pager\ArgumentAccess\ArgumentAccessInterface;
  6. use Knp\Component\Pager\Exception\PageLimitInvalidException;
  7. use Knp\Component\Pager\Exception\PageNumberInvalidException;
  8. use Knp\Component\Pager\Exception\PageNumberOutOfRangeException;
  9. use Knp\Component\Pager\Pagination\PaginationInterface;
  10. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  12. /**
  13.  * Paginator uses event dispatcher to trigger pagination
  14.  * lifecycle events. Subscribers are expected to paginate
  15.  * wanted target and finally it generates pagination view
  16.  * which is only the result of paginator
  17.  */
  18. final class Paginator implements PaginatorInterface
  19. {
  20.     private EventDispatcherInterface $eventDispatcher;
  22.     /**
  23.      * Default options of paginator
  24.      *
  25.      * @var array<string, string|int|bool>
  26.      */
  27.     private array $defaultOptions = [
  28.         self::PAGE_PARAMETER_NAME => 'page',
  29.         self::SORT_FIELD_PARAMETER_NAME => 'sort',
  30.         self::SORT_DIRECTION_PARAMETER_NAME => 'direction',
  31.         self::FILTER_FIELD_PARAMETER_NAME => 'filterParam',
  32.         self::FILTER_VALUE_PARAMETER_NAME => 'filterValue',
  33.         self::DISTINCT => true,
  34.         self::PAGE_OUT_OF_RANGE => self::PAGE_OUT_OF_RANGE_IGNORE,
  35.         self::DEFAULT_LIMIT => self::DEFAULT_LIMIT_VALUE,
  36.     ];
  38.     private ArgumentAccessInterface $argumentAccess;
  40.     public function __construct(EventDispatcherInterface $eventDispatcher, ArgumentAccessInterface $argumentAccess)
  41.     {
  42.         $this->eventDispatcher = $eventDispatcher;
  43.         $this->argumentAccess = $argumentAccess;
  44.     }
  46.     /**
  47.      * Override the default paginator options
  48.      * to be reused for paginations
  49.      */ 
  50.     public function setDefaultPaginatorOptions(array $options): void
  51.     {
  52.         $this->defaultOptions = \array_merge($this->defaultOptions, $options);
  53.     }
  55.     public function paginate($target, int $page = 1, int $limit = null, array $options = []): PaginationInterface
  56.     {
  57.         if ($page <= 0) {
  58.             throw PageNumberInvalidException::create($page);
  59.         }
  61.         $limit = $limit ?? $this->defaultOptions[self::DEFAULT_LIMIT];
  62.         if ($limit <= 0) {
  63.             throw PageLimitInvalidException::create($limit);
  64.         }
  66.         $offset = ($page - 1) * $limit;
  67.         $options = \array_merge($this->defaultOptions, $options);
  69.         // normalize default sort field
  70.         if (isset($options[PaginatorInterface::DEFAULT_SORT_FIELD_NAME]) && is_array($options[PaginatorInterface::DEFAULT_SORT_FIELD_NAME])) {
  71.             $options[PaginatorInterface::DEFAULT_SORT_FIELD_NAME] = implode('+', $options[PaginatorInterface::DEFAULT_SORT_FIELD_NAME]);
  72.         }
  74.         $argumentAccess = $this->argumentAccess;
  75.         
  76.         // default sort field and direction are set based on options (if available)
  77.         if (isset($options[self::DEFAULT_SORT_FIELD_NAME]) && !$argumentAccess->has($options[self::SORT_FIELD_PARAMETER_NAME])) {
  78.            $argumentAccess->set($options[self::SORT_FIELD_PARAMETER_NAME], $options[self::DEFAULT_SORT_FIELD_NAME]);
  80.             if (!$argumentAccess->has($options[PaginatorInterface::SORT_DIRECTION_PARAMETER_NAME])) {
  81.                 $argumentAccess->set($options[PaginatorInterface::SORT_DIRECTION_PARAMETER_NAME], $options[PaginatorInterface::DEFAULT_SORT_DIRECTION] ?? 'asc');
  82.             }
  83.         }
  85.         // before pagination start
  86.         $beforeEvent = new Event\BeforeEvent($this->eventDispatcher, $this->argumentAccess);
  87.         $this->eventDispatcher->dispatch($beforeEvent, 'knp_pager.before');
  88.         // items
  89.         $itemsEvent = new Event\ItemsEvent($offset, $limit);
  90.         $itemsEvent->options = &$options;
  91.         $itemsEvent->target = &$target;
  92.         $this->eventDispatcher->dispatch($itemsEvent, 'knp_pager.items');
  93.         if (!$itemsEvent->isPropagationStopped()) {
  94.             throw new \RuntimeException('One of listeners must count and slice given target');
  95.         }
  96.         if ($page > ceil($itemsEvent->count / $limit)) {
  97.             $pageOutOfRangeOption = $options[PaginatorInterface::PAGE_OUT_OF_RANGE] ?? $this->defaultOptions[PaginatorInterface::PAGE_OUT_OF_RANGE];
  98.             if ($pageOutOfRangeOption === PaginatorInterface::PAGE_OUT_OF_RANGE_FIX && $itemsEvent->count > 0) {
  99.                 // replace page number out of range with max page
  100.                 return $this->paginate($target, (int) ceil($itemsEvent->count / $limit), $limit, $options);
  101.             }
  102.             if ($pageOutOfRangeOption === self::PAGE_OUT_OF_RANGE_THROW_EXCEPTION && $page > 1) {
  103.                 throw new PageNumberOutOfRangeException(
  104.                     sprintf('Page number: %d is out of range.', $page),
  105.                     (int) ceil($itemsEvent->count / $limit)
  106.                 );
  107.             }
  108.         }
  110.         // pagination initialization event
  111.         $paginationEvent = new Event\PaginationEvent;
  112.         $paginationEvent->target = &$target;
  113.         $paginationEvent->options = &$options;
  114.         $this->eventDispatcher->dispatch($paginationEvent, 'knp_pager.pagination');
  115.         if (!$paginationEvent->isPropagationStopped()) {
  116.             throw new \RuntimeException('One of listeners must create pagination view');
  117.         }
  118.         // pagination class can be different, with different rendering methods
  119.         $paginationView = $paginationEvent->getPagination();
  120.         $paginationView->setCustomParameters($itemsEvent->getCustomPaginationParameters());
  121.         $paginationView->setCurrentPageNumber($page);
  122.         $paginationView->setItemNumberPerPage($limit);
  123.         $paginationView->setTotalItemCount($itemsEvent->count);
  124.         $paginationView->setPaginatorOptions($options);
  125.         $paginationView->setItems($itemsEvent->items);
  127.         // after
  128.         $afterEvent = new Event\AfterEvent($paginationView);
  129.         $this->eventDispatcher->dispatch($afterEvent, 'knp_pager.after');
  131.         return $paginationView;
  132.     }
  133. }