Ego_User_Search_Factory.php

gehe zur Dokumentation dieser Datei

<?php
 
class Ego_User_Search_Factory {
    private static $elastic;
 
    public static function start(string $table = 'egotec_user', array $param = [], bool $checkHealthy = false) {
        if (Ego_System::checkLicence($GLOBALS['egotec_conf']['lib_dir'] . 'elastic')) {
            require_once('base/Ego_User_Elastic.php');
            self::$elastic = true;
 
            try {
                $elastic = new Ego_User_Elastic($table, $param, true);
                return $elastic;
            } catch (Exception $e) {
                // Fallback Ego_User_Sql
                self::$elastic = false;
 
                // Wenn geprüft wird, ob der Elasticsearch-Dienst verfügbar ist, muss die Exception weitergereicht werden
                if ($checkHealthy) {
                    throw $e;
                }
            }
        }
 
        require_once('base/Ego_User_Sql.php');
        self::$elastic = false;
        return new Ego_User_Sql();
    }
 
    public static function isElastic(): bool {
        return self::$elastic;
    }
 
    public static function filterSearch(array $search): array {
        // Werte aus der Suchmaske anpassen
        if ($search['no_admin'] !== '' || $search['liveserver'] !== '' || $search['no_singlesignon'] !== '') {
            switch ((int) $search['no_admin']) {
                case 0:
                    unset($search['no_admin']);
                    break;
                case 1:
                    $search['no_admin'] = 1;
                    break;
                case 2:
                    $search['no_admin'] = 0;
            }
        }
 
        // Folgende Parameter müssen vor der Suche angepasst werden
        $params_to_change = [
            'multiple_login',
            'user_inactive',
            'liveserver',
            'no_singlesignon'
        ];
 
        // Suchparameter anpassen
        foreach ($search as $search_param => $search_value) {
            if (in_array($search_param, $params_to_change)) {
                switch ($search_value) {
                    case 0:
                        unset($search[$search_param]);
                        break;
                    case 1:
                        $search[$search_param] = 0;
                        break;
                    case 2:
                        $search[$search_param] = 1;
                }
            }
        }
 
        return $search;
    }
 
    public static function checkSearchFilter(string $type, array $search): bool {
        if (
            ($search['no_admin'] === 1 && $type === 'admin') // Wenn der Suchfilter nach Intranet-Usern sucht und die Admin-Benutzer geöffent werden
            || ($search['no_admin'] === 0 && $type === 'intranet') // Wenn der Suchfilter nach Admin-Usern sucht und die Intranet-Benutzer geöffnet werden
            || ($search['user_inactive'] === 0 && $type === 'inactive') // Wenn nach aktiven Benutzern gesucht wird und inaktive geöffnet werden
            || ($search['user_inactive'] === 1 && $type !== 'inactive') // Inaktive Benutzer nur bei type=inactive
            || (!empty($search['group_role']) && $type === 'norelation') // Wenn nach einem Benutzer mit bestimmter Gruppe oder Rolle gesucht wird und die nicht zugeordneten Benutzer geöffnet werden
            || (!$search['search_deleted'] && $type === 'trash') // Papierkorb wird aufgeklappt und der Suchfilter sucht nicht nach gelöschten Benutzern
        ) {
            return false;
        } else {
            return true;
        }
    }
 
    public static function isAcceptedUser(User_SQL $user, array $group_role_rel = null): bool {
        // Gruppen/Rollen des angegebenen Benutzers
        $group_role_rel = $group_role_rel ?? $user->getGroupRoleRelations();
 
        if (
            empty($group_role_rel) // Nicht zugeordnete Benutzer können immer eingesehen werden
            || $GLOBALS['auth']->hasSuperuserPermission() // Superuser dürfen alle anderen Benutzer sehen
        ) {
            return true;
        } else {
            // Alle Gruppen durchgehen
            foreach ($group_role_rel as $group_id => $roles) {
                // Alle Rollen in der Gruppe durchgehen
                foreach (explode(',', $roles) as $role_id) {
                    if (
                        $GLOBALS['auth']->hasPermission($group_id, $role_id) // Aktueller Benutzer hat Rechte auf die Gruppen/Rollen Kombination
                    ) {
                        // Benutzer kann eingesehen werden, sobald der aktuelle Benutzer Rechte auf eine der Gruppen/Rollen Kombinationen hat
                        return true;
                    }
                }
            }
 
            // Aktueller Benutzer darf den angegebenen Benutzer nicht sehen
            return false;
        }
    }
 
    public static function checkRightsFilter(string $rightsFilter, User_SQL $user, array $group_role_rel = null): bool {
        // Ausgewählte Gruppe
        $group_to_check = explode(',', $rightsFilter)[0];
        // Ausgewählte Rolle
        $role_to_check = explode(',', $rightsFilter)[1];
 
        $has_group = false;
        $has_role = false;
 
        // Gruppen/Rollen des gefundenen Benutzers
        $groups = [];
        $roles = [];
        $group_role_rel = $group_role_rel ?? $user->getGroupRoleRelations();
 
        // Alle Gruppen/Rollen durchgehen
        foreach ($group_role_rel as $user_group=>$user_roles) {
            $groups[] = $user_group;
            foreach (explode(',', $user_roles) as $role) {
                $roles[] = $role;
            }
        }
 
        $roles = array_unique($roles);
 
        // Prüfen, ob der Benutzer die Gruppe, nach der gesucht wurde, hat, oder keine Gruppe angegeben wurde
        if (!$group_to_check || in_array($group_to_check, $groups)) {
            $has_group = true;
        }
 
        // Prüfen, ob der Benutzer die Rolle, nach der gesucht wurde, hat, oder keine Rolle angegeben wurde
        if (!$role_to_check || in_array($role_to_check, $roles)) {
            $has_role = true;
        }
 
        return ($has_group && $has_role);
    }
 
    public static function updateIndex(): void {
        $search = self::start();
 
        if (self::isElastic()) {
            // Alle Benutzer holen
            $db = new_db_connection([
                'table' => 'egotec_user'
            ]);
 
            // Index neu anlegen
            $search->indexDelete(false);
 
            // Alle Benutzer updaten
            while ($record = $db->nextRecord()) {
                $user = new User_SQL($record['user_id']);
 
                $user->update([], true);
            }
        }
    }
}