/**
* {@inheritdoc}
*/
public function getResult(QueryBuilder $queryBuilder)
{
$doctrineOrmPaginator = new DoctrineOrmPaginator($queryBuilder);
// Disable output walkers by default (performance)
$doctrineOrmPaginator->setUseOutputWalkers(false);
return new Paginator($doctrineOrmPaginator);
}
/**
* Calculates total count of query records
* Notes: this method do not make any modifications of the given query
*
* @param Query|SqlQuery $query
*
* @return integer
*/
public function getCount($query)
{
if ($this->useWalker($query)) {
if (!$query->contains('DISTINCT')) {
$query->setHint(CountWalker::HINT_DISTINCT, false);
}
$paginator = new Paginator($query);
$paginator->setUseOutputWalkers(false);
$result = $paginator->count();
} else {
if ($query instanceof Query) {
$parserResult = QueryUtils::parseQuery($query);
$parameterMappings = $parserResult->getParameterMappings();
list($params, $types) = QueryUtils::processParameterMappings($query, $parameterMappings);
$statement = $query->getEntityManager()->getConnection()->executeQuery('SELECT COUNT(*) FROM (' . $query->getSQL() . ') AS e', $params, $types);
} elseif ($query instanceof SqlQuery) {
$countQuery = clone $query->getQueryBuilder();
$statement = $countQuery->resetQueryParts()->select('COUNT(*)')->from('(' . $query->getSQL() . ')', 'e')->execute();
} else {
throw new \InvalidArgumentException(sprintf('Expected instance of Doctrine\\ORM\\Query or Oro\\Bundle\\EntityBundle\\ORM\\SqlQuery, "%s" given', is_object($query) ? get_class($query) : gettype($query)));
}
$result = $statement->fetchColumn();
}
return $result ? (int) $result : 0;
}
public function items(ItemsEvent $event)
{
if (!class_exists('Doctrine\\ORM\\Tools\\Pagination\\Paginator')) {
return;
}
if (!$event->target instanceof Query) {
return;
}
$event->stopPropagation();
$useOutputWalkers = false;
if (isset($event->options['wrap-queries'])) {
$useOutputWalkers = $event->options['wrap-queries'];
}
$event->target->setFirstResult($event->getOffset())->setMaxResults($event->getLimit())->setHint(CountWalker::HINT_DISTINCT, $event->options['distinct']);
$fetchJoinCollection = true;
if ($event->target->hasHint(self::HINT_FETCH_JOIN_COLLECTION)) {
$fetchJoinCollection = $event->target->getHint(self::HINT_FETCH_JOIN_COLLECTION);
}
$paginator = new Paginator($event->target, $fetchJoinCollection);
$paginator->setUseOutputWalkers($useOutputWalkers);
if (($count = $event->target->getHint(QuerySubscriber::HINT_COUNT)) !== false) {
$event->count = intval($count);
} else {
$event->count = count($paginator);
}
$event->items = iterator_to_array($paginator);
}
public function paginate(QueryBuilder $query, $limit, $page)
{
$query->setMaxResults($limit)->setFirstResult($limit * ($page - 1));
$paginator = new Paginator($query->getQuery());
$paginator->setUseOutputWalkers(false);
return $paginator;
}
public function getQueryResult($class, $params)
{
if (!$params instanceof OdataParameters) {
$params = OdataParameters::parse($params);
}
$repository = $this->entityManager->getRepository($class);
$queryBuilder = $repository->createQueryBuilder('X');
$odataBuilder = new OdataQueryBuilderWrapper($queryBuilder);
$odataBuilder->applyOdataParameters($params);
if ($params->inlinecount) {
// $count = $odataBuilder->getInlineCount();
}
$query = $queryBuilder->getQuery();
$inlineCount = null;
$fetchJoinCollection = isset($params->expand);
$fetchCount = $params->inlinecount;
if ($fetchJoinCollection || $fetchCount) {
$paginator = new Paginator($query, $fetchJoinCollection);
$paginator->setUseOutputWalkers(false);
if ($fetchCount) {
$inlineCount = count($paginator);
}
$result = array();
foreach ($paginator as $object) {
$result[] = $object;
}
} else {
$result = $query->getResult();
}
if ($inlineCount !== null) {
return array('Results' => $result, 'InlineCount' => $inlineCount);
}
return $result;
}
public function getListagem($arrData = array(), $intPage = 1, $intQtdPage = 10)
{
$queryBuilder = $this->_em->createQueryBuilder();
$queryBuilder->select('PessoaFisica')->addSelect('Login.dsLogin')->from('Application\\Entity\\PessoaFisica', 'PessoaFisica')->innerJoin('Application\\Entity\\Login', 'Login', 'with', 'Login.idPessoaFisica = PessoaFisica.idPessoaFisica')->setMaxResults($intQtdPage)->setFirstResult($intPage * ($intPage - 1))->orderBy('PessoaFisica.dsNome', 'asc');
# bind nome
if ($arrData['dsNome']) {
$queryBuilder->andWhere($queryBuilder->expr()->like('PessoaFisica.dsNome', ':dsNome'))->setParameter('dsNome', '%' . $arrData['dsNome'] . '%');
}
# bind cpf
if ($arrData['dsCpf']) {
$queryBuilder->andWhere('PessoaFisica.dsCpf = :dsCpf')->setParameter('dsCpf', Format::clearCpfCnpj($arrData['dsCpf']));
}
# bind dsEmail
if ($arrData['dsEmail']) {
$queryBuilder->andWhere('PessoaFisica.dsEmail = :dsEmail')->setParameter('dsEmail', $arrData['dsEmail']);
}
# bind dsLogin
if ($arrData['dsLogin']) {
$queryBuilder->andWhere('Login.dsLogin = :dsLogin')->setParameter('dsLogin', $arrData['dsLogin']);
}
$query = $queryBuilder->getQuery();
$registerPaginator = new Paginator($query);
$registerPaginator->setUseOutputWalkers(false);
$intCountResult = $registerPaginator->count();
$arrDadosPaginator = array('qtdRegister' => $intCountResult, 'qtdPages' => ceil($intCountResult / $intQtdPage), 'pageActual' => $intPage, 'maxResult' => $intQtdPage, 'register' => $registerPaginator);
return $arrDadosPaginator;
}
/**
* Get the latest moderation actions
*
* @param integer $offset
* @param integer $limit
*
* @return Paginator
*/
public function getLatestModerations($offset, $limit)
{
$queryBuilder = $this->createQueryBuilder('mo')->select(array('mo', 'u', 'f', 'm', 't', 'b'))->join('mo.user', 'u')->leftJoin('mo.flag', 'f')->leftJoin('mo.message', 'm')->leftJoin('mo.topic', 't')->leftJoin('mo.board', 'b')->orderBy('mo.id', 'DESC');
$query = $queryBuilder->getQuery();
$query->setFirstResult($offset)->setMaxResults($limit);
$paginator = new Paginator($query, false);
return $paginator->setUseOutputWalkers(false);
}
public function getLatestTopicsByBoard(BoardInterface $board, $offset, $limit, $isDeleted)
{
$queryBuilder = $this->createQueryBuilder('t')->select(array('t'))->where('t.board = :board')->setParameter('board', $board)->addOrderBy('t.isPinned', 'DESC')->addOrderBy('t.lastMessageDate', 'DESC');
if ($isDeleted !== null) {
$queryBuilder->andWhere('t.isDeleted = :isDeleted')->setParameter('isDeleted', $isDeleted);
}
$query = $queryBuilder->getQuery()->setFirstResult($offset)->setMaxResults($limit);
$paginator = new Paginator($query, false);
return $paginator->setUseOutputWalkers(false);
}
public function getTotalCount() : int
{
$queryBuilder = $this->getQueryBuilder();
$query = $queryBuilder->getQuery();
$query->useQueryCache(true);
$query->useResultCache(true);
$paginator = new Paginator($query, true);
$paginator->setUseOutputWalkers(false);
return $paginator->count();
}
public function listCompanies($page = 1, $pageSize = 20)
{
$query = $this->em->createQuery('SELECT c, cls FROM SSEICSSBundle:Company c LEFT JOIN c.class cls ORDER BY c.id ASC');
$paginator = new Paginator($query);
$paginator->setUseOutputWalkers(false);
$totalRecruits = count($paginator);
$pagesCount = ceil($totalRecruits / $pageSize);
$paginator->getQuery()->setFirstResult($pageSize * ($page - 1))->setMaxResults($pageSize);
$list = $query->getArrayResult();
return ["totalRecruits" => $totalRecruits, "currentPage" => $page, "pagesCount" => $pagesCount, "list" => $list];
}
public function getListagem($arrData = array(), $intPage = 1, $intQtdPage = 10)
{
$queryBuilder = $this->_em->createQueryBuilder();
$queryBuilder->select('Empreendimento')->from('Application\\Entity\\Empreendimento', 'Empreendimento')->innerJoin('Application\\Entity\\Municipio', 'Municipio', 'with', 'Municipio.idMunicipio = Empreendimento.idMunicipio')->innerJoin('Application\\Entity\\Estado', 'Estado', 'with', 'Estado.idEstado = Municipio.idEstado')->setMaxResults($intQtdPage)->setFirstResult($intPage * ($intPage - 1))->orderBy('Empreendimento.dsEmpreendimento', 'asc');
$query = $queryBuilder->getQuery();
$registerPaginator = new Paginator($query);
$registerPaginator->setUseOutputWalkers(false);
$intCountResult = $registerPaginator->count();
$arrDadosPaginator = array('qtdRegister' => $intCountResult, 'qtdPages' => ceil($intCountResult / $intQtdPage), 'pageActual' => $intPage, 'maxResult' => $intQtdPage, 'register' => $registerPaginator);
return $arrDadosPaginator;
}
/**
* {@inheritdoc}
*/
public function getTotalRows(QueryBuilder $queryBuilder, ColumnCollection $columns)
{
$builder = clone $queryBuilder;
$having = $builder->getDQLPart('having');
if (is_object($having)) {
$this->replaceHaving($having, $columns, $builder);
}
$query = $builder->getQuery();
$paginator = new Paginator($query, true);
$paginator->setUseOutputWalkers(false);
return $paginator->count();
}
/**
* {@inheritdoc}
*/
public function getTotalRows(QueryBuilder $queryBuilder, ColumnCollection $columns) : int
{
$builder = clone $queryBuilder;
$having = $builder->getDQLPart('having');
if (is_object($having)) {
$this->replaceHaving($having, $columns, $builder);
}
$query = $builder->getQuery();
$query->useQueryCache(true);
$query->useResultCache(true, 3600, self::RESULT_CACHE_ID);
$paginator = new Paginator($query, true);
$paginator->setUseOutputWalkers(false);
return $paginator->count();
}
public function listRecruits($page = 1, $pageSize = 20)
{
$query = $this->em->createQuery('SELECT r, p FROM SSEICSSBundle:Recruit r LEFT JOIN r.suitableProjects p ORDER BY r.publishAt DESC');
$paginator = new Paginator($query);
$paginator->setUseOutputWalkers(false);
$totalRecruits = count($paginator);
$pagesCount = ceil($totalRecruits / $pageSize);
$paginator->getQuery()->setFirstResult($pageSize * ($page - 1))->setMaxResults($pageSize);
$list = $query->getArrayResult();
foreach ($list as &$rec) {
$rec['publishAt'] = $rec['publishAt']->format('Y-m-d');
}
return ["totalRecruits" => $totalRecruits, "currentPage" => $page, "pagesCount" => $pagesCount, "list" => $list];
}
/**
* paginate results
*
* @param $query - naming is a bit off as it can be a NativeQuery OR
* QueryBuilder, we'll survive eventually
* @param int $page
* @param $limit
* @return array
*/
public function paginate($query, $page, $limit, $userCount)
{
$totalPages = '';
// setting current page
$this->currentPage = $page;
// set the limit
$limit = (int) $limit;
$this->count = $userCount;
$this->totalPages = ceil($this->count / $limit);
$newquery = $query->setFirstResult(($page - 1) * $limit)->setMaxResults($limit)->getQuery();
$paginator = new DoctrinePaginator($newquery);
$paginator->setUseOutputWalkers(false);
// set total pages
return $newquery->getResult();
}
/**
*
* @param array $arrData
* @param integer $intPage
* @param integer $intQtdPage
* @return Paginator
*/
public function getListagem($arrData = array(), $intPage = 1, $intQtdPage = 10)
{
$queryBuilder = $this->_em->createQueryBuilder();
$queryBuilder->select('Perefil')->from('Application\\Entity\\Perfil', 'Perefil')->setFirstResult($intPage * ($intPage - 1))->orderBy('Perefil.noPerfil', 'asc');
# bind nome
if ($arrData['noPerfil']) {
$queryBuilder->andWhere($queryBuilder->expr()->like('Perfil.dsNome', ':noPerfil'))->setParameter('noPerfil', '%' . $arrData['noPerfil'] . '%');
}
# bind situacao
if ($arrData['inAtivo'] != '') {
$queryBuilder->andWhere('Perefil.inAtivo = :inAtivo')->setParameter('inAtivo', $arrData['inAtivo']);
}
$query = $queryBuilder->getQuery();
$registerPaginator = new Paginator($query);
$registerPaginator->setUseOutputWalkers(false);
$intCountResult = $registerPaginator->count();
$arrDadosPaginator = array('qtdRegister' => $intCountResult, 'qtdPages' => ceil($intCountResult / $intQtdPage), 'pageActual' => $intPage, 'maxResult' => $intQtdPage, 'register' => $registerPaginator);
return $arrDadosPaginator;
}
public function getData()
{
// Paginator is better if the query uses ManyToMany associations
$usePaginator = $this->qb->getMaxResults() !== NULL || $this->qb->getFirstResult() !== NULL;
$data = [];
if ($usePaginator) {
$paginator = new Paginator($this->getQuery(), $this->fetchJoinCollection);
$paginator->setUseOutputWalkers($this->useOutputWalkers);
// Convert paginator to the array
foreach ($paginator as $result) {
// Return only entity itself
$data[] = $result;
}
} else {
foreach ($this->qb->getQuery()->getResult() as $result) {
// Return only entity itself
$data[] = $result;
}
}
return $data;
}
/**
* @param ORM\Query
* @return ResultPaginator
*/
private function createPaginatedQuery(ORM\Query $query)
{
$paginated = new ResultPaginator($query, $this->fetchJoinCollection);
$paginated->setUseOutputWalkers($this->useOutputWalkers);
return $paginated;
}
/**
* {@inheritdoc}
*/
public function getResult(QueryBuilder $queryBuilder)
{
$doctrineOrmPaginator = new DoctrineOrmPaginator($queryBuilder);
$doctrineOrmPaginator->setUseOutputWalkers($this->useOutputWalkers($queryBuilder));
return new Paginator($doctrineOrmPaginator);
}
/**
* Constructor.
*
* @param \Doctrine\ORM\Query|\Doctrine\ORM\QueryBuilder $query A Doctrine ORM query or query builder.
* @param Boolean $fetchJoinCollection Whether the query joins a collection (true by default).
* @param Boolean $useOutputWalkers Whether to use output walkers pagination mode
*/
public function __construct($query, $fetchJoinCollection = true, $useOutputWalkers = null)
{
$this->paginator = new DoctrinePaginator($query, $fetchJoinCollection);
$this->paginator->setUseOutputWalkers($useOutputWalkers);
}
public function testIterateComplexWithOutputWalker()
{
$dql = "SELECT g, COUNT(u.id) AS userCount FROM Doctrine\\Tests\\Models\\CMS\\CmsGroup g LEFT JOIN g.users u GROUP BY g HAVING COUNT(u.id) > 0";
$query = $this->_em->createQuery($dql);
$paginator = new Paginator($query);
$paginator->setUseOutputWalkers(true);
$this->assertCount(9, $paginator->getIterator());
}
/**
* Get all results from offset
*
* NOTE: Looping pages in a single request will force the ENTIRE EntityManager to be cleared for memory saving purposes
*
* @return ArrayIterator
*/
public function getResults($offset, $itemCountPerPage)
{
$qb = $this->getQueryBuilder();
$filter = $this->getFilter();
$i = 0;
if ($this->hasResults) {
$qb->getEntityManager()->clear();
}
foreach ($filter->getAllFieldValues() as $group => $fields) {
$expressions = $group === 0 ? $qb->expr()->andX() : $qb->expr()->orX();
foreach ($fields as $field => $values) {
foreach ($values as $data) {
$param = ':param' . $i++;
$value = $this->prepareValue($data['value'], $field);
$mappedField = $this->getMappedField($field);
foreach ((array) $mappedField['field'] as $fieldName) {
$this->addJoin($fieldName, $group);
if (!isset($this->conditionalFields[$fieldName])) {
$expressions->add($this->getExpression($fieldName, $data['comparison'], $value, $param, $mappedField['type']));
} else {
$value = null;
}
}
if (null !== $value) {
$qb->setParameter(trim($param, ':'), $value);
}
}
}
$qb->andWhere($expressions);
}
$keywordFields = $this->getOptions()->getKeywordFields();
if (!empty($keywordFields) && null !== $filter->getKeywords()) {
$hasFulltext = false;
$orX = $qb->expr()->orX();
foreach ($keywordFields as $field) {
$mappedField = $this->getMappedField($field);
foreach ((array) $mappedField['field'] as $fieldName) {
$this->addJoin($fieldName);
if ($mappedField['type'] === self::FIELD_TYPE_FULLTEXT) {
$hasFulltext = true;
$orX->add(sprintf('MATCH (%s) AGAINST (%s) > 1', $fieldName, ':fulltext_keyword'));
} else {
$orX->add($qb->expr()->like($fieldName, ':keyword'));
}
}
}
$qb->andWhere($orX);
$qb->setParameter('keyword', '%' . $filter->getKeywords() . '%');
if ($hasFulltext) {
$qb->setParameter('fulltext_keyword', $filter->getKeywords());
}
}
if (null !== $filter->getSortField()) {
$mappedSortField = $this->getMappedField($filter->getSortField());
$this->addJoin($mappedSortField['field']);
$qb->orderBy($mappedSortField['field'], $filter->getSortOrder());
}
$qb->setFirstResult($offset);
$qb->setMaxResults($itemCountPerPage);
$query = $qb->getQuery();
$query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, 'DoctrineExtensions\\Query\\MysqlWalker');
$query->setHint('mysqlWalker.sqlCalcFoundRows', true);
$paginator = new DoctrinePaginator($query, false);
try {
$results = $paginator->setUseOutputWalkers(false)->getIterator();
$this->count = $qb->getEntityManager()->getConnection()->query('SELECT FOUND_ROWS()')->fetchColumn(0);
} catch (\RuntimeException $ex) {
$results = $paginator->setUseOutputWalkers(true)->getIterator();
$this->count = $paginator->count();
}
if (0 == $this->count) {
return new ArrayIterator([]);
}
foreach ($this->getConverters() as $converter) {
$results = $converter->convert($results);
}
$this->hasResults = true;
return $results;
}
/**
* @param \Kdyby\Doctrine\QueryBuilder $qb
* @param int $hydrationMode
* @param \Carrooi\NoGrid\Condition[] $conditions
* @param null|int $maxResults
* @param null|int $firstResult
* @param array $hints
* @param bool $fetchJoinCollections
* @param null|bool $useOutputWalkers
* @return array
*/
protected static function fetchDataFromQuery(QueryBuilder $qb, $hydrationMode = Query::HYDRATE_OBJECT, array $conditions, $maxResults = null, $firstResult = null, array $hints = [], $fetchJoinCollections = true, $useOutputWalkers = null)
{
foreach ($conditions as $condition) {
self::makeWhere($qb, $condition);
}
$query = $qb->getQuery();
$query->setHydrationMode($hydrationMode);
foreach ($hints as $name => $value) {
$query->setHint($name, $value);
}
if ($maxResults !== null || $firstResult !== null) {
$result = new Paginator($query, $fetchJoinCollections);
if ($useOutputWalkers !== null) {
$result->setUseOutputWalkers($useOutputWalkers);
}
} else {
$result = $query->getResult();
}
$data = [];
foreach ($result as $item) {
$data[] = is_array($item) && array_key_exists(0, $item) ? $item[0] : $item;
}
return $data;
}
public function testQueryWalkerIsKept()
{
$dql = "SELECT u FROM Doctrine\\Tests\\Models\\CMS\\CmsUser u";
$query = $this->_em->createQuery($dql);
$query->setHint(Query::HINT_CUSTOM_TREE_WALKERS, array('Doctrine\\Tests\\ORM\\Functional\\CustomPaginationTestTreeWalker'));
$paginator = new Paginator($query, true);
$paginator->setUseOutputWalkers(false);
$this->assertCount(1, $paginator->getIterator());
$this->assertEquals(1, $paginator->count());
}
public function getResponse($buildQuery = true)
{
false === $buildQuery ?: $this->buildQuery();
$fresults = new Paginator($this->execute(), true);
$fresults->setUseOutputWalkers(false);
$output = array('data' => array());
foreach ($fresults as $item) {
// Line formatter
if (is_callable($this->lineFormatter)) {
$callable = $this->lineFormatter;
$item = call_user_func($callable, $item);
}
// Images
foreach ($this->columns as $column) {
$data = $column->getDql();
/** @var ImageColumn $column */
if ('image' === $column->getAlias()) {
if (true === $this->imagineBundle) {
$item[$data] = $this->renderImage($item[$data], $column);
} else {
$item[$data] = $this->twig->render('SgDatatablesBundle:Helper:render_image.html.twig', array('image_name' => $item[$data], 'path' => $column->getRelativePath()));
}
}
if ('gallery' === $column->getAlias()) {
$fields = explode('.', $data);
if (true === $this->imagineBundle) {
$galleryImages = '';
foreach ($item[$fields[0]] as $image) {
$galleryImages = $galleryImages . $this->renderImage($image[$fields[1]], $column);
}
$item[$fields[0]] = $galleryImages;
} else {
throw new InvalidArgumentException('getResponse(): Bundle "LiipImagineBundle" does not exist or it is not enabled.');
}
}
}
$output['data'][] = $item;
}
$outputHeader = array('draw' => (int) $this->requestParams['draw'], 'recordsTotal' => (int) $this->getCountAllResults($this->rootEntityIdentifier), 'recordsFiltered' => (int) $this->getCountFilteredResults($this->rootEntityIdentifier));
$json = $this->serializer->serialize(array_merge($outputHeader, $output), 'json');
$response = new Response($json);
$response->headers->set('Content-Type', 'application/json');
return $response;
}
public function getResponse($buildQuery = true)
{
false === $buildQuery ?: $this->buildQuery();
$fresults = new Paginator($this->execute(), true);
$fresults->setUseOutputWalkers(false);
$output = array('data' => array());
foreach ($fresults as $item) {
if (is_callable($this->lineFormatter)) {
$callable = $this->lineFormatter;
$item = call_user_func($callable, $item);
}
$output['data'][] = $item;
}
$outputHeader = array('draw' => (int) $this->requestParams['draw'], 'recordsTotal' => (int) $this->getCountAllResults($this->rootEntityIdentifier), 'recordsFiltered' => (int) $this->getCountFilteredResults($this->rootEntityIdentifier));
$json = $this->serializer->serialize(array_merge($outputHeader, $output), 'json');
$response = new Response($json);
$response->headers->set('Content-Type', 'application/json');
return $response;
}
/**
* @return int
*/
public function getCount()
{
$paginator = new Paginator($this->getQuery(), $this->fetchJoinCollection);
$paginator->setUseOutputWalkers($this->useOutputWalkers);
return $paginator->count();
}
/**
* Get response.
*
* @param bool $buildQuery
* @param bool $outputWalkers
*
* @return Response
* @throws Exception
*/
public function getResponse($buildQuery = true, $outputWalkers = false)
{
false === $buildQuery ?: $this->buildQuery();
$this->paginator = new Paginator($this->execute(), true);
$this->paginator->setUseOutputWalkers($outputWalkers);
$formatter = new DatatableFormatter($this);
$formatter->runFormatter();
$outputHeader = array('draw' => (int) $this->requestParams['draw'], 'recordsTotal' => (int) $this->getCountAllResults($this->rootEntityIdentifier), 'recordsFiltered' => (int) $this->getCountFilteredResults($this->rootEntityIdentifier, $buildQuery));
$fullOutput = array_merge($outputHeader, $formatter->getOutput());
$fullOutput = $this->applyResponseCallbacks($fullOutput);
$json = $this->serializer->serialize($fullOutput, 'json');
$response = new Response($json);
$response->headers->set('Content-Type', 'application/json');
return $response;
}
/**
* Get response.
*
* @param bool $buildQuery
*
* @return Response
* @throws Exception
*/
public function getResponse($buildQuery = true)
{
false === $buildQuery ?: $this->buildQuery();
$fresults = new Paginator($this->execute(), true);
$fresults->setUseOutputWalkers(false);
$output = array('data' => array());
foreach ($fresults as $item) {
if (is_callable($this->lineFormatter)) {
$callable = $this->lineFormatter;
$item = call_user_func($callable, $item);
}
foreach ($this->columns as $column) {
$column->renderContent($item, $this);
/** @var ActionColumn $column */
if ('action' === $column->getAlias()) {
$column->checkVisibility($item);
}
}
$output['data'][] = $item;
}
$outputHeader = array('draw' => (int) $this->requestParams['draw'], 'recordsTotal' => (int) $this->getCountAllResults($this->rootEntityIdentifier), 'recordsFiltered' => (int) $this->getCountFilteredResults($this->rootEntityIdentifier, $buildQuery));
$fullOutput = array_merge($outputHeader, $output);
$fullOutput = $this->applyResponseCallbacks($fullOutput);
$json = $this->serializer->serialize($fullOutput, 'json');
$response = new Response($json);
$response->headers->set('Content-Type', 'application/json');
return $response;
}
/**
* @param \Kdyby\Persistence\Queryable $repository
* @param ResultSet $resultSet
* @param \Doctrine\ORM\Tools\Pagination\Paginator $paginatedQuery
* @return integer
*/
public function count(Queryable $repository, ResultSet $resultSet = NULL, Paginator $paginatedQuery = NULL)
{
if ($query = $this->doCreateCountQuery($repository)) {
return (int) $this->toQuery($query)->getSingleScalarResult();
}
if ($this->lastQuery && $this->lastQuery instanceof NativeQueryWrapper) {
$class = get_called_class();
throw new NotSupportedException("You must implement your own count query in {$class}::doCreateCountQuery(), Paginator from Doctrine doesn't support NativeQueries.");
}
if ($paginatedQuery !== NULL) {
return $paginatedQuery->count();
}
$query = $this->getQuery($repository)->setFirstResult(NULL)->setMaxResults(NULL);
$paginatedQuery = new Paginator($query, $resultSet ? $resultSet->getFetchJoinCollection() : TRUE);
$paginatedQuery->setUseOutputWalkers($resultSet ? $resultSet->getUseOutputWalkers() : NULL);
return $paginatedQuery->count();
}
