FilterGroupFactory.php

Go to the documentation of this file.

<?php
declare(strict_types=1);

namespace Magento\Framework\GraphQl\Query\Resolver\Argument\SearchCriteria;

use Magento\Framework\GraphQl\Query\Resolver\Argument\Filter\Clause;
use Magento\Framework\GraphQl\Query\Resolver\Argument\Filter\Connective;
use Magento\Framework\GraphQl\Query\Resolver\Argument\Filter\Operator;
use Magento\Framework\Api\FilterBuilder;
use Magento\Framework\Api\Search\FilterGroupBuilder;
use Magento\Framework\GraphQl\Exception\GraphQlInputException;
use Magento\Framework\Phrase;
use Magento\Framework\Api\Search\FilterGroup;

class FilterGroupFactory
{
    private $filterBuilder;

    private $filterGroupBuilder;

    public function __construct(
        \Magento\Framework\Api\FilterBuilder $filterBuilder,
        \Magento\Framework\Api\Search\FilterGroupBuilder $filterGroupBuilder
    ) {
        $this->filterBuilder = $filterBuilder;
        $this->filterGroupBuilder = $filterGroupBuilder;
    }

    public function create(Connective $arguments) : array
    {
        $filters = $arguments;
        $searchCriteriaFilterGroups = [];

        foreach ($filters->getConditions() as $filter) {
            if ($filter instanceof Operator) {
                throw new GraphQlInputException(new Phrase('Can\'t support nested operators'));
            }

            if ($filter instanceof Clause) {
                $searchCriteriaFilterGroups[] = $this->processClause($filter);
            } elseif ($filter instanceof Connective) {
                $searchCriteriaFilterGroups[] = $this->processConnective($filter);
            } else {
                throw new GraphQlInputException(new Phrase('Nesting "OR" node type not supported'));
            }
        }

        return $searchCriteriaFilterGroups;
    }

    private function processConnective(Connective $connective) : FilterGroup
    {
        foreach ($connective->getConditions() as $subNode) {
            if ($subNode instanceof Clause) {
                $subFilter = $this->filterBuilder
                    ->setField($subNode->getFieldName())
                    ->setValue($subNode->getClauseValue())// Not strictly needed for "null" and "notnull"
                    ->setConditionType($subNode->getClauseType())
                    ->create();

                $this->filterGroupBuilder->addFilter($subFilter);
            } elseif ($subNode instanceof Connective) {
                // This recursive OR processing can be done because AND is not yet supported
                // we should not be doing this for OR if both AND and OR will be nestedly supported
                // because it's mathematically incorrect to reduce OR in a boolean operation
                // you can only do it when you have only OR operation.
                if (((string)$subNode->getOperator()) == 'OR') {
                    return $this->processConnective($subNode);
                } else {
                    throw new GraphQlInputException(
                        new Phrase('Sub nesting of %1 is not supported', [$subNode->getOperator()])
                    );
                }
            }
        }
        return $this->filterGroupBuilder->create();
    }

    private function processClause(Clause $clause)
    {
        $searchCriteriaFilter = $this->filterBuilder
            ->setField($clause->getFieldName())
            ->setValue($clause->getClauseValue())// Not strictly needed for "null" and "notnull"
            ->setConditionType($clause->getClauseType())
            ->create();

        $this->filterGroupBuilder->addFilter($searchCriteriaFilter);
        return $this->filterGroupBuilder->create();
    }
}