ResultProvider::applyAfter() - Code Metrics - Inspection of "Added ability to transform result items (#8)" - paysera/lib-pagination - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ef2696...0afeed )

by Marius

created 2020-09-22 12:59 UTC

ResultProvider::applyAfter() A

↳ Parent: ResultProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	3
cts	3
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	3
crap	1

<?php
declare(strict_types=1);

namespace Paysera\Pagination\Service\Doctrine;

use Doctrine\ORM\Query\Expr;
use Doctrine\ORM\Query\Expr\Andx;
use Doctrine\ORM\Query\Expr\Orx;
use Doctrine\ORM\Query\Expr\GroupBy;
use Doctrine\ORM\Query\Expr\Comparison;
use Doctrine\ORM\QueryBuilder;
use Paysera\Pagination\Entity\Doctrine\AnalysedQuery;
use Paysera\Pagination\Entity\OrderingConfiguration;
use Paysera\Pagination\Entity\Doctrine\ConfiguredQuery;
use Paysera\Pagination\Entity\Pager;
use Paysera\Pagination\Entity\Result;
use Paysera\Pagination\Exception\InvalidGroupByException;
use Paysera\Pagination\Service\CursorBuilderInterface;

class ResultProvider
{
    private $queryAnalyser;
    private $cursorBuilder;

    public function __construct(QueryAnalyser $queryAnalyser, CursorBuilderInterface $cursorBuilder)
    {
        $this->queryAnalyser = $queryAnalyser;
        $this->cursorBuilder = $cursorBuilder;
    }

    public function getResultForQuery(ConfiguredQuery $configuredQuery, Pager $pager): Result
    {
        $analysedQuery = $this->queryAnalyser->analyseQuery($configuredQuery, $pager);

        $result = $this->buildResult($analysedQuery, $pager);

        if ($configuredQuery->getItemTransformer() !== null) {
            $this->transformResultItems($configuredQuery->getItemTransformer(), $result);
        }

        if ($configuredQuery->isTotalCountNeeded()) {
            $totalCount = $this->calculateTotalCount($pager, count($result->getItems()));
            if ($totalCount === null) {
                $totalCount = $this->findCount($analysedQuery);
            }
            $result->setTotalCount($totalCount);
        }

        return $result;
    }

    public function getTotalCountForQuery(ConfiguredQuery $configuredQuery): int
    {
        $analysedQuery = $this->queryAnalyser->analyseQueryWithoutPager($configuredQuery);

        return $this->findCount($analysedQuery);
    }

    private function buildResult(AnalysedQuery $analysedQuery, Pager $pager)
    {
        $items = $this->findItems($analysedQuery, $pager);

        if (count($items) === 0) {
            return $this->buildResultForEmptyItems($analysedQuery, $pager);
        }

        $orderingConfigurations = $analysedQuery->getOrderingConfigurations();
        $previousCursor = $this->cursorBuilder->getCursorFromItem($items[0], $orderingConfigurations);
        $nextCursor = $this->cursorBuilder->getCursorFromItem($items[count($items) - 1], $orderingConfigurations);

        return (new Result())
            ->setItems($items)
            ->setPreviousCursor($previousCursor)
            ->setNextCursor($nextCursor)
            ->setHasPrevious($this->existsBeforeCursor($previousCursor, $analysedQuery))
            ->setHasNext($this->existsAfterCursor($nextCursor, $analysedQuery))
        ;
    }

    private function findItems(AnalysedQuery $analysedQuery, Pager $pager)
    {
        $pagedQueryBuilder = $this->pageQueryBuilder($analysedQuery, $pager);
        $query = $pagedQueryBuilder->getQuery();
        $items = $query->getResult();

        if ($pager->getBefore() !== null) {
            return array_reverse($items);
        }
        return $items;
    }

    private function pageQueryBuilder(AnalysedQuery $analysedQuery, Pager $pager)
    {
        $queryBuilder = $analysedQuery->cloneQueryBuilder();

        if ($pager->getLimit() !== null) {
            $queryBuilder->setMaxResults($pager->getLimit());
        }

        $orderingConfigurations = $analysedQuery->getOrderingConfigurations();
        if ($pager->getBefore() !== null) {
            $orderingConfigurations = $this->reverseOrderingDirection($orderingConfigurations);
        }

        $this->applyOrdering($queryBuilder, $orderingConfigurations);

        if ($pager->getOffset() !== null) {
            $this->applyOffset($queryBuilder, $pager->getOffset());
        } elseif ($pager->getBefore() !== null) {
            $this->applyBefore($queryBuilder, $pager->getBefore(), $analysedQuery);
        } elseif ($pager->getAfter() !== null) {
            $this->applyAfter($queryBuilder, $pager->getAfter(), $analysedQuery);
        }

        return $queryBuilder;
    }

    /**
     * @param QueryBuilder $queryBuilder
     * @param array|OrderingConfiguration[] $orderingConfigurations
     */
    private function applyOrdering(QueryBuilder $queryBuilder, array $orderingConfigurations)
    {
        foreach ($orderingConfigurations as $orderingConfiguration) {
            $queryBuilder->addOrderBy(
                $orderingConfiguration->getOrderByExpression(),
                $orderingConfiguration->isOrderAscending() ? 'ASC' : 'DESC'
            );
        }
    }

    private function applyOffset(QueryBuilder $queryBuilder, int $offset)
    {
        $queryBuilder->setFirstResult($offset);
    }

    /**
     * @param QueryBuilder $queryBuilder
     * @param string $after
     * @param AnalysedQuery $analysedQuery
     */
    private function applyAfter(QueryBuilder $queryBuilder, string $after, AnalysedQuery $analysedQuery)
    {
        $this->applyCursor($queryBuilder, $after, $analysedQuery, false);
    }

    /**
     * @param QueryBuilder $queryBuilder
     * @param string $after
     * @param AnalysedQuery $analysedQuery
     */
    private function applyBefore(QueryBuilder $queryBuilder, string $after, AnalysedQuery $analysedQuery)
    {
        $this->applyCursor($queryBuilder, $after, $analysedQuery, true);
    }

    /**
     * @param QueryBuilder $queryBuilder
     * @param string $cursor
     * @param AnalysedQuery $analysedQuery
     * @param bool $invert
     */
    private function applyCursor(QueryBuilder $queryBuilder, string $cursor, AnalysedQuery $analysedQuery, bool $invert)
    {
        $orderingConfigurations = $analysedQuery->getOrderingConfigurations();
        $parsedCursor = $this->cursorBuilder->parseCursor($cursor, count($orderingConfigurations));

        $expr = new Expr();
        $whereClause = new Orx();
        $previousConditions = new Andx();
        foreach ($orderingConfigurations as $index => $orderingConfiguration) {
            $useLargerThan = $orderingConfiguration->isOrderAscending();
            if ($invert) {
                $useLargerThan = !$useLargerThan;
            }
            $sign = $useLargerThan ? '>' : '<';
            if ($parsedCursor->isCursoredItemIncluded() && $index === count($orderingConfigurations) - 1) {
                $sign .= '=';
            }

            $currentCondition = clone $previousConditions;
            $currentCondition->add(new Comparison(
                $orderingConfiguration->getOrderByExpression(),
                $sign,
                $expr->literal($parsedCursor->getElementAtIndex($index))
            ));

            $whereClause->add($currentCondition);

            $previousConditions->add(new Comparison(
                $orderingConfiguration->getOrderByExpression(),
                '=',
                $expr->literal($parsedCursor->getElementAtIndex($index))
            ));
        }

        $queryBuilder->andWhere($whereClause);
    }

    private function buildResultForEmptyItems(AnalysedQuery $analysedQuery, Pager $pager): Result
    {
        if ($pager->getLimit() === 0) {
            return $this->buildResultForZeroLimit($analysedQuery, $pager);

        } elseif ($pager->getBefore() !== null) {
            $nextCursor = $this->cursorBuilder->invertCursorInclusion($pager->getBefore());
            return (new Result())
                ->setPreviousCursor($pager->getBefore())
                ->setNextCursor($nextCursor)
                ->setHasPrevious(false)
                ->setHasNext($this->existsAfterCursor($nextCursor, $analysedQuery))
            ;

        } elseif ($pager->getAfter() !== null) {
            $previousCursor = $this->cursorBuilder->invertCursorInclusion($pager->getAfter());
            return (new Result())
                ->setPreviousCursor($previousCursor)
                ->setNextCursor($pager->getAfter())
                ->setHasPrevious($this->existsBeforeCursor($previousCursor, $analysedQuery))
                ->setHasNext(false)
            ;

        } elseif ($pager->getOffset() !== null && $pager->getOffset() > 0) {
            return $this->buildResultForTooLargeOffset($analysedQuery);

        }

        return (new Result())
            ->setHasPrevious(false)
            ->setHasNext(false)
        ;
    }

    private function buildResultForZeroLimit(AnalysedQuery $analysedQuery, Pager $zeroLimitPager): Result
    {
        $pager = (clone $zeroLimitPager)->setLimit(1);
        $items = $this->findItems($analysedQuery, $pager);

        if (count($items) === 0) {
            return $this->buildResultForEmptyItems($analysedQuery, $pager);
        }

        $orderingConfigurations = $analysedQuery->getOrderingConfigurations();
        $previousCursor = $this->cursorBuilder->getCursorFromItem($items[0], $orderingConfigurations);
        $nextCursor = $this->cursorBuilder->buildCursorWithIncludedItem($previousCursor);

        return (new Result())
            ->setPreviousCursor($previousCursor)
            ->setNextCursor($nextCursor)
            ->setHasPrevious($this->existsBeforeCursor($previousCursor, $analysedQuery))
            ->setHasNext(true)
        ;
    }

    private function buildResultForTooLargeOffset(AnalysedQuery $analysedQuery): Result
    {
        $result = (new Result())->setHasNext(false);

        $pagerForLastElement = (new Pager())->setLimit(1);
        $modifiedAnalysedQuery = (clone $analysedQuery)->setOrderingConfigurations(
            $this->reverseOrderingDirection($analysedQuery->getOrderingConfigurations())
        );
        $items = $this->findItems($modifiedAnalysedQuery, $pagerForLastElement);
        if (count($items) === 0) {
            return $result->setHasPrevious(false);
        }

        $lastItemCursor = $this->cursorBuilder->getCursorFromItem($items[0], $modifiedAnalysedQuery->getOrderingConfigurations());
        return $result
            ->setHasPrevious(true)
            ->setPreviousCursor($this->cursorBuilder->buildCursorWithIncludedItem($lastItemCursor))
            ->setNextCursor($lastItemCursor)
        ;
    }

    /**
     * @param array|OrderingConfiguration[] $orderingConfigurations
     * @return array|OrderingConfiguration[]
     */
    private function reverseOrderingDirection(array $orderingConfigurations): array
    {
        $reversedOrderingConfigurations = [];
        foreach ($orderingConfigurations as $orderingConfiguration) {
            $reversedOrderingConfigurations[] = (clone $orderingConfiguration)
                ->setOrderAscending(!$orderingConfiguration->isOrderAscending())
            ;
        }
        return $reversedOrderingConfigurations;
    }

    private function existsBeforeCursor(string $previousCursor, AnalysedQuery $analysedQuery)

    {
        $nextPager = (new Pager())
            ->setBefore($previousCursor)
            ->setLimit(1)
        ;

        return count($this->findItems($analysedQuery, $nextPager)) > 0;
    }

    private function existsAfterCursor(string $nextCursor, AnalysedQuery $analysedQuery)

    {
        $nextPager = (new Pager())
            ->setAfter($nextCursor)
            ->setLimit(1)
        ;

        return count($this->findItems($analysedQuery, $nextPager)) > 0;
    }

    private function calculateTotalCount(Pager $filter, int $resultCount)
    {
        if (
            $filter->getOffset() !== null
            && ($filter->getLimit() === null || $resultCount < $filter->getLimit())
            && ($resultCount !== 0 || $filter->getOffset() === 0)
        ) {
            return $resultCount + $filter->getOffset();
        }

        return null;
    }

    private function findCount(AnalysedQuery $analysedQuery): int
    {
        $countQueryBuilder = $analysedQuery->cloneQueryBuilder();
        $groupByColumn = $this->getSingleValidGroupByColumn($countQueryBuilder);

        if ($groupByColumn !== null) {
            return $this->findCountWithGroupBy($groupByColumn, $analysedQuery);
        }

        $countQueryBuilder->select(sprintf('count(%s)', $analysedQuery->getRootAlias()));
        return (int)$countQueryBuilder->getQuery()->getSingleScalarResult();
    }

    private function findCountWithGroupBy(string $groupByColumn, AnalysedQuery $analysedQuery): int
    {
        $countQueryBuilder = $analysedQuery->cloneQueryBuilder();
        $countQueryBuilder
            ->resetDQLPart('groupBy')
            ->select(sprintf('count(distinct %s)', $groupByColumn))
        ;

        $nullQueryBuilder = $analysedQuery->cloneQueryBuilder()
            ->resetDQLPart('groupBy')
            ->select($analysedQuery->getRootAlias())
            ->setMaxResults(1)
            ->andWhere($groupByColumn . ' is null')
        ;

        $nonNullCount = (int)$countQueryBuilder->getQuery()->getSingleScalarResult();
        $nullExists = count($nullQueryBuilder->getQuery()->getScalarResult());

        return $nonNullCount + $nullExists;
    }

    /**
     * @param QueryBuilder $queryBuilder
     * @return string|null
     */
    private function getSingleValidGroupByColumn(QueryBuilder $queryBuilder)
    {
        /** @var GroupBy[] $groupByParts */
        $groupByParts = $queryBuilder->getDQLPart('groupBy');

        if (count($groupByParts) === 0) {
            return null;
        }

        if (count($groupByParts) > 1) {
            $groupNames = array_map(
                function (GroupBy $groupBy) {
                    return $groupBy->getParts()[0];
                },
                $groupByParts
            );
            throw new InvalidGroupByException(implode(', ', $groupNames));
        }

        if (count($groupByParts) === 1 && count($groupByParts[0]->getParts()) > 1) {
            throw new InvalidGroupByException(implode(', ', $groupByParts[0]->getParts()));
        }

        return $groupByParts[0]->getParts()[0];
    }

    private function transformResultItems(callable $transform, Result $result)
    {
        $transformedItems = [];
        foreach ($result->getItems() as $item) {
            $transformedItems[] = $transform($item);
        }

        $result->setItems($transformedItems);
    }
}


1			<?php
2			declare(strict_types=1);
3
4			namespace Paysera\Pagination\Service\Doctrine;
5
6			use Doctrine\ORM\Query\Expr;
7			use Doctrine\ORM\Query\Expr\Andx;
8			use Doctrine\ORM\Query\Expr\Orx;
9			use Doctrine\ORM\Query\Expr\GroupBy;
10			use Doctrine\ORM\Query\Expr\Comparison;
11			use Doctrine\ORM\QueryBuilder;
12			use Paysera\Pagination\Entity\Doctrine\AnalysedQuery;
13			use Paysera\Pagination\Entity\OrderingConfiguration;
14			use Paysera\Pagination\Entity\Doctrine\ConfiguredQuery;
15			use Paysera\Pagination\Entity\Pager;
16			use Paysera\Pagination\Entity\Result;
17			use Paysera\Pagination\Exception\InvalidGroupByException;
18			use Paysera\Pagination\Service\CursorBuilderInterface;
19
20			class ResultProvider
21			{
22			private $queryAnalyser;
23			private $cursorBuilder;
24
25	42		public function __construct(QueryAnalyser $queryAnalyser, CursorBuilderInterface $cursorBuilder)
26			{
27	42		$this->queryAnalyser = $queryAnalyser;
28	42		$this->cursorBuilder = $cursorBuilder;
29	42		}
30
31	36		public function getResultForQuery(ConfiguredQuery $configuredQuery, Pager $pager): Result
32			{
33	36		$analysedQuery = $this->queryAnalyser->analyseQuery($configuredQuery, $pager);
34
35	35		$result = $this->buildResult($analysedQuery, $pager);
36
37	35		if ($configuredQuery->getItemTransformer() !== null) {
38	1		$this->transformResultItems($configuredQuery->getItemTransformer(), $result);
39			}
40
41	35		if ($configuredQuery->isTotalCountNeeded()) {
42	2		$totalCount = $this->calculateTotalCount($pager, count($result->getItems()));
43	2		if ($totalCount === null) {
44	1		$totalCount = $this->findCount($analysedQuery);
45			}
46	2		$result->setTotalCount($totalCount);
47			}
48
49	35		return $result;
50			}
51
52	6		public function getTotalCountForQuery(ConfiguredQuery $configuredQuery): int
53			{
54	6		$analysedQuery = $this->queryAnalyser->analyseQueryWithoutPager($configuredQuery);
55
56	6		return $this->findCount($analysedQuery);
57			}
58
59	35		private function buildResult(AnalysedQuery $analysedQuery, Pager $pager)
60			{
61	35		$items = $this->findItems($analysedQuery, $pager);
62
63	35		if (count($items) === 0) {
64	11		return $this->buildResultForEmptyItems($analysedQuery, $pager);
65			}
66
67	25		$orderingConfigurations = $analysedQuery->getOrderingConfigurations();
68	25		$previousCursor = $this->cursorBuilder->getCursorFromItem($items[0], $orderingConfigurations);
69	25		$nextCursor = $this->cursorBuilder->getCursorFromItem($items[count($items) - 1], $orderingConfigurations);
70
71	25		return (new Result())
72	25		->setItems($items)
73	25		->setPreviousCursor($previousCursor)
74	25		->setNextCursor($nextCursor)
75	25		->setHasPrevious($this->existsBeforeCursor($previousCursor, $analysedQuery))
76	25		->setHasNext($this->existsAfterCursor($nextCursor, $analysedQuery))
77			;
78			}
79
80	35		private function findItems(AnalysedQuery $analysedQuery, Pager $pager)
81			{
82	35		$pagedQueryBuilder = $this->pageQueryBuilder($analysedQuery, $pager);
83	35		$query = $pagedQueryBuilder->getQuery();
84	35		$items = $query->getResult();
85
86	35		if ($pager->getBefore() !== null) {
87	33		return array_reverse($items);
88			}
89	35		return $items;
90			}
91
92	35		private function pageQueryBuilder(AnalysedQuery $analysedQuery, Pager $pager)
93			{
94	35		$queryBuilder = $analysedQuery->cloneQueryBuilder();
95
96	35		if ($pager->getLimit() !== null) {
97	35		$queryBuilder->setMaxResults($pager->getLimit());
98			}
99
100	35		$orderingConfigurations = $analysedQuery->getOrderingConfigurations();
101	35		if ($pager->getBefore() !== null) {
102	33		$orderingConfigurations = $this->reverseOrderingDirection($orderingConfigurations);
103			}
104
105	35		$this->applyOrdering($queryBuilder, $orderingConfigurations);
106
107	35		if ($pager->getOffset() !== null) {
108	6		$this->applyOffset($queryBuilder, $pager->getOffset());
109	35		} elseif ($pager->getBefore() !== null) {
110	33		$this->applyBefore($queryBuilder, $pager->getBefore(), $analysedQuery);
111	35		} elseif ($pager->getAfter() !== null) {
112	32		$this->applyAfter($queryBuilder, $pager->getAfter(), $analysedQuery);
113			}
114
115	35		return $queryBuilder;
116			}
117
118			/**
119			* @param QueryBuilder $queryBuilder
120			* @param array\|OrderingConfiguration[] $orderingConfigurations
121			*/
122	35		private function applyOrdering(QueryBuilder $queryBuilder, array $orderingConfigurations)
123			{
124	35		foreach ($orderingConfigurations as $orderingConfiguration) {
125	35		$queryBuilder->addOrderBy(
126	35		$orderingConfiguration->getOrderByExpression(),
127	35		$orderingConfiguration->isOrderAscending() ? 'ASC' : 'DESC'
128			);
129			}
130	35		}
131
132	6		private function applyOffset(QueryBuilder $queryBuilder, int $offset)
133			{
134	6		$queryBuilder->setFirstResult($offset);
135	6		}
136
137			/**
138			* @param QueryBuilder $queryBuilder
139			* @param string $after
140			* @param AnalysedQuery $analysedQuery
141			*/
142	32		private function applyAfter(QueryBuilder $queryBuilder, string $after, AnalysedQuery $analysedQuery)
143			{
144	32		$this->applyCursor($queryBuilder, $after, $analysedQuery, false);
145	32		}
146
147			/**
148			* @param QueryBuilder $queryBuilder
149			* @param string $after
150			* @param AnalysedQuery $analysedQuery
151			*/
152	33		private function applyBefore(QueryBuilder $queryBuilder, string $after, AnalysedQuery $analysedQuery)
153			{
154	33		$this->applyCursor($queryBuilder, $after, $analysedQuery, true);
155	33		}
156
157			/**
158			* @param QueryBuilder $queryBuilder
159			* @param string $cursor
160			* @param AnalysedQuery $analysedQuery
161			* @param bool $invert
162			*/
163	33		private function applyCursor(QueryBuilder $queryBuilder, string $cursor, AnalysedQuery $analysedQuery, bool $invert)
164			{
165	33		$orderingConfigurations = $analysedQuery->getOrderingConfigurations();
166	33		$parsedCursor = $this->cursorBuilder->parseCursor($cursor, count($orderingConfigurations));
167
168	33		$expr = new Expr();
169	33		$whereClause = new Orx();
170	33		$previousConditions = new Andx();
171	33		foreach ($orderingConfigurations as $index => $orderingConfiguration) {
172	33		$useLargerThan = $orderingConfiguration->isOrderAscending();
173	33		if ($invert) {
174	33		$useLargerThan = !$useLargerThan;
175			}
176	33		$sign = $useLargerThan ? '>' : '<';
177	33		if ($parsedCursor->isCursoredItemIncluded() && $index === count($orderingConfigurations) - 1) {
178	11		$sign .= '=';
179			}
180
181	33		$currentCondition = clone $previousConditions;
182	33		$currentCondition->add(new Comparison(
183	33		$orderingConfiguration->getOrderByExpression(),
184	33		$sign,
185	33		$expr->literal($parsedCursor->getElementAtIndex($index))
186			));
187
188	33		$whereClause->add($currentCondition);
189
190	33		$previousConditions->add(new Comparison(
191	33		$orderingConfiguration->getOrderByExpression(),
192	33		'=',
193	33		$expr->literal($parsedCursor->getElementAtIndex($index))
194			));
195			}
196
197	33		$queryBuilder->andWhere($whereClause);
198	33		}
199
200	11		private function buildResultForEmptyItems(AnalysedQuery $analysedQuery, Pager $pager): Result
201			{
202	11		if ($pager->getLimit() === 0) {
203	3		return $this->buildResultForZeroLimit($analysedQuery, $pager);
204
205	9		} elseif ($pager->getBefore() !== null) {
206	2		$nextCursor = $this->cursorBuilder->invertCursorInclusion($pager->getBefore());
207	2		return (new Result())
208	2		->setPreviousCursor($pager->getBefore())
209	2		->setNextCursor($nextCursor)
210	2		->setHasPrevious(false)
211	2		->setHasNext($this->existsAfterCursor($nextCursor, $analysedQuery))
212			;
213
214	7		} elseif ($pager->getAfter() !== null) {
215	5		$previousCursor = $this->cursorBuilder->invertCursorInclusion($pager->getAfter());
216	5		return (new Result())
217	5		->setPreviousCursor($previousCursor)
218	5		->setNextCursor($pager->getAfter())
219	5		->setHasPrevious($this->existsBeforeCursor($previousCursor, $analysedQuery))
220	5		->setHasNext(false)
221			;
222
223	3		} elseif ($pager->getOffset() !== null && $pager->getOffset() > 0) {
224	3		return $this->buildResultForTooLargeOffset($analysedQuery);
225
226			}
227
228	1		return (new Result())
229	1		->setHasPrevious(false)
230	1		->setHasNext(false)
231			;
232			}
233
234	3		private function buildResultForZeroLimit(AnalysedQuery $analysedQuery, Pager $zeroLimitPager): Result
235			{
236	3		$pager = (clone $zeroLimitPager)->setLimit(1);
237	3		$items = $this->findItems($analysedQuery, $pager);
238
239	3		if (count($items) === 0) {
240	1		return $this->buildResultForEmptyItems($analysedQuery, $pager);
241			}
242
243	2		$orderingConfigurations = $analysedQuery->getOrderingConfigurations();
244	2		$previousCursor = $this->cursorBuilder->getCursorFromItem($items[0], $orderingConfigurations);
245	2		$nextCursor = $this->cursorBuilder->buildCursorWithIncludedItem($previousCursor);
246
247	2		return (new Result())
248	2		->setPreviousCursor($previousCursor)
249	2		->setNextCursor($nextCursor)
250	2		->setHasPrevious($this->existsBeforeCursor($previousCursor, $analysedQuery))
251	2		->setHasNext(true)
252			;
253			}
254
255	3		private function buildResultForTooLargeOffset(AnalysedQuery $analysedQuery): Result
256			{
257	3		$result = (new Result())->setHasNext(false);
258
259	3		$pagerForLastElement = (new Pager())->setLimit(1);
260	3		$modifiedAnalysedQuery = (clone $analysedQuery)->setOrderingConfigurations(
261	3		$this->reverseOrderingDirection($analysedQuery->getOrderingConfigurations())
262			);
263	3		$items = $this->findItems($modifiedAnalysedQuery, $pagerForLastElement);
264	3		if (count($items) === 0) {
265	1		return $result->setHasPrevious(false);
266			}
267
268	2		$lastItemCursor = $this->cursorBuilder->getCursorFromItem($items[0], $modifiedAnalysedQuery->getOrderingConfigurations());
269			return $result
270	2		->setHasPrevious(true)
271	2		->setPreviousCursor($this->cursorBuilder->buildCursorWithIncludedItem($lastItemCursor))
272	2		->setNextCursor($lastItemCursor)
273			;
274			}
275
276			/**
277			* @param array\|OrderingConfiguration[] $orderingConfigurations
278			* @return array\|OrderingConfiguration[]
279			*/
280	35		private function reverseOrderingDirection(array $orderingConfigurations): array
281			{
282	35		$reversedOrderingConfigurations = [];
283	35		foreach ($orderingConfigurations as $orderingConfiguration) {
284	35		$reversedOrderingConfigurations[] = (clone $orderingConfiguration)
285	35		->setOrderAscending(!$orderingConfiguration->isOrderAscending())
286			;
287			}
288	35		return $reversedOrderingConfigurations;
289			}
290
291	31	View Code Duplication	private function existsBeforeCursor(string $previousCursor, AnalysedQuery $analysedQuery)
			0 ignored issues – show Duplication introduced 2018-12-18 19:51 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
292			{
293	31		$nextPager = (new Pager())
294	31		->setBefore($previousCursor)
295	31		->setLimit(1)
296			;
297
298	31		return count($this->findItems($analysedQuery, $nextPager)) > 0;
299			}
300
301	27	View Code Duplication	private function existsAfterCursor(string $nextCursor, AnalysedQuery $analysedQuery)
			0 ignored issues – show Duplication introduced 2018-12-18 19:51 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
302			{
303	27		$nextPager = (new Pager())
304	27		->setAfter($nextCursor)
305	27		->setLimit(1)
306			;
307
308	27		return count($this->findItems($analysedQuery, $nextPager)) > 0;
309			}
310
311	2		private function calculateTotalCount(Pager $filter, int $resultCount)
312			{
313			if (
314	2		$filter->getOffset() !== null
315	2		&& ($filter->getLimit() === null \|\| $resultCount < $filter->getLimit())
316	2		&& ($resultCount !== 0 \|\| $filter->getOffset() === 0)
317			) {
318	1		return $resultCount + $filter->getOffset();
319			}
320
321	1		return null;
322			}
323
324	7		private function findCount(AnalysedQuery $analysedQuery): int
325			{
326	7		$countQueryBuilder = $analysedQuery->cloneQueryBuilder();
327	7		$groupByColumn = $this->getSingleValidGroupByColumn($countQueryBuilder);
328
329	5		if ($groupByColumn !== null) {
330	2		return $this->findCountWithGroupBy($groupByColumn, $analysedQuery);
331			}
332
333	3		$countQueryBuilder->select(sprintf('count(%s)', $analysedQuery->getRootAlias()));
334	3		return (int)$countQueryBuilder->getQuery()->getSingleScalarResult();
335			}
336
337	2		private function findCountWithGroupBy(string $groupByColumn, AnalysedQuery $analysedQuery): int
338			{
339	2		$countQueryBuilder = $analysedQuery->cloneQueryBuilder();
340			$countQueryBuilder
341	2		->resetDQLPart('groupBy')
342	2		->select(sprintf('count(distinct %s)', $groupByColumn))
343			;
344
345	2		$nullQueryBuilder = $analysedQuery->cloneQueryBuilder()
346	2		->resetDQLPart('groupBy')
347	2		->select($analysedQuery->getRootAlias())
348	2		->setMaxResults(1)
349	2		->andWhere($groupByColumn . ' is null')
350			;
351
352	2		$nonNullCount = (int)$countQueryBuilder->getQuery()->getSingleScalarResult();
353	2		$nullExists = count($nullQueryBuilder->getQuery()->getScalarResult());
354
355	2		return $nonNullCount + $nullExists;
356			}
357
358			/**
359			* @param QueryBuilder $queryBuilder
360			* @return string\|null
361			*/
362	7		private function getSingleValidGroupByColumn(QueryBuilder $queryBuilder)
363			{
364			/** @var GroupBy[] $groupByParts */
365	7		$groupByParts = $queryBuilder->getDQLPart('groupBy');
366
367	7		if (count($groupByParts) === 0) {
368	3		return null;
369			}
370
371	4		if (count($groupByParts) > 1) {
372	1		$groupNames = array_map(
373	1		function (GroupBy $groupBy) {
374	1		return $groupBy->getParts()[0];
375	1		},
376	1		$groupByParts
377			);
378	1		throw new InvalidGroupByException(implode(', ', $groupNames));
379			}
380
381	3		if (count($groupByParts) === 1 && count($groupByParts[0]->getParts()) > 1) {
382	1		throw new InvalidGroupByException(implode(', ', $groupByParts[0]->getParts()));
383			}
384
385	2		return $groupByParts[0]->getParts()[0];
386			}
387
388	1		private function transformResultItems(callable $transform, Result $result)
389			{
390	1		$transformedItems = [];
391	1		foreach ($result->getItems() as $item) {
392	1		$transformedItems[] = $transform($item);
393			}
394
395	1		$result->setItems($transformedItems);
396	1		}
397			}
398

paysera / lib-pagination

Push — master ( ef2696...0afeed )

ResultProvider::applyAfter() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like