filter.php

<?php
namespace Bitrix\Main\Filter;
 
class Filter
{
    protected $ID = '';
    protected $entityDataProvider = null;
    protected $extraProviders = null;
 
    protected $params = null;
 
    protected $fields = null;
 
    protected $uiFilterPostfixes = [
        '_datesel', '_month', '_quarter', '_year', '_days', // date
        '_numsel', // number
        '_from', '_to', // date and number ranges
        '_isEmpty', // has no value
        '_hasAnyValue', // has any value
        '_label', // custom entity title
    ];
 
    protected $uiFilterServiceFields = [
        'FILTER_ID',
        'FILTER_APPLIED',
        'PRESET_ID',
        'FIND',
    ];
 
    function __construct($ID, DataProvider $entityDataProvider, array $extraDataProviders = null, array $params = null)
    {
        $this->ID = $ID;
        $this->entityDataProvider = $entityDataProvider;
 
        $this->extraProviders = [];
        if(is_array($extraDataProviders))
        {
            foreach($extraDataProviders as $dataProvider)
            {
                if($dataProvider instanceof DataProvider)
                {
                    $this->extraProviders[] = $dataProvider;
                }
            }
        }
 
        $this->params = is_array($params) ? $params : [];
    }
 
    function getID()
    {
        return $this->ID;
    }
 
    public function getDefaultFieldIDs()
    {
        $results = [];
        foreach($this->getFields() as $fieldID => $field)
        {
            if($field->isDefault())
            {
                $results[] = $fieldID;
            }
        }
        return $results;
    }
 
    public function getFields()
    {
        if($this->fields === null)
        {
            $this->fields = $this->entityDataProvider->prepareFields();
            foreach($this->extraProviders as $dataProvider)
            {
                $fields = $dataProvider->prepareFields();
                if(!empty($fields))
                {
                    $this->fields += $fields;
                }
            }
        }
        return $this->fields;
    }
 
    public function getFieldArrays(array $fieldMask = [])
    {
        $results = [];
        $allFields = true;
        if (!empty($fieldMask))
        {
            $fieldMask = array_fill_keys($fieldMask, true);
            $allFields = false;
        }
        $fields = $this->getFields();
        foreach($fields as $field)
        {
            if ($allFields || isset($fieldMask[$field->getId()]))
            {
                $results[] = $field->toArray();
            }
        }
        return $results;
    }
 
    public function getField($fieldID)
    {
        $fields = $this->getFields();
        return $fields[$fieldID] ?? null;
    }
 
    public function getEntityDataProvider()
    {
        return $this->entityDataProvider;
    }
 
    public function prepareListFilterParams(array &$filter)
    {
        foreach ($filter as $k => $v)
        {
            $this->entityDataProvider->prepareListFilterParam($filter, $k);
        }
    }
 
    public function getValue(?array $rawValue = null): array
    {
        $gridId = $this->getEntityDataProvider()->getSettings()->getID();
 
        if (!isset($rawValue))
        {
            $options = new \Bitrix\Main\UI\Filter\Options($gridId);
            $rawValue =
                $options->getFilter()
                + $options->getFilterLogic($this->getFieldArrays())
            ;
        }
 
        $result = $rawValue;
        $this->removeNotUiFilterFields($result);
        $this->prepareListFilterParams($result);
        $this->prepareFilterValue($result);
        $this->removeServiceUiFilterFields($result);
 
        return $result;
    }
 
    protected function removeServiceUiFilterFields(array &$filter): void
    {
        foreach ($filter as $fieldId => $fieldValue)
        {
            if (in_array($fieldId, $this->uiFilterServiceFields, true))
            {
                unset($filter[$fieldId]);
                continue;
            }
            foreach ($this->uiFilterPostfixes as $postfix)
            {
                if (mb_substr($fieldId, -mb_strlen($postfix)) === $postfix)
                {
                    unset($filter[$fieldId]);
                    continue;
                }
            }
        }
    }
 
    protected function removeNotUiFilterFields(array &$filter): void
    {
        $filterFieldsIds = array_map(
            function(Field $filterField)
            {
                return $filterField->getId();
            },
            $this->getFields()
        );
        $sqlWhere = new \CSQLWhere();
 
        foreach ($filter as $fieldId => $fieldValue)
        {
            if (in_array($fieldId, $this->uiFilterServiceFields, true))
            {
                continue;
            }
            if (in_array($fieldId, $filterFieldsIds, true))
            {
                continue;
            }
 
            $fieldIdWithoutOperation = $sqlWhere->makeOperation($fieldId)['FIELD'];
            if (in_array($fieldIdWithoutOperation, $filterFieldsIds, true))
            {
                continue;
            }
 
            foreach ($this->uiFilterPostfixes as $postfix)
            {
                $postfixLength = mb_strlen($postfix);
                if (mb_substr($fieldId, -$postfixLength) === $postfix)
                {
                    $realFieldId = mb_substr($fieldId, 0, -$postfixLength);
                    if (in_array($realFieldId, $filterFieldsIds, true))
                    {
                        continue(2);
                    }
                }
            }
            unset($filter[$fieldId]); // not a valid filter field
        }
    }
 
    protected function prepareFilterValue(array &$value): void
    {
        $dataProviders = array_merge(
            [
                $this->getEntityDataProvider(),
            ],
            $this->extraProviders,
        );
 
        foreach ($dataProviders as $dataProvider)
        {
            $value = $dataProvider->prepareFilterValue($value);
        }
    }
}