Ego_Search_Elastic.php

gehe zur Dokumentation dieser Datei

<?php 
require_once('base/Ego_Search.php');
require_once('composer/vendor/autoload.php');

class Ego_Search_Elastic extends Ego_Search
{
    private $client = null;

    private $officeImport = false;

    private const MAX_CLAUSE_COUNT = 10000;

    public function optimize() {
        // no function
    }

    public function __construct($table = '', $param = []) {
        if (!Ego_System::checkLicence($GLOBALS['egotec_conf']['lib_dir'] . 'elastic')) {
            throw new Exception("missing licence");
        }

        $this->officeImport = Ego_System::checkLicence($GLOBALS['egotec_conf']['lib_dir'] . 'office');

        $this->config = [
            'index' => '', // Pfad für den Index (demo_de / wiki_de / multimedia_de)
            'type' => 'content', //  je INDEX ist nur ein type erlaubt, siehe https://www.elastic.co/guide/en/elasticsearch/reference/6.0/removal-of-types.html
            'leading_wildcard' => true
        ];

        if (empty($table)) {
            $table = $GLOBALS['site']->pageTable;
        }

        if (!$GLOBALS['egotec_conf']['elastic']['max_results']) {
            $GLOBALS['egotec_conf']['elastic']['max_results'] = 10000;
        }

        // examples host
        // https://username:password@foo.com:9200/
        // http://foo.com:9200/

        $hosts = [];
        for ($i = 0; $i < 4; $i++) {
            if ($GLOBALS['egotec_conf']['elastic']['host' . $i]) {
                $hosts[] = trim($GLOBALS['egotec_conf']['elastic']['host' . $i], '/');
            }
        }

        if (empty($hosts)) {
            throw new Exception("missing hosts for elastic");
        }

        $this->client = Elasticsearch\ClientBuilder::create()->setHosts($hosts)->build();

        $this->config['index'] = strtolower($table);
        $this->config['table'] = $table;
        $this->config['param'] = $param;

        $this->indexCreate();
        $this->createPipeline();
    }

    public function delete($id) {
        $params = [
            'index' => $this->config['index'],
            'type' => $this->config['type'],
            'id' => $id
        ];

        $this->client->delete($params);

        return true;
    }

    public function reset() {
        $GLOBALS['monitor']['search_reset']++;

        $this->indexDelete(false);
        $this->indexCreate();

        return true;
    }


    public function resetAll() {
        $GLOBALS['monitor']['search_reset_all']++;

        $this->indexDelete(true);

        return true;
    }

    public function indexCreate() {
        $params = [
            'index' => $this->config['index']
        ];

        if (!$this->client->indices()->exists($params)) {
            $params = [
                'index' => $this->config['index'],
                'body' => [
                    'settings' => [
                        'number_of_shards' => $GLOBALS['egotec_conf']['elastic']['number_of_shards'],
                        'number_of_replicas' => $GLOBALS['egotec_conf']['elastic']['number_of_replicas'],
                        'index.mapping.ignore_malformed' => true,
                        'index.mapping.total_fields.limit' => self::MAX_CLAUSE_COUNT
                    ],
                    'mappings' => [
                        $this->config['type'] => [
                            'properties' => [
                                'suggest' => [
                                    'type' => 'completion'
                                ]
                            ]
                        ]
                    ]
                ]
            ];

            $this->client->indices()->create($params);
        }

        return true;
    }

    public function indexDelete($all) {
        $params = [
            'index' => $all ? "_all" : $this->config['index'],
            'client' => ['ignore' => [400, 404]]
        ];

        if ($this->client->indices()->exists($params)) {
            $this->client->indices()->delete($params);
        }

        return true;
    }

    public function updateBulk($pages) {
        foreach ($pages as $page) {
            $page = $this->indexFiles($page);

            $params['body'][] = [
                'index' => [
                    '_index' => $this->config['index'],
                    '_type' => $this->config['type'],
                    '_id' => $page->field['id']
                ]
            ];

            $params['body'][] = $this->getBody($page);
        }

        $this->client->bulk($params);
    }

    public function update($id, $page, $count = []) {
        $page = $this->indexFiles($page);

        $GLOBALS['monitor']['search_update_count']++;

        $params = [
            'index' => $this->config['index'],
            'type' => $this->config['type'],
            'id' => $id,
            'body' => $this->getBody($page),
            'client' => ['ignore' => 404]
        ];

        $this->client->index($params);

        return true;
    }

    private function getBody($page) {
        // Alle Inhalte aus extra._contents an den Inhalt von field.content hängen
        $extra_contents = is_array($page->extra['_contents'])
            ? implode(
                ' ',
                array_filter(
                    array_map(
                        function ($value) {
                            return trim(strip_tags(implode(' ', $value)));
                        },
                        Ego_System::arrayFlatRecursive(
                            $page->extra['_contents'],
                            function ($value) {
                                if (
                                    preg_match('/^(index\.php\?|https?:\/\/|[^@ ]+@[^ ]+|\d{4}-\d{2}-\d{2}|\d{2}:\d{2}:?)/si', $value) // Keine URLs, E-Mail und Datum/Uhrzeit
                                    || preg_match('/^\{.*?\}$/si', $value) // Kein JSON
                                ) {
                                    $value = '';
                                } else {
                                    // Zeilenumbrüche umwandeln
                                    $value = preg_replace('/(\r\n|\r|\n)/s', ' ', $value);
                                }
                                return $value;
                            }
                        )
                    )
                )
            )
            : '';

        // Blöcke aus dem Extrafeld nicht doppelt in die Suche übernehmen
        $extra = $this->_getExtra($page);
        unset($page->extra['_contents']);
        $extra_values = $this->_getExtra($page, true);

        $keywords = $this->_getContent($page, 'keywords');
        $name = $this->_getContent($page, 'name');
        $title = $this->_getContent($page, 'title');
        $short = $this->_getContent($page, 'short');
        $content = trim(
            preg_replace( // Mehrfache Leerzeichen entfernen
                '/\s{2,}?/ms',
                ' ',
                $this->_getContent($page, 'content') . ($extra_contents ? ' ' . $extra_contents : '')
            )
        );

        $suggestions = array_values(
            array_unique(
                array_filter(
                    array_map(
                        function ($value) {
                            return preg_replace('/\W/', '', $value);
                        },
                        explode(
                            ' ',
                            mb_strtolower(
                                html_entity_decode(
                                    implode(
                                        ' ',
                                        [$keywords, $name, $title, $short, $content]
                                    )
                                )
                            )
                        )
                    ),
                    function ($value) {
                        return !is_numeric($value) && strlen($value) > 2;
                    }
                )
            )
        );

        return [
            'keywords' => $keywords,
            'url' => $this->_getContent($page, 'url'),
            'name' => $name,
            'title' => $title,
            'short' => $short,
            'content' => $content,
            'extra' => $extra,
            'extra_values' => trim(
                implode(
                    ' ',
                    array_values(
                        array_map(
                            function ($value) {
                                return implode(' ', $value);
                            },
                            $extra_values
                        )
                    )
                )
            ),
            'type' => $page->field['type'],
            // 'nav_hide' => (int)$page->field['nav_hide'],
            'ignore_search' => (($page->field['nav_hide'] & 4) == 4) ? 1 : 0,
            'inactive' => (int)$page->field['inactive'],
            'deleted' => (int)$page->field['deleted'],
            'suggest' => [
                'input' => $suggestions
            ]];
    }

    private function getSearchParam($tables, $search, $filter, $fuzzy, $id_list = []) {
        $fields = ['keywords', 'url', 'name', 'title', 'short', 'content', 'extra_values'];

        // Verwendete "rewrite" Einstellung
        $rewrite = 'top_terms_' . self::MAX_CLAUSE_COUNT;

        // Immer alles klein verwenden: Elastic startet eine Case Sensitive Suche, wenn ein Großbuchstabe im Suchbegriff vorkommt
        $search = trim(mb_strtolower($search));

        // Suchbegriff automatisch korrigieren
        $search = trim(preg_replace([
            '/[+-?*]( |$)/',
            '/(^| )\{(.*?)\}/'
        ], [
            ' ',
            '\\1\\2'
        ], $search));

        // Suchbegriffe mit Bindestrich automatisch um die einzelnen Begriffe erweitern (diese werden sonst nicht gefunden)
        if (preg_match_all('/( |^)([^+-][^ "]+-[^ "]+)/is', $search, $matches)) {
            foreach ($matches[2] as $word) {
                $search .= ' ' . str_replace('-', ' ', $word);
            }
        }

        // Suchrelevanz für Ein-Mandanten-Suche hinzufügen
        $count = [];
        if ($tables === null) {
            try {
                list($name, $lang) = preg_split('/_(?=[^_]*$)/', $this->config['table']);
                $site = new Site($name, $lang);
                $count = $site->getSearchCount();
            } catch (Site_Exception $e) {
                // ignorieren
            }
        }

        $must = [];
        $must_not = [];
        $should = [];
        $must_should = [];

        if (preg_match_all('/(".*?"|[^ ]+)/is', $search, $matches)) {
            // Zusätzliche Phrasen-Suche ausführen
            $match_phrase = sizeof($matches[0]) > 1 && !preg_match('/(^| )["*+-]/', $search);

            foreach ($fields as $field) {
                $boost = 1;
                if ($field == 'extra_values' && isset($count['extra'])) {
                    $boost = (int)$count['extra'];
                } elseif (isset($count[$field])) {
                    $boost = (int)$count[$field];
                }

                foreach ($matches[0] as $query) {
                    // Hotfix: Enthält der Suchbegriff ein "-", muss dieser eine exakte Suche auslösen
                    if (!in_array($query[0], ['"', '-']) && strpos($query, '-') !== false) {
                        $query = "\"$query\"";
                    }

                    if ($query[0] == '"') {
                        // Phrase
                        $query = trim($query, '"');
                        $should[] = [
                            'match_phrase' => [
                                $field => [
                                    'query' => $query,
                                    'boost' => $boost
                                ]
                            ]
                        ];
                    } else {
                        if ($fuzzy) {
                            // Fuzzy
                            $should[] = [
                                'fuzzy' => [
                                    $field => [
                                        'value' => $query,
                                        'rewrite' => $rewrite,
                                        'boost' => $boost
                                    ]
                                ]
                            ];
                        } elseif (preg_match('/^(.*?)~([0-9.]+|)$/', $query, $match)) {
                            // Fuzzy für diesen Suchbegriff
                            $query = $match[1];
                            $fuzziness = floatval($match[2] !== '' ? $match[2] : 1);

                            $should[] = [
                                'fuzzy' => [
                                    $field => [
                                        'value' => $query,
                                        'rewrite' => $rewrite,
                                        'boost' => $boost,
                                        'fuzziness' => round(2 * $fuzziness)
                                    ]
                                ]
                            ];
                        } else {
                            // Wildcard
                            $wildcard = function ($query) {
                                if (strpos($query, '*') === false) {
                                    $query = "*$query*";
                                }
                                return $query;
                            };

                            switch ($query[0]) {
                                case '+':
                                    $query = ltrim($query, '+');
                                    $must_should[md5($query)][] = [
                                        'wildcard' => [
                                            $field => [
                                                'value' => $wildcard($query),
                                                'rewrite' => $rewrite,
                                                'boost' => $boost
                                            ]
                                        ]
                                    ];
                                    break;
                                case '-':
                                    $query = ltrim($query, '-');
                                    $must_not[] = [
                                        'wildcard' => [
                                            $field => [
                                                'value' => $wildcard($query),
                                                'rewrite' => $rewrite,
                                                'boost' => $boost
                                            ]
                                        ]
                                    ];
                                    break;
                                default:
                                    $should[] = [
                                        'wildcard' => [
                                            $field => [
                                                'value' => $wildcard($query),
                                                'rewrite' => $rewrite,
                                                'boost' => $boost
                                            ]
                                        ]
                                    ];
                            }
                        }
                    }
                }

                // Ein Suchbegriff mit mehreren Wörtern erzeugt gleichzeitig auch eine bevorzugte Phrasen-Suche
                if ($match_phrase) {
                    $should[] = [
                        'match_phrase' => [
                            $field => [
                                'query' => trim($search),
                                'boost' => $boost + 1
                            ]
                        ]
                    ];
                }
            }
        }

        $minimum_should_match = $search == '' && (!empty($filter) || !empty($this->extraQuery)) ? 0 : 1;

        if (sizeof($must_should)) {
            $minimum_should_match = 0;

            foreach ($must_should as $items) {
                $must[] = [
                    'bool' => [
                        'should' => $items,
                        'minimum_should_match' => 1
                    ]
                ];
            }
        }

        if ($this->config['param']['only_active']) {
            $must[] = [
                'match' => [
                    'inactive' => 0
                ]
            ];
        }
        if (!$this->config['param']['deleted'] && !$this->conig['param']['deleted_or']) {
            $must[] = [
                'match' => [
                    'deleted' => 0
                ]
            ];
        }
        if ($this->config['param']['search']) {
            $must[] = [
                'match' => [
                    'ignore_search' => 0
                ]
            ];
        }

        // Nur Treffer in einer ID Liste ermitteln
        if (!empty($id_list)) {
            $must[] = [
                'constant_score' => [
                    'filter' => [
                        'terms' => [
                            '_id' => $id_list
                        ]
                    ]
                ]
            ];
        }

        // Limit ermitteln (standardmäßig werden alle Ergebnisse zurückgegeben)
        $from = 0;
        $size = (int) $GLOBALS['egotec_conf']['elastic']['max_results'];

        // Extra-Suche hinzufügen
        if (!empty($this->extraQuery)) {
            $must[] = [
                'query_string' => [
                    'query' => $this->extraQuery
                ]
            ];
        }

        // Filter ermitteln
        if (!empty($filter)) {
            if ($search == '') {
                /* Ohne Suchbegriff liefert die Suche keine Ergebnisse.
                 * Der Filter wird dann zum Suchkriterium. */
                $must[] = [
                    'query_string' => [
                        'query' => $filter
                    ]
                ];
                $filter = [];
            } else {
                $filter = [
                    'query_string' => [
                        'query' => $filter
                    ]
                ];
            }
        } else {
            $filter = [];
        }

        return [
            'index' => $tables ? $tables : $this->config['index'],
            // KEINE Inhalte zurückliefern
            '_source' => false,
            'type' => $this->config['type'],
            'sort' => ['_score'], // The order defaults to desc when sorting on the _score, and defaults to asc when sorting on anything else.
            'body' => [
                'from' => $from,
                'size' => $size,
                'query' => [
                    'bool' => [
                        'must' => $must,
                        'must_not' => $must_not,
                        'should' => $should,
                        'filter' => $filter,
                        'minimum_should_match' => $minimum_should_match
                    ]
                ]
            ]
        ];
    }

    private function createPipeline() {
        if ($this->officeImport) {
            $params = [
                'id' => 'attachment',
                'body' => [
                    'description' => 'Extract attachment information',
                    'processors' => [
                        [
                            'attachment' => [
                                'field' => 'base64',
                                'indexed_chars' => -1
                            ]
                        ]
                    ]
                ]
            ];

            $this->client->ingest()->putPipeline($params);
        }
    }

    private function indexFile(Page $page, $path) {
        if (!Ego_System::file_exists($path)) {
            return null;
        }

        @ini_set("memory_limit", "-1");

        $pageTable = strtolower($page->getSite()->pageTable);
        $identity = $page->getIdentity();

        $params = [
            'index' => $pageTable,
            'type' => $this->config['type'],
            'id' => $identity,
            'pipeline' => 'attachment',
            'body' => [
                'base64' => base64_encode(Ego_System::file_get_contents($path, false))
            ]
        ];
        $result = $this->client->index($params);

        if ($result) {
            $content = $this->getIndexFile($pageTable, $identity);
            $this->delete($identity);

            return $content;
        }

        return null;
    }

    private function getIndexFile($pageTable, $identity) {
        $params = [
            'index' => strtolower($pageTable),
            'type' => $this->config['type'],
            'id' => $identity
        ];

        $response = $this->client->get($params);
        return $response['_source']['attachment']['content'];
    }

    private function indexFiles(Page $page) {
        if (!$this->officeImport) {
            return $page;
        }

        if (
            $page->field['type'] == 'multimedia/file'
            && !$page->extra['_indexed']
        ) {
            if (!preg_match('/(image|video|audio|zip|exe|rar|octet-stream|postscript)/is', $page->extra['mime_type'])) {
                $page->extra['_indexed'] = true;
                try {
                    $content = $this->indexFile($page, $GLOBALS['egotec_conf']['var_dir'] . 'media/' . $page->getSite()->name . '/' . $page->getMediaFilename());
                    $page->field['content'] = Ego_System::filterNonUtf8($content, '', true);
                } catch (Exception $e) {
                    // Datei kann nicht indiziert werden
                    if (
                        strpos($e->getMessage(), 'EncryptedDocumentException') === false
                        && strpos($e->getMessage(), 'TikaException') === false
                    ) {
                        egotec_error_log($page->getIdentity() . " Fehler beim Indizieren: " . $page->extra['mime_type'] . "\n" .  $e->getMessage());
                    }
                }

                $page->update([], true, true);
            }
        }
        //else {
        // TODO MediaPool nun auch indezieren?
        /*foreach ($page->getMediapool() as $file) {
            if (!$file['isImage']) {
                $content = $this->indexFile($page, $file['file']);
            }
        }*/
        //}

        return $page;
    }

    public function search($search, $relation, $query, $filter = '', $fuzzy = false) {
        $this->checkSearch($search);

        $GLOBALS['monitor']['search_count']++;
        $GLOBALS['monitor']['search_length'] += mb_strlen($search);
        $GLOBALS['monitor']['search_words'] += substr_count($search, ' ') + 1;

        $params = $this->getSearchParam(null, $search, $filter, $fuzzy, $query['id_list']);

        $start = microtime(true);
        try {
            $results = $this->client->search($params);
        } catch (Exception $e) {
            $this->error($e);
        }

        $hits = $results["hits"]["hits"];
        $stop = microtime(true);

        $duration = (int)(($stop - $start) * 1000);
        $GLOBALS['monitor']['search_duration'] += $duration;

        if (empty($hits)) {
            unset($query['order']);
            unset($query['limit']);
            $query['where'] = '1=0';
            return $query;
        }

        $ids = [];

        foreach ($hits as $key => $value) {
            $ids[$value["_id"]] = $value["_score"];
        }

        $max_value = $results["hits"]["max_score"];
        $min_value = min(array_values($ids));

        if ($max_value == $min_value) {
            $multiply = 4 / $max_value;
            $min_value = 0;
        } else {
            $multiply = 4 / ($max_value - $min_value);
        }

        return $this->buildQuery($ids, $relation, $query, $min_value, $multiply);
    }

    public function globalSearch($search, $sites = [], $query = [], $param = [], $sort = [], $filter = '') {
        $this->checkSearch($search);

        $start1 = microtime(true);
        $GLOBALS['monitor']['search_global_count']++;
        $GLOBALS['monitor']['search_global_length'] += mb_strlen($search);
        $GLOBALS['monitor']['search_global_words'] += substr_count($search, ' ') + 1;

        // Standardmäßig im Frontend nur Seiten anzeigen, die auch von der Suche gefunden werden dürfen
        if (!isset($param['search']) && empty($GLOBALS['admin_area'])) {
            $param['search'] = true;
        }

        // Betroffene Tabellen ermitteln
        $lang = $_REQUEST['lang'] ? $_REQUEST['lang'] : ($GLOBALS['site'] ? $GLOBALS['site']->language : null);
        $relations = [];
        if (empty($sites)) {
            // keine bestimmten Mandanten, also alle durchsuchen
            $sites = Ego_System::getAllSites();
        }
        $tables = $this->getTables($sites, $lang, $relations);

        // Suche durchführen
        $start2 = microtime(true);
        $params = $this->getSearchParam($tables, $search, $filter, (bool)$param['fuzzy']);
        try {
            $results = $this->client->search($params);
        } catch (Exception $e) {
            $this->error($e);
        }
        $stop2 = microtime(true);
        $duration = (int)(($stop2 - $start2) * 1000);
        $GLOBALS['monitor']['search_global_d2'] += $duration;

        $hits = $results["hits"]["hits"];

        if (empty($hits)) {
            return [];
        }

        $min_value = PHP_INT_MAX;

        $sorted_hits = [];
        foreach ($hits as $hit) {
            if (!isset($sorted_hits[$hit['_index']])) {
                $sorted_hits[$hit['_index']] = [];
            }
            $sorted_hits[$hit['_index']][$hit['_id']] = $hit['_score'];
            if ($hit['_score'] < $min_value) {
                $min_value = $hit['_score'];
            }
        }

        $max_value = $results["hits"]["max_score"];

        if ($max_value == $min_value) {
            $multiply = 4 / $max_value;
            $min_value = 0;
        } else {
            $multiply = 4 / ($max_value - $min_value);
        }

        // Treffer sammeln und sortiert zurückliefern
        $pages = [];
        foreach ($sorted_hits as $table => $ids) {
            $site = $relations[$table];
            foreach ($site->getPages($this->buildQuery($ids, $site->pageTable . '.id', $query, $min_value, $multiply), $param) as $page) {
                $pages[] = $page;
            }
        }
        $pages = $this->sortPages($pages, $query['order'], $sort);

        $stop1 = microtime(true);
        $duration = (int)(($stop1 - $start1) * 1000);
        $GLOBALS['monitor']['search_global_d1'] += $duration;

        return $pages;
    }

    public function getSuggestions($query, $sites = [], $max = 5) {
        $tables = $this->config['index'];
        if (!empty($sites)) {
            $tables = $this->getTables($sites);
        }
        try {
            $results = $this->client->search([
                'index' => $tables,
                // KEINE Inhalte zurückliefern
                '_source' => false,
                'type' => $this->config['type'],
                'size' => $max,
                'sort' => ['_score'], // The order defaults to desc when sorting on the _score, and defaults to asc when sorting on anything else.
                'body' => [
                    'suggest' => [
                        'suggest' => [
                            'prefix' => $query,
                            'completion' => [
                                'field' => 'suggest',
                                'skip_duplicates' => true
                            ]
                        ]
                    ]
                ]
            ]);
        } catch (Exception $e) {
            $this->error($e);
        }

        $suggestions = [];
        if (is_array($results['suggest']['suggest'][0]['options'])) {
            foreach ($results['suggest']['suggest'][0]['options'] as $result) {
                if (mb_strtolower($query) != mb_strtolower($result['text'])) {
                    $suggestions[] = $result['text'];
                }
            }
        }

        return $suggestions;
    }

    private function buildQuery($result, $relation, $query, $min_value, $multiply) {
        if (!empty($result)) {
            $ids = array_keys($result);
            if (empty($query['where'])) {
                $query['where'] = '';
            } else {
                $query['where'] .= ' AND ';
            }

            // Für Oracle splitten: maximal 1000 pro Liste
            $id_groups = [];
            foreach (array_chunk($ids, 999) as $id_group) {
                $id_groups[] = "$relation IN (" . implode(', ', $id_group) . ")";
            }
            $query['where'] .= '(' . implode(' OR ', $id_groups) . ')';

            $query['fields2'] = 'CASE ';
            foreach ($result as $id => $value) {
                $query['fields2'] .= "WHEN $relation = $id THEN " . (str_replace(',', '.', ($value - $min_value) * $multiply)) . " ";
            }
            $query['fields2'] .= 'ELSE 0 END AS score';
            if (empty($query['order'])) {
                $query['order'] = 'score DESC';
            }
        } else { // No result, so construct an query with no results.
            unset($query['order']);
            unset($query['limit']);
            $query['where'] = '1=0';
        }
        return $query;
    }

    public function setExtraQuery($query, $bind = []) {
        // Binds anwenden
        if (is_array($bind)) {
            // Zeichen, die von Elastic verwendet werden: + - && || ! ( ) { } [ ] ^ " ~ * ? : \ /
            $reserved_characters = preg_quote('+-&|!(){}[]^"~*?:\\');
            foreach ($bind as $key => $value) {
                $query = str_replace(
                    ":$key",
                    preg_replace_callback(
                        '/[' . $reserved_characters . ']/',
                        function ($matches) {
                            return '\\' . $matches[0];
                        },
                        $value
                    ),
                    $query
                );
            }
        }

        // Elastic Query generieren
        $Elastic_query = $query;
        $sub_queries = preg_split('/\s+(and|or)\s+/si', $query);
        foreach ($sub_queries as $sub_query) {
            if (preg_match('/(!?extra\.[^ !=<>]+)(\s*(like|>=|<=|!=|=|>|<)\s*(.*?))?$/si', trim($sub_query, '() '), $matches)) {
                $param = $matches[1];
                $operator = mb_strtolower($matches[3]);
                $value = trim($matches[4], '\'"');

                // Feld darf nicht im Dokument gesetzt sein
                $exclude = false;
                if ($param[0] == '!') {
                    $exclude = true;
                    $param = substr($param, 1);
                }

                if ($exclude) {
                    // Ausnahme bilden
                    $replace = "-$param:*" . (sizeof($sub_queries) == 1 ? ' AND *' : '');
                } else {
                    // Elastic Syntax schreiben
                    $replace = "$param:";
                    if (!is_numeric($value)) {
                        if ($operator == 'like') {
                            $value = $this->prepareSearch(str_replace('%', '', $value), '', true);
                        } else {
                            $value = "'$value'";
                        }
                    }

                    // Vergleich bilden
                    switch ($operator) {
                        case '=':
                        case 'like':
                            $replace .= $value;
                            break;
                        case '!=':
                            $replace = "($param:* NOT $param:$value)";
                            break;
                        case '>':
                            $replace .= '{' . $value . ' TO *}';
                            break;
                        case '>=':
                            $replace .= '[' . $value . ' TO *]';
                            break;
                        case '<':
                            $replace .= '{* TO ' . $value . '}';
                            break;
                        case '<=':
                            $replace .= '[* TO ' . $value . ']';
                            break;
                        default:
                            $replace .= $value;
                    }
                }

                $Elastic_query = str_replace($matches[0], $replace, $Elastic_query);
            }
        }

        $this->extraQuery = $Elastic_query;
    }

    public function getConfig() {
        return $this->config;
    }

    public function clearCache() {
        foreach ($this->hosts as $host) {
            @file_get_contents($host . '_cache/clear');
        }
    }

    private function getTables($sites, $lang = '', &$relations = []) {
        $tables = '';
        if (!$lang) {
            $lang = $_REQUEST['lang'] ? $_REQUEST['lang'] : ($GLOBALS['site'] ? $GLOBALS['site']->language : null);
        }
        foreach ($sites as $site) {
            try {
                if (is_string($site)) {
                    $site = new Site($site);
                }
                if ($lang) {
                    $site->setLanguage($lang);
                }
            } catch (Exception $e) {
                // Mandant existiert nicht in dieser Sprache, ignorieren
                continue;
            }
            $table = strtolower($site->pageTable);
            $tables = $tables . ',' . $table;
            $relations[$table] = $site;
        }
        return ltrim($tables, ',');
    }

    private function error($e) {
        $response = @json_decode($e->getMessage(), true);
        $messages = [];
        if ($response['error']) {
            if ($response['error']['root_cause']) {
                foreach ($response['error']['root_cause'] as $cause) {
                    $messages[] = $cause['type'] . ' for index ' . $cause['index'];
                }
            }
            if ($response['error']['failed_shards']) {
                foreach ($response['error']['failed_shards'] as $shard) {
                    if (!empty($shard['reason']['caused_by'])) {
                        $messages[] = 'caused by ' . $shard['reason']['caused_by']['type'] . ' (reason: ' . $shard['reason']['caused_by']['reason'] . ')';
                    }
                }
            }
        }
        if (empty($messages)) {
            $messages[] = $e->getMessage();
        }
        egotec_error_log('Elastic Exception thrown (' . get_class($e) . ', Code ' . $e->getCode() . '): ' . implode('; ', $messages));
        Ego_System::header($response['status'] ?? 400);
        exit;
    }
}