src/App/Util/Pagination.php line 155

Open in your IDE?
  1. <?php
  3. namespace App\Util;
  5. use Doctrine\ORM\AbstractQuery;
  6. use Doctrine\ORM\Query;
  7. use Doctrine\ORM\QueryBuilder;
  8. use Doctrine\ORM\Tools\Pagination\Paginator;
  10. final class Pagination
  11. {
  12.     public const PAGE_LIMIT = 12;
  13.     public const PAGE_START = 0;
  14.     public const PAGE_VAR = 'pagination';
  16.     /**
  17.      * @param int|null $limit
  18.      * @return int
  19.      */
  20.     static public function limit(?int $limit = null): int
  21.     {
  22.         return (((int) $limit) <= 0) ? self::PAGE_LIMIT : $limit;
  23.     }
  25.     /**
  26.      * @param int $page
  27.      * @return int
  28.      */
  29.     static public function page(int $page = self::PAGE_START): int
  30.     {
  31.         return ($page < self::PAGE_START) ? self::PAGE_START : $page;
  32.     }
  34.     /**
  35.      * @param int $page
  36.      * @param int $limit
  37.      * @return int
  38.      */
  39.     static public function offset(int $page, int $limit = self::PAGE_LIMIT): int
  40.     {
  41.         return (self::page($page) * self::limit($limit));
  42.     }
  44.     /**
  45.      * @param QueryBuilder|Query $query
  46.      * @param int|null $limit
  47.      * @param int|null $offset
  48.      * @return QueryBuilder|Query
  49.      */
  50.     static public function paginate($query, ?int $limit = null, ?int $offset = null)
  51.     {
  52.         if ($limit !== null || $offset !== null) {
  53.             $query
  54.                 ->setMaxResults(self::limit($limit))
  55.                 ->setFirstResult($offset ?? 0);
  56.         }
  57.         return $query;
  58.     }
  60.     /**
  61.      * @param QueryBuilder|Query $query
  62.      * @return iterable|array|Paginator
  63.      */
  64.     static function query($query): iterable
  65.     {
  66.         if ($query instanceof QueryBuilder) {
  67.             $query = $query->getQuery();
  68.         }
  69.         if ( ! $query instanceof Query) {
  70.             throw new \Exception();
  71.         }
  72.         if ($query->getFirstResult() !== null && $query->getMaxResults() !== null) {
  73.             return new Paginator($query);
  74.         }
  75.         return $query->getResult($query->getHydrationMode() ?: AbstractQuery::HYDRATE_OBJECT);
  76.     }
  78.     /**
  79.      * @param QueryBuilder|Query $query
  80.      * @param int|null $limit
  81.      * @param int|null $offset
  82.      * @return iterable|array|Paginator
  83.      */
  84.     static public function paginateThenQuery($query, ?int $limit = null, ?int $offset = null): iterable
  85.     {
  86.         return self::query(
  87.             self::paginate($query, $limit, $offset)
  88.         );
  89.     }
  91.     /**
  92.      * @param QueryBuilder $qb
  93.      * @return int
  94.      */
  95.     static public function count(QueryBuilder $qb): int
  96.     {
  97.         return $qb
  98.             ->resetDQLParts([
  99.                 'select',
  100.                 'orderBy',
  101.             ])
  102.             ->select(sprintf(
  103.                 'COUNT(%s)',
  104.                 $qb->getRootAliases()[0]
  105.             ))
  106.             ->getQuery()
  107.             ->getSingleScalarResult()
  108.         ;
  109.     }
  111.     /**
  112.      * @param mixed $objects
  113.      * @param int $max
  114.      * @param int $page
  115.      * @param int $limit
  116.      * @return array
  117.      */
  118.     static public function controller($objects, int $max, int $page, int $limit = self::PAGE_LIMIT): array
  119.     {
  120.         return array_merge(
  121.             self::stats($objects, $max, $page, $limit),
  122.             [
  123.                 'results' => $objects,
  124.             ]
  125.         );
  126.     }
  128.     /**
  129.      * @param mixed $objects
  130.      * @param int $max
  131.      * @param int $page
  132.      * @param int $limit
  133.      * @return array
  134.      */
  135.     static public function stats($objects, int $max, int $page, int $limit = self::PAGE_LIMIT): array
  136.     {
  137.         return [
  138.             'results_count' => count($objects),
  139.             'results_max' => $max,
  140.             'page_prev' => max(self::PAGE_START, $page - 1),
  141.             'page' => $page,
  142.             'limit' => self::limit($limit),
  143.             'page_next' => min(self::maxPage($objects, $limit), $page + 1),
  144.             'pages_min' => self::PAGE_START,
  145.             'pages_max' => self::maxPage($objects, $limit),
  146.         ];
  147.     }
  149.     /**
  150.      * @param mixed $objects
  151.      * @param int $page
  152.      * @param int $limit
  153.      * @return bool
  154.      */
  155.     static public function outOfBounds($objects, int $page, int $limit = self::PAGE_LIMIT): bool
  156.     {
  157.         return (self::page($page) > self::maxPage($objects, $limit));
  158.     }
  160.     /**
  161.      * @param mixed $objects
  162.      * @param int $limit
  163.      * @return int
  164.      */
  165.     static public function maxPage($objects, int $limit = self::PAGE_LIMIT): int
  166.     {
  167.         return max((intval(ceil(count($objects) / self::limit($limit))) - 1), 0);
  168.     }
  169. }