ListQueryBuilder::__construct() - Code Metrics - povs/ListerBundle - Measure and Improve Code Quality continuously with Scrutinizer

ListQueryBuilder::__construct() A
last analyzed 2024-09-16 11:13 UTC

↳ Parent: ListQueryBuilder
Complexity

Conditions	1
Paths	1
Size

Total Lines	10
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	5
CRAP Score	1
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	4
c	1
b	0
f	0
dl	0
loc	10
ccs	5
cts	5
cp	1
rs	10
cc	1
nc	1
nop	4
crap	1
<?php

namespace Povs\ListerBundle\Service;

use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\QueryBuilder;
use Povs\ListerBundle\Declaration\ListInterface;
use Povs\ListerBundle\Declaration\ListValueInterface;
use Povs\ListerBundle\DependencyInjection\Locator\QueryTypeLocator;
use Povs\ListerBundle\DependencyInjection\Locator\SelectorTypeLocator;
use Povs\ListerBundle\Exception\ListFieldException;
use Povs\ListerBundle\Mapper\FilterField;
use Povs\ListerBundle\Mapper\FilterMapper;
use Povs\ListerBundle\Mapper\JoinField;
use Povs\ListerBundle\Mapper\JoinMapper;
use Povs\ListerBundle\Mapper\ListField;
use Povs\ListerBundle\Mapper\ListMapper;
use Povs\ListerBundle\Type\QueryType\QueryTypeInterface;
use Povs\ListerBundle\Type\SelectorType\SelectorTypeInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

/**
 * @author Povilas Margaiatis <[email protected]>
 */
class ListQueryBuilder
{
    public const IDENTIFIER_ALIAS = 'list_identifier';

    /**
     * @var EntityManagerInterface
     */
    private $em;

    /**
     * @var QueryBuilder
     */
    private $queryBuilder;

    /**
     * @var QueryTypeLocator
     */
    private $queryTypeLocator;

    /**
     * @var SelectorTypeLocator
     */
    private $selectorTypeLocator;

    /**
     * @var ConfigurationResolver
     */
    private $configuration;

    /**
     * @var bool
     */
    private $hasAggregation = false;

    /**
     * ListQueryBuilder constructor.
     *
     * @param EntityManagerInterface $entityManager
     * @param QueryTypeLocator       $queryTypeLocator
     * @param SelectorTypeLocator    $selectorTypeLocator
     * @param ConfigurationResolver  $configuration
     */
    public function __construct(
        EntityManagerInterface $entityManager,
        QueryTypeLocator $queryTypeLocator,
        SelectorTypeLocator $selectorTypeLocator,
        ConfigurationResolver $configuration
    ) {
        $this->em = $entityManager;
        $this->queryTypeLocator = $queryTypeLocator;
        $this->selectorTypeLocator = $selectorTypeLocator;
        $this->configuration = $configuration;
    }

    /**
     * @param ListInterface   $list
     * @param JoinMapper      $joinMapper
     * @param ListMapper      $listMapper
     * @param FilterMapper    $filterMapper
     * @param ListValueInterface $listValue
     *
     * @return QueryBuilder
     */
    public function buildQuery(
        ListInterface $list,
        JoinMapper $joinMapper,
        ListMapper $listMapper,
        FilterMapper $filterMapper,
        ListValueInterface $listValue
    ): QueryBuilder {
        $this->hasAggregation = false;
        $this->queryBuilder = $this->em->createQueryBuilder()
            ->from($list->getDataClass(), $this->configuration->getAlias());

        $this->applyJoins($joinMapper, false);
        $this->applySelects($listMapper, $joinMapper, false);
        $this->applyFilter($filterMapper, $joinMapper);
        $this->applyGroup();
        $list->configureQuery($this->queryBuilder, $listValue);

        return $this->queryBuilder;
    }

    /**
     * @param ListInterface $list
     * @param JoinMapper    $joinMapper
     * @param ListMapper    $listMapper
     *
     * @return QueryBuilder|null
     */
    public function buildLazyQuery(
        ListInterface $list,
        JoinMapper $joinMapper,
        ListMapper $listMapper
    ): ?QueryBuilder {
        if ($listMapper->getFields(true)->isEmpty()) {
            return null;
        }

        $this->hasAggregation = false;
        $this->queryBuilder = $this->em->createQueryBuilder()
            ->from($list->getDataClass(), $this->configuration->getAlias());
        $this->applyJoins($joinMapper, true);
        $this->applySelects($listMapper, $joinMapper, true);
        $this->applyGroup();

        return $this->queryBuilder;
    }

    /**
     * Adds join dql parts.
     *
     * @param JoinMapper $joinMapper
     * @param bool       $lazy
     */
    private function applyJoins(JoinMapper $joinMapper, bool $lazy): void
    {
        foreach ($joinMapper->getFields(null, $lazy) as $field) {
            $joinPath = $field->getJoinPath($this->configuration->getAlias());
            $condition = null;
            $conditionType = null;

            if ($field->hasOption(JoinField::OPTION_CONDITION)) {
                $condition = $field->getOption(JoinField::OPTION_CONDITION);
                $conditionType = $field->getOption(JoinField::OPTION_CONDITION_TYPE);
            }

            if ($field->getOption(JoinField::OPTION_JOIN_TYPE) === JoinField::JOIN_INNER) {
                $this->queryBuilder->innerJoin($joinPath, $field->getAlias(), $conditionType, $condition);
            } else {
                $this->queryBuilder->leftJoin($joinPath, $field->getAlias(), $conditionType, $condition);
            }

            if ($field->hasOption(JoinField::OPTION_CONDITION_PARAMETERS)) {
                $this->queryBuilder->setParameters($field->getOption(JoinField::OPTION_CONDITION_PARAMETERS));
            }
        }
    }

    /**
     * Adds select and sort DQL parts
     *
     * @param ListMapper $listMapper
     * @param JoinMapper $joinMapper
     * @param bool       $lazy
     */
    private function applySelects(ListMapper $listMapper, JoinMapper $joinMapper, bool $lazy): void
    {
        if ($lazy === false) {
            $idSelector = sprintf(
                '%s.%s as %s',
                $this->configuration->getAlias(),
                $this->configuration->getIdentifier(),
                self::IDENTIFIER_ALIAS
            );
            $this->queryBuilder->addSelect($idSelector);
        }

        foreach ($listMapper->getFields($lazy) as $field) {
            $paths = $this->parsePaths($joinMapper, $field->getPaths(), $lazy);
            $selectorType = $field->getOption(ListField::OPTION_SELECTOR);

            if (!$this->selectorTypeLocator->has($selectorType)) {
                throw ListFieldException::invalidType($field->getId(), $selectorType, SelectorTypeInterface::class);
            }

            $selectorType = $this->selectorTypeLocator->get($selectorType);
            $selectorType->apply($this->queryBuilder, $paths, $field->getId());

            if ($selectorType->hasAggregation()) {
                $this->hasAggregation = true;
            }

            if (
                false === $lazy && $field->getOption(ListField::OPTION_SORTABLE) &&
                ($dir = $field->getOption(ListField::OPTION_SORT_VALUE))
            ) {
                if ($sortPath = $field->getOption(ListField::OPTION_SORT_PATH)) {
                    $select = $this->parsePaths($joinMapper, (array) $sortPath, false)[0];
                } else {
                    $select = $selectorType->getSortPath($field->getId());
                }

                $this->queryBuilder->addOrderBy($select, $dir);
            }
        }
    }

    /**
     * @param FilterMapper $filterMapper
     * @param JoinMapper   $joinMapper
     */
    private function applyFilter(FilterMapper $filterMapper, JoinMapper $joinMapper): void
    {
        foreach ($filterMapper->getFields() as $field) {
            if (!$field->hasValue() || false === $field->getOption(FilterField::OPTION_MAPPED)) {
                continue;
            }

            $queryType = $field->getOption(FilterField::OPTION_QUERY_TYPE);

            if (!$this->queryTypeLocator->has($queryType)) {
            if (!$this->queryTypeLocator->has(/** @scrutinizer ignore-type */ $queryType)) {
                throw ListFieldException::invalidType($field->getId(), $queryType, QueryTypeInterface::class);
            }

            $paths = $this->parsePaths($joinMapper, $field->getPaths(), false);
            $queryType = $this->queryTypeLocator->get($queryType);
            $resolver = new OptionsResolver();
            $queryType->configureOptions($resolver);
            $queryType->setOptions($resolver->resolve($field->getOption(FilterField::OPTION_QUERY_OPTIONS)));
            $queryType->setOptions($resolver->resolve(/** @scrutinizer ignore-type */ $field->getOption(FilterField::OPTION_QUERY_OPTIONS)));
            $queryType->filter($this->queryBuilder, $paths, $field->getId(), $field->getValue());

            if ($queryType->hasAggregation()) {
                $this->hasAggregation = true;
            }
        }
    }

    /**
     * Applies group by identifier if query has aggregations
     */
    private function applyGroup(): void
    {
        if ($this->hasAggregation) {
            $statement = sprintf('%s.%s', $this->configuration->getAlias(), $this->configuration->getIdentifier());
            $this->queryBuilder->groupBy($statement);
        } else {
            $this->queryBuilder->distinct();
        }
    }

    /**
     * @param JoinMapper $joinMapper
     * @param array      $paths
     * @param bool       $lazy
     *
     * @return array
     */
    private function parsePaths(JoinMapper $joinMapper, array $paths, bool $lazy): array
    {
        $parsedPaths = [];

        foreach ($paths as $path) {
            $pathElements = explode('.', $path);

            if (count($pathElements) === 1) {
                $prop = $pathElements[0];
                $path = null;
            } else {
                $prop = array_pop($pathElements);
                $path = implode('.', $pathElements);
            }

            if (null !== $path) {
                if (!$joinField = $joinMapper->getByPath($path, $lazy)) {
                    throw ListFieldException::invalidPath($path);
                }

                $alias = $joinField->getAlias();
            } else {
                $alias = $this->configuration->getAlias();
            }

            $parsedPaths[] = sprintf('%s.%s', $alias, $prop);
        }

        return $parsedPaths;
    }
}

povs / ListerBundle

ListQueryBuilder::__construct() A last analyzed 2024-09-16 11:13 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

ListQueryBuilder::__construct() A
last analyzed 2024-09-16 11:13 UTC
