PHP Pagerfanta::hasPreviousPage方法代码示例

 public function __construct(Pagerfanta $paginator, Request $request, $base_url)
 {
     $this->data = $paginator->getCurrentPageResults();
     $this->total_count = $paginator->getNbResults();
     $this->count = count($this->data);
     $query = array('q' => $request->get('q'), 'limit' => $request->get('limit'), 'page' => $request->get('page'));
     $this->query = $query;
     $this->urls['current'] = $base_url . '?' . http_build_query($query);
     if ($paginator->hasPreviousPage()) {
         $query['page'] = $paginator->getPreviousPage();
         $this->urls['previous'] = $base_url . '?' . http_build_query($query);
         if ($paginator->getCurrentPage() > 2) {
             $query['page'] = 1;
             $this->urls['start'] = $base_url . '?' . http_build_query($query);
         }
     }
     if ($paginator->hasNextPage()) {
         $query['page'] = $paginator->getNextPage();
         $this->urls['next'] = $base_url . '?' . http_build_query($query);
         if ($paginator->getCurrentPage() < $paginator->getNbPages() - 1) {
             $query['page'] = $paginator->getNbPages();
             $this->urls['end'] = $base_url . '?' . http_build_query($query);
         }
     }
 }

 public function searchAction(Request $request)
 {
     $format = $request->getRequestFormat();
     $query = trim($request->query->get('q'));
     if (empty($query)) {
         if ('json' === $format) {
             return new JsonResponse(array('status' => 'error', 'message' => 'Missing or too short search query, example: ?q=example'), 400);
         }
         return $this->render('KnpBundlesBundle:Bundle:search.html.twig');
     }
     // Skip search if query matches exactly one bundle name, and such was found in database
     if (!$request->isXmlHttpRequest() && preg_match('/^[a-z0-9-]+\\/[a-z0-9-]+$/i', $query)) {
         list($ownerName, $name) = explode('/', $query);
         $bundle = $this->getRepository('Bundle')->findOneBy(array('ownerName' => $ownerName, 'name' => $name));
         if ($bundle) {
             return $this->redirect($this->generateUrl('bundle_show', array('ownerName' => $ownerName, 'name' => $name, '_format' => $format)));
         }
     }
     /** @var $solarium \Solarium_Client */
     $solarium = $this->get('solarium.client');
     $select = $solarium->createSelect();
     $escapedQuery = $select->getHelper()->escapeTerm($query);
     $dismax = $select->getDisMax();
     $dismax->setQueryFields(array('name^2', 'ownerName', 'fullName^1.5', 'description', 'keywords', 'text', 'text_ngram'));
     $dismax->setPhraseFields(array('description^30'));
     $dismax->setQueryParser('edismax');
     $select->setQuery($escapedQuery);
     try {
         $paginator = new Pagerfanta(new SolariumAdapter($solarium, $select));
         $paginator->setMaxPerPage($request->query->get('limit', 10))->setCurrentPage($request->query->get('page', 1), false, true);
         if (1 === $paginator->getNbResults() && !$request->isXmlHttpRequest()) {
             $first = $paginator->getCurrentPageResults()->getIterator()->current();
             if (strtolower($first['name']) == strtolower($query)) {
                 return $this->redirect($this->generateUrl('bundle_show', array('ownerName' => $first['ownerName'], 'name' => $first['name'], '_format' => $format)));
             }
         }
     } catch (\Solarium_Client_HttpException $e) {
         $msg = 'Seems that our search engine is currently offline. Please check later.';
         if ('json' === $format) {
             return new JsonResponse(array('status' => 'error', 'message' => $msg), 500);
         }
         throw new HttpException(500, $msg);
     }
     if ('json' === $format) {
         $result = array('results' => array(), 'total' => $paginator->getNbResults());
         foreach ($paginator as $bundle) {
             $result['results'][] = array('name' => $bundle->fullName, 'description' => null !== $bundle->description ? substr($bundle->description, 0, 110) . '...' : '', 'avatarUrl' => $bundle->avatarUrl ?: 'http://www.gravatar.com/avatar/?d=identicon&f=y&s=50', 'state' => $bundle->state, 'score' => $bundle->totalScore, 'url' => $this->generateUrl('bundle_show', array('ownerName' => $bundle->ownerName, 'name' => $bundle->name), true));
         }
         if (!$request->isXmlHttpRequest()) {
             if ($paginator->hasPreviousPage()) {
                 $result['prev'] = $this->generateUrl('search', array('q' => urldecode($query), 'page' => $paginator->getPreviousPage(), '_format' => 'json'), true);
             }
             if ($paginator->hasNextPage()) {
                 $result['next'] = $this->generateUrl('search', array('q' => urldecode($query), 'page' => $paginator->getNextPage(), '_format' => 'json'), true);
             }
         }
         return new JsonResponse($request->isXmlHttpRequest() ? $result['results'] : $result);
     }
     return $this->render('KnpBundlesBundle:Bundle:searchResults.html.twig', array('query' => urldecode($query), 'bundles' => $paginator));
 }

 public function createRepresentationFromPagerfanta(Pagerfanta $pager)
 {
     $this->pager = empty($pager) ? $this->pager : $pager;
     if (empty($this->pager)) {
         return array();
     }
     $representation = array('hasToPaginate' => $this->pager->haveToPaginate(), 'hasNextPage' => $this->pager->hasNextPage(), 'hasPreviousPage' => $this->pager->hasPreviousPage(), 'totalItems' => $this->pager->getNbResults(), 'itemsPerPage' => $this->pager->getMaxPerPage(), 'currentPage' => $this->pager->getCurrentPage(), 'data' => $this->pager->getCurrentPageResults());
     return $representation;
 }

 public function createCollection(QueryBuilder $qb, Request $request, $route, array $routeParams = array())
 {
     $page = $request->query->get(self::PARAMETER_NAME_PAGE_NUMBER, 1);
     $count = $request->query->get(self::PARAMETER_NAME_PAGE_SIZE, self::PAGE_DEFAULT_COUNT);
     if ($count > self::MAX_PAGE_COUNT) {
         $count = self::MAX_PAGE_COUNT;
     }
     if ($count <= 0) {
         $count = self::PAGE_DEFAULT_COUNT;
     }
     $adapter = new DoctrineORMAdapter($qb);
     $pagerfanta = new Pagerfanta($adapter);
     $pagerfanta->setMaxPerPage($count);
     $pagerfanta->setCurrentPage($page);
     $players = [];
     foreach ($pagerfanta->getCurrentPageResults() as $result) {
         $players[] = $result;
     }
     $paginatedCollection = new PaginatedCollection($players, $pagerfanta->getNbResults());
     // make sure query parameters are included in pagination links
     $routeParams = array_merge($routeParams, $request->query->all());
     $createLinkUrl = function ($targetPage) use($route, $routeParams) {
         return $this->router->generate($route, array_merge($routeParams, array(self::PARAMETER_NAME_PAGE_NUMBER => $targetPage)));
     };
     $paginatedCollection->addLink('self', $createLinkUrl($page));
     $paginatedCollection->addLink('first', $createLinkUrl(1));
     $paginatedCollection->addLink('last', $createLinkUrl($pagerfanta->getNbPages()));
     if ($pagerfanta->hasNextPage()) {
         $paginatedCollection->addLink('next', $createLinkUrl($pagerfanta->getNextPage()));
     }
     if ($pagerfanta->hasPreviousPage()) {
         $paginatedCollection->addLink('prev', $createLinkUrl($pagerfanta->getPreviousPage()));
     }
     return $paginatedCollection;
 }

 /**
  * Return pagers
  *
  * @return array
  */
 public function getPager()
 {
     // view
     if (!$this->pagerfanta) {
         return [];
     }
     $pager = ['maxPerPage' => $this->maxPerPage, 'current' => $this->currentPage, 'total' => $this->pagerfanta->getNbResults(), 'hasNext' => $this->pagerfanta->hasNextPage(), 'hasPrevious' => $this->pagerfanta->hasPreviousPage(), 'html' => $this->getHtml($this->pagerfanta)];
     return $pager;
 }

 public function showAction()
 {
     $emRepo = $this->getDoctrine()->getManager()->getRepository('AppBundle:Post');
     $posts = $emRepo->findAll();
     $adapter = new ArrayAdapter($posts);
     $pagerFanta = new Pagerfanta($adapter);
     $pagerFanta->setMaxPerPage(2);
     $pagerFanta->hasNextPage();
     $pagerFanta->hasPreviousPage();
     return $this->render('AppBundle:default:showPost.html.twig', array('posts' => $posts, 'pager' => $pagerFanta));
 }

 /**
  * @param JsonApiSerializationVisitor $visitor
  * @param Pagerfanta                  $pagerfanta
  * @param array                       $type
  * @param Context                     $context
  * @return Pagerfanta
  */
 public function serializePagerfanta(JsonApiSerializationVisitor $visitor, Pagerfanta $pagerfanta, array $type, Context $context)
 {
     $request = $this->requestStack->getCurrentRequest();
     $pagerfanta->setNormalizeOutOfRangePages(true);
     $pagerfanta->setAllowOutOfRangePages(true);
     $pagerfanta->setMaxPerPage($request->get('page[limit]', $this->paginationOptions['limit'], true));
     $pagerfanta->setCurrentPage($request->get('page[number]', 1, true));
     $results = $pagerfanta->getCurrentPageResults();
     if ($results instanceof \ArrayIterator) {
         $results = $results->getArrayCopy();
     }
     $data = $context->accept($results);
     $root = $visitor->getRoot();
     $root['meta'] = array('page' => $pagerfanta->getCurrentPage(), 'limit' => $pagerfanta->getMaxPerPage(), 'pages' => $pagerfanta->getNbPages(), 'total' => $pagerfanta->getNbResults());
     $root['links'] = array('first' => $this->getUriForPage(1), 'last' => $this->getUriForPage($pagerfanta->getNbPages()), 'prev' => $pagerfanta->hasPreviousPage() ? $this->getUriForPage($pagerfanta->getPreviousPage()) : null, 'next' => $pagerfanta->hasNextPage() ? $this->getUriForPage($pagerfanta->getNextPage()) : null);
     $visitor->setRoot($root);
     return $data;
 }

 private function getNavigationLinks(Pagerfanta $pager, array $params = array())
 {
     $page = $pager->getCurrentPage();
     $limit = $pager->getMaxPerPage();
     $links = [];
     if ($pager->getCurrentPage() > 1) {
         $links['first'] = $this->generateUrl('app_api_categories', array_merge($params, ['offset' => $this->getOffset(1, $limit)]));
     }
     if ($pager->hasPreviousPage()) {
         $links['previous'] = $this->generateUrl('app_api_categories', array_merge($params, ['offset' => $this->getOffset($pager->getPreviousPage(), $limit)]));
     }
     if ($pager->hasNextPage()) {
         $links['next'] = $this->generateUrl('app_api_categories', array_merge($params, ['offset' => $this->getOffset($pager->getNextPage(), $limit)]));
     }
     if ($pager->getNbPages() != $page) {
         $links['last'] = $this->generateUrl('app_api_categories', array_merge($params, ['offset' => $this->getOffset($pager->getNbPages(), $limit)]));
     }
     return $links;
 }

 protected function addPagination(Request $request, Pagerfanta $pager, $resource)
 {
     $route = $request->attributes->get('_route');
     $params = $request->attributes->get('_route_params');
     $params = array_merge($params, $request->query->all());
     $resource->setMetaValue('page', $pager->getCurrentPage());
     $resource->setMetaValue('count', $pager->getNbResults());
     $resource->setMetaValue('nextPage', null);
     $resource->setMetaValue('previousPage', null);
     $resource->setMetaValue('next', null);
     $resource->setMetaValue('previous', null);
     if ($pager->hasNextPage()) {
         $resource->setMetaValue('next', $this->generateUrl($route, array_replace($params, ['page' => $pager->getNextPage(), 'limit' => $pager->getMaxPerPage()]), true));
         $resource->setMetaValue('nextPage', $pager->getNextPage());
     }
     if ($pager->hasPreviousPage()) {
         $resource->setMetaValue('previous', $this->generateUrl($route, array_replace($params, ['page' => $pager->getPreviousPage(), 'limit' => $pager->getMaxPerPage()]), true));
         $resource->setMetaValue('previousPage', $pager->getPreviousPage());
     }
 }

 /**
  * Return list of children node
  * @param \eZ\Publish\Core\Repository\Values\Content\Location $location
  * @param type $maxPerPage
  * @param type $currentPage
  * @return type
  */
 public function getFolderChildrens(\eZ\Publish\Core\Repository\Values\Content\Location $location, $currentUser, $maxPerPage, $currentPage = 1, $category)
 {
     $criteria = array(new Criterion\ParentLocationId($location->id), new Criterion\ContentTypeIdentifier(array('service_link')), new Criterion\Visibility(Criterion\Visibility::VISIBLE));
     if (isset($category) && $category != "all") {
         $criteria[] = new Criterion\Field('category', Criterion\Operator::CONTAINS, $category);
     }
     $query = new Query();
     $query->filter = new Criterion\LogicalAnd($criteria);
     $query->sortClauses = array($this->sortClauseAuto($location));
     $searchResult = $this->repository->getSearchService()->findContent($query);
     $subscritions = $this->fetchByUserId($currentUser->id);
     //$this->debug($subscritions);
     $content = array();
     $contentId = null;
     foreach ($searchResult->searchHits as $serviceLink) {
         if (!$contentId) {
             $contentId = $serviceLink->valueObject->getVersionInfo()->getContentInfo()->id;
         }
         $content[] = array('serviceLink' => $serviceLink->valueObject->contentInfo->mainLocationId, 'subscrition' => $this->hasSubscription($subscritions, $serviceLink->valueObject->getVersionInfo()->getContentInfo()->id));
     }
     $result['offset'] = ($currentPage - 1) * $maxPerPage;
     $adapter = new ArrayAdapter($content);
     $pagerfanta = new Pagerfanta($adapter);
     $pagerfanta->setMaxPerPage($maxPerPage);
     $pagerfanta->setCurrentPage($currentPage);
     $httpReferer = $_SERVER['SCRIPT_URL'];
     if (isset($category)) {
         $httpReferer .= "?category=" . $category;
     } else {
         $httpReferer .= "?";
     }
     $result['offset'] = ($currentPage - 1) * $maxPerPage;
     $result['prev_page'] = $pagerfanta->hasPreviousPage() ? $pagerfanta->getPreviousPage() : 0;
     $result['next_page'] = $pagerfanta->hasNextPage() ? $pagerfanta->getNextPage() : 0;
     $result['nb_pages'] = $pagerfanta->getNbPages();
     $result['items'] = $pagerfanta->getCurrentPageResults();
     $result['base_href'] = $httpReferer;
     $result['current_page'] = $pagerfanta->getCurrentPage();
     $result['options'] = isset($contentId) ? $this->getCategorie($contentId, "ezselection") : array();
     return $result;
 }

 protected function configureCollectionRepresentation(CollectionRepresentation $collectionRepresentation, Pagerfanta $pager, $entity = null, $collectionRel = null)
 {
     // Properties
     $collectionRepresentation->total = $pager->getNbResults();
     $collectionRepresentation->page = $pager->getCurrentPage();
     $collectionRepresentation->limit = $pager->getMaxPerPage();
     // Links between pages
     $createRoute = function ($page, $limit) use($entity, $collectionRel) {
         $parameters = array('search' => array('page' => $page, 'limit' => $limit));
         return null !== $entity && null !== $collectionRel ? $this->getUrlGenerator()->generateEntityCollectionUrl($entity, $collectionRel, $parameters) : $this->getUrlGenerator()->generateCollectionUrl($parameters);
     };
     $collectionRepresentation->addLink($this->atomLinkFactory->create('self', $createRoute($pager->getCurrentPage(), $pager->getMaxPerPage())));
     if ($pager->hasNextPage()) {
         $collectionRepresentation->addLink($this->atomLinkFactory->create('next', $createRoute($pager->getNextPage(), $pager->getMaxPerPage())));
     }
     if ($pager->hasPreviousPage()) {
         $collectionRepresentation->addLink($this->atomLinkFactory->create('previous', $createRoute($pager->getPreviousPage(), $pager->getMaxPerPage())));
     }
     $collectionRepresentation->addLink($this->atomLinkFactory->create('first', $createRoute(1, $pager->getMaxPerPage())));
     $collectionRepresentation->addLink($this->atomLinkFactory->create('last', $createRoute($pager->getNbPages(), $pager->getMaxPerPage())));
 }

 public function testHasPreviousPageShouldReturnFalseWhenTheCurrentPageIs1()
 {
     $this->setAdapterNbResultsAny(100);
     $this->pagerfanta->setCurrentPage(1);
     $this->assertFalse($this->pagerfanta->hasPreviousPage());
 }

 /**
  * @param Pagerfanta $paginator
  * @param $route
  * @param $limit
  */
 protected function addLinksToMetadata(Pagerfanta $paginator, $route, $limit)
 {
     $data = $this->get('bite_codes_rest_api_generator.services.response_data');
     $router = $this->get('router');
     $first = $router->generate($route, ['page' => 1, 'limit' => $limit], UrlGeneratorInterface::ABSOLUTE_URL);
     $prev = $paginator->hasPreviousPage() ? $router->generate($route, ['page' => $paginator->getPreviousPage(), 'limit' => $limit], UrlGeneratorInterface::ABSOLUTE_URL) : null;
     $current = $router->generate($route, ['page' => $paginator->getCurrentPage(), 'limit' => $limit], UrlGeneratorInterface::ABSOLUTE_URL);
     $next = $paginator->hasNextPage() ? $router->generate($route, ['page' => $paginator->getNextPage(), 'limit' => $limit], UrlGeneratorInterface::ABSOLUTE_URL) : null;
     $last = $router->generate($route, ['page' => $paginator->getNbPages(), 'limit' => $limit], UrlGeneratorInterface::ABSOLUTE_URL);
     $data->addLink('first', $first);
     $data->addLink('prev', $prev);
     $data->addLink('current', $current);
     $data->addLink('next', $next);
     $data->addLink('last', $last);
     $data->addMeta('total', $paginator->getNbResults());
 }

    /**
     * Return list of event sorted 
     * @param Location $location
     * @param type $maxPerPage
     * @param type $currentPage
     * @return type
     */
    public function getFolderChildrens( Location $location, $maxPerPage, $currentPage = 1 )
    {

        $criteria = array(
            new Criterion\ParentLocationId( $location->parentLocationId ),
            new Criterion\ContentTypeIdentifier( array( 'agenda_event' ) ),
            new Criterion\Visibility( Criterion\Visibility::VISIBLE ),
            new Criterion\Field( 'publish_start', Criterion\Operator::LT, time() ),
            new Criterion\LogicalOr( array(
                new Criterion\Field( 'publish_end', Criterion\Operator::GT, time() ), new Criterion\Field( 'publish_end', Criterion\Operator::EQ, 0 )
                    ) )
        );
        $query = new Query();
        $query->filter = new Criterion\LogicalAnd( $criteria );
        $query->sortClauses = array(
            $this->sortClauseAuto( $location )
        );

        $searchResult = $this->repository->getSearchService()->findContent( $query );

        $content = array();
        foreach( $searchResult->searchHits as $agendaEvent )
        {
            $listDates = $this->getChildren( $agendaEvent );
            foreach( $listDates->searchHits as $agendaSchedule )
            {
                $content[] = array(
                    'AgendaEvent' => $agendaEvent->valueObject->contentInfo->mainLocationId,
                    'AgendaSchedule' => $agendaSchedule->valueObject->contentInfo->mainLocationId,
                    'start' => $this->getFormattedDate( $agendaSchedule, 'order' )
                );
            }
        }

        usort( $content, array( $this, 'agendaSortMethod' ) );

        $result['offset'] = ($currentPage - 1) * $maxPerPage;
        $adapter = new ArrayAdapter( $content );
        $pagerfanta = new Pagerfanta( $adapter );

        $pagerfanta->setMaxPerPage( $maxPerPage );
        $pagerfanta->setCurrentPage( $currentPage );

        $result['prev_page'] = $pagerfanta->hasPreviousPage() ? $pagerfanta->getPreviousPage() : 0;
        $result['next_page'] = $pagerfanta->hasNextPage() ? $pagerfanta->getNextPage() : 0;
        $result['nb_pages'] = $pagerfanta->getNbPages();
        $result['items'] = $pagerfanta->getCurrentPageResults();
        $result['base_href'] = "?";
        $result['current_page'] = $pagerfanta->getCurrentPage();
        return $result;
    }

 /**
  * @return boolean
  */
 public function hasPreviousPage()
 {
     return $this->pagerfanta->hasPreviousPage();
 }