Ego_User_Elastic.php

gehe zur Dokumentation dieser Datei

<?php
 
require_once 'base/Ego_Search_Elastic.php';
require_once 'base/Ego_User_Search_Factory.php';
require_once('composer/vendor/autoload.php');
 
class Ego_User_Elastic extends Ego_Search_Elastic {
    public function indexCreate(): bool {
        // Prüfen ob der angegebene Index bereits existiert
        if (!$this->client->indices()->exists(['index' => $this->config['index']])) {
            // Index existiert nicht -> Index erstellen
            $index_params = [
                'index' => $this->config['index'],
                'include_type_name' => true,
                'body' => [
                    'settings' => [
                        'number_of_shards' => $GLOBALS['egotec_conf']['elastic']['number_of_shards'],
                        'number_of_replicas' => $GLOBALS['egotec_conf']['elastic']['number_of_replicas'] ?: 0,
                        'index.mapping.ignore_malformed' => true,
                        'index.mapping.total_fields.limit' => $this->maxClauseCount,
                        'analysis' => [
                            'normalizer' => [
                                'case_insensitive' => [
                                    'filter' => 'lowercase'
                                ]
                            ]
                        ]
                    ],
                    'mappings' => [
                        '_doc' => [
                            'properties' => [
                                'user_id' => ['type' => 'text'],
                                'username' => [
                                    'type' => 'keyword', // Username muss als keyword angelegt werden, damit danach sortiert werden kann
                                    'fields' => [
                                        'keyword' => [
                                            'type' => 'keyword',
                                            'ignore_above' => 256,
                                            'normalizer' => 'case_insensitive'
                                        ]
                                    ]
                                ],
                                'categories' => [
                                    'type' => 'keyword',
                                    'fields' => [
                                        'keyword' => [
                                            'type' => 'keyword',
                                            'ignore_above' => 256,
                                            'normalizer' => 'case_insensitive'
                                        ]
                                    ]
                                ],
                                'username_char' => ['type' => 'keyword'],
                                'release_from' => [
                                    'type' => 'date',
                                    'format' => 'epoch_second'
                                ],
                                'release_until' => [
                                    'type' => 'date',
                                    'format' => 'epoch_second'
                                ],
                                'email' => [
                                    'type' => 'keyword',
                                    'fields' => [
                                        'keyword' => [
                                            'type' => 'keyword',
                                            'ignore_above' => 256,
                                            'normalizer' => 'case_insensitive'
                                        ]
                                    ]
                                ],
                                'anrede' => ['type' => 'text'],
                                'name' => [
                                    'type' => 'keyword',
                                    'fields' => [
                                        'keyword' => [
                                            'type' => 'keyword',
                                            'ignore_above' => 256,
                                            'normalizer' => 'case_insensitive'
                                        ]
                                    ]
                                ],
                                'vorname' => [
                                    'type' => 'keyword',
                                    'fields' => [
                                        'keyword' => [
                                            'type' => 'keyword',
                                            'ignore_above' => 256,
                                            'normalizer' => 'case_insensitive'
                                        ]
                                    ]
                                ],
                                'strasse' => ['type' => 'text'],
                                'plz' => ['type' => 'text'],
                                'ort' => ['type' => 'text'],
                                'land' => ['type' => 'text'],
                                'branche' => ['type' => 'text'],
                                'abteilung' => ['type' =>  'text'],
                                'firma' => ['type' => 'text'],
                                'telefon' => ['type' => 'text'],
                                'mobil' => ['type' => 'text'],
                                'multiple_login' => ['type' => 'integer'],
                                'liveserver' => ['type' => 'integer'],
                                'user_inactive' => ['type' => 'integer'],
                                'user_deleted' => ['type' => 'integer'],
                                'no_admin' => ['type' => 'integer'],
                                'no_singlesignon' => ['type' => 'integer'],
                                'no_relation' => ['type' => 'integer'],
                                'auth_persist_token' => ['type' => 'text'],
                                'auth_persist_expire' => ['type' => 'integer'],
                                'tfa_secret' => ['type' => 'text']
                            ]
                        ]
                    ]
                ]
            ];
 
            // Index anlegen
            try {
                $this->client->indices()->create($index_params);
            } catch (Exception $e) {
                if (strpos($e->getMessage(), 'resource_already_exists_exception') === false) {
                    throw new Exception($e->getMessage(), $e->getCode());
                }
            }
        }
 
        return true;
    }
 
    public function updateUserIndex(string $id, User_SQL $user): bool {
        try {
            $params = [
                'index' => $this->config['index'],
                'id' => $id,
                'body' => $this->getUserBody($user), // Informationen aus dem Benutzer auslesen
                'client' => [
                    'ignore' => 404
                ]
            ];
 
            // Benutzer indizieren
            $this->client->index($params);
        } catch (Exception $e) {
            Ego_Action::add(Ego_Action::USER_UPDATE_INDEX, [
                'id' => $id
            ], $e);
        }
 
        return true;
    }
 
    public function updateUserBulk(User_Iterator $users, bool $verbose = false, $new_line = "\n"): void {
        $max = 500;
        $params = [
            'body' => []
        ];
 
        if ($verbose) {
            Ego_System::flush("Start update for user search index{$new_line}Collect user data to update");
        }
 
        while ($user = $users->nextUser()) {
            $params['body'][] = [
                'index' => [
                    '_index' => $this->config['index'],
                    '_id' => $user->field['user_id']
                ]
            ];
 
            $params['body'][] = $this->getUserBody($user);
 
            if ($verbose) {
                Ego_System::flush('. ');
            }
 
            if (floor(sizeof($params['body']) / 2) == $max) {
                if ($verbose) {
                    Ego_System::flush("updating $max users. . .");
                }
 
                $this->client->bulk($params);
 
                if ($verbose) {
                    Ego_System::flush("done{$new_line}");
                }
 
                $params['body'] = [];
 
                if ($verbose) {
                    Ego_System::flush("Collect user data to update");
                }
            }
        }
 
        if (!empty($params['body'])) {
            $num = floor(sizeof($params['body']) / 2);
 
            if ($verbose) {
                Ego_System::flush("updating " . $num . " users. . .");
            }
 
            $this->client->bulk($params);
 
            if ($verbose) {
                Ego_System::flush("done{$new_line}");
            }
        }
 
        if ($verbose) {
            Ego_System::flush("Update for user search index completed!");
        }
    }
 
    public function searchUsers(array $search, int $limit = -1, string $type = '', bool $checkRights = true, bool $filterSearch = true, bool $sortResult = true, int $from = 0, bool $returnTotal = false, array $sort_order = [], string $rights = ''): array {
        // Sucharray filtern und ungewünschte Werte entfernen
        unset($search['show_norelation']);
 
        /* Alle Suchbegriffe klein übergeben, da diese in Elasticsearch als "keyword" hinterlegt sind,
         * die bei einer Suche immer die Groß- und Kleinschreibung berücksichtigen. Bei der Benutzersuche
         * soll diese aber ignoriert werden. */
        foreach ($search as $key => $value) {
            if (is_string($value)) {
                $search[$key] = mb_strtolower($value);
            }
        }
 
        if ($filterSearch) {
            $search = Ego_User_Search_Factory::filterSearch($search);
        }
 
        // Rückgabe-Array
        $users = [];
 
        if ($type && !Ego_User_Search_Factory::checkSearchFilter($type, $search)) {
            return $returnTotal ? ['users' => [], 'hits' => 0] : [];
        }
 
        // Gruppe/Rolle zum aussortieren nach der Suche
        $group_role = $search['group_role'];
        unset($search['group_role']); // Gruppen/Rollen stehen nicht im index
        unset($search['group_role_tmp']); // Gruppen/Rollen stehen nicht im index
 
        // Elasticsearch Parameter vorbereiten
        $search_params = $this->getSearchParams($search, $group_role ? -1 : $limit, $type, $sortResult, $from, $sort_order);
 
        try {
            // Suche durchführen
            $search_result = $this->client->search($search_params);
        } catch (Exception $e) {
            egotec_error_log('<hr>Uncaught exception: ' . $e->getMessage() . "\n" . $e->getTraceAsString(), -1);
            return $returnTotal ? ['users' => [], 'hits' => 0] : [];
        }
 
        // Wenn überhaupt Ergebnisse gefunden wurden
        if ($search_result) {
            // Jeden gefundenen Benutzer zurückgeben
            $user_ids = [];
            foreach ($search_result['hits']['hits'] as $user) {
                $user_ids[] = $user['_source']['user_id'];
            }
 
            $all_users = new User_Iterator($user_ids);
            $n = 0;
            foreach ($all_users as $user_sql) {
                $group_role_rel = null;
 
                // Kundenspezifische Filter
                if (
                    function_exists('user_search_fields')
                    || Ego_System::file_exists($user_search_fields = ($GLOBALS['egotec_conf']['var_dir'] . 'lib/admin/user_search_fields.php'))
                ) {
                    if (isset($user_search_fields)) {
                        require_once $user_search_fields;
                    }
                    if (function_exists('user_search_fields') && !user_search_fields($user_sql, $search)) {
                        continue;
                    }
                }
 
                // Wenn der Benutzer keine Gruppen/Rollen hat und nach Benutzern mit Backendzugang gesucht wird
                if ($type === 'admin' && empty($group_role_rel = $user_sql->getGroupRoleRelations())) {
                    continue;
                }
 
                $checked_rights = false;
                $checked_group_role = false;
 
                // Rechte prüfen
                if (!$checkRights || Ego_User_Search_Factory::isAcceptedUser($user_sql, $group_role_rel)) {
                    $checked_rights = true;
                }
 
                // Wenn in der Suchmaske eine Gruppe oder Rolle ausgewählt wurde
                if (!$group_role || Ego_User_Search_Factory::checkRightsFilter($group_role, $user_sql, $group_role_rel)) {
                    $checked_group_role = true;
                }
 
                if ($rights !== '') {
                    foreach (explode(';', $rights) as $group_role) {
                        [$group, $role] = explode(',', $group_role);
 
                        if (!$user_sql->hasGroupRoleRelation($group, $role)) {
                            continue 2;
                        }
                    }
                }
 
                if ($checked_rights && $checked_group_role) {
                    if ($group_role) {
                        // Die Paginierung für eine Gruppe/Rolle Suche muss logisch erfolgen
                        $n++;
                        if ($from > 0 && $n <= $from) {
                            continue;
                        }
                        if (sizeof($users) == $limit) {
                            break;
                        }
                    }
 
                    $users[] = $user_sql;
                }
            }
        }
 
        return $returnTotal ? [
            'users' => $users,
            'hits' => sizeof($users)
        ] : $users;
    }
 
    public function getChars($type = ''): array {
        // Suchparameter für die Suche
        $search_params = [
            'index' => $this->config['index'],
            'body' => [
                'aggs' => [
                    'username_chars' => [
                        'aggs' => [ // Unterteilung nötig, damit je nach Typ ein Filter eingestellt werden kann
                            'username_chars' => [
                                'terms' => [
                                    'field' => 'username_char',
                                    'size' => 128 // Länge der ASCII-Tabelle (Mögliche Anfangsbuchstaben)
                                ]
                            ]
                        ]
                    ]
                ],
                'size' => -1 // Kein Suchlimit
            ]
        ];
 
        // Je nach Typ den Filter für die Abfrage setzten
        if ($type) {
            switch ($type) {
                case 'admin' :
                    $search_params['body']['aggs']['username_chars']['filter'] = [
                        'bool' => [
                            'must' => [
                                [
                                    'match' => [
                                        'no_admin' => 0 // Nur Benutzer, die in den Adminbereich dürfen
                                    ]
                                ],[
                                    'match' => [
                                        'no_relation' => 0 // Nur Benutzer, die in eine Gruppe/Rolle haben
                                    ]
                                ], [
                                    'match' => [
                                        'user_inactive' => 0
                                    ]
                                ], [
                                    'bool' => [
                                        'should' => [
                                            [
                                                'range' => [
                                                    'release_from' => [
                                                        'lte' => strtotime('now')
                                                    ]
                                                ]
                                            ], [
                                                'match' => [
                                                    'release_from' => 0
                                                ]
                                            ]
                                        ]
                                    ]
                                ], [
                                    'bool' => [
                                        'should' => [
                                            [
                                                'range' => [
                                                    'release_until' => [
                                                        'gte' => strtotime('now')
                                                    ]
                                                ]
                                            ], [
                                                'match' => [
                                                    'release_until' => 0
                                                ]
                                            ]
                                        ]
                                    ]
                                ]
                            ]
                        ]
                    ];
                    break;
                case 'intranet' :
                    $search_params['body']['aggs']['username_chars']['filter'] = [
                        'bool' => [
                            'must' => [
                                [
                                    'match' => [
                                        'no_admin' => 1 // Nur Benutzer, die nicht in den Adminbereich dürfen
                                    ]
                                ], [
                                    'match' => [
                                        'user_inactive' => 0
                                    ]
                                ], [
                                    'bool' => [
                                        'should' => [
                                            [
                                                'range' => [
                                                    'release_from' => [
                                                        'lte' => strtotime('now')
                                                    ]
                                                ]
                                            ], [
                                                'match' => [
                                                    'release_from' => 0
                                                ]
                                            ]
                                        ]
                                    ]
                                ], [
                                    'bool' => [
                                        'should' => [
                                            [
                                                'range' => [
                                                    'release_until' => [
                                                        'gte' => strtotime('now')
                                                    ]
                                                ]
                                            ], [
                                                'match' => [
                                                    'release_until' => 0
                                                ]
                                            ]
                                        ]
                                    ]
                                ]
                            ]
                        ]
                    ];
                    break;
                case 'norelation' :
                    $search_params['body']['aggs']['username_chars']['filter'] = [
                        'bool' => [
                            'must' => [
                                [
                                    'match' => [
                                        'no_relation' => 1 // Nur Benutzer, die keiner Gruppe zugewiesen sind
                                    ]
                                ], [
                                    'match' => [
                                        'user_inactive' => 0
                                    ]
                                ], [
                                    'bool' => [
                                        'should' => [
                                            [
                                                'range' => [
                                                    'release_from' => [
                                                        'lte' => strtotime('now')
                                                    ]
                                                ]
                                            ], [
                                                'match' => [
                                                    'release_from' => 0
                                                ]
                                            ]
                                        ]
                                    ]
                                ], [
                                    'bool' => [
                                        'should' => [
                                            [
                                                'range' => [
                                                    'release_until' => [
                                                        'gte' => strtotime('now')
                                                    ]
                                                ]
                                            ], [
                                                'match' => [
                                                    'release_until' => 0
                                                ]
                                            ]
                                        ]
                                    ]
                                ]
                            ]
                        ]
                    ];
                    break;
                case 'inactive' :
                    $search_params['body']['aggs']['username_chars']['filter'] = [
                        'bool' => [
                            'should' => [
                                [
                                    'match' => [
                                        'user_inactive' => 1
                                    ]
                                ], [
                                    'bool' => [
                                        'should' => [
                                            'range' => [
                                                'release_from' => [
                                                    'gte' => strtotime('now')
                                                ]
                                            ]
                                        ],
                                        'must_not' =>[
                                            'match' => [
                                                'release_from' => 0
                                            ]
                                        ]
                                    ]
                                ], [
                                    'bool' => [
                                        'should' => [
                                            'range' => [
                                                'release_until' => [
                                                    'lte' => strtotime('now')
                                                ]
                                            ]
                                        ],
                                        'must_not' =>[
                                            'match' => [
                                                'release_until' => 0
                                            ]
                                        ]
                                    ]
                                ]
                            ],
                            'must_not' => [
                                'match' => [
                                    'user_deleted' => 1 // Keine gelöschten Benutzer finden
                                ]
                            ],
                            'minimum_should_match' => 1
                        ]
                    ];
            }
        }
 
        // Suche durchführen
        $results = $this->client->search($search_params)['aggregations']['username_chars']['username_chars']['buckets'];
        $return_array = [];
 
        // Ergebnis alphabetisch sortieren
        usort($results, function($a, $b) {
            return strcasecmp($a['key'], $b['key']);
        });
 
        // Für jedes Ergebnis ein Array aus Buchstabe und Anzahl der Benutzer zurückliefern
        foreach ($results as $bucket) {
            $return_array[] = [
                'char' => $bucket['key'], // Anfangsbuchstabe
                'number' => $bucket['doc_count'] // Anzahl der Benutzer mit diesen Anfangsbuchstaben
            ];
        }
 
        return $return_array;
    }
 
    private function getUserBody(User_SQL $user): array {
        // Prüfen ob der Benutzer einer Gruppe zugeordnet ist
        if (!$user->getAllGroups()) {
            // Der Benutzer ist keiner Gruppe zugewiesen
            $no_relation = 1;
        } else {
            // Der Benutzer ist mindestens einer Gruppe zugewiesen
            $no_relation = 0;
        }
 
        $fields = [
            'user_id' => $user->field['user_id'],
            'username' => mb_strtolower($user->field['username']),
            'categories' => $user->extra['categories'],
            'username_char' => mb_strtoupper(mb_substr($user->field['username'], 0, 1)), // Für die Sortierung in der Sitemap
            'release_from' => ($user->field['release_from'] == '0000-00-00 00:00:00' || !$user->field['release_from']) ? 0 : strtotime($user->field['release_from']),
            'release_until' => ($user->field['release_until'] == '0000-00-00 00:00:00' || !$user->field['release_until']) ? 0 : strtotime($user->field['release_until']),
            'email' => mb_strtolower(trim((string) $user->field['email'])),
            'anrede' => mb_strtolower(trim((string) $user->extra['anrede'])),
            'name' => mb_strtolower(trim((string) $user->extra['name'])),
            'vorname' => mb_strtolower(trim((string) $user->extra['vorname'])),
            'strasse' => mb_strtolower(trim((string) $user->extra['strasse'])),
            'plz' => mb_strtolower(trim((string) $user->extra['plz'])),
            'ort' => mb_strtolower(trim((string) $user->extra['ort'])),
            'land' => mb_strtolower(trim((string) $user->extra['land'])),
            'branche' => mb_strtolower(trim((string) $user->extra['branche'])),
            'abteilung' => mb_strtolower(trim((string) $user->extra['abteilung'])),
            'position' => mb_strtolower(trim((string) $user->extra['position'])),
            'firma' => mb_strtolower(trim((string) $user->extra['firma'])),
            'telefon' => mb_strtolower(trim((string) $user->extra['telefon'])),
            'mobil' => mb_strtolower(trim((string) $user->extra['mobil'])),
            'multiple_login' => $user->field['multiple_login'] ? 1 : 0, // Immer als int speichern
            'liveserver' => $user->extra['liveserver'] ? 1 : 0, // Immer als int speichern
            'user_inactive' => $user->extra['user_inactive'] ? 1 : 0, // Immer als int speichern
            'user_deleted' => $user->field['deleted'] ? 1 : 0, // Immer als int speichern
            'no_admin' => $user->field['no_admin'] ? 1 : 0, // Immer als int speichern
            'no_singlesignon' => $user->extra['no_singlesignon'] ? 1 : 0, // Immer als int speichern
            'no_relation' => $no_relation,
            'auth_persist_token' => (string) $user->extra['auth_persist_token'],
            'auth_persist_expire' => (int) $user->extra['auth_persist_expire'],
            'tfa_secret' => (string) $user->extra['tfa_secret']
        ];
 
        // Kundenspezifische Felder in den Index aufnehmen
        if ($GLOBALS['egotec_conf']['user_search_fields']) {
            foreach ($GLOBALS['egotec_conf']['user_search_fields'] as $name => $type) {
                $fields[$name] = $type == 'boolean' ? ((int) $user->extra[$name]) : mb_strtolower(trim((string) $user->extra[$name]));
            }
        }
 
        return $fields;
    }
 
    private function getSearchParams(array $search, int $limit = -1, string $type = '', bool $sortResult = true, int $from = 0, array $sort_order = []): array {
        $search_deleted = $search['search_deleted'];
        unset($search['search_deleted']);
 
        // Suchparameter je nach Typ anpassen
        switch ($type) {
            case 'admin':
                // Wenn Admin-Benutzer aufgeklappt werden
                $search['no_admin'] = 0;
                $search['user_inactive'] = 0;
                break;
            case 'intranet':
                // Wenn Intranet-Benutzern aufgeklappt werden
                $search['no_admin'] = 1;
                $search['no_relation'] = 0;
                $search['user_deleted'] = 0;
                $search['user_inactive'] = 0;
                break;
            case 'norelation':
                // Wenn Benutzer ohne Gruppenzuweisung aufgeklappt werden
                $search['no_relation'] = 1;
                $search['user_deleted'] = 0;
                $search['user_inactive'] = 0;
                break;
            case 'inactive':
                // Wenn Inaktive Benutzer aufgeklappt werden
                $search['user_inactive'] = 1;
                $search['user_deleted'] = 0;
                break;
            case 'trash':
                $search['user_deleted'] = 1;
        }
 
        // Maximale Anzahl an Treffer
        if ($limit == -1 && ($max_results = intval($GLOBALS['egotec_conf']['elastic']['max_results']))) {
            $limit = $max_results;
            $from = 0;
        }
 
        // Suchparameter
        $search_params = [
            'index' => $this->config['index'],
            'body' => [
                'query' => [
                    'bool' => [
                        'must' => [],
                        'should' => [],
                        'minimum_should_match' => 0
                    ]
                ],
                'size' => $limit,
                'from' => $from,
            ]
        ];
 
        // Wenn das Ergebnis Sortiert werden soll muss die query um "sort" erweitert werden
        if ($sortResult) {
            $field = 'username.keyword';
            $order = 'asc';
 
            if ($sort_order && $sort_order['field'] && $sort_order['field'] !== '') {
                $field = $sort_order['field'];
            }
 
            if ($sort_order && $sort_order['order'] && $sort_order['order'] !== '') {
                $order = $sort_order['order'];
            }
 
            $search_params['body']['sort'] = [
                $field => [
                    'order' => $order,
                    'unmapped_type' => 'keyword'
                ]
            ];
        }
 
        $must = [];
        $should = [];
        $minimum_should_match = 0;
 
        // Query um Parameter erweitern, die für die Suche nach inaktiven/aktiven Benutzern nötig sind
        if ($search['user_inactive'] === 0) {
            // Suche nach aktiven Benutzern
 
            // Nur wenn user_inactive = 0, kann der Benutzer aktiv sein (muss aber nicht)
            $must[] = [
                'match' => [
                    'user_inactive' => 0
                ]
            ];
 
            // Nur wenn "Freigabe von" in der Vergangenheit liegt, oder "Freigabe von" 0 ist (kein Freigabedatum), kann der Benutzer aktiv sein
            $must[] = [
                'bool' => [
                    'should' => [
                        [
                            'range' => [
                                'release_from' => [
                                    'lte' => strtotime('now')
                                ]
                            ]
                        ], [
                            'match' => [
                                'release_from' => 0
                            ]
                        ]
                    ]
                ]
            ];
 
            // Nur wenn "Freigabe bis" in der Zukunft liegt, oder "Freigabe bis" 0 ist (kein Freigabedatum), kann der Benutzer aktiv sein
            $must[] = [
                'bool' => [
                    'should' => [
                        [
                            'range' => [
                                'release_until' => [
                                    'gte' => strtotime('now')
                                ]
                            ]
                        ], [
                            'match' => [
                                'release_until' => 0
                            ]
                        ]
                    ]
                ]
            ];
        } else if ($search['user_inactive'] === 1) {
            // Suche nach inaktiven Benutzern -> OR verknüpfte Abfrage
 
            // Wenn user_inactive = 1, dann ist der Benutzer immer inaktiv
            $should[] = [
                'match' => [
                    'user_inactive' => 1
                ]
            ];
 
            // Wenn das Freigabedatum in der Zukunft liegt, oder 0 ist (kein Freigabedatum), ist der Benutzer inaktiv
            $should[] = [
                'bool' => [
                    'should' => [
                        'range' => [
                            'release_from' => [
                                'gte' => strtotime('now')
                            ]
                        ]
                    ],
                    'must_not' =>[
                        'match' => [
                            'release_from' => 0
                        ]
                    ]
                ]
            ];
 
            // Wenn das Freigabedatum in der Vergangenheit liegt, oder 0 ist (kein Freigabedatum), ist der Benutzer inaktiv
            $should[] = [
                'bool' => [
                    'should' => [
                        'range' => [
                            'release_until' => [
                                'lte' => strtotime('now')
                            ]
                        ]
                    ],
                    'must_not' => [
                        'match' => [
                            'release_until' => 0
                        ]
                    ]
                ]
            ];
 
            // Mindestens eine der Bedingungen trifft zu, wenn der Benutzer inaktiv ist
            $minimum_should_match = 1;
        }
 
        unset($search['user_inactive']);
 
        // Folgende Parameter exakt suchen, den Rest als wildcard
        $match_exact = ['no_admin', 'no_relation', 'user_inactive', 'user_deleted', 'username_char'];
 
        $search_lower = ['username', 'email', 'vorname', 'name', 'categories'];
 
        // Kundenspezifische Felder berücksichtigen
        if ($GLOBALS['egotec_conf']['user_search_fields']) {
            if (Ego_System::file_exists($GLOBALS['egotec_conf']['var_dir'] . 'lib/admin/user_search_fields.php')) {
                // Gibt es einen kundenspezifischen Filter, dann werden die eigenen Felder nicht abgefragt
                $search = array_diff_key($search, $GLOBALS['egotec_conf']['user_search_fields']);
            } else {
                foreach ($GLOBALS['egotec_conf']['user_search_fields'] as $name => $type) {
                    if ($type == 'boolean') {
                        $match_exact[] = $name;
                    }
                }
            }
        }
 
        // Query aufbauen
        foreach ($search as $key => $value) {
            // Keine leeren Werte in den Query aufnehmen (0 ist kein leerer Wert)
            if (($value !== '' && $value !== false && $value !== null) || $key === 'username') { // Username kann bei der Suche leer sein
                if (in_array($key, $match_exact)) {
                    // Wenn der aktuelle $key muss exakt gesucht werden muss
                    $must[] = [
                        'match' => [
                            $key => $value
                        ]
                    ];
                } else {
                    // Bei manchen keys muss nach dem keyword gesucht werden
                    if (in_array($key, ['username', 'vorname', 'name'])) {
                        $key = "$key.keyword";
                    }
 
                    // Der aktuelle $key muss als wildcard gesucht werden
                    $must[] = [
                        'wildcard' => [
                            $key => $value && !in_array($key, ['tfa_secret'])
                                ? '*' . (in_array($key, $search_lower) ? mb_strtolower($value) : $value) . '*'
                                : '*'
                        ]
                    ];
                }
            }
        }
 
        $search_params['body']['query']['bool']['must'] = $must;
        $search_params['body']['query']['bool']['should'] = $should;
        $search_params['body']['query']['bool']['minimum_should_match'] = $minimum_should_match;
 
        return $search_params;
    }
}