options.php

См. документацию.

<?php
 
namespace Bitrix\Main\UI\Filter;
 
use Bitrix\Main\Application;
use Bitrix\Main\Context;
use Bitrix\Main\HttpRequest;
use Bitrix\Main\Type\Date;
use Bitrix\Main\UI\Filter;

class Options
{
    const DEFAULT_FILTER = "default_filter";
    const TMP_FILTER = "tmp_filter";
 
    protected $id;
    protected $options;
    protected $commonPresets;
    protected $useCommonPresets;
    protected $commonPresetsId;
    protected $request;
    protected ?string $currentFilterPresetId = null;

    public function __construct($filterId, $filterPresets = [], $commonPresetsId = null)
    {
        $this->id = $filterId;
        $this->options = $this->fetchOptions($this->id);
        $this->useCommonPresets = false;
 
        if (!empty($commonPresetsId) && is_string($commonPresetsId))
        {
            $this->commonPresets = static::fetchCommonPresets($commonPresetsId);
            $this->useCommonPresets = true;
            $this->commonPresetsId = $commonPresetsId;
            $this->options["filters"] = $this->commonPresets["filters"] ?? null;
            $this->options["deleted_presets"] = $this->commonPresets["deleted_presets"] ?? null;
        }
 
        if (!isset($this->options["use_pin_preset"]))
        {
            $this->options["use_pin_preset"] = true;
        }
 
        if (!isset($this->options["deleted_presets"]) || !is_array($this->options["deleted_presets"]))
        {
            $this->options["deleted_presets"] = [];
        }
 
        if (!empty($filterPresets) && is_array($filterPresets))
        {
            $this->options["default_presets"] = $filterPresets;
        }
        else
        {
            $this->options["default_presets"] = [];
        }
 
        if (!isset($this->options["default"]) || empty($this->options["default"]) ||
            ($this->options["default"] === self::DEFAULT_FILTER && $this->options["use_pin_preset"]))
        {
            $this->options["default"] = self::findDefaultPresetId($this->options["default_presets"]);
        }
 
        if (!isset($this->options["filter"]) || empty($this->options["filter"]) || !is_string($this->options["filter"]))
        {
            $this->options["filter"] = $this->options["default"];
        }
 
        if (!isset($this->options["filters"]) || !is_array($this->options["filters"]))
        {
            $this->options["filters"] = $this->options["default_presets"];
        }
 
        // Move additional fields from options to session
        if (is_array($this->options["filters"]))
        {
            foreach ($this->options["filters"] as $presetId => $options)
            {
                if (isset($options["additional"]) && is_array($options["additional"]))
                {
                    $this->setAdditionalPresetFields($presetId, $options["additional"]);
                    unset($this->options["filters"][$presetId]["additional"]);
                }
            }
        }
 
        if (!empty($this->options["update_default_presets"]) &&
            !empty($filterPresets) &&
            is_array($filterPresets))
        {
            $this->options["update_default_presets"] = false;
            $sort = 0;
 
            foreach ($filterPresets as $key => $defaultPreset)
            {
                $this->options["filters"][$key] = $defaultPreset;
                $this->options["filters"][$key]["sort"] = $sort;
                $sort++;
            }
 
            foreach ($this->options["filters"] as $key => $preset)
            {
                if (!array_key_exists($key, $filterPresets))
                {
                    $this->options["filters"][$key]["sort"] = $sort;
                    $sort++;
                }
            }
        }
    }

    public function getCommonPresetsId()
    {
        return $this->commonPresetsId;
    }

    public function isUseCommonPresets()
    {
        return $this->useCommonPresets;
    }

    public function getId()
    {
        return $this->id;
    }

    public function setPresets($presets = [])
    {
        $this->options["filters"] = $presets;
    }

    public function setCurrentPreset($presetId = "default_filter")
    {
        $this->options["filter"] = $presetId;
    }

    public function getDefaultPresets()
    {
        return $this->options["default_presets"];
    }

    public function getPresets()
    {
        return $this->options["filters"];
    }

    public function setDefaultPreset($presetId = "default_filter")
    {
        $this->options["default"] = $presetId;
    }

    public function isUsePinPreset()
    {
        return $this->options["use_pin_preset"];
    }

    public function setDefaultPresets($presets = [])
    {
        $this->options["default_presets"] = $presets;
    }

    public function setDeletedPresets($deletedPresets = [])
    {
        $this->options["deleted_presets"] = $deletedPresets;
    }

    public function setUsePinPreset($value = true)
    {
        $this->options["use_pin_preset"] = $value;
    }

    public static function fetchCommonPresets($id)
    {
        global $USER;
 
        $options = \CUserOptions::getOption("main.ui.filter.presets", $id, [], (int)$USER?->getID());
 
        return $options;
    }

    public function fetchOptions($id)
    {
        global $USER;
 
        $storage = $this->getStorage();
        $userId = (int)$USER?->getID();
 
        if ($userId > 0 || !isset($storage[$this->getId()]["options"]))
        {
            $options = [];
 
            if ($userId > 0)
            {
                $options = \CUserOptions::getOption("main.ui.filter", $id, [], $userId);
            }
 
            if (empty($options))
            {
                $options = \CUserOptions::getOption("main.ui.filter.common", $id, [], 0);
            }
        }
        else
        {
            $options = $storage[$this->getId()]["options"];
        }
 
        return $options;
    }
 
    protected function getRequest()
    {
        return Context::getCurrent()->getRequest();
    }
 
    protected function getStorage()
    {
        return Application::getInstance()->getLocalSession('main.ui.filter');
    }

    public static function findDefaultPresetId($presets = [])
    {
        $result = "default_filter";
 
        if (!empty($presets) && is_array($presets))
        {
            foreach ($presets as $presetId => $preset)
            {
                if (isset($preset["default"]) && $preset["default"])
                {
                    $result = $presetId;
                }
            }
        }
 
        return $result;
    }

    public function getOptions()
    {
        return $this->options;
    }

    public function pinPreset($presetId = "default_filter")
    {
        if ($presetId === "default_filter")
        {
            $this->options["use_pin_preset"] = false;
        }
        else
        {
            $this->options["use_pin_preset"] = true;
        }
 
        $this->options["default"] = $presetId;
    }

    public static function isSetFromRequest(HttpRequest $request)
    {
        $applyFilter = $request->get("apply_filter");
        $isAjaxRequest = $request->get("ajax_request");
 
        return $applyFilter !== null && $isAjaxRequest === null && !$request->isAjaxRequest();
    }

    public static function fetchSettingsFromQuery($fields, HttpRequest $request)
    {
        $result = ["fields" => [], "rows" => []];
 
        foreach ($fields as $field)
        {
            $id = $field["id"];
            $fromId = $id . "_from";
            $toId = $id . "_to";
            $quarterId = $id . "_quarter";
            $yearId = $id . "_year";
            $monthId = $id . "_month";
            $daysId = $id . "_days";
            $nameId = $id . "_name";
            $labelId = $id . "_label";
            $dateselId = $id . "_datesel";
            $numselId = $id . "_numsel";
            $type = $field["type"] ?? null;
            $isEmpty = $id . "_isEmpty";
            $hasAnyValue = $id . "_hasAnyValue";
 
            if ($type == "date")
            {
                if ($request[$dateselId] !== null && ($request[$fromId] !== null ||
                        $request[$toId] !== null ||
                        $request[$quarterId] !== null ||
                        $request[$yearId] !== null ||
                        $request[$daysId] !== null ||
                        $request[$monthId] !== null))
                {
                    $result["fields"][$dateselId] = $request[$dateselId];
                    $result["fields"][$fromId] = $request[$fromId] !== null ? $request[$fromId] : "";
                    $result["fields"][$toId] = $request[$toId] !== null ? $request[$toId] : "";
                    $result["fields"][$yearId] = $request[$yearId] !== null ? $request[$yearId] : "";
                    $result["fields"][$monthId] = $request[$monthId] !== null ? $request[$monthId] : "";
                    $result["fields"][$daysId] = $request[$daysId] !== null ? $request[$daysId] : "";
                    $result["rows"][] = $id;
                }
            }
            else
            {
                if ($type == "number")
                {
                    if ($request[$numselId] !== null && ($request[$fromId] !== null || $request[$toId]))
                    {
                        $result["fields"][$numselId] = $request[$numselId];
                        $result["fields"][$fromId] = $request[$fromId] !== null ? $request[$fromId] : "";
                        $result["fields"][$toId] = $request[$toId] !== null ? $request[$toId] : "";
                        $result["rows"][] = $id;
                    }
                }
                else
                {
                    if ($type == "custom_entity")
                    {
                        if ($request[$id] !== null)
                        {
                            if ($request[$id] !== null || $request[$labelId] !== null)
                            {
                                $result["fields"][$labelId] = ($request[$nameId] !== null ?
                                    $request[$nameId] : $request[$labelId]);
                            }
                            $result["fields"][$id] = $request[$id];
                            $result["rows"][] = $id;
                        }
                    }
                    else
                    {
                        if ($type == "dest_selector" || $type == "entity_selector")
                        {
                            if ($request[$id] !== null)
                            {
                                $result["fields"][$id] = $request[$id];
                                if (isset($request[$labelId]))
                                {
                                    $result["fields"][$labelId] = $request[$labelId];
                                }
                                $result["rows"][] = $id;
                            }
                        }
                        else
                        {
                            if ($request[$id] !== null)
                            {
                                $result["fields"][$id] = $request[$id];
                                $result["rows"][] = $id;
                            }
                        }
                    }
                }
            }
 
            if (isset($request[$isEmpty]))
            {
                $result['fields'][$isEmpty] = $request[$isEmpty];
                $result["rows"][] = $id;
            }
 
            if (isset($request[$hasAnyValue]))
            {
                $result['fields'][$hasAnyValue] = $request[$hasAnyValue];
                $result["rows"][] = $id;
            }
        }
 
        if ($request["FIND"] !== null)
        {
            $result["fields"]["FIND"] = $request["FIND"];
        }
 
        if (empty($result["fields"]) && empty($result["rows"]))
        {
            $result = null;
        }
 
        return $result;
    }

    public function getSessionFilterId()
    {
        $storage = $this->getStorage();
 
        return $storage[$this->getId()]["filter"] ?? null;
    }
 
    public function isSetOutside(): bool
    {
        $storage = $this->getStorage();
 
        return filter_var(
            $storage[$this->getId()]["isSetOutside"] ?? false,
            FILTER_VALIDATE_BOOLEAN
        );
    }

    public function getAdditionalPresetFields($presetId)
    {
        $storage = $this->getStorage();
 
        $additional = $storage[$this->getId()]["filters"][$presetId]["additional"] ?? [];
 
        return is_array($additional) ? $additional : [];
    }

    public function setAdditionalPresetFields($presetId, $additional = [])
    {
        $storage = $this->getStorage();
 
        $storage[$this->getId()]["filters"][$presetId]["additional"] = $additional;
    }

    public function getDefaultFilterId()
    {
        return $this->options["default"];
    }

    public function getCurrentFilterId()
    {
        $sessionFilterId = ($this->getCurrentFilterPresetId() ?? $this->getSessionFilterId());
        $defaultFilterId = $this->getDefaultFilterId();
        return !empty($sessionFilterId) ? $sessionFilterId : $defaultFilterId;
    }
 
    protected function trySetFilterFromRequest($fields = [])
    {
        $request = $this->getRequest();
 
        if (self::isSetFromRequest($request))
        {
            $settings = self::fetchSettingsFromQuery($fields, $this->getRequest());
            $clear = strtoupper($request->get("clear_filter")) == "Y";
 
            if ($settings !== null || $clear)
            {
                $presetId = $clear ? self::DEFAULT_FILTER : self::TMP_FILTER;
 
                $this->setFilterSettings($presetId, $settings);
                $this->save();
            }
        }
    }

    public function getFilterSettings($presetId)
    {
        return $this->options["filters"][$presetId] ?? null;
    }

    protected static function fetchFieldsFromFilterSettings($filterSettings = [], $additionalFields = [])
    {
        $filterFields = [];
 
        if (is_array($filterSettings))
        {
            if (is_array($filterSettings["fields"]))
            {
                $filterFields = $filterSettings["fields"];
            }
 
            if (is_array($additionalFields))
            {
                $filterFields = array_merge($filterFields, $additionalFields);
            }
        }
 
        return $filterFields;
    }

    public static function isDateField($key = "")
    {
        return is_string($key) && str_ends_with($key, "_datesel");
    }

    public static function fetchDateFieldValue($key = "", $filterFields = [])
    {
        $date = [];
        $date[$key] = $filterFields[$key];
 
        $cleanKey = str_replace("_datesel", "", $key);
 
        self::calcDates($cleanKey, $filterFields, $date);
 
        if (!isset($date[$cleanKey . "_from"]) && !isset($date[$cleanKey . "_to"]))
        {
            unset($date[$cleanKey . "_datesel"]);
            unset($date[$cleanKey . "_to"]);
            unset($date[$cleanKey . "_from"]);
        }
 
        return $date;
    }

    public static function fetchNumberFieldValue($key = "", $filterFields = [])
    {
        $number = [];
        $number[$key] = $filterFields[$key];
        $cleanKey = str_replace("_numsel", "", $key);
 
        if (array_key_exists($cleanKey . "_from", $filterFields))
        {
            $number[$cleanKey . "_from"] = $filterFields[$cleanKey . "_from"];
        }
 
        if (array_key_exists($cleanKey . "_to", $filterFields))
        {
            $number[$cleanKey . "_to"] = $filterFields[$cleanKey . "_to"];
        }
 
        if ($number[$cleanKey . "_from"] === "" && $number[$cleanKey . "_to"] === "")
        {
            unset($number[$cleanKey . "_from"]);
            unset($number[$cleanKey . "_to"]);
            unset($number[$cleanKey . "_numsel"]);
        }
 
        return $number;
    }
 
    public static function isNumberField($key = "")
    {
        return is_string($key) && str_ends_with($key, "_numsel");
    }
 
    public static function fetchFieldValuesFromFilterSettings($filterSettings = [], $additionalFields = [], $sourceFields = [])
    {
        $filterFields = self::fetchFieldsFromFilterSettings($filterSettings, $additionalFields);
        $resultFields = [];
        foreach ($filterFields as $key => $field)
        {
            $isStrictField = false;
 
            foreach ($sourceFields as $sourceField)
            {
                if (isset($sourceField["id"]) && $key === $sourceField["id"] && isset($sourceField["strict"]))
                {
                    $isStrictField = true;
                }
            }
 
            if ($field !== "")
            {
                if (self::isDateField($key))
                {
                    $date = self::fetchDateFieldValue($key, $filterFields);
                    $resultFields = array_merge($resultFields, $date);
                }
 
                elseif (self::isNumberField($key))
                {
                    $number = self::fetchNumberFieldValue($key, $filterFields);
                    $resultFields = array_merge($resultFields, $number);
                }
 
                elseif (!str_ends_with($key, "_from") && !str_ends_with($key, "_to"))
                {
                    if (str_ends_with($key, "_isEmpty"))
                    {
                        $resultFields[substr($key, 0, -8)] = false;
                    }
                    elseif (str_ends_with($key, "_hasAnyValue"))
                    {
                        $resultFields['!' . substr($key, 0, -12)] = false;
                    }
                    else
                    {
                        $resultFields[$key] = $field;
                    }
                }
            }
        }
 
        return $resultFields;
    }

    public static function isDefaultFilter($presetId = "")
    {
        return $presetId === self::DEFAULT_FILTER;
    }

    public function getFilter($sourceFields = [])
    {
        $result = [];
        $this->trySetFilterFromRequest($sourceFields);
        $currentPresetId = $this->getCurrentFilterId();
 
        if (!self::isDefaultFilter($currentPresetId))
        {
            $filterSettings = $this->getFilterSettings($currentPresetId);
            $additionalFields = $this->getAdditionalPresetFields($currentPresetId);
            $fieldsValues = self::fetchFieldValuesFromFilterSettings($filterSettings, $additionalFields, $sourceFields);
 
            $result = $fieldsValues;
            $searchString = $this->getSearchString();
 
            if (!empty($result) || $searchString !== "")
            {
                $result["PRESET_ID"] = $currentPresetId;
                $result["FILTER_ID"] = $currentPresetId;
                $result["FILTER_APPLIED"] = true;
                $result["FIND"] = $searchString;
            }
        }
        return $result;
    }

    public function getFilterLogic($sourceFields = [])
    {
        $filter = $this->getFilter($sourceFields);
        $applied = ($filter["FILTER_APPLIED"] ?? false);
        if ($applied === true)
        {
            return Type::getLogicFilter($filter, $sourceFields);
        }
        return [];
    }

    public function getSearchString()
    {
        $storage = $this->getStorage();
 
        $search = $storage[$this->id]["filter_search"] ?? '';
 
        return is_string($search) ? $search : "";
    }

    public function save()
    {
        global $USER;
 
        if ($this->isUseCommonPresets())
        {
            $presets = [
                "filters" => $this->options["filters"],
                "deleted_presets" => $this->options["deleted_presets"],
            ];
 
            if ($USER->isAuthorized())
            {
                \CUserOptions::setOption("main.ui.filter.presets", $this->getCommonPresetsId(), $presets);
            }
        }
 
        if ($USER->isAuthorized())
        {
            \CUserOptions::setOption("main.ui.filter", $this->getId(), $this->options);
        }
        else
        {
            $storage = $this->getStorage();
            $storage[$this->getId()]["options"] = $this->options;
        }
    }

    public function getAllUserOptions()
    {
        return \CUserOptions::getList(null, ["CATEGORY" => "main.ui.filter", "NAME" => $this->getId()]);
    }

    public static function isCurrentUserEditOtherSettings()
    {
        global $USER;
        return $USER->CanDoOperation("edit_other_settings");
    }

    public function saveForAll()
    {
        global $USER;
 
        if (self::isCurrentUserEditOtherSettings())
        {
            $allUserOptions = $this->getAllUserOptions();
 
            if ($allUserOptions)
            {
                $currentOptions = $this->options;
 
                $forAllPresets = [];
 
                foreach ($currentOptions["filters"] as $key => $preset)
                {
                    if ($preset["for_all"])
                    {
                        $forAllPresets[$key] = $preset;
                    }
                }
 
                while ($userOptions = $allUserOptions->fetch())
                {
                    $currentUserOptions = unserialize($userOptions["VALUE"], ['allowed_classes' => false]);
 
                    if (is_array($currentUserOptions))
                    {
                        if (!self::isCommon($userOptions))
                        {
                            $currentUserOptions["deleted_presets"] = $currentOptions["deleted_presets"];
                            $currentUserOptions["filters"] = $forAllPresets;
 
                            if (!$USER->CanDoOperation("edit_other_settings", $userOptions["USER_ID"]))
                            {
                                $currentUserOptions["default_presets"] = $forAllPresets;
                            }
                        }
 
                        $this->saveOptionsForUser($currentUserOptions, $userOptions["USER_ID"]);
                    }
                }
 
                $this->saveCommon();
            }
        }
    }

    public static function isCommon($options)
    {
        return isset($options["USER_ID"]) && $options["USER_ID"] == 0;
    }

    public function saveOptionsForUser($options, $userId)
    {
        if ($this->isUseCommonPresets())
        {
            $presets = [
                "filters" => $options["filters"],
                "deleted_presets" => $options["deleted_presets"],
            ];
 
            \CUserOptions::SetOption("main.ui.filter.presets", $this->getCommonPresetsId(), $presets, null, $userId);
        }
 
        $userOptions = \CUserOptions::GetOption("main.ui.filter", $this->getId(), ["filters" => [], "default_presets" => []], $userId);
 
        if (is_array($options["deleted_presets"]))
        {
            foreach ($options["deleted_presets"] as $key => $isDeleted)
            {
                if (array_key_exists($key, $userOptions["filters"]))
                {
                    unset($userOptions["filters"][$key]);
                }
            }
        }
 
        $options["filters"] = array_merge($userOptions["filters"], $options["filters"]);
        \CUserOptions::SetOption("main.ui.filter", $this->getId(), $options, null, $userId);
    }

    public function saveCommon()
    {
        $presets = [];
        $options = $this->getOptions();
 
        foreach ($options["filters"] as $key => $preset)
        {
            if ($preset["for_all"])
            {
                $presets[$key] = $preset;
            }
        }
 
        $options["filters"] = $presets;
 
        \CUserOptions::setOption("main.ui.filter.common", $this->id, $options, true);
    }

    public function setFilterRows($presetId, $rows)
    {
        $aColsTmp = explode(",", $rows);
        $aCols = [];
        foreach ($aColsTmp as $col)
        {
            if (($col = trim($col)) <> "")
            {
                $aCols[] = $col;
            }
        }
        if ($presetId <> '')
        {
            $this->options["filters"][$presetId]["filter_rows"] = implode(",", $aCols);
        }
        else
        {
            $this->options["filter_rows"] = implode(",", $aCols);
        }
    }
 
    public function removeRowFromPreset(string $presetId, string $rowName): bool
    {
        $rowsString = $this->options["filters"][$presetId]["filter_rows"] ?? '';
        if ($rowsString === '')
        {
            return false;
        }
        $rows = explode(",", $rowsString);
        $pos = array_search($rowName, $rows, true);
        if ($pos !== false)
        {
            unset($rows[$pos]);
            $this->options["filters"][$presetId]["filter_rows"] = implode(",", $rows);
 
            return true;
        }
 
        return false;
    }

    public function restore($settings = [])
    {
        if (!empty($settings))
        {
            foreach ($settings as $key => $preset)
            {
                $this->setFilterSettings($key, $preset, false);
 
                if (array_key_exists($key, $this->options["deleted_presets"]))
                {
                    unset($this->options["deleted_presets"][$key]);
                }
            }
 
            $this->options["default"] = self::findDefaultPresetId($this->options["default_presets"]);
            $this->options["use_pin_preset"] = true;
            $this->options["filter"] = $this->options["default"];
 
            $storage = $this->getStorage();
            unset($storage[$this->id]["filter"]);
        }
    }

    public function setFilterSettingsArray($settings = [])
    {
        if (!empty($settings))
        {
            foreach ($settings as $key => $preset)
            {
                if ($key !== "current_preset" && $key !== "common_presets_id")
                {
                    $this->setFilterSettings($key, $preset, false);
                }
            }
 
            $this->options["filter"] = $settings["current_preset"];
            $request = $this->getRequest();
 
            if (
                isset($request["params"]["forAll"])
                && (
                    $request["params"]["forAll"] === "true"
                    || $request["params"]["forAll"] === true
                )
            )
            {
                $this->saveForAll();
            }
        }
    }

    public function setFilterSettings($presetId, $settings, $currentPreset = true, $useRequest = true)
    {
        if (!empty($presetId))
        {
            $storage = $this->getStorage();
 
            if ($currentPreset)
            {
                $request = $this->getRequest();
                $params = $request->getPost('params');
                $params = is_array($params) ? $params : [];
 
                $isApplyFilter = (
                    ($request->get("apply_filter") == "Y" || $request->get("apply_filter") == "y") ||
                    (isset($params["apply_filter"]) && ($params["apply_filter"] == "Y" || $params["apply_filter"] == "y"))
                );
                $isClearFilter = (
                    ($request->get("clear_filter") == "Y" || $request->get("clear_filter") == "y") ||
                    (isset($params["clear_filter"]) && ($params["clear_filter"] == "Y" || $params["clear_filter"] == "y"))
                );
                $isWithPreset = (
                    ($request->get("with_preset") == "Y" || $request->get("with_preset") == "y") ||
                    (isset($params["with_preset"]) && ($params["with_preset"] == "Y" || $params["with_preset"] == "y"))
                );
                $currentPresetId = $this->getCurrentFilterId();
 
                if (
                    ($useRequest
                        && ($isApplyFilter || $isClearFilter)
                        && (!$isWithPreset || $currentPresetId === static::DEFAULT_FILTER)
                    )
                    || $useRequest === false
                )
                {
                    $storage[$this->id]["filter"] = $presetId;
                    $storage[$this->id]["isSetOutside"] = $params["isSetOutside"] ?? false;
                }
            }
 
            if (!isset($this->options["filters"][$presetId]) || !is_array($this->options["filters"][$presetId]))
            {
                $this->options["filters"][$presetId] = [];
            }
 
            if (!empty($settings["name"]))
            {
                $this->options["filters"][$presetId]["name"] = $settings["name"];
            }
 
            if (isset($settings["for_all"]))
            {
                $this->options["filters"][$presetId]["for_all"] = $settings["for_all"] === "true";
            }
 
            if (isset($settings["sort"]) && is_numeric($settings["sort"]))
            {
                $this->options["filters"][$presetId]["sort"] = $settings["sort"];
            }
 
            if (isset($settings["fields"]) && is_array($settings["fields"]))
            {
                if (array_key_exists("FIND", $settings["fields"]))
                {
                    $storage[$this->id]["filter_search"] = $settings["fields"]["FIND"];
                    unset($settings["fields"]["FIND"]);
                }
 
                if ($presetId == "default_filter")
                {
                    $this->options["filters"][$presetId]["fields"] = [];
                }
                else
                {
                    $this->options["filters"][$presetId]["fields"] = $settings["fields"];
 
                    $additionalFields = isset($settings["additional"]) && is_array($settings["additional"]) ? $settings["additional"] : [];
                    $this->setAdditionalPresetFields($presetId, $additionalFields);
                }
            }
 
            if (!isset($settings["fields"]) && isset($settings["clear_filter"]) && $settings["clear_filter"] === 'Y')
            {
                $this->options["filters"][$presetId]["fields"] = [];
            }
 
            if (!empty($settings["name"]))
            {
                $this->options["filters"][$presetId]["name"] = $settings["name"];
            }
 
            if (isset($settings["rows"]))
            {
                $rows = $settings["rows"];
                if (is_array($rows))
                {
                    $result = [];
                    foreach ($rows as $id)
                    {
                        $id = trim($id);
                        if ($id !== "")
                        {
                            $result[] = $id;
                        }
                    }
                    $this->options["filters"][$presetId]["filter_rows"] = implode(",", $result);
                }
                elseif (is_string($settings["rows"]))
                {
                    $this->options["filters"][$presetId]["filter_rows"] = $settings["rows"];
                }
            }
        }
    }

    public function deleteFilter($presetId, $isDefault = false)
    {
        if ($isDefault)
        {
            $this->options["deleted_presets"][$presetId] = true;
        }
 
        unset($this->options["filters"][$presetId]);
    }

    public function isDeletedPreset($presetId)
    {
        return array_key_exists($presetId, $this->options["deleted_presets"]);
    }

    public function setupDefaultFilter(array $fields, array $rows)
    {
        $this->setFilterSettings("tmp_filter", ["fields" => $fields, "rows" => $rows], true, false);
        $this->save();
    }

    public static function calcDates($fieldId, $source, &$result)
    {
        switch ($source[$fieldId . "_datesel"])
        {
            case DateType::YESTERDAY :
            {
                $dateTime = Filter\DateTimeFactory::createToday();
 
                $result[$fieldId . "_datesel"] = DateType::YESTERDAY;
                $result[$fieldId . "_month"] = $dateTime->month();
                $result[$fieldId . "_quarter"] = $dateTime->quarter();
                $result[$fieldId . "_year"] = $dateTime->year();
                $result[$fieldId . "_from"] = $dateTime->offset("- 1 days");
                $result[$fieldId . "_to"] = $dateTime->offset("- 1 second");
                break;
            }
 
            case DateType::CURRENT_DAY :
            {
                $dateTime = Filter\DateTimeFactory::createToday();
 
                $result[$fieldId . "_datesel"] = DateType::CURRENT_DAY;
                $result[$fieldId . "_month"] = $dateTime->month();
                $result[$fieldId . "_quarter"] = $dateTime->quarter();
                $result[$fieldId . "_year"] = $dateTime->year();
                $result[$fieldId . "_from"] = $dateTime->toString();
                $result[$fieldId . "_to"] = $dateTime->offset("+ 1 days - 1 second");
                break;
            }
 
            case DateType::TOMORROW :
            {
                $dateTime = Filter\DateTimeFactory::createToday();
 
                $result[$fieldId . "_datesel"] = DateType::TOMORROW;
                $result[$fieldId . "_month"] = $dateTime->month();
                $result[$fieldId . "_year"] = $dateTime->year();
                $result[$fieldId . "_quarter"] = $dateTime->quarter();
                $result[$fieldId . "_from"] = $dateTime->offset("+ 1 days");
                $result[$fieldId . "_to"] = $dateTime->offset("+ 2 days - 1 second");
                break;
            }
 
            case DateType::CURRENT_WEEK :
            {
                $dateTime = Filter\DateTimeFactory::createCurrentWeekMonday();
 
                $result[$fieldId . "_datesel"] = DateType::CURRENT_WEEK;
                $result[$fieldId . "_month"] = $dateTime->month();
                $result[$fieldId . "_year"] = $dateTime->year();
                $result[$fieldId . "_quarter"] = $dateTime->quarter();
                $result[$fieldId . "_from"] = $dateTime->toString();
                $result[$fieldId . "_to"] = $dateTime->offset("7 days - 1 second");
                break;
            }
 
            case DateType::NEXT_WEEK :
            {
                $dateTime = Filter\DateTimeFactory::createNextWeekMonday();
 
                $result[$fieldId . "_datesel"] = DateType::NEXT_WEEK;
                $result[$fieldId . "_month"] = $dateTime->month();
                $result[$fieldId . "_year"] = $dateTime->year();
                $result[$fieldId . "_quarter"] = $dateTime->quarter();
                $result[$fieldId . "_from"] = $dateTime->toString();
                $result[$fieldId . "_to"] = $dateTime->offset("7 days - 1 second");
                break;
            }
 
            case DateType::CURRENT_MONTH :
            {
                $dateTime = Filter\DateTimeFactory::createFirstDayOfCurrentMonth();
 
                $result[$fieldId . "_datesel"] = DateType::CURRENT_MONTH;
                $result[$fieldId . "_month"] = $dateTime->month();
                $result[$fieldId . "_year"] = $dateTime->year();
                $result[$fieldId . "_quarter"] = $dateTime->quarter();
                $result[$fieldId . "_from"] = $dateTime->toString();
                $result[$fieldId . "_to"] = $dateTime->offset("1 month - 1 second");
                break;
            }
 
            case DateType::NEXT_MONTH :
            {
                $dateTime = Filter\DateTimeFactory::createFirstDayOfNextMonth();
 
                $result[$fieldId . "_datesel"] = DateType::NEXT_MONTH;
                $result[$fieldId . "_month"] = $dateTime->month();
                $result[$fieldId . "_year"] = $dateTime->year();
                $result[$fieldId . "_quarter"] = $dateTime->quarter();
                $result[$fieldId . "_from"] = $dateTime->toString();
                $result[$fieldId . "_to"] = $dateTime->offset("1 month - 1 second");
                break;
            }
 
            case DateType::CURRENT_QUARTER :
            {
                $dateTime = Filter\DateTimeFactory::createToday();
 
                $result[$fieldId . "_datesel"] = DateType::QUARTER;
                $result[$fieldId . "_month"] = $dateTime->month();
                $result[$fieldId . "_quarter"] = $dateTime->quarter();
                $result[$fieldId . "_year"] = $dateTime->year();
                $result[$fieldId . "_from"] = $dateTime->quarterStart();
                $result[$fieldId . "_to"] = $dateTime->quarterEnd();
                break;
            }
 
            case DateType::LAST_7_DAYS :
            {
                $dateTime = Filter\DateTimeFactory::createToday();
 
                $result[$fieldId . "_datesel"] = DateType::LAST_7_DAYS;
                $result[$fieldId . "_month"] = $dateTime->month();
                $result[$fieldId . "_quarter"] = $dateTime->quarter();
                $result[$fieldId . "_year"] = $dateTime->year();
                $result[$fieldId . "_from"] = $dateTime->offset("- 7 days");
                $result[$fieldId . "_to"] = $dateTime->offset("1 days - 1 second");
                break;
            }
 
            case DateType::LAST_30_DAYS :
            {
                $dateTime = Filter\DateTimeFactory::createToday();
 
                $result[$fieldId . "_datesel"] = DateType::LAST_30_DAYS;
                $result[$fieldId . "_month"] = $dateTime->month();
                $result[$fieldId . "_quarter"] = $dateTime->quarter();
                $result[$fieldId . "_year"] = $dateTime->year();
                $result[$fieldId . "_from"] = $dateTime->offset("- 30 days");
                $result[$fieldId . "_to"] = $dateTime->offset("1 days - 1 second");
                break;
            }
 
            case DateType::LAST_60_DAYS :
            {
                $dateTime = Filter\DateTimeFactory::createToday();
 
                $result[$fieldId . "_datesel"] = DateType::LAST_60_DAYS;
                $result[$fieldId . "_month"] = $dateTime->month();
                $result[$fieldId . "_quarter"] = $dateTime->quarter();
                $result[$fieldId . "_year"] = $dateTime->year();
                $result[$fieldId . "_from"] = $dateTime->offset("- 60 days");
                $result[$fieldId . "_to"] = $dateTime->offset("1 days - 1 second");
                break;
            }
 
            case DateType::LAST_90_DAYS :
            {
                $dateTime = Filter\DateTimeFactory::createToday();
 
                $result[$fieldId . "_datesel"] = DateType::LAST_90_DAYS;
                $result[$fieldId . "_month"] = $dateTime->month();
                $result[$fieldId . "_quarter"] = $dateTime->quarter();
                $result[$fieldId . "_year"] = $dateTime->year();
                $result[$fieldId . "_from"] = $dateTime->offset("- 90 days");
                $result[$fieldId . "_to"] = $dateTime->offset("1 days - 1 second");
                break;
            }
 
            case DateType::MONTH :
            {
                $month = $source[$fieldId . "_month"];
                $year = $source[$fieldId . "_year"];
 
                if (!empty($month) && !empty($year))
                {
                    $dateTime = new Filter\DateTime(mktime(0, 0, 0, $month, 1, $year));
 
                    $result[$fieldId . "_datesel"] = DateType::MONTH;
                    $result[$fieldId . "_month"] = $dateTime->month();
                    $result[$fieldId . "_quarter"] = $dateTime->quarter();
                    $result[$fieldId . "_year"] = $dateTime->year();
                    $result[$fieldId . "_from"] = $dateTime->toString();
                    $result[$fieldId . "_to"] = $dateTime->offset("1 month - 1 second");
                }
 
                break;
            }
 
            case DateType::NEXT_DAYS :
            {
                if (is_numeric($source[$fieldId . "_days"]))
                {
                    $dateTime = Filter\DateTimeFactory::createToday();
                    $days = (int)$source[$fieldId . "_days"];
                    $days = $days > 0 ? ($days + 1) : $days;
 
                    $result[$fieldId . "_datesel"] = DateType::NEXT_DAYS;
                    $result[$fieldId . "_month"] = $dateTime->month();
                    $result[$fieldId . "_quarter"] = $dateTime->quarter();
                    $result[$fieldId . "_days"] = $source[$fieldId . "_days"];
                    $result[$fieldId . "_year"] = $dateTime->year();
                    $result[$fieldId . "_from"] = $dateTime->offset("1 days");
                    $result[$fieldId . "_to"] = $dateTime->offset($days . " days - 1 second");
                }
 
                break;
            }
 
            case DateType::PREV_DAYS :
            {
                if (is_numeric($source[$fieldId . "_days"]))
                {
                    $dateTime = Filter\DateTimeFactory::createToday();
                    $days = (int)$source[$fieldId . "_days"];
                    $days = max($days, 0);
 
                    $result[$fieldId . "_datesel"] = DateType::PREV_DAYS;
                    $result[$fieldId . "_month"] = $dateTime->month();
                    $result[$fieldId . "_quarter"] = $dateTime->quarter();
                    $result[$fieldId . "_days"] = $source[$fieldId . "_days"];
                    $result[$fieldId . "_year"] = $dateTime->year();
                    $result[$fieldId . "_from"] = $dateTime->offset("- " . $days . " days");
                    $result[$fieldId . "_to"] = $dateTime->offset("1 days -1 second");
                }
 
                break;
            }
 
            case AdditionalDateType::PREV_DAY :
            {
                if (is_numeric($source[$fieldId . "_days"]))
                {
                    $dateTime = Filter\DateTimeFactory::createToday();
                    $days = (int)$source[$fieldId . "_days"];
 
                    $result[$fieldId . "_days"] = $source[$fieldId . "_days"];
                    $result[$fieldId . "_from"] = $dateTime->offset(-$days . " days");
                    $result[$fieldId . "_to"] = $dateTime->offset(-($days - 1) . " days -1 second");
                }
 
                break;
            }
 
            case AdditionalDateType::NEXT_DAY :
            case AdditionalDateType::AFTER_DAYS :
            {
                if (is_numeric($source[$fieldId . "_days"]))
                {
                    $dateTime = Filter\DateTimeFactory::createToday();
                    $days = (int)$source[$fieldId . "_days"];
 
                    $result[$fieldId . "_days"] = $source[$fieldId . "_days"];
                    $result[$fieldId . "_from"] = $dateTime->offset($days . " days");
                    $result[$fieldId . "_to"] = $dateTime->offset(($days + 1) . " days -1 second");
                }
 
                break;
            }
 
            case AdditionalDateType::MORE_THAN_DAYS_AGO :
            {
                if (is_numeric($source[$fieldId . "_days"]))
                {
                    $dateTime = Filter\DateTimeFactory::createToday();
                    $days = (int)$source[$fieldId . "_days"];
 
                    $result[$fieldId . "_days"] = $source[$fieldId . "_days"];
                    $result[$fieldId . "_from"] = $dateTime->offset(-($days + 1) . " days");
                    $result[$fieldId . "_to"] = $dateTime->offset(-$days . " days -1 second");
                }
 
                break;
            }
 
            case DateType::QUARTER :
            {
                $quarter = $source[$fieldId . "_quarter"];
                $year = $source[$fieldId . "_year"];
 
                if (!empty($quarter) && !empty($year))
                {
                    $dateTime = new Filter\DateTime(MakeTimeStamp(Quarter::getStartDate($quarter, $year)));
 
                    $result[$fieldId . "_datesel"] = DateType::QUARTER;
                    $result[$fieldId . "_quarter"] = $dateTime->quarter();
                    $result[$fieldId . "_year"] = $dateTime->year();
                    $result[$fieldId . "_month"] = $dateTime->month();
                    $result[$fieldId . "_from"] = $dateTime->quarterStart();
                    $result[$fieldId . "_to"] = $dateTime->quarterEnd();
                }
 
                break;
            }
 
            case DateType::YEAR :
            {
                $year = $source[$fieldId . "_year"];
 
                if (!empty($year))
                {
                    $dateTime = new Filter\DateTime(mktime(0, 0, 0, 1, 1, $year));
 
                    $result[$fieldId . "_datesel"] = DateType::YEAR;
                    $result[$fieldId . "_year"] = $dateTime->year();
                    $result[$fieldId . "_from"] = $dateTime->toString();
                    $result[$fieldId . "_to"] = $dateTime->offset("1 year - 1 second");
                }
 
                break;
            }
 
            case DateType::EXACT :
            {
                $sourceDate = $source[$fieldId . "_from"];
 
                if (!empty($sourceDate))
                {
                    $date = new Date($sourceDate);
                    $dateTime = new Filter\DateTime(MakeTimeStamp($sourceDate));
 
                    $result[$fieldId . "_datesel"] = DateType::EXACT;
 
                    if ($dateTime->getTimestamp() > $date->getTimestamp())
                    {
                        $result[$fieldId . "_from"] = $dateTime->toString();
                        $result[$fieldId . "_to"] = $dateTime->toString();
                    }
                    else
                    {
                        $result[$fieldId . "_from"] = $dateTime->toString();
                        $result[$fieldId . "_to"] = $dateTime->offset("1 days - 1 second");
                    }
                }
 
                break;
            }
 
            case DateType::LAST_WEEK :
            {
                $dateTime = Filter\DateTimeFactory::createLastWeekMonday();
 
                $result[$fieldId . "_datesel"] = DateType::LAST_WEEK;
                $result[$fieldId . "_from"] = $dateTime->toString();
                $result[$fieldId . "_to"] = $dateTime->offset("7 days - 1 second");
                break;
            }
 
            case DateType::LAST_MONTH :
            {
                $dateTime = Filter\DateTimeFactory::createFirstDayOfLastMonth();
 
                $result[$fieldId . "_datesel"] = DateType::LAST_MONTH;
                $result[$fieldId . "_year"] = $dateTime->year();
                $result[$fieldId . "_month"] = $dateTime->month();
                $result[$fieldId . "_from"] = $dateTime->toString();
                $result[$fieldId . "_to"] = $dateTime->offset("1 month - 1 second");
                break;
            }
 
            case DateType::RANGE :
            {
                $startSourceDate = $source[$fieldId . "_from"];
                $endSourceDate = $source[$fieldId . "_to"];
 
                $result[$fieldId . "_from"] = "";
                $result[$fieldId . "_to"] = "";
 
                if (!empty($startSourceDate))
                {
                    $startDateTime = new Filter\DateTime(MakeTimeStamp($startSourceDate));
 
                    $result[$fieldId . "_datesel"] = DateType::RANGE;
                    $result[$fieldId . "_from"] = $startDateTime->toString();
                }
 
                if (!empty($endSourceDate))
                {
                    $endDate = Date::createFromTimestamp(MakeTimeStamp($endSourceDate));
                    $endDateTime = new Filter\DateTime(MakeTimeStamp($endSourceDate));
 
                    $result[$fieldId . "_datesel"] = DateType::RANGE;
 
                    if ($endDateTime->getTimestamp() > $endDate->getTimestamp())
                    {
                        $result[$fieldId . "_to"] = $endDateTime->toString();
                    }
                    else
                    {
                        $result[$fieldId . "_to"] = $endDateTime->offset("1 days - 1 second");
                    }
                }
 
                break;
            }
        }
    }

    public function reset()
    {
        $storage = $this->getStorage();
        $storage[$this->id] = null;
    }

    public function destroy()
    {
        $filterId = $this->getId();
 
        \CUserOptions::deleteOption("main.ui.filter", $filterId);
        \CUserOptions::deleteOption("main.ui.filter.presets", $filterId);
 
        $storage = $this->getStorage();
        unset($storage[$filterId]);
    }
 
    public static function getRowsFromFields($fields = [])
    {
        $rows = [];
 
        foreach ($fields as $key => $field)
        {
            $rows[] = str_replace(
                [
                    "_datesel",
                    "_numsel",
                    "_from",
                    "_to",
                    "_days",
                    "_month",
                    "_quarter",
                    "_id",
                    "_year",
                    "_name",
                    "_label",
                    "_value",
                    "_days",
                    "_months",
                    "_years",
                    "_isEmpty",
                    "_hasAnyValue",
                ],
                "",
                $key
            );
        }
 
        return array_unique($rows);
    }

    public static function fetchPresetFields($preset)
    {
        if (isset($preset["filter_rows"]) && is_string($preset["filter_rows"]))
        {
            $fields = explode(",", $preset["filter_rows"]);
            return array_unique($fields);
        }
 
        return static::getRowsFromFields($preset["fields"]);
    }

    public function getUsedFields()
    {
        $fields = [];
 
        // Fetch fields from user presets
        foreach ($this->getPresets() as $preset)
        {
            $presetFields = static::fetchPresetFields($preset);
            $fields = array_merge($fields, $presetFields);
        }
 
        $defaultPresetFieldsOrder = [];
        // Fetch fields from default presets
        foreach ($this->getDefaultPresets() as $preset)
        {
            $presetFields = static::fetchPresetFields($preset);
            $fields = array_merge($fields, $presetFields);
            if (isset($preset['default']))
            {
                $defaultPresetFieldsOrder = $presetFields;
            }
        }
 
        $fields = array_unique($fields);
 
        if (!empty($defaultPresetFieldsOrder))
        {
            // fields order should be defined by default filter preset
            $fields = array_unique(array_merge($defaultPresetFieldsOrder, $fields));
        }
 
        return $fields;
    }

    public function getCurrentFilterPresetId(): ?string
    {
        return $this->currentFilterPresetId;
    }

    public function setCurrentFilterPresetId(?string $presetId): Options
    {
        $this->currentFilterPresetId = $presetId;
        return $this;
    }
}