/**
* @param AbstractQuery $query
* @param IndexDefinitionInterface $index
* @param Request $request
* @return PaginationInterface
*/
public function getGrid(AbstractQuery $query, IndexDefinitionInterface $index, Request $request)
{
$sortDirection = $request->get('direction', IndexDefinitionInterface::SORT_ASC);
$sortColumn = $request->get('sort');
if (!in_array($sortDirection, [IndexDefinitionInterface::SORT_ASC, IndexDefinitionInterface::SORT_DESC])) {
throw new CrudifyException("Invalid sorting direction {$sortDirection}");
}
if (null !== $sortColumn && !$index->hasColumnWithField($sortColumn)) {
throw new CrudifyException("No such column '{$sortColumn}' in definition.");
}
if (null !== $sortColumn && !$index->getColumnWithField($sortColumn)->isSortable()) {
throw new CrudifyException("Not allowed to sort column '{$sortColumn}'.");
}
/** @var SlidingPagination $pagination */
$pagination = $this->paginator->paginate($query, $request->get('page', 1), $index->getObjectsPerPage());
if (null !== $index->getDefaultSortColumn()) {
$pagination->setParam('sort', $index->getDefaultSortColumn()->getField());
$pagination->setParam('direction', $index->getDefaultSortDirection());
}
if (null !== $sortColumn) {
$pagination->setParam('sort', $sortColumn);
$pagination->setParam('direction', $sortDirection);
}
$pagination->setTemplate($index->getParent()->getTemplates()->getPagination());
$pagination->setSortableTemplate($index->getParent()->getTemplates()->getSortable());
return $pagination;
}
public function findAllPaginate($pagina, $limit)
{
$dql = "SELECT r FROM EMLRecetaBundle:Receta r ORDER BY r.id DESC";
$recetas = $this->_em->createQuery($dql);
$pagination = $this->paginator->paginate($recetas, $pagina, $limit);
return $pagination;
}
/**
* @test
*/
function shouldCustomizeParameterNames()
{
$dispatcher = new EventDispatcher();
$dispatcher->addSubscriber(new MockPaginationSubscriber());
// pagination view
$dispatcher->addSubscriber(new ArraySubscriber());
$p = new Paginator($dispatcher);
$items = array('first', 'second');
$view = $p->paginate($items, 1, 10);
// test default names first
$this->assertEquals('page', $view->getPaginatorOption('pageParameterName'));
$this->assertEquals('sort', $view->getPaginatorOption('sortFieldParameterName'));
$this->assertEquals('direction', $view->getPaginatorOption('sortDirectionParameterName'));
$this->assertTrue($view->getPaginatorOption('distinct'));
$this->assertNull($view->getPaginatorOption('sortFieldWhitelist'));
// now customize
$options = array('pageParameterName' => 'p', 'sortFieldParameterName' => 's', 'sortDirectionParameterName' => 'd', 'distinct' => false, 'sortFieldWhitelist' => array('a.f', 'a.d'));
$view = $p->paginate($items, 1, 10, $options);
$this->assertEquals('p', $view->getPaginatorOption('pageParameterName'));
$this->assertEquals('s', $view->getPaginatorOption('sortFieldParameterName'));
$this->assertEquals('d', $view->getPaginatorOption('sortDirectionParameterName'));
$this->assertFalse($view->getPaginatorOption('distinct'));
$this->assertEquals(array('a.f', 'a.d'), $view->getPaginatorOption('sortFieldWhitelist'));
// change default paginator options
$p->setDefaultPaginatorOptions(array('pageParameterName' => 'pg', 'sortFieldParameterName' => 'srt', 'sortDirectionParameterName' => 'dir'));
$view = $p->paginate($items, 1, 10);
$this->assertEquals('pg', $view->getPaginatorOption('pageParameterName'));
$this->assertEquals('srt', $view->getPaginatorOption('sortFieldParameterName'));
$this->assertEquals('dir', $view->getPaginatorOption('sortDirectionParameterName'));
$this->assertTrue($view->getPaginatorOption('distinct'));
}
/**
* @Route("/", bind="example_list")
* @return string
*/
public function listAction(Request $request)
{
/** @var EntityRepository $repo */
$repo = $this->doctrine->getManager()->getRepository(get_class(new Example()));
$qb = $repo->createQueryBuilder('e');
$examples = $this->paginator->paginate($qb, $request->query->get('page', 1), 10);
return $this->twig->render('@VendorSkeleton/Example/list.html.twig', array('examples' => $examples));
}
/**
* @Route()
* @Method("GET")
* @Template(":Todo/Search:index.html.twig")
*
* @param Request $request
*/
public function indexAction(Request $request)
{
$search = new TodoList();
$form = $this->formFactory->create('todo_list', $search);
$form->handleRequest($request);
/** @var SlidingPagination $pagination */
$pagination = $this->paginator->paginate($this->todoRepository->getPaginateQuery($search), (int) $request->get('page', 1), 10, ['defaultSortFieldName' => 'a.id', 'defaultSortDirection' => 'desc']);
return ['pagination' => $pagination];
}
public function searchAction()
{
$phrase = $this->request->get('search_type[phrase]', false, true);
if (empty($phrase)) {
return $this->render('ValantirForumBundle:Search:search-result.html.twig', array('phrase' => $phrase));
}
$searchQuery = $this->getTopicManager()->findWith($phrase);
$pagination = $this->paginator->paginate($searchQuery, $this->request->get('page', 1), 10, array('wrap-queries' => true));
return $this->render('ValantirForumBundle:Search:search-result.html.twig', array('topics' => $pagination, 'phrase' => $phrase));
}
/**
* {@inheritdoc}
*/
public function paginate($target, $page = 1, $limit = 10)
{
if (null === $this->paginator) {
throw new \LogicException(sprintf('Knp\\Component\\Pager\\Paginator not injected in constructor of %s', __CLASS__));
}
$this->page = $page;
$this->pager = $this->paginator->paginate($target, $page, $limit, array('distinct' => true));
$this->data = $this->pager->getPaginationData();
return $this;
}
/**
* Paginate the lists.
*
* @param ThreadListEvent $event
*/
public function onPageList(ThreadListEvent $event)
{
$statement = $event->getStatement();
if (!$statement->supportPagination()) {
return;
}
$page = $event->getRequest()->get($this->pageParameterName);
if (!$page || !is_numeric($page)) {
$page = 1;
}
$pagination = $this->paginator->paginate($statement->getPaginationResource(), $page, 20);
$event->setList($pagination);
}
/**
* @test
*/
function shouldSortWithoutSpecificWhitelist()
{
$this->populate();
$_GET['sort'] = 'a.title';
$_GET['direction'] = 'asc';
$query = $this->em->createQuery('SELECT a FROM Test\\Fixture\\Entity\\Article a');
$p = new Paginator();
$view = $p->paginate($query, 1, 10);
$items = $view->getItems();
$this->assertEquals('autumn', $items[0]->getTitle());
$_GET['sort'] = 'a.id';
$view = $p->paginate($query, 1, 10);
$items = $view->getItems();
$this->assertEquals('summer', $items[0]->getTitle());
}
/**
* @test
*/
function shouldSortWithoutSpecificWhitelist()
{
$this->populate();
$_GET['sort'] = 'title';
$_GET['direction'] = 'asc';
$query = $this->dm->createQueryBuilder('Test\\Fixture\\Document\\Article')->getQuery();
$p = new Paginator();
$view = $p->paginate($query, 1, 10);
$items = array_values($view->getItems());
$this->assertEquals('autumn', $items[0]->getTitle());
$_GET['sort'] = 'id';
$view = $p->paginate($query, 1, 10);
$items = array_values($view->getItems());
$this->assertEquals('summer', $items[0]->getTitle());
}
/**
* @test
* @expectedException RuntimeException
*/
function shouldFailToPaginateUnsupportedValue()
{
$dispatcher = new EventDispatcher();
$dispatcher->addSubscriber(new PaginationSubscriber());
$p = new Paginator($dispatcher);
$view = $p->paginate(null, 1, 10);
}
/**
* @test
*/
function shouldSupportPaginateStrategySubscriber()
{
$query = $this->getMockSqliteEntityManager()->createQuery('SELECT a FROM Test\\Fixture\\Entity\\Article a');
$p = new Paginator();
$view = $p->paginate($query, 1, 10);
$this->assertTrue($view instanceof PaginationInterface);
}
/**
* @Route()
* @Method("GET")
* @Template(":Todo/Default:index.html.twig")
*
* @param Request $request
* @return array
*/
public function indexAction(Request $request)
{
// TODO: このダサいifなんとかしたい。。。
$type = $request->get('type', 1);
if ($type == 1) {
$spec = $this->openSpecification;
} elseif ($type == 2) {
$spec = $this->closeSpecification;
} else {
$spec = null;
$type = 3;
}
/** @var SlidingPagination $pagination */
$pagination = $this->paginator->paginate($this->todoRepository->getPaginateQuery($spec), (int) $request->get('page', 1), 10, ['defaultSortFieldName' => 'a.id', 'defaultSortDirection' => 'desc']);
return ['pagination' => $pagination, 'type' => $type];
}
/**
* @param $data
* @param $currentPage
* @param $limitPerPage
* @param $options
*/
public function paginate($data, $currentPage = 1, $limitPerPage = 10, $options = array())
{
$paginator = new KnpPaginator();
if ($currentPage === null) {
$currentPage = 1;
}
if (!isset($options['searchParameter'])) {
$options['searchParameter'] = 'search';
}
// Temporary solution. We'll try to figure out a better one soon!
$searchFields = isset($options['searchFields']) ? $options['searchFields'] : false;
$searchValue = $this->app['request']->query->get($options['searchParameter'], false);
if ($searchFields && !$data instanceof QueryBuilder) {
throw new \Exception('If you want to use search, you MUST use the QueryBuilder!');
}
if ($searchFields && $searchValue) {
if (is_string($searchFields)) {
$searchFields = explode(',', $searchFields);
}
foreach ($searchFields as $searchFieldKey => $searchField) {
$data->orWhere($searchField . ' LIKE ?' . $searchFieldKey)->setParameter($searchFieldKey, '%' . $searchValue . '%');
}
}
$pagination = $paginator->paginate($data, $currentPage, $limitPerPage, $options);
return $pagination;
}
/**
* @test
*/
function shouldSupportPaginateStrategySubscriber()
{
$query = $this->getMockDocumentManager()->createQueryBuilder('Test\\Fixture\\Document\\Article')->getQuery();
$p = new Paginator();
$pagination = $p->paginate($query, 1, 10);
$this->assertTrue($pagination instanceof SlidingPagination);
}
/**
*
* @param Request $request
* @param AbstractType|string $formType
* @param Query $query
* @param string $sessionKey
* @param array $formOptions
* @return array
*/
public function process(Request $request, $formType, $query, $sessionKey, array $formOptions = array())
{
$filterForm = $this->formFactory->create($formType, null, $formOptions);
$method = $filterForm->getConfig()->getMethod();
$requestData = $method == 'GET' ? $request->query->get($filterForm->getName()) : $request->request->get($filterForm->getName());
if (isset($requestData['reset'])) {
if ($method == 'POST') {
$request->getSession()->remove($sessionKey);
return array($filterForm, null, true);
}
$request->getSession()->set($sessionKey, array());
$requestData = array();
}
$filterData = empty($requestData) ? $request->getSession()->get($sessionKey, $requestData) : $requestData;
if (!empty($filterData)) {
$this->applyFilter($filterForm, $filterData, $query);
if (empty($filterData)) {
$request->getSession()->remove($sessionKey);
} else {
$request->getSession()->set($sessionKey, $filterData);
}
}
$this->updatePerPage($request, $sessionKey);
$page = $request->query->get($this->knpParams['pageParameterName'], 1);
$event = $this->eventDispatcher->dispatch(FilterEvent::POST_FILTER, new FilterEvent($query));
if ($event->hasNewQuery()) {
$query = $event->getNewQuery();
}
return array($filterForm, $this->paginator->paginate($query, $page, $this->perPage, $this->knpParams), false);
}
/**
* @test
*/
function shouldSupportPaginateStrategySubscriber()
{
$items = new ArrayCollection(array('first', 'second'));
$p = new Paginator();
$view = $p->paginate($items, 1, 10);
$this->assertTrue($view instanceof PaginationInterface);
}
/**
* @test
*/
function shouldPaginateArrayObject()
{
$items = array('first', 'second');
$array = new \ArrayObject($items);
$p = new Paginator();
$view = $p->paginate($array, 1, 10);
$this->assertTrue($view instanceof PaginationInterface);
}
public function testRepresentation()
{
$representation = new KnpPaginatorRepresentationFactory(PaginationInterface::PAGE_PARAMETER_NAME, PaginationInterface::LIMIT_PARAMETER_NAME);
$paginator = new Paginator();
$pagination = $paginator->paginate(['item_1', 'item_2'], 1, 10);
$response = $representation->createRepresentation($pagination, new Request());
self::assertTrue(is_array($response->getInline()->getResources()));
self::assertTrue(count($response->getInline()->getResources()) == 2);
$pagination = $paginator->paginate(new ArrayCollection(['test_item', 'test_item2', 'test_item_3']), 1, 10);
$response = $representation->createRepresentation($pagination, new Request());
self::assertTrue(is_array($response->getInline()->getResources()));
self::assertTrue(count($response->getInline()->getResources()) == 3);
$pagination = $paginator->paginate(new \ArrayObject(['test_item', 'test_item2']), 1, 10);
$response = $representation->createRepresentation($pagination, new Request());
self::assertTrue(is_array($response->getInline()->getResources()));
self::assertTrue(count($response->getInline()->getResources()) == 2);
}
/**
* @test
*/
function shouldSortOnAnyField()
{
$_GET['sort'] = '"title\'';
$_GET['direction'] = 'asc';
$query = $this->getMockDocumentManager()->createQueryBuilder('Test\\Fixture\\Document\\Article')->getQuery();
$p = new Paginator();
$view = $p->paginate($query, 1, 10);
}
/**
*
* @access public
* @param \Doctrine\ORM\QueryBuilder $qb
* @param int $itemsPerPage
* @param int $page
* @return \Knp\Bundle\PaginatorBundle\Pagination\SlidingPagination
*/
public function paginateQuery(QueryBuilder $qb, $itemsPerPage, $page)
{
$pager = $this->paginator->paginate($qb, $page, $itemsPerPage);
if ($this->pagerTheme) {
$pager->setTemplate($this->pagerTheme);
}
return $pager;
}
/**
* @test
* @expectedException RuntimeException
* @expectedExceptionMessage One of listeners must count and slice given target
*/
function testArrayShouldNotBeHandled()
{
$array = array('results' => array(0 => array('city' => 'Lyon', 'market' => 'E'), 1 => array('city' => 'Paris', 'market' => 'G')), 'nbTotalResults' => 2);
$dispatcher = new EventDispatcher();
$dispatcher->addSubscriber(new SolariumQuerySubscriber());
$dispatcher->addSubscriber(new MockPaginationSubscriber());
$p = new Paginator($dispatcher);
$p->paginate($array, 1, 10);
}
/**
* @test
* @expectedException RuntimeException
* @expectedExceptionMessage One of listeners must count and slice given target
*/
function testArrayShouldNotBeHandled()
{
$array = array(1 => 'foo', 2 => 'bar');
$dispatcher = new EventDispatcher();
$dispatcher->addSubscriber(new SolariumQuerySubscriber());
$dispatcher->addSubscriber(new MockPaginationSubscriber());
$p = new Paginator($dispatcher);
$p->paginate($array, 1, 10);
}
/**
* @test
*/
function shouldPaginate()
{
$this->populate();
$query = $this->dm->createQueryBuilder('Test\\Fixture\\Document\\Image')->getQuery();
$p = new Paginator();
$view = $p->paginate($query, 1, 10);
$cursor = $query->execute();
$this->assertEquals(4, count($view->getItems()));
}
/**
* $params = [
* service => String, service name that created queue item
* from => DateTime, stating time to search items for
* to => DateTime, ending time to search items for
* user => User, user entity who created this queue item
* ]
*
* @param Paginator $paginator
* @param [] $params
* @param integer $activePage
* @param integer $itemsPerPage
*
* @return type
*/
public function findByParamsWithPagination(Paginator $paginator, $params, $orderBy = [], $activePage = 1, $itemsPerPage = 10)
{
$qb = $this->_em->createQueryBuilder();
$qb->select('q');
$qb->from($this->_em->getRepository('CoreBundle:Queue')->getClassName(), 'q');
$qb->where('1 = 1');
if (isset($params['service'])) {
$qb->andWhere('q.service = :service');
$qb->setParameter('service', $params['service']);
}
$ids = null;
// Такой вот некрасивый код, чтобы фильтровать Queue по дате.
// Одним запросом DQL мы это сделать не можем, т.к. связи между Queue и
// QueueLog нет, а скатившись на уровень Plain SQL нам придется отказаться
// от пагинации.
if (isset($params['from']) || isset($params['to']) || isset($params['user'])) {
$dateFrom = isset($params['from']) ? $params['from'] : null;
$dateTo = isset($params['to']) ? $params['to'] : null;
$user = isset($params['user']) ? $params['user'] : null;
$qbql = $this->_em->createQueryBuilder();
$qbql->select('ql.queue');
$qbql->from($this->_em->getRepository('CoreBundle:QueueLog')->getClassName(), 'ql');
$qbql->where('1 = 1');
if (isset($params['service'])) {
$qbql->andWhere('ql.service = :service');
$qbql->setParameter('service', $params['service']);
}
if (!empty($user)) {
$qbql->andWhere('ql.userId = :user');
$qbql->setParameter('user', $user);
}
if (!empty($dateFrom)) {
$qbql->andWhere('ql.createdAt >= :from');
$qbql->setParameter('from', $dateFrom);
}
if (!empty($dateTo)) {
$qbql->andWhere('ql.createdAt < :to');
$qbql->setParameter('to', $dateTo);
}
$result = $qbql->getQuery()->getResult();
foreach ($result as $item) {
$ids[] = $item->getId();
}
//$ids = array_map('current', $result);
}
if (is_array($ids)) {
$qb->andWhere('q.id IN (:ids)');
$qb->setParameter('ids', $ids);
}
foreach ($orderBy as $sort => $order) {
if (in_array($sort, ['id', 'status'])) {
$qb->addOrderBy('q.' . $sort, $order);
}
}
$pagination = $paginator->paginate($qb, $activePage, $itemsPerPage);
return $pagination;
}
/**
* @test
*/
public function shouldFilterWithoutSpecificWhitelist()
{
$this->populate();
$_GET['filterParam'] = 'a.title';
$_GET['filterValue'] = 'autumn';
$query = $this->em->createQuery('SELECT a FROM Test\\Fixture\\Entity\\Article a');
$dispatcher = new EventDispatcher();
$dispatcher->addSubscriber(new PaginationSubscriber());
$dispatcher->addSubscriber(new Filtration());
$p = new Paginator($dispatcher);
$view = $p->paginate($query, 1, 10);
$items = $view->getItems();
$this->assertEquals('autumn', $items[0]->getTitle());
$_GET['filterParam'] = 'a.id';
$view = $p->paginate($query, 1, 10);
$items = $view->getItems();
$this->assertEquals(0, count($items));
}
public function paginate($data, $currentPage = 1, $limitPerPage = 10, $options = array())
{
$paginator = new KnpPaginator();
if ($currentPage == null) {
$currentPage = 1;
}
$pagination = $paginator->paginate($data, $currentPage, $limitPerPage, $options);
return $pagination;
}
/**
* @param int $id
* @param int $page
* @return array
*/
public function getResult($id, $page)
{
if ($id === 0) {
throw new NotFoundHttpException('Album does not exist');
}
$album = $this->em->getRepository(Album::class)->find($id);
if (!$album instanceof Album) {
throw new NotFoundHttpException('Album not found');
}
$query = $this->em->getRepository(Image::class)->getPaginationQuery($album);
/** @var SlidingPagination $pagination */
$pagination = $this->paginator->paginate($query, $page < 1 ? 1 : $page, 10, array('pageParameterName' => 'page'));
if (count($pagination->getItems()) === 0) {
throw new NotFoundHttpException('Images not found');
}
$pagination->setUsedRoute('DefaultAlbumPage');
return array('pagination' => $pagination);
}
/**
* @test
*/
function shouldBeHandledByQueryHintByPassingCount()
{
$p = new Paginator();
$em = $this->getMockSqliteEntityManager();
$count = $em->createQuery('SELECT COUNT(c) FROM Test\\Fixture\\Entity\\Composite c')->getSingleScalarResult();
$query = $em->createQuery('SELECT c FROM Test\\Fixture\\Entity\\Composite c')->setHint('knp_paginator.count', $count);
$view = $p->paginate($query);
$items = $view->getItems();
$this->assertEquals(0, count($items));
}
/**
* @param Album $album
* @param int $page Page number
*
* @return \Knp\Component\Pager\Pagination\PaginationInterface
*/
public function getItems(Album $album, $page)
{
$em = $this->getEntityManager();
$qb = $em->createQueryBuilder();
$qb->select('i')->from('ImageBundle:Image', 'i')->where('i.album=:album')->setParameter('album', $album);
$query = $qb->getQuery();
return $this->paginator->paginate($query, $page, 12);
}
