/**
* {@inheritdoc}
*/
public function getResult(QueryBuilder $queryBuilder)
{
$doctrineOrmPaginator = new DoctrineOrmPaginator($queryBuilder);
// Disable output walkers by default (performance)
$doctrineOrmPaginator->setUseOutputWalkers(false);
return new Paginator($doctrineOrmPaginator);
}
public function paginationToPaginatorORM(\Doctrine\ORM\Tools\Pagination\Paginator $paginator)
{
$this->setTotal($paginator->count());
$this->paginator = $paginator;
$dados = array(self::_TOTAL_RECORDS => $this->getTotalGeral(), self::_RECORDS_FILTERED => $this->getTotalGeral());
$this->outPut = array_merge($this->outPut, $dados);
}
/**
* Realiza a pesquisa paginada
* IMPORTANTE: definir o hydration mode em sua repository (QUERY::HYDRATE_ARRAY), pois afeta a performance
* @return \StdClass
*/
public function getGridData($searchQueryMethod = 'searchQuery', $prepareGridRowsMethod = 'prepareGridRows', $hydration_mode = null)
{
// Busca a query que será utilizada na pesquisa para a grid
$query = $this->getService()->{$searchQueryMethod}($this->getDto());
// pagina a ser retornada
// quantidade de linhas a serem retornadas por página
$rows = $this->getDto()->query->has('rows') ? $this->getDto()->query->get('rows', 20) : $this->getDto()->request->get('rows', 20);
$page = $this->getDto()->query->has('page') ? $this->getDto()->query->get('page', 1) : $this->getDto()->request->get('page', 1);
$rows = $rows >= 1 ? $rows : 20;
//só para evitar divisão por 0
$page = $page >= 1 ? $page : 1;
//só para evitar página negativa
$start = $page * $rows - $rows;
$start = $start >= 0 ? $start : 0;
$query->setFirstResult($start)->setMaxResults($rows);
if ($hydration_mode) {
$query->setHydrationMode($hydration_mode);
}
$pagination = new Paginator($query, true);
// Objeto de resposta
$data = new \StdClass();
$data->count = $pagination->count();
$data->itemsPerPage = $rows;
$data->page = $page;
$data->pageCount = ceil($pagination->count() / $rows);
// linhas da resposta - o método abaixo pode (e provavelmente deve)
// ser implantado de acordo com as necessidades da aplicação
$data->items = $this->{$prepareGridRowsMethod}($pagination);
return $data;
}
/**
* Lists all Viaggio entities.
*
* @Route("/", name="travel")
* @Method("GET")
* @Template("AppBundle:Viaggio:mete-visitate.html.twig")
*/
public function indexAction()
{
$this->denyAccessUnlessGranted('ROLE_USER', null, 'Unable to access this page!');
$em = $this->getDoctrine()->getManager();
$user = $this->container->get('security.context')->getToken()->getUser();
$user_id = $user->getId();
// $entities = $em->getRepository('AppBundle:Viaggio')->findBy(['utente'=>$user, 'salvato'=>true],['id' => 'DESC']);
// Limit per page.
$limit = 4;
$page = $this->getRequest()->query->get("page", 1);
$thisPage = $page;
$query = $em->createQuery("SELECT viaggio, viaggio.id, viaggio.descrizione, viaggio.meta, viaggio.partenza, viaggio.arrivo, viaggio.periodo, viaggio.salvato, user.id\n FROM AppBundle:Viaggio viaggio\n JOIN AppBundle:User user WHERE (viaggio.utente = {$user_id})\n WHERE viaggio.salvato = true\n ORDER BY viaggio.id DESC")->setFirstResult($limit * ($page - 1))->setMaxResults($limit);
// $questo=$query->getResult();
$paginator = new Paginator($query, $fetchJoinCollection = true);
$maxPages = ceil($paginator->count() / $limit);
// $c = count($paginator);
// foreach ($paginator as $post) {
// echo $post->getHeadline() . "\n";
// }
$birthDate = $user->getDataDiNascita();
$age = null;
if ($birthDate != null) {
//explode the date to get month, day and year
$birthDate = explode("-", $birthDate);
//get age from date or birthdate
$age = date("md", date("U", mktime(0, 0, 0, $birthDate[0], $birthDate[1], $birthDate[2]))) > date("md") ? date("Y") - $birthDate[2] - 1 : date("Y") - $birthDate[2];
}
$ultimaSalvata = $em->getRepository('AppBundle:Viaggio')->findOneBy(array('utente' => $user->getId(), 'salvato' => true), array('id' => 'DESC'));
return array('eta' => $age, 'salvata' => $ultimaSalvata, 'user' => $user, 'maxPages' => $maxPages, 'thisPage' => $thisPage, 'issues' => $paginator->getIterator());
}
/**
* @Route("/{page}", name="vacancy_index", requirements={"page": "\d+"}, defaults={"page" = 1})
*/
public function indexAction($page, Request $request)
{
$page = max(1, $page);
$length = 5;
$start = ($page - 1) * $length;
$filter = new Filter();
$form = $this->createForm(FilterType::class, $filter);
$form->handleRequest($request);
$locale = $this->getParameter('locale');
/** @var EntityManager $em */
$em = $this->getDoctrine()->getManager();
$builder = $em->createQueryBuilder();
$builder->select(['v', 'd', 'vd'])->from('VacancyBundle:Vacancy', 'v')->join('v.department', 'd')->leftJoin('v.descriptions', 'vd')->leftJoin('vd.language', 'l')->andWhere('l.id = :language OR l.name = :locale')->setParameter('language', $filter->getLanguage())->setParameter('locale', $locale);
if ($filter->getDepartment()) {
$builder->andWhere('d.id = :department')->setParameter('department', $filter->getDepartment());
}
$builder->addOrderBy("d.name", 'ASC')->addOrderBy("l.id", 'DESC')->addOrderBy("vd.name", 'ASC')->addGroupBy("v.id, l.id");
// Group by: hax for getting only row of selected language
$builder->setFirstResult($start)->setMaxResults($length);
$paginator = new Paginator($builder);
$filters = [];
foreach ($request->query->getIterator() as $key => $value) {
$filters[$key] = $value;
}
return $this->render('VacancyBundle:vacancy:index.html.twig', ['form' => $form->createView(), 'isValid' => $form->isValid(), 'filter' => $filter, 'data' => $paginator, 'pagination' => ['page' => $page, 'total' => ceil($paginator->count() / $length), 'currentFilters' => $filters]]);
}
/**
* (non-PHPdoc)
* @see \Neutron\DataGridBundle\DataGrid\DataGridHandlerInterface::buildQuery()
*/
public function buildQuery()
{
$qb = $this->dataGrid->getQueryBuilder();
if (!$qb instanceof QueryBuilder) {
throw new \InvalidArgumentException('Value must be instance of Doctrine\\ORM\\QueryBuilder.');
}
$options = $this->getOptions();
// Is dependant grid ?
if ($this->dataGrid->isDependentGrid()) {
$qb->setParameter('masterGridRowId', $options['masterGridRowId']);
}
// Orders the records
if ($options['orderBy']) {
$qb->addOrderBy($options['orderBy'], $options['sort']);
}
// Applying search filters
if ($options['search'] && !empty($options['filters'])) {
$this->applyFilters($qb, $options['filters']);
}
// dispatch should onQueryBuilderReady event here
if (!$this->dataGrid->isSortableEnabled() && $options['page'] && $options['records']) {
$qb->setMaxResults($options['records']);
$qb->setFirstResult(($options['page'] - 1) * $options['records']);
}
$this->setQuery($qb->getQuery());
// Getting count
$paginator = new Paginator($this->getQuery());
//$paginator->setUseOutputWalkers(false);
$this->setCount($paginator->count());
return $this;
}
/**
* @return array
* @throws OutOfBoundsException
*/
public function execute()
{
$queryBuilder = $this->getData();
$aliases = [];
$queryBuilder->resetDQLParts(['select', 'orderBy', 'having']);
foreach ($this->getColumns() as $column) {
if ($column instanceof Select) {
$aliases[] = $column->getAlias();
}
}
foreach (array_unique($aliases) as $alias) {
$queryBuilder->addSelect($alias);
}
foreach ($this->getSortConditions() as $column => $sortDirection) {
/** @noinspection PhpParamsInspection */
$queryBuilder->add('orderBy', new OrderBy($column, $sortDirection), true);
}
if (null !== $this->first) {
$queryBuilder->setFirstResult($this->first);
}
if (null !== $this->max) {
$queryBuilder->setMaxResults($this->max);
}
$paginator = new Paginator($queryBuilder);
$this->resultCount = $paginator->count();
$result = $queryBuilder->getQuery()->getResult();
if ($this->resultCount > 0 && empty($result)) {
throw new OutOfBoundsException();
}
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;
}
/**
* @param int $offset
* @param int $limit
* @param string|null $status
* @return PaginationResult
*/
public function paginateAll($offset, $limit, $status = null)
{
$queryBuilder = $this->entityRepository->createQueryBuilder('invoice');
$queryBuilder->innerJoin('invoice.client', 'client');
$queryBuilder->setFirstResult($offset);
$queryBuilder->setMaxResults($limit);
$queryBuilder->orderBy('invoice.id', 'desc');
switch ($status) {
case 'paid':
$queryBuilder->andWhere('invoice.payDate IS NOT NULL');
break;
case 'late':
$queryBuilder->andWhere('invoice.payDate IS NULL');
$queryBuilder->andWhere('invoice.dueDate IS NOT NULL');
$queryBuilder->andWhere('invoice.dueDate < :now');
$queryBuilder->setParameter('now', new DateTime());
break;
case 'sent':
$queryBuilder->andWhere('invoice.payDate IS NULL');
$queryBuilder->andWhere('invoice.dueDate IS NULL OR invoice.dueDate >= :now');
$queryBuilder->andWhere('invoice.sendDate IS NOT NULL');
$queryBuilder->setParameter('now', new DateTime());
break;
case 'draft':
$queryBuilder->andWhere('invoice.payDate IS NULL');
$queryBuilder->andWhere('invoice.dueDate IS NULL OR invoice.dueDate >= :now');
$queryBuilder->andWhere('invoice.sendDate IS NULL');
$queryBuilder->setParameter('now', new DateTime());
break;
}
$paginator = new Paginator($queryBuilder->getQuery(), false);
return new PaginationResult($paginator->getIterator(), $paginator->count());
}
/**
* 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;
}
/**
* Required by interface IteratorAggregate.
*
* {@inheritdoc}
*/
public function getIterator()
{
$query = $this->paginator->getQuery();
$query->setFirstResult(null);
$query->setMaxResults(null);
return $this->paginator;
}
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;
}
/**
* Prepare listing instance from Doctrine ORM Query or QueryBuilder.
*
* Sets 'order by' only for QueryBuilder.
*
* @param Query|QueryBuilder
* @param boolean
* @param boolean
* @param boolean
* @return self
* @see Paginator
*/
public function setQuery($query, $fetchJoinCollection = false, $appendLimit = true, $appendOrder = true)
{
if ($query instanceof QueryBuilder) {
$order = $this->order();
if ($appendOrder && $order) {
if (is_array($order)) {
call_user_func_array([$query, 'orderBy'], $order);
} else {
$query->add('orderBy', $order);
}
}
$query = $query->getQuery();
}
if (!$query instanceof Query) {
throw \InvalidArgumentException('Instance of Doctrine\\ORM\\Query or Doctrine\\ORM\\QueryBuilder required!');
}
if ($appendLimit) {
$paginator = new Paginator($query, $fetchJoinCollection);
$this->setCount($paginator->count());
$query->setFirstResult($this->offset())->setMaxResults($this->limit());
$this->setItems($paginator);
} else {
$this->setItems($query->getResult());
}
return $this;
}
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;
}
/**
* @inheritDoc
*/
public function paginate($target, $offset, $limit)
{
$target->setFirstResult($offset)->setMaxResults($limit);
$paginator = new Paginator($target);
$this->total = $paginator->count();
return $paginator->getIterator();
}
/**
* @param string $collector
* @param int $page
* @param int $maxItemPerPage
*
* @return Paginator
*/
public function findByCollector($collector, $page, $maxItemPerPage)
{
$query = $this->createQueryBuilder('c')->where('c.collector = :collector')->setParameter('collector', $collector)->getQuery();
$paginator = new Paginator($query);
$paginator->getQuery()->setFirstResult($maxItemPerPage * ($page - 1))->setMaxResults($maxItemPerPage);
return $paginator;
}
/**
* Paginator Helper
* Pass through a query object, current page & limit
* the offset is calculated from the page and limit
* returns an `Paginator` instance, which you can call the following on:
* $paginator->getIterator()->count() # Total fetched (ie: `5` posts)
* $paginator->count() # Count of ALL posts (ie: `20` posts)
* $paginator->getIterator() # ArrayIterator
*
* @param Doctrine\ORM\Query $dql
* DQL Query Object
* @param integer $page
* Current page (defaults to 1)
* @param integer $limit
* The total number per page (defaults to 5)
* @return \Doctrine\ORM\Tools\Pagination\Paginator
*/
public function paginate($dql, $page = 1, $limit = 15)
{
$paginator = new Paginator($dql);
$paginator->getQuery()->setFirstResult($limit * ($page - 1))->setMaxResults($limit);
// Limit
return $paginator;
}
public function buildCount($query)
{
// Getting count
$paginator = new Paginator($this->getQuery());
//$paginator->setUseOutputWalkers(false);
$this->setCount($paginator->count());
return $this;
}
/**
* 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 __construct(DoctrineOrmPaginator $paginator)
{
$this->paginator = $paginator;
$query = $paginator->getQuery();
$this->firstResult = $query->getFirstResult();
$this->maxResults = $query->getMaxResults();
$this->totalItems = count($paginator);
}
public function paginate($dql, $offset = 1, $limit = 10)
{
if ($limit > 100 || $limit <= 0) {
$limit = 100;
}
$paginator = new Paginator($dql, false);
$paginator->getQuery()->setMaxResults($limit)->setFirstResult(($offset - 1) * $limit);
return $paginator;
}
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 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;
}
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];
}
/**
* @return Job
*/
public function findAllPublishedOrderedByRecentlyActive(JobSearchFormTypeData $data, $currentPage = 1, $limit = 5)
{
$query = $this->findAllPublishedOrderedByRecentlyActiveQ($data);
// Paginator
$paginator = new Paginator($query);
$rowsCountTotal = $paginator->count();
$data = $query->setFirstResult($limit * ($currentPage - 1))->setMaxResults($limit)->execute();
// ->getOneOrNullResult()
$rowsCountThisPage = count($data);
return ['limit' => $limit, 'currentPage' => $currentPage, 'maxPages' => ceil($rowsCountTotal / $limit), 'rowsCountTotal' => $rowsCountTotal, 'rowsCountThisPage' => $rowsCountThisPage, 'data' => $data];
}
public function findAllStartsWith($letter, $page, $per_page)
{
$query = $this->joinQuery();
if ($letter != 'ALL') {
$query->where('s.name LIKE :letter')->setParameter('letter', "{$letter}%");
}
$query->orderBy('s.name', 'ASC')->addOrderBy('p.name', 'ASC')->addOrderBy('i.imageName', 'ASC');
$paginator = new Paginator($query, $fetchJoinCollection = true);
$paginator->getQuery()->setFirstResult(($page - 1) * $per_page)->setMaxResults($per_page);
return $paginator;
}
/**
* @param $params
*
* @return mixed
*/
public function findWithJoins($params)
{
$queryBuilder = $this->createQueryBuilder('h')->select('h, s, t, lc, cer, pm, hp, tr')->leftJoin('h.services', 's')->leftJoin('h.thematics', 't')->leftJoin('h.linkedCities', 'lc')->leftJoin('h.certificates', 'cer')->leftJoin('h.paymentMethods', 'pm')->leftJoin('h.hotelPois', 'hp')->leftJoin('h.transports', 'tr');
$i = 0;
foreach ($params as $key => $value) {
$queryBuilder->andWhere("h.{$key} = :param_{$i}")->setParameter("param_{$i}", $value);
$i++;
}
$query = $queryBuilder->setMaxResults(1)->getQuery();
$results = new Paginator($query, $fetchJoin = true);
return $results->getIterator()->current();
}
/**
* {@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();
}