Ego_Combo.php

gehe zur Dokumentation dieser Datei

<?php
class Ego_Combo_Exception extends Exception {
    const  INVALID_VALUE = 1; 
}
 
class Ego_Combo_Text {
    public $selected = false;
 
    private $text = '';
 
    public function __construct($text) {
        $this->text = $text;
    }
 
    public function getText(): string {
        return $this->text;
    }
 
    public function __toString() {
        return $this->text;
    }
}
 
class Ego_Combo {
    const EMPTY_VALUE = '{"pages":[],"users":[],"rights":[],"text":[],"data":[]}';
 
    private $value;
 
    public function __construct($value = '') {
        if (empty($value) || $value == '[]') {
            // Standardwert setzen
            $this->setValue(self::EMPTY_VALUE);
        } else {
            $this->setValue($value);
        }
    }
 
    public function getValue() {
        return $this->value;
    }
 
    public function setValue($value) {
        if (!empty($value)) {
            $this->value = @json_decode($value);
 
            // Leere Werte setzen
            if (!empty($this->value) && is_object($this->value)) {
                if (empty($this->value->pages)) {
                    $this->value->pages = array();
                }
                if (empty($this->value->users)) {
                    $this->value->users = array();
                }
                if (empty($this->value->rights)) {
                    $this->value->rights = array();
                }
                if (empty($this->value->text)) {
                    $this->value->text = array();
                }
                if (empty($this->value->data)) {
                    $this->value->data = array();
                }
            } else {
                throw new Ego_Combo_Exception('Invalid value.', Ego_Combo_Exception::INVALID_VALUE);
            }
        }
    }
 
    public function getString() {
        return json_encode($this->value);
    }
 
    public function getPages($no_rights = false, $only_active = false, $lang = '', $user_id = null) {
        $pages = array();
        if (!empty($this->value->pages)) {
            $sites = []; // Zwischengespeicherte Site Objekte
 
            foreach ($this->value->pages as $page) {
                try {
                    if (isset($sites["{$page->site}-{$page->lang}"])) {
                        $site = $sites["{$page->site}-{$page->lang}"];
                    } else {
                        $site = new Site($page->site, $page->lang);
                        $sites["{$page->site}-{$page->lang}"] = $site;
                    }
                    if ($no_rights) {
                        $site->addParam(array(
                            'auth_or' => '1=1',
                            'inactive' => true,
                            'only_active' => false,
                            'no_cache' => 1
                        ));
                    }
                    if ($only_active) {
                        $site->addParam(array(
                            'inactive' => false,
                            'only_active' => true,
                            'no_cache' => 1
                        ));
                    }
                    if (
                        ($p = $site->getPage($page->id))
                        && ($no_rights
                            || ($user_id
                                ? $p->hasRights('view', $user_id)
                                : ($user_id === null
                                    ? $p->hasRights('view') // Der aktuelle Benutzer ist berechtigt
                                    : !$p->hasRightsOn('view') // Die Seite darf keine Ansichtsrechte haben
                                )
                            )
                        )
                    ) {
                        if (
                            !empty($lang)
                            && ($lang_page = $p->getLanguagePage($lang))
                        ) {
                            $p = $lang_page;
                        }
                        $p->{'selected'} = (bool) $page->selected;
                        $pages[] = $p;
                    }
                } catch (Exception $e) {
                    // Seite kann nicht ermittelt werden
                    egotec_warning_log($e->getMessage());
                }
            }
        }
        return $pages;
    }
 
    public function setPages($pages) {
        $this->value->pages = $pages;
    }
 
    public function addPage($page) {
        if (!$this->hasPage($page)) {
            $site = $page->getSite();
            $p = new stdClass();
            $p->site = $site->name;
            $p->lang = $site->language;
            $p->id = $page->field['id'];
            $this->value->pages[] = $p;
            return true;
        }
        return false;
    }
 
    public function hasPage($page) {
        $site = $page->getSite();
        if (!empty($this->value->pages)) {
            foreach ($this->value->pages as $p) {
                if (
                    $site->name == $p->site
                    && $site->language == $p->lang
                    && $page->field['id'] == $p->id
                ) {
                    return true;
                }
            }
        }
        return false;
    }
 
    public function getUsers() {
        $users = array();
        if (!empty($this->value->users)) {
            foreach ($this->value->users as $user_id) {
                try {
                    $user = new User_SQL(ltrim($user_id, '+'));
                } catch (Exception $e) {
                    // ignorieren
                    continue;
                }
 
                $user->{'selected'} = $user_id[0] === '+';
                $users[] = $user;
            }
        }
        return $users;
    }
 
    public function setUsers($users) {
        $this->value->users = $users;
    }
 
    public function addUser($user_id) {
        if (!in_array($user_id, $this->value->users)) {
            $this->value->users[] = $user_id;
            return true;
        }
        return false;
    }
 
    public function hasUser($user_id) {
        foreach ($this->getUsers() as $user) {
            if ($user->field['user_id'] == $user_id) {
                return true;
            }
        }
        return false;
    }
 
    public function getRights() {
        $rights = array();
        if (!empty($this->value->rights)) {
            foreach ($this->value->rights as $right) {
                $r = array(
                    'group' => new Group_SQL($right->group),
                    'role' => new Role_SQL($right->role)
                );
                $r['selected'] = (bool) $right->selected;
                $rights[] = $r;
            }
        }
        return $rights;
    }
 
    public function getRightsUsers() {
        $users = [];
        if (!empty($this->value->rights)) {
            foreach ($this->value->rights as $right) {
                $db = new_db_connection([
                    'table' => 'egotec_user_group',
                    'fields' => 'egotec_user_group.user_id',
                    'where' => "egotec_user_group.group_id = '$right->group' AND egotec_user_group.role_id = '$right->role'",
                    'join' => 'egotec_user ON egotec_user.user_id = egotec_user_group.user_id',
                    'distinct' => true,
                    'order' => 'username ASC'
                ]);
 
                while ($record = $db->nextRecord()) {
                    $user = null;
 
                    try {
                        $user = new User_SQL($record['user_id']);
                    } catch (Exception $e) {}
 
                    if ($user !== null) {
                        $users[] = $user;
                    }
                }
            }
        }
        return $users;
    }
 
    public function setRights($rights) {
        $this->value->rights = $rights;
    }
 
    public function addRight($group, $role) {
        $right = new stdClass();
        $right->group = $group;
        $right->role = $role;
        foreach ($this->value->rights as $_right) {
            if ($_right->group == $right->group && $_right->role == $right->role) {
                return false;
            }
        }
        $this->value->rights[] = $right;
        return true;
    }
 
    public function hasRight(string $user_id): bool {
        foreach ($this->getRights() as $right) {
            try {
                $user_sql = new User_SQL($user_id);
 
                if ($user_sql->hasGroupRoleRelation($right['group']->field['group_id'], $right['role']->field['role_id'])) {
                    return true;
                }
            } catch (Exception $e) {
                // ignorieren
            }
        }
 
        return false;
    }
 
    public function getText() {
        return array_map(function($text) {
            $obj = new Ego_Combo_Text(ltrim($text, '+'));
            $obj->selected = $text[0] === '+';
            return $obj;
        }, $this->value->text);
    }
 
    public function setText($text) {
        $this->value->text = $text;
    }
 
    public function addText($text) {
        if (!in_array($text, $this->value->text)) {
            $this->value->text[] = $text;
            return true;
        }
        return false;
    }
 
    public function getData() {
        return $this->value->data;
    }
 
    public function getDataBy($key, $value) {
        $result = array();
        foreach ($this->getData() as $data) {
            if (isset($data->{$key}) && $data->{$key} == $value) {
                $result[] = $data;
            }
        }
        return $result;
    }
 
    public function getDataByKey($key) {
        foreach ($this->getData() as $data) {
            if ($data->key == $key) {
                return $data;
            }
        }
        return null;
    }
 
    public function setData($data) {
        $this->value->data = $data;
    }
 
    public function addData($data) {
        $this->value->data[] = $data;
        return true;
    }
 
    public function getMailAddresses($params = array()) {
        $addresses = array();
 
        // E-Mail Adressen aus den Seiten
        if (!empty($params['pages'])) {
            foreach ($this->getPages(true, true) as $page) {
                if ($params['pages']['type'] == '*' || $page->field['type'] == $params['pages']['type']) {
                    $address = array(
                        'username' => '',
                        'salutation' => '',
                        'firstname' => '',
                        'lastname' => '',
                        'email' => '',
                        'email_name' => ''
                    );
                    foreach (array_keys($address) as $key) {
                        if (!empty($params['pages']['values'][$key])) {
                            [$field, $name] = explode('.', $params['pages']['values'][$key], 2);
                            $address[$key] = (string) Ego_System::getAssocValue($page->{$field}, $name);
                        }
                    }
                    if (!empty($address['email']) && Ego_System::isEmail($address['email'])) {
                        $key = md5($address['email']);
                        if (empty($address['username'])) {
                            $address['username'] = $address['email'];
                        }
                        if ($address['email_name'] == '') {
                            $address['email_name'] = $page->field['name'];
                        }
                        $address['identity'] = array(
                            'type' => 'page',
                            'value' => $page->getIdentity()
                        );
                        $address['data'] = $page->extra;
                        $addresses[$key] = $address;
                    }
                }
            }
        }
 
        // E-Mail Adressen aus den Unterseiten der Seiten
        if (!empty($params['children'])) {
            foreach ($this->getPages(true) as $page) {
                foreach ($page->getChildren(array(), array(
                    'auth_or' => '1=1',
                    'only_active' => true
                )) as $child) {
                    if ($params['children']['type'] == '*' || $child->field['type'] == $params['children']['type']) {
                        $address = array(
                            'username' => '',
                            'salutation' => '',
                            'firstname' => '',
                            'lastname' => '',
                            'email' => '',
                            'email_name' => ''
                        );
                        foreach (array_keys($address) as $key) {
                            if (!empty($params['children']['values'][$key])) {
                                [$field, $name] = explode('.', $params['children']['values'][$key], 2);
                                $address[$key] = (string) Ego_System::getAssocValue($child->{$field}, $name);
                            }
                        }
                        if (!empty($address['email']) && Ego_System::isEmail($address['email'])) {
                            $key = md5($address['email']);
                            if (empty($address['username'])) {
                                $address['username'] = $address['email'];
                            }
                            if ($address['email_name'] == '') {
                                $address['email_name'] = $child->field['name'];
                            }
                            $address['identity'] = array(
                                'type' => 'page',
                                'value' => $child->getIdentity()
                            );
                            $address['data'] = $child->extra;
                            $addresses[$key] = $address;
                        }
                    }
                }
            }
        }
 
        // Alle Gruppen/Rollen Benutzer
        foreach ($this->getRightsUsers() as $user) {
            if (
                !empty($user->field['email'])
                && !$user->isInactive()
                && Ego_System::isEmail($user->field['email'])
                && (
                    $params['users']['no_admin'] !== false
                    || !$user->field['no_admin']
                )
            ) {
                $key = md5($user->field['email']);
                $addresses[$key] = array(
                    'username' => $user->field['username'],
                    'salutation' => $user->extra['anrede'],
                    'firstname' => $user->extra['vorname'],
                    'lastname' => $user->extra['name'],
                    'email' => $user->field['email'],
                    'email_name' => $user->getFullname(false),
                    'identity' => array(
                        'type' => 'user',
                        'value' => $user->field['user_id']
                    ),
                    'data' => $user->extra
                );
            } elseif ($user) {
                egotec_warning_log('Der Benutzer '.$user->getFullname().' besitzt keine E-Mail Adresse und kann nicht verwendet werden.');
            }
        }
 
        // Alle Benutzer
        foreach ($this->getUsers() as $user) {
            if (
                !empty($user->field['email'])
                && !$user->isInactive()
                && Ego_System::isEmail($user->field['email'])
                && (
                    $params['users']['no_admin'] !== false
                    || !$user->field['no_admin']
                )
            ) {
                $key = md5($user->field['email']);
                $addresses[$key] = array(
                    'username' => $user->field['username'],
                    'salutation' => $user->extra['anrede'],
                    'firstname' => $user->extra['vorname'],
                    'lastname' => $user->extra['name'],
                    'email' => $user->field['email'],
                    'email_name' => $user->getFullname(false),
                    'identity' => array(
                        'type' => 'user',
                        'value' => $user->field['user_id']
                    ),
                    'data' => $user->extra
                );
            } elseif ($user) {
                egotec_warning_log('Der Benutzer '.$user->getFullname().' besitzt keine E-Mail Adresse und kann nicht verwendet werden.');
            }
        }
 
        // Alle Direkteingaben
        foreach ($this->getText() as $text) {
            $key = md5($text);
            if (!isset($adresses[$key])) {
                // Nur setzen wenn es hierzu keinen Eintrag mit mehr Informationen gibt
                $email = (string) $text;
                $email_name = '';
 
                // E-Mail Adresse und Anzeigenamen ermitteln aus: "Anzeigename" mail@egotec.com
                if (preg_match('/^"(.*?)"(.*?)$/i', $email, $matches)) {
                    $email = trim($matches[2]);
                    $email_name = trim($matches[1]);
                }
 
                if (Ego_System::isEmail($email)) {
                    $addresses[$key] = array(
                        'username' => $email,
                        'salutation' => '',
                        'firstname' => '',
                        'lastname' => '',
                        'email' => $email,
                        'email_name' => $email_name,
                        'identity' => array(
                            'type' => 'text',
                            'value' => $email
                        ),
                        'data' => array()
                    );
                }
            }
        }
 
        // Alle Daten
        if (!empty($params['data'])) {
            foreach ($this->getData() as $data) {
                $address = array(
                    'username' => '',
                    'salutation' => '',
                    'firstname' => '',
                    'lastname' => '',
                    'email' => '',
                    'email_name' => ''
                );
                foreach (array_keys($address) as $key) {
                    if (!empty($params['data'][$key])) {
                        $address[$key] = @$data[$params['data'][$key]];
                    }
                }
                if (!empty($address['email']) && Ego_System::isEmail($address['email'])) {
                    $key = md5($address['email']);
                    if (empty($address['username'])) {
                        $address['username'] = $address['email'];
                    }
                    $address['identity'] = array(
                        'type' => 'data',
                        'value' => $data['key']
                    );
                    $address['data'] = array();
                    $addresses[$key] = $address;
                }
            }
        }
 
        return array_values($addresses);
    }
}
?>