Filter implementation for ElasticSearch

[nilportugues]

class FilterToElasticSearchQuery
{
    const MUST_NOT = 'must_not';
    const MUST = 'must';
    const SHOULD = 'should';

    /**
     * @param FilterInterface $filter
     * @param array $mapping
     * @return array
     */
    public static function filter(FilterInterface $filter, array $mapping): array
    {
        $conditions = [];

        foreach ($filter->filters() as $condition => $filters) {
            $filters = self::removeEmptyFilters($filters);
            if (count($filters) > 0) {
                self::processConditions($mapping, $conditions, $condition, $filters);
            }
        }

        return $conditions;
    }

    /**
     * @param array $filters
     *
     * @return array
     */
    private static function removeEmptyFilters(array $filters)
    {
        $filters = array_filter(
            $filters,
            function ($v) {
                return count($v) > 0;
            }
        );

        return $filters;
    }

    /**
     * @param array $mapping
     * @param array $conditions
     * @param $condition
     * @param array $filters
     */
    private static function processConditions(
        array &$mapping,
        array &$conditions,
        $condition,
        array &$filters
    ) {
        switch ($condition) {
            case self::MUST:
                self::apply($mapping, $conditions, $filters, 'must');
                break;

            case self::MUST_NOT:
                self::apply($mapping, $conditions, $filters, 'must_not');
                break;

            case self::SHOULD:
                self::apply($mapping, $conditions, $filters, 'should');
                break;
        }
    }

    /**
     * @param array $mapping
     * @param array $conditions
     * @param array $filters
     * @param $operator
     */
    protected static function apply(
        array &$mapping,
        array &$conditions,
        array $filters,
        $operator
    ) {
        foreach ($filters as $filterName => $valuePair) {
            foreach ($valuePair as $key => $value) {
                if (false === array_key_exists($key, $mapping)) {
                    break;
                }

                $key = self::fetchColumnName($mapping, $key);
                if (is_array($value) && count($value) > 0) {
                    $value = array_values($value);
                    if (count($value[0]) > 1) {
                        switch ($filterName) {
                            case BaseFilter::RANGES:
                                self::rangeQuery($conditions, $operator, $key, $value);
                                break;

                            case BaseFilter::NOT_RANGES:
                                $operator = self::getOppositeOperator($operator);

                                self::rangeQuery($conditions, $operator, $key, $value);
                                break;
                        }
                    } else {
                        switch ($filterName) {
                            case BaseFilter::GROUP:
                                $operatorIn = 'should';
                                if (self::MUST_NOT === $operator) {
                                    $operatorIn = 'should_not';
                                }

                                self::inGroupQuery($conditions, $operatorIn, $key, $value);
                                break;
                            case BaseFilter::NOT_GROUP:
                                $operatorIn = 'should_not';
                                if (self::MUST_NOT === self::getOppositeOperator($operator)) {
                                    $operatorIn = 'should';
                                }

                                self::inGroupQuery($conditions, $operatorIn, $key, $value);
                                break;
                        }
                    }
                }

                $value = (array)$value;
                $value = array_shift($value);

                switch ($filterName) {
                    case BaseFilter::GREATER_THAN_OR_EQUAL:
                        self::query($conditions, $operator, $key, 'gte', $value);
                        break;

                    case BaseFilter::GREATER_THAN:
                        self::query($conditions, $operator, $key, 'gt', $value);
                        break;

                    case BaseFilter::LESS_THAN_OR_EQUAL:
                        self::query($conditions, $operator, $key, 'lte', $value);
                        break;

                    case BaseFilter::LESS_THAN:
                        self::query($conditions, $operator, $key, 'lt', $value);
                        break;

                    case BaseFilter::CONTAINS:
                        self::query($conditions, $operator, $key, 'match', '*' . $value . '*');
                        break;

                    case BaseFilter::NOT_CONTAINS:
                        $operator = self::getOppositeOperator($operator);

                        self::query($conditions, $operator, $key, 'match', '*' . $value . '*');
                        break;

                    case BaseFilter::EQUALS:
                        self::query($conditions, $operator, $key, 'match', $value);
                        break;

                    case BaseFilter::NOT_EQUAL:
                        $operator = self::getOppositeOperator($operator);

                        self::query($conditions, $operator, $key, 'match', $value);
                        break;

                    case BaseFilter::EMPTY_FILTER:
                        self::query($conditions, $operator, $key, 'match', null);
                        break;

                    case BaseFilter::NOT_EMPTY:
                        $operator = self::getOppositeOperator($operator);
                        self::query($conditions, $operator, $key, 'match', null);
                        break;

                    case BaseFilter::ENDS_WITH:
                        $newValue = '*' . $value;
                        self::query($conditions, $operator, $key, 'match', $newValue);
                        break;

                    case BaseFilter::NOT_ENDS:
                        $operator = self::getOppositeOperator($operator);
                        self::query($conditions, $operator, $key, 'match', '*' . $value);
                        break;

                    case BaseFilter::STARTS_WITH:
                        self::query($conditions, $operator, $key, 'match', '*' . $value);
                        break;

                    case BaseFilter::NOT_STARTS:
                        $operator = self::getOppositeOperator($operator);
                        self::query($conditions, $operator, $key, 'match', $value . '*');
                        break;
                }
            }
        }
    }

    /**
     * @param $columns
     * @param $propertyName
     *
     * @return int
     */
    protected static function fetchColumnName(array &$columns, $propertyName)
    {
        if (empty($columns[$propertyName])) {
            throw new \RuntimeException(sprintf('Property %s has no associated column.', $propertyName));
        }

        return $columns[$propertyName];
    }

    /**
     * @param array $conditions
     * @param $operator
     * @param $key
     * @param $value
     */
    protected static function rangeQuery(array &$conditions, $operator, $key, $value)
    {
        $rangeCondition = ['gte' => $value[0][0], 'lte' => $value[0][1]];
        if (self::MUST_NOT === $operator) {
            $rangeCondition = ['lt' => $value[0][0], 'gt' => $value[0][1]];
        }

        $conditions['query']['bool']['filter'][] = ['range' => [$key => $rangeCondition]];
        $conditions['query']['bool']['filter'] = array_values($conditions['query']['bool']['filter']);
    }

    /**
     * @param $operator
     * @return string
     */
    protected static function getOppositeOperator($operator): string
    {
        if ($operator === self::MUST) {
            $operator = self::MUST_NOT;
        }

        if ($operator === self::MUST_NOT) {
            $operator = self::MUST;
            return $operator;
        }
        return $operator;
    }

    /**
     * @param array $conditions
     * @param $operator
     * @param $key
     * @param $value
     */
    protected static function inGroupQuery(array &$conditions, $operator, $key, $value)
    {
        $query =  [
            ['bool' => [$operator => ['exists' => ['field' => $key]]]]
        ];

        foreach ($value as $v) {
            $query[] = ['match' => [$key => $v]];
        }

        $conditions['query']['bool']['filter']['bool'][$operator][] = $query;
    }

    /**
     * @param array $conditions
     * @param $operator
     * @param $key
     * @param $op
     * @param $value
     */
    protected static function query(array &$conditions, $operator, $key, $op, $value)
    {
        $conditions['query']['bool'][$operator][] = [$op => [$key => $value]];
    }
}