Ynlo\GraphQLBundle\Filter\Common\NodeFilter

Complexity

Total Complexity

17

Size/Duplication

Total Lines	78
Duplicated Lines	0 %

Test Coverage

Coverage

92.11%

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	__invoke()	0	26	6
B	applyFilter()	0	38	11

<?php
/*******************************************************************************
 *  This file is part of the GraphQL Bundle package.
 *
 *  (c) YnloUltratech <support@ynloultratech.com>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 ******************************************************************************/

namespace Ynlo\GraphQLBundle\Filter\Common;

use Doctrine\ORM\Mapping\ClassMetadataInfo;
use Doctrine\ORM\QueryBuilder;
use Ynlo\GraphQLBundle\Filter\FilterContext;
use Ynlo\GraphQLBundle\Filter\FilterInterface;
use Ynlo\GraphQLBundle\Model\Filter\NodeComparisonExpression;
use Ynlo\GraphQLBundle\Model\NodeInterface;
use Ynlo\GraphQLBundle\Type\NodeComparisonOperatorType;

/**
 * Node filter to filter by related nodes
 */
class NodeFilter implements FilterInterface
{
    /**
     * @inheritDoc
     */
    public function __invoke(FilterContext $context, QueryBuilder $qb, $condition)
    {
        if (!$condition instanceof NodeComparisonExpression) {
            throw new \RuntimeException('Invalid filter condition');
        }

        if (!$context->getField() || !$context->getField()->getName()) {
            throw new \RuntimeException('There are not valid field related to this filter.');
        }

        $entity = $context->getNode()->getClass();

The method getClass() does not exist on Ynlo\GraphQLBundle\Definition\FieldsAwareDefinitionInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Ynlo\GraphQLBundle\Definition\ImplementorInterface. Are you sure you never get one of those?

        $metadata = $qb->getEntityManager()->getClassMetadata($entity);
        $column = $context->getField()->getOriginName();
        if ($context->getField()->getOriginType() === 'ReflectionMethod') {
            $column = $context->getField()->getName();
        }

        if (!$metadata->hasAssociation($column)) {
            throw new \RuntimeException(sprintf('There are not valid association in %s called %s.', $entity, $column));
        }

        $association = $metadata->getAssociationMapping($column);

        $alias = $qb->getRootAliases()[0];

        $this->applyFilter($qb, $association['type'], $alias, $column, $condition);
    }

    /**
     * @param QueryBuilder             $qb
     * @param string                   $assocType
     * @param string                   $alias
     * @param string                   $column
     * @param NodeComparisonExpression $condition
     */
    protected function applyFilter(QueryBuilder $qb, $assocType, $alias, $column, NodeComparisonExpression $condition): void
    {
        $ids = [];
        foreach ($condition->getNodes() as $node) {
            if ($node instanceof NodeInterface) {
                $ids[] = $node->getId();
            }
        }
        $ids = array_filter($ids);

        switch ($assocType) {
            case ClassMetadataInfo::MANY_TO_ONE:
            case ClassMetadataInfo::ONE_TO_ONE:
            case ClassMetadataInfo::ONE_TO_MANY:
                if ($condition->getOp() === NodeComparisonOperatorType::IN) {
                    if (empty($ids)) {
                        $qb->andWhere($qb->expr()->isNull("{$alias}.{$column}"));
                    } else {
                        $qb->andWhere($qb->expr()->in("{$alias}.{$column}", $ids));
                    }
                } else {
                    if (empty($ids)) {
                        $qb->andWhere($qb->expr()->isNotNull("{$alias}.{$column}"));
                    } else {
                        $qb->andWhere($qb->expr()->notIn("{$alias}.{$column}", $ids));
                    }
                }
                break;
            case ClassMetadataInfo::MANY_TO_MANY:
                $paramName = sprintf('%s_ids_%s', $column, mt_rand());
                if ($condition->getOp() === NodeComparisonOperatorType::IN) {
                    $qb->andWhere(sprintf(':%s MEMBER OF %s.%s', $paramName, $alias, $column))
                       ->setParameter($paramName, $ids);
                } else {
                    $qb->andWhere(sprintf(':%s NOT MEMBER OF %s.%s', $paramName, $alias, $column))
                       ->setParameter($paramName, $ids);
                }
                break;
        }
    }
}