Ego_Search.php

gehe zur Dokumentation dieser Datei

<?php
abstract class Ego_Search
{
    protected $config = [];

    abstract function delete( $index );

    abstract function reset();

    abstract function update($index, $page);

    abstract function search($search, $relation, $query);

    protected $extraQuery = '';

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

        $pages = array();
        if (empty($sites)) {
            $sites = Ego_System::getAllSites();
        }
        foreach ($sites as $site) {
            if (is_string($site)) {
                $site = new Site($site);
            }
            try {
                $lang = $_REQUEST['lang'] ? $_REQUEST['lang'] : ($GLOBALS['site'] ? $GLOBALS['site']->language : null);
                if ($lang) {
                    $site->setLanguage($lang);
                }
            } catch (Exception $e) {
                // Mandant existiert nicht in dieser Sprache, ignorieren
                continue;
            }
            foreach ($site->getPages($query, array_merge($param, array('fulltext' => $search, 'filter' => $filter))) as $page) {
                $pages[] = $page;
            }
        }
        return $this->sortPages($pages, $query['order'], $sort);
    }

    protected function sortPages($pages, $order = '', $sort = array()) {
        if (!empty($order) && preg_match('/^([^ ]+) ?(asc|desc)?/i', $order, $match)) {
            return Ego_System::sortPages($pages, 'field', $match[1], $match[2] ? strtolower($match[2]) : 'asc');
        } elseif (!empty($sort)) {
            return Ego_System::sortPages($pages, $sort[0], $sort[1], $sort[2]);
        }
        return Ego_System::sortPages($pages, 'field', 'score', 'desc');
    }

    protected function _getContent($page, $k) {
        switch ($k) {
            // Schlagwörter
            case 'keywords':
                $content = str_replace(',', ' ', $page->getKeywords($page->getSite()->language, true));
                if ($page->getSite()->admin['keyword_register_own_site']) {
                    $keyword_parents = $page->getParents(array(
                        'fields'    => 'name,extra',
                        'where'     => "type='_keywords/entry'"
                    ),array(
                        'auth_or'   => "1=1"
                    ));
                    foreach ($keyword_parents as $keyword) {
                        $content .= ' '.$keyword->field['name'];

                        // Synonyme
                        require_once 'base/Ego_Combo.php';
                        $combo = new Ego_Combo($keyword->extra['synonym']);
                        foreach ($combo->getText() as $text) {
                            $content .= ' '.$text;
                        }
                    }
                }
                break;

            // Page Extra
            case 'extra':
                $extra = Ego_System::arrayValuesRecursive($this->filterExtra($page)); // Keine Schlüssel in den Suchindex aufnehmen.
                $content = implode(' ', $extra);
                break;

            // Page Felder
            default:
                $content = $page->field[$k];
        }

        return $this->filterContent($content, $k);
    }

    protected function _getExtra($page, $clean = false) {
        return Ego_System::arrayFlatRecursive($this->filterExtra($page), function($content) use ($clean) {
            // Werte aus dem Extrafeld entfernen, die nicht gefunden werden sollen
            if ($clean) {
                // Keine 0 und 1
                $content = preg_replace('/(?<!\d)(0|1)(?!\d)/', '', $content);
            }
            return $this->filterContent($content);
        });
    }

    public function filterContent($content, $k = 'extra') {
        if (
            in_array($k, array('short', 'content', 'extra'))
            && is_string($content) // Falls doch Objekte im Extrafeld gelandet sind.
            && preg_match_all('/(title|alt)=(["\'])(.*?)\\2/ims', $content, $matches)
        ) {
            // Bestimmte HTML Attribute beibehalten
            foreach ($matches[3] as $match) {
                $content .= " $match";
            }
        }

        $content = preg_replace('/<[^>]*>/', ' ', $content);
        $content = preg_replace('/&[^ ;]+;/', ' ', $content);
        $content = preg_replace('/\s+/', ' ', $content);
        $content = strtr($content, "\"\n\r\t", '    ');
        return trim($content);
    }

    public function filterExtra($page) {
        $extra = $page->extra;
        if (!is_array($extra)) { // Vor der Verwendung sicherstellen, dass es sich auch um ein Array handelt
            $extra = array();
        } else {
            unset(
                $extra['history'],
                $extra['language_link'],
                $extra['language_standard'],
                $extra['origImgWidth'],
                $extra['origImgHeight'],
                $extra['origFileSize'],
                $extra['clones'],
                $extra['clone_original'],
                $extra['_blocks'],
                $extra['_layout'],
                $extra['_forms'],
                $extra['_template'],
                $extra['_style'],
                $extra['mediapool']
            );
            $site = $page->getSite();
            if ($file = $site->getSiteFile('admin/search_index.php')) {
                require_once($file);
                $extra = search_index($page, $extra);
            }
        }
        return $extra;
    }

    public function setExtraQuery($query, $bind = array()) {
        // SQL Query generieren
        $sql_query = $query;
        foreach (preg_split('/(and|or)/si', $query) as $sub_query) {
            if (preg_match('/(!?extra\.[^ ]+)(\s*(!=|=)\s*(.*?))?$/si', trim($sub_query, '() '), $matches)) {
                $param = $matches[1];
                if (!in_array($GLOBALS['egotec_conf']['search_engine'], ['lucene', 'elastic'])) {
                    $param = substr($param, 6);
                }
                $operator = mb_strtolower($matches[3]);
                $value = trim($matches[4], '\'"');
                if (is_numeric($value)) {
                    $value = (int) $value;
                }

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

                // Für die Extra Suche mit den SQL Treibern gibt es keine Binds
                if (is_array($bind) && strpos($value, ':') === 0 && isset($bind[substr($value, 1)])) {
                    $value = $bind[substr($value, 1)];
                }

                if ($exclude) {
                    // Ausnahme bilden
                    $replace = "extra NOT LIKE '%s:" . strlen($param) . ":" . $param . ";%'";
                } else {
                    // SQL Syntax schreiben
                    $replace = "extra ";
                    if (is_string($value)) {
                        $value = "'%s:" . strlen($param) . ":\"" . $param . "\";s:" . strlen($value) . ":\"" . $value . "\"%'";
                    } else {
                        $value = "'%s:" . strlen($param) . ":\"" . $param . "\";_:" . $value . "%'";
                    }

                    // Vergleich bilden
                    switch ($operator) {
                        case '=':
                            $replace .= "LIKE $value";
                            break;
                        case '!=':
                            $replace .= "NOT LIKE $value";
                            break;
                        default:
                            $replace .= "LIKE $value";
                    }
                }

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

        $this->extraQuery = $sql_query;
    }

    protected function prepareSearch($search, $filter = '', $original = false, $fuzzy = false) {
        $search = mb_strtolower(trim($search));
        foreach (array('+', '-', '~', '&') as $char) {
            // Diese Zeichen dürfen nicht mehrmals nacheinander vorkommen
            $search = preg_replace('/[' . $char . ']{2,}/', $char, $search);
        }
        // Andere Lucene Query Zeichen escapen
        $search = preg_replace('%([\|!(){}[\]^*?:/]+)%', '\\\\$1', $search);

        // Hotfix: Punkt am Ende funktioniert nicht
        $search = rtrim($search, '.');

        $search_asterix = ''; // Die Suche mit * erweitern
        $search_fuzzy = ''; // Die Suche mit ~ erweitern
        $in_string = '';
        $in_word = '';
        $in_fuzzy = '';

        // Fuzzy Einstellung setzen
        $fuzzy_num = '';
        if ($GLOBALS['egotec_conf']['search']['fuzzy_num']) {
            $fuzzy_num = $GLOBALS['egotec_conf']['search']['fuzzy_num'];
        }

        for ($i = 0; $i < strlen($search); $i++) {
            $character = $search[$i];
            switch ($character) {
                case '"':
                    if ($in_string == '"') {
                        $in_string = '';
                    } else {
                        $in_string = '"';
                    }
                    $search_asterix .= $character;
                    $search_fuzzy .= $character;
                    if (!$in_string) {
                        $search_fuzzy .= '~' . $fuzzy_num;
                    }
                    $in_word = '';
                    break;
                case ' ':
                    if (
                        !$in_string
                        && !$in_fuzzy
                        && !in_array(substr($search_asterix, -1), array('"', '*'))
                    ) {
                        $search_asterix .= '*';
                        $search_fuzzy .= '~' . $fuzzy_num;
                    }
                    $search_asterix .= $character;
                    $search_fuzzy .= $character;
                    $in_word = $in_fuzzy = '';
                    break;
                case '-':
                    // Suche mit Bindestrichen ermöglichen
                    if ($search_asterix != '' && substr($search_asterix, -1) != ' ') {
                        $search_asterix .= ' '; // @TODO Workaround, nicht die Lösung.
                    } else {
                        $search_asterix .= $character;
                    }
                    break;
                case '~':
                    // Suche mit Tilde (Fuzzy Search)
                    $search_asterix = substr_replace($search_asterix, '', strrpos($search_asterix, '*'), 1);
                    $search_asterix .= $character;
                    $search_fuzzy .= $character;
                    $in_fuzzy = $character;
                    break;
                default:
                    if ($this->config['leading_wildcard'] && !$in_word) {
                        // Asterix vor einem Wort
                        if (!$in_string && !in_array($character, array('+', '-', '*')) && $search_asterix[strlen($search_asterix) - 1] != '-') {
                            $search_asterix .= '*';
                        }
                        $in_word = $character;
                    }
                    $search_asterix .= $character;
                    $search_fuzzy .= $character;
            }
        }
        if ($character != '"' && !$in_fuzzy) {
            if ($character != '*') {
                // Am Ende noch einen Asterix hinzufügen
                $search_asterix .= '*';
            }
            if ($search_asterix != '*' && $character != '~') {
                // Am Ende noch eine Tilde hinzufügen
                $search_fuzzy .= '~' . $fuzzy_num;
            }
        }

        $search_string = $search_asterix;
        if ($fuzzy) {
            $search_string .= " $search_fuzzy";
        }

        if (!$original) {
            // Lucene Filter hinzufügen
            if (is_string($filter) && !empty($filter)) {
                if ($search_string == '*') {
                    $search_string = $filter;
                } else {
                    $search_string = "($search_string) AND ($filter)";
                }
            }

            // Zusätzlicher Query für die Extra Suche
            if (!empty($this->extraQuery)) {
                if ($search_string == '*') {
                    $search_string = $this->extraQuery;
                } else {
                    $search_string = "($search_string) AND ({$this->extraQuery})";
                }
            }

            // Ausrufezeichen maskieren
            $search_string = str_replace('!', '\!', $search_string);
        }

        return $search_string;
    }

    function clearCache() {
        return;
    }

    protected function checkSearch($search) {
        $maxlength = $GLOBALS['egotec_conf']['search']['maxlength']
            ? $GLOBALS['egotec_conf']['search']['maxlength']
            : 200;
        if (mb_strlen($search) > $maxlength) {
            Ego_System::header(400);
            exit;
        }
    }
}