dbxApi.php

Go to the documentation of this file.

<?php
 
//include_once dbx_os_path_file(dbx_get_base_dir().'dbx/add_ons/sftp/vendor/autoload.php');
//use phpseclib3\Crypt\AES;
use \phpseclib3\Crypt\AES;
 
Global $_dbxCache;
 
function dbx_log_missing_entry($missing = '') {
   return function_exists('dbx') ? (int) dbx()->log_missing($missing) : 0;
}

class dbxApi {

   public array $editor_files = array();

   private array $owner_stack = array();

   private bool $sys_msg_running = false;

   private array $timer_state = array();

   private array $admin_bypass_user = array();

   private bool $admin_bypass_user_loaded = false;

   private bool $admin_bypass_user_loading = false;

   public function push_owner($owner): void {
      if (is_object($owner)) {
         $this->owner_stack[] = $owner;
      }
   }

   public function pop_owner(): void {
      if ($this->owner_stack) {
         array_pop($this->owner_stack);
      }
   }

   public function set_current_owner($owner): void {
      if (is_object($owner)) {
         if ($this->owner_stack) {
            $this->owner_stack[count($this->owner_stack) - 1] = $owner;
         } else {
            $this->owner_stack[] = $owner;
         }
      }
   }

   public function get_current_owner() {
      if (!$this->owner_stack) {
         return null;
      }
 
      return $this->owner_stack[count($this->owner_stack) - 1];
   }

   public function run_owner($owner, string $method = 'run', ...$args) {
      if (!is_object($owner) || !is_callable(array($owner, $method))) {
         return null;
      }
 
      $this->push_owner($owner);
 
      try {
         return $owner->$method(...$args);
      } finally {
         $this->pop_owner();
      }
   }

   public function get_system_obj(string $class, string $use = ''): ?object {
      global $_dbxCache;
 
      if (!preg_match('/^[A-Za-z_][A-Za-z0-9_]*$/', $class)) {
         throw new Exception("Invalid system class name '$class'.");
      }
 
      if (isset($_dbxCache[$class])) {
         return !$use ? $_dbxCache[$class] : null;
      }
 
      $baseClass = '\\' . $class;
      $baseFile  = dbx_os_path_file(dbx_get_base_dir() . "dbx/include/" . $class . ".class.php");
 
      if (file_exists($baseFile)) {
         require_once $baseFile;
      } else {
         $baseClass = "\\dbxUndefClass";
      }
 
      $myClass = $this->get_SysClassOverrideName($class);
      $myFile  = $this->ensure_SysClassOverride($class, $myClass, $baseClass);
 
      if ($myFile && file_exists($myFile)) {
         $this->register_editor_file('sysclass', $myFile);
         require_once $myFile;
      }
 
      $myClassFull = '\\' . $myClass;
      $createClass = class_exists($myClassFull, false) ? $myClassFull : $baseClass;
 
      if ($use) {
         return null;
      }
 
      if (class_exists($createClass)) {
         $_dbxCache[$class] = new $createClass();
         return $_dbxCache[$class];
      }
 
      throw new Exception("Klasse '$createClass' konnte nicht geladen werden.");
   }

   public function editor_file_path(string $file): string {
      $file = str_replace('\\', '/', $file);
      $base = str_replace('\\', '/', dbx_get_base_dir());
 
      if (strpos($file, $base) === 0) {
         $file = substr($file, strlen($base));
      }
 
      return ltrim($file, '/');
   }

   public function register_editor_file(string $kind, string $file): void {
      $kind = strtolower(trim($kind));
      $file = trim($file);
 
      if ($kind === '' || $file === '') {
         return;
      }
 
      $path = $this->editor_file_path($file);
      $key  = $kind . '|' . $path;
      $this->editor_files[$key] = array('kind' => $kind, 'file' => $path);
   }

   public function get_editor_files(): array {
      return $this->editor_files;
   }

   public function editor_marker(string $kind, string $file): string {
      $kind = strtolower(trim($kind));
      $mode = (int) $this->get_system_var('dbx_edit', 0, 'int');
      $modes = array('fd' => 4, 'dd' => 5, 'class' => 6, 'sysclass' => 7, 'config' => 8);
 
      if (!isset($modes[$kind]) || ($mode !== 9 && $mode !== $modes[$kind]) || $file === '') {
         return '';
      }
 
      $path = $this->editor_file_path($file);
      $path = str_replace('--', '-', $path);
 
      return "\n<!-- DBX-EDITOR|$kind|$path -->\n";
   }

   public function get_modul_obj(string $class): object {
      // Vollqualifizierten Klassennamen vorbereiten
      $namespace_class = '\dbx\-class-\-class-';
      $namespace_class = str_replace('-class-', $class, $namespace_class);
   
      // Modul-ID auslesen und inkrementieren
      $modul_id = $this->get_system_var('dbx_activ_modul_id', 0, '*');
      $modul_id++;
      $this->set_system_var('dbx_activ_modul_id', $modul_id);
   
      // Modulname in System- und Modulvariablen speichern
      $this->set_system_var('dbx_activ_modul', $class);
      $this->set_modul_var('dbx_modul_id', $modul_id);
      $this->set_modul_var('dbx_modul', $class);
   
      // Admin-spezifisches Design anwenden, falls Modul ein Admin-Modul ist
      if (stripos($class, 'admin') !== false) {
          //$admin_design = $this->get_config('dbx', 'default_design_admin');
          //$this->set_system_var('dbx_design', $admin_design);
      }
   
      // Pfad zur Klassen-Datei des Moduls berechnen
      $modul_class_file = dbx_os_path_file(dbx_get_base_dir() . "dbx/modules/$class/$class.class.php");
   
      // Klassen-Datei einbinden, wenn vorhanden
      if (file_exists($modul_class_file)) {
          $this->register_editor_file('class', $modul_class_file);
          require_once $modul_class_file;
      } else {
          // Fallback-Klasse verwenden, falls die Datei fehlt
          $namespace_class = "\\dbxUndefClass";
      }
   
      // Prüfen, ob die Klasse existiert, und Instanz erstellen
      if (class_exists($namespace_class)) {
          $object = new $namespace_class();
          if (method_exists($object, 'set_editor_class_file')) {
              $object->set_editor_class_file($modul_class_file);
          }
          $this->set_current_owner($object);
          return $object;
      }
   
      // Fehler werfen, falls die Klasse nicht existiert
      throw new Exception("Modul-Klasse '$namespace_class' konnte nicht geladen werden.");
   }

   public function get_include_obj(string $class, string $modul = '', string $use = ''): ?object {
      // Aktuelles Modul verwenden, wenn keins angegeben wurde
      if (!$modul) {
          $modul = $this->get_system_var('dbx_activ_modul', 'dbx', '*');
      }
   
      // Systemvariable für das aktuell geladene Include setzen
      $this->set_system_var('dbx_inc', $class);
   
      // Vollqualifizierten Klassennamen generieren
      $namespace_class = '\dbx\-modul-\-class-';
      $namespace_class = str_replace('-modul-', $modul, $namespace_class);
      $namespace_class = str_replace('-class-', $class, $namespace_class);
   
      // Pfad zur Klassen-Datei bestimmen
      $modul_class_file = dbx_os_path_file(dbx_get_base_dir() . "dbx/modules/$modul/include/$class.class.php");
   
      // Klassen-Datei einbinden, wenn sie existiert
      if (file_exists($modul_class_file)) {
          $this->register_editor_file('class', $modul_class_file);
          require_once $modul_class_file;
      } else {
          // Fallback-Klasse verwenden, falls Datei fehlt
          $namespace_class = "\\dbxUndefClass";
      }
   
      // Objekt erstellen und zurückgeben, falls $use nicht gesetzt ist
      if (!$use) {
          if (class_exists($namespace_class)) {
              $object = new $namespace_class();
              if (method_exists($object, 'set_editor_class_file')) {
                  $object->set_editor_class_file($modul_class_file);
              }
              $this->set_current_owner($object);
              return $object;
          }
   
          // Fehler werfen, falls die Klasse nicht existiert
          throw new Exception("Klasse '$namespace_class' konnte nicht geladen werden.");
      }
   
      // Keine Rückgabe, wenn $use gesetzt ist
      return null;
   }

   public function use_system_class($class)  {
      $modul_id=0;
      $dbx_class_file=dbx_get_base_dir()."dbx/include/".$class.".class.php";
      $dbx_class_file=dbx_os_path_file($dbx_class_file);
   
   
      if (file_exists($dbx_class_file)) {
        require_once $dbx_class_file;
      }
   }

   public function get_system_var(string $varname, $default = '', string $rules = '*') {
      // Initialisierung der Rückgabevariable
      $value = $default;
      $danger_value = '';
   
      // Überprüfen, ob die Variable in der Session vorhanden ist
      if (isset($_SESSION['dbx']['tmp'][0]['dbx'][$varname])) {
          $danger_value = $_SESSION['dbx']['tmp'][0]['dbx'][$varname];
      } else {
          // Wenn nicht, nach der Variable in GET oder POST suchen
          if (isset($_GET[$varname])) {
              $danger_value = $_GET[$varname];
          }
          if (isset($_POST[$varname])) {
              $danger_value = $_POST[$varname];
          }
      }
   
      // Wenn ein Wert vorhanden und gültig ist, validieren und zurückgeben
      if (($danger_value !== '') && ($danger_value !== null)) {
          if (dbx_validate_var($danger_value, $rules, $varname)) {
              $value = $danger_value;
          }
      }
   
      // Rückgabe des validierten Werts oder des Standardwerts
      return $value;
   }

   public function set_system_var(string $varname, $value) {
      // Speichert den Wert der Systemvariable in der Session
      $_SESSION['dbx']['tmp'][0]['dbx'][$varname] = $value;
   }

   public function get_modul_var($varname, $default = '', $rules = 'alphanum') {
      // Standardwert initialisieren
      $value = $default;
   
      // Das aktive Modul und die Modul-ID holen
      $modul = $this->get_system_var('dbx_activ_modul', 'undef', '*');
      $mid   = $this->get_system_var('dbx_activ_modul_id', 88888, '*');
   
      // Versuchen, die Variable aus der Session zu holen
      if (isset($_SESSION['dbx']['tmp'][$mid][$modul][$varname])) {
          $danger_value = $_SESSION['dbx']['tmp'][$mid][$modul][$varname];
      } else {
          // Wenn nicht in der Session, versuche GET und POST
          $danger_value = '';
   
          if (isset($_GET[$varname])) {
              $danger_value = $_GET[$varname];
          }
   
          if (isset($_POST[$varname])) {
              $danger_value = $_POST[$varname];
          }
      }
   
      // Wenn ein Wert vorhanden ist und er gültig ist, validiere den Wert
      if ($danger_value !== '' && $danger_value !== null && dbx_validate_var($danger_value, $rules, $varname)) {
          $value = $danger_value;
      }
   
      // Rückgabe des Werts (entweder der gefundene gültige Wert oder der Standardwert)
      return $value;
   }

   public function get_modul_request_var($varname, $default = '', $rules = '*') {
      return $this->get_modul_var($varname, $default, $rules);
   }

   public function set_modul_var($varname, $value = null, $check_protected = true) {
      // Das aktive Modul und die Modul-ID holen
      $mid   = $this->get_system_var('dbx_activ_modul_id', 0, 'int');
      $modul = $this->get_system_var('dbx_activ_modul', 'dbx', 'parameter');
   
      // Geschützte ModulVariablen prüfen.
      // Wichtig: Schutzliste nur aus der echten ModulVar-Session lesen,
      // nicht ueber $this->get_modul_var(), damit GET/POST hier niemals mitreden.
      if ($check_protected) {
         $protected = array();
         if (isset($_SESSION['dbx']['tmp'][$mid][$modul]['dbx_protected_modulvars'])) {
            $protected = $_SESSION['dbx']['tmp'][$mid][$modul]['dbx_protected_modulvars'];
         }
         if (is_array($protected) && array_key_exists($varname, $protected)) {
            dbx()->debug("PROTECTED ($varname)");
            return;
         }   
      }
   
      // Setze den Wert in der Session
      $_SESSION['dbx']['tmp'][$mid][$modul][$varname] = $value;
   
      // Optional: Debugging-Informationen hinzufügen
      // dbx_debug("dbx_set_ModulVar modul=($modul) Mod=($mid) Var=($varname) val=($value)");
   }

   public function req(string $varname, $default = '', string $rules = 'parameter') {
      // Standardwert initialisieren
      $value = $default;
      $danger_value = '';
   
      // Prüfen, ob die Variable in GET oder POST vorhanden ist
      if (isset($_GET[$varname])) {
          $danger_value = $_GET[$varname];
      }
      if (isset($_POST[$varname])) {
          $danger_value = $_POST[$varname];
      }
   
      // Wenn ein Wert vorhanden ist und nicht null ist, validieren
      if (($danger_value !== '') && ($danger_value !== null)) {
          if (dbx_validate_var($danger_value, $rules, $varname)) {
              $value = $danger_value;
          }
      }
   
      // Rückgabe des validierten Werts oder des Standardwerts
      return $value;
   }

   public function get(string $varname, $default = '', string $rules = 'parameter') {
      // Standardwert initialisieren
      $value = $default;
   
      // Prüfen, ob die GET-Variable gesetzt ist
      if (isset($_GET[$varname])) {
          $danger_value = $_GET[$varname];
   
          // Validierung des Werts
          if (dbx_validate_var($danger_value, $rules, $varname)) {
              $value = $danger_value;
          }
      }
   
      // Rückgabe des validierten Werts oder des Standardwerts
      return $value;
   }

   public function post(string $varname, $default = '', string $rules = 'parameter') {
      // Standardwert initialisieren
      $value = $default;
   
      // Prüfen, ob die POST-Variable gesetzt ist
      if (isset($_POST[$varname])) {
          $danger_value = $_POST[$varname];
   
          // Validierung des Werts
          if (dbx_validate_var($danger_value, $rules, $varname)) {
              $value = $danger_value;
          }
      }
   
      // Rückgabe des validierten Werts oder des Standardwerts
      return $value;
   }

   public function get_request_var(string $varname, $default = '', string $rules = 'parameter') {
      return $this->req($varname, $default, $rules);
   }

   public function get_query_var(string $varname, $default = '', string $rules = 'parameter') {
      return $this->get($varname, $default, $rules);
   }

   public function get_post_var(string $varname, $default = '', string $rules = 'parameter') {
      return $this->post($varname, $default, $rules);
   }

   public function get_config(string $modul = 'dbx', string $key = '', $default = null) {
      $moduleConfigFile = dbx_os_path_file(dbx_get_base_dir() . "dbx/modules/$modul/cfg/config.php");
 
      if (file_exists($moduleConfigFile)) {
          $_SESSION['dbx']['config_file'][$modul] = $moduleConfigFile;
          $this->register_editor_file('config', $moduleConfigFile);
      }
   
      // Prüfen, ob die Konfiguration bereits im Session-Cache vorhanden ist
      if (!isset($_SESSION['dbx']['config'][$modul])) {
          $config = [];
          $content = '';
 
          $dir_file = $moduleConfigFile;
          if (file_exists($dir_file)) {
              $_SESSION['dbx']['config_file'][$modul] = $dir_file;
              $this->register_editor_file('config', $dir_file);
              $content = file_get_contents($dir_file);
          }
   
          // Wenn Inhalt vorhanden ist, diesen ausführen
          if ($content) {
              $clean_code = str_replace(['<?php', '?>'], '', $content);
   
              // Benutzerdefinierte Fehlerbehandlung für eval()
              set_error_handler(function ($errno, $errstr, $errfile, $errline) {
                  throw new Exception("Fehler in eval() Code: $errstr in Zeile $errline");
              });
   
              try {
                  eval($clean_code); // Führt den bereinigten Code aus
              } catch (Exception $e) {
                  echo "Fehler: " . $e->getMessage();
              } finally {
                  restore_error_handler(); // Fehlerbehandlung zurücksetzen
              }
          }
   
          // Standardgruppe setzen, falls keine Gruppen definiert sind
          if (!isset($config['groups'])) {
              $config['groups'] = ['admin'];
          } elseif (!is_array($config['groups'])) {
              $config['groups'] = array_filter(explode(',', $config['groups']));
          }
 
          $fileDefaults = $this->read_module_config_defaults($modul);
          if (is_array($fileDefaults) && count($fileDefaults)) {
              $config = array_merge($fileDefaults, $config);
          }
   
          // Konfiguration im Session-Cache speichern
          $_SESSION['dbx']['config'][$modul] = $config;
      }
   
      // Konfiguration aus dem Cache laden
      $config = $_SESSION['dbx']['config'][$modul];
 
      static $configDefaultsMerged = array();
      if (!isset($configDefaultsMerged[$modul])) {
         $fileDefaults = $this->read_module_config_defaults($modul);
         if (is_array($fileDefaults) && count($fileDefaults)) {
            $merged = array_merge($fileDefaults, $config);
            if ($merged !== $config) {
               $config = $merged;
               $_SESSION['dbx']['config'][$modul] = $config;
            }
         }
         $configDefaultsMerged[$modul] = 1;
      }
   
      // Spezifischen Schlüssel zurueckgeben, falls angegeben
      if ($key) {
          if (!array_key_exists($key, $config)) {
              return $default !== null ? $default : 'undef';
          }
 
          $val = $config[$key];
          if (($val === 'undef' || $val === '' || $val === null) && $default !== null) {
              return $default;
          }
 
          return $val;
      }
   
      // Gesamte Konfiguration zurückgeben
      return $config;
   }

   private function read_module_config_defaults(string $modul): array {
      if ($modul === 'dbx') {
         $dir_file = dbx_os_path_file(dbx_get_base_dir() . 'dbx/modules/dbx/cfg/config.php');
      } else {
         $dir_file = dbx_os_path_file(dbx_get_base_dir() . "dbx/modules/$modul/cfg/config.php");
      }
      if (!is_file($dir_file) || !is_readable($dir_file)) {
         return array();
      }
 
      $config = array();
      $content = file_get_contents($dir_file);
      if (!is_string($content) || $content === '') {
         return array();
      }
 
      $clean_code = str_replace(array('<?php', '?>'), '', $content);
      set_error_handler(function ($errno, $errstr, $errfile, $errline) {
         throw new \Exception("Fehler in config.php: $errstr in Zeile $errline");
      });
 
      try {
         eval($clean_code);
      } catch (\Exception $e) {
         $config = array();
      } finally {
         restore_error_handler();
      }
 
      return is_array($config) ? $config : array();
   }

   public function set_config(string $modul, array $config): int {
      $content = "<?php \n"; // PHP-Tag hinzufügen, um die Datei als ausführbaren Code zu speichern
      $dir = dbx_get_base_dir() . "dbx/modules/$modul/cfg/";
      if (isset($config['form-config-edit'])) unset($config['form-config-edit']);
      $config = dbx_normalize_config_for_store($config);
   
      $dir_file = dbx_os_path_file($dir . 'config.php');
      $dir = dbx_os_path_file($dir);
   
      // Konfigurationsarray in PHP-Code konvertieren
      if (is_array($config)) {
          $_SESSION['dbx']['config'][$modul] = $config; // Cache aktualisieren
          $content .= dbx_convertArrayToPHPCode($config, '$config'); // Array in PHP-Code umwandeln
      }
   
      // Verzeichnis erstellen, falls es nicht existiert
      if (!is_dir($dir)) {
          mkdir($dir, 0700, true);
      }
   
      // Dateiinhalt schreiben und Erfolg prüfen
      $ok = file_put_contents($dir_file, $content);
      dbx()->debug("#CFG write ok=($ok) file=($dir_file)");
      if ($ok) {
          $_SESSION['dbx']['config_file'][$modul] = $dir_file;
          $this->register_editor_file('config', $dir_file);
      }
   
   
      return $ok ?: 0; // Gibt 0 zurück, falls `file_put_contents` fehlschlägt
   }

   public function send_mail($from, $to, string $subject = '', string $body = '', string $format = 'html', $attachments = array(), array $options = array()): int {
      $mail = $this->get_system_obj('dbxMail');
      if (!$mail) {
         return 0;
      }
 
      $mail->init();
      $options['from'] = $from;
 
      $format = strtolower(trim($format));
      if ($format === 'txt') {
         $format = 'text';
      }
 
      if ($format === 'html') {
         $mail->bodyhtml($body);
         if (isset($options['text'])) {
            $mail->bodytext((string) $options['text']);
         }
      } else {
         $mail->bodytext($body);
      }
 
      foreach ($this->normalize_mail_attachments($attachments) as $attachment) {
         if (is_array($attachment)) {
            $mail->attachfile(
               (string) ($attachment['path'] ?? $attachment['file'] ?? ''),
               (string) ($attachment['disposition'] ?? 'attachment'),
               (string) ($attachment['content_type'] ?? $attachment['type'] ?? ''),
               (string) ($attachment['cid'] ?? '')
            );
         } else {
            $mail->attachfile((string) $attachment);
         }
      }
 
      return (int) $mail->send($to, $subject, $options);
   }
 
   private function normalize_mail_attachments($attachments): array {
      if ($attachments === null || $attachments === '') {
         return array();
      }
 
      if (is_string($attachments)) {
         return array_filter(array_map('trim', preg_split('/[;,]+/', $attachments)));
      }
 
      if (is_array($attachments)) {
         if (isset($attachments['path']) || isset($attachments['file'])) {
            return array($attachments);
         }
         return $attachments;
      }
 
      return array();
   }

   public function get_remember_var(string $varname, $default = '', string $modul = 'modul') {
      // Initialisierung der Rückgabevariable
      $value = $default;
      $danger_value = '';
   
      // Wenn das Modul nicht angegeben ist, den aktiven Modulnamen aus der Session holen
      if ($modul == 'modul') {
          $modul = $this->get_system_var('dbx_activ_modul', 'dbx', '*');
      }
   
      // Überprüfen, ob die Variable in der Session unter der richtigen Modul-Sektion existiert
      if (isset($_SESSION['dbx']['remember'][$modul][$varname])) {
          $value = $_SESSION['dbx']['remember'][$modul][$varname];
      }
   
      // Rückgabe des validierten Werts oder des Standardwerts
      return $value;
   }

   public function set_remember_var(string $varname, $value, string $modul = 'modul') {
      // Wenn das Modul nicht angegeben ist, den aktiven Modulnamen aus der Session holen
      if ($modul == 'modul') {
          $modul = $this->get_system_var('dbx_activ_modul', 'dbx', '*');
      }
   
      // Setzt den Wert der Variable in der Session unter der "remember"-Sektion
      $_SESSION['dbx']['remember'][$modul][$varname] = $value;
   
      // Wenn das Modul 'dbx' ist, wird der Wert auch in der System-Session gespeichert
      if ($modul == 'dbx') {
          $this->set_system_var($varname, $value);
      }
   }

   public function get_session_var($key,$default=null,$section='sys',$modul='modul') {
     $val=$default;
     if ($modul=='modul')  $modul =$this->get_system_var('dbx_activ_modul' ,'dbx');
     if ($key != '*') {
       if (isset($_SESSION['dbx']['session'][$modul][$section][$key])) {
         $val=$_SESSION['dbx']['session'][$modul][$section][$key];
       }
     } else {
       if (isset($_SESSION['dbx']['session'][$modul][$section])) {
          $val=$_SESSION['dbx']['session'][$modul][$section];
       }
     }
     return $val;
   }

   public function set_session_var($key,$val,$section='sys',$modul='') {
     if (!$modul)   $modul =$this->get_system_var('dbx_activ_modul' ,'dbx');
     if ($key != '*') $_SESSION['dbx']['session'][$modul][$section][$key]=$val;
     if ($key == '*') $_SESSION['dbx']['session'][$modul][$section]=$val;
   }
   public function delete_session_var($key,$section='sys',$modul='modul') {
     if ($modul=='modul')  $modul =$this->get_system_var('dbx_activ_modul' ,'dbx');
     if ($key != '*') {
       if (isset($_SESSION['dbx']['session'][$modul][$section][$key])) {
           unset($_SESSION['dbx']['session'][$modul][$section][$key]);
       }
     }
     if ($key == '*') {
       if (isset($_SESSION['dbx']['session'][$modul][$section])) {
           unset($_SESSION['dbx']['session'][$modul][$section]);
       }
     }
     if ($key == '*' && $section=='*') {
      if (isset($_SESSION['dbx']['session'][$modul])) {
          unset($_SESSION['dbx']['session'][$modul]);
      }
    }
    //dbx_debug("DEL Session Store Key=($key) section=($section) Modul=($modul)"); 
   
   }

   public function action_token(string $scope = 'global'): string {
     $scope = preg_replace('/[^a-zA-Z0-9_.:-]/', '', $scope) ?: 'global';
     $tokens = $this->get_session_var('action_tokens', array(), 'security', 'dbx');
     if (!is_array($tokens)) {
       $tokens = array();
     }
 
     if (empty($tokens[$scope]) || !preg_match('/^[a-f0-9]{64}$/', (string)$tokens[$scope])) {
       $tokens[$scope] = bin2hex(random_bytes(32));
       $this->set_session_var('action_tokens', $tokens, 'security', 'dbx');
     }
 
     return (string)$tokens[$scope];
   }

   public function check_action_token(string $scope = 'global', string $token = ''): bool {
     $scope = preg_replace('/[^a-zA-Z0-9_.:-]/', '', $scope) ?: 'global';
     $expected = $this->action_token($scope);
     return $token !== '' && hash_equals($expected, $token);
   }

   public function user($key='id') {
      $current_user = $_SESSION['dbx']['current_user'] ?? array();
 
      if (defined('dbxRunAsAdmin') && (int) constant('dbxRunAsAdmin') === 1) {
         $current_user = $this->get_admin_bypass_user($current_user);
      }
 
      if ($key === '*') {
         return $current_user;
      }
 
      return $current_user[$key] ?? null;
   }

   private function get_admin_bypass_user(array $session_user = array()): array {
      if ((int)($session_user['id'] ?? 0) === 1) {
         return $session_user;
      }
 
      if ($this->admin_bypass_user_loaded || $this->admin_bypass_user_loading) {
         return $this->admin_bypass_user;
      }
 
      $this->admin_bypass_user = array_merge($session_user, array(
         'id'       => 1,
         'uname'    => 'admin',
         'roles'    => 'admin',
         'email'    => '',
         'name'     => 'Admin',
         'design'   => $session_user['design'] ?? 'default',
         'color'    => $session_user['color'] ?? 'default',
         'language' => $session_user['language'] ?? 'de',
         'edit'     => $session_user['edit'] ?? 0,
      ));
      $this->admin_bypass_user_loading = true;
 
      try {
         $session = $this->get_system_obj('dbxSession');
         if (is_object($session) && method_exists($session, 'get_current_user')) {
            $admin_user = $session->get_current_user(1);
            if (is_array($admin_user) && (int)($admin_user['id'] ?? 0) === 1) {
               $this->admin_bypass_user = $admin_user;
            }
         }
      } catch (\Throwable $e) {
         // Der sichere Admin-Fallback bleibt auch ohne verfuegbare DB erhalten.
      } finally {
         $this->admin_bypass_user_loading = false;
         $this->admin_bypass_user_loaded = true;
      }
 
      return $this->admin_bypass_user;
   }

   public function can($access_groups = '', $user_groups = '') {
       $access = 0;
       if (defined('dbxRunAsAdmin') && (int) constant('dbxRunAsAdmin') === 1) return 1;
       if ($access_groups=='*') return 1;
       if (!$access_groups)     return 1;
       $current_user_groups = !$user_groups;
       if ($current_user_groups) $user_groups = $_SESSION['dbx']['current_user']['roles'] ?? '';
 
       if (!is_array($user_groups))    $user_groups   = explode(',', $user_groups);
       if (!is_array($access_groups))  $access_groups = explode(',', $access_groups);
       $user_groups   = array_map('trim', $user_groups);
       $access_groups = array_map('trim', $access_groups);
 
       if ($current_user_groups && in_array('authenticated', $access_groups, true) && (int)$this->user() > 0) {
           return 1;
       }
   
       foreach ($user_groups as $role) {
           if ($role === 'admin') return 1; // Immer Zugriff für Admins
   
           foreach ($access_groups as $group) {
               if ($group === '*' || $group === $role)  $access = 1;           
               if ($access) break 2; // Beide Schleifen abbrechen
           }
       }
   
       return $access;
   }
 
   public function has_group($access_groups = '', $user_groups = '') {
      return $this->can($access_groups, $user_groups);   
   }

   public function is_dbx_edit(): bool {
      return (int) $this->get_system_var('dbx_edit', 0, 'int') > 0;
   }
 

   public function can_modul($modul) {
   
     $access=0;
     
     $current_user= $_SESSION['dbx']['current_user'] ?? array();
     $modul_config= $this->get_config($modul);
     $groups =$modul_config['groups'] ?? '';
     $uid    =$current_user['id'] ?? 0;
     $install=$this->get_system_var('dbx_install',0,'int');
 
     if (defined('dbxRunAsAdmin') && (int) constant('dbxRunAsAdmin') === 1) {
        return 1;
     }
     if ((int)$uid === 1) {
        return 1;
     }
 
     $access = $install ? 1 : $this->can($groups);
 
     if ($access==0) $this->set_system_var('dbx_noaccess_modul',"(User=$uid Modul=$modul)");
     return $access;
   }

   public function login($uid=0,$remember=0) {
     $old=$this->user();
     dbx()->debug("API dbx_login von ($old) Zu ($uid)");
     if ($uid != $old) {
       $oSession=$this->get_system_obj('dbxSession');
       $oSession->login($uid,$remember);
   
       $page     =  $this->get_base_url();
       $from     =  $this->user('email');
       $fromname =  $this->user('name');
       $subject  = 'Login ('.$from.') on ('.$page.') User=('.$uid.')';
       $text     = $subject;
       //$this->sys_msg('info','login',$uid,$subject,'ok');
       //dbx_sendMail($from,$fromname,'login@dbxapp.de',$subject,$text,'text'); // #todo 
   
     }
   }

   public function logout($uid=0) {
      if (!$uid) $uid=$this->user();
      dbx()->debug("API dbx_logout uid=($uid)"); 
      $oSession=$this->get_system_obj('dbxSession');
      $oSession->logout($uid);
   }

   public function get_base_url() {
      return $this->get_system_var('dbx_base_url','','*');  
   }

   public function get_self_url() {
      return $this->get_system_var('dbx_self_url','','*');
   }

   public function get_base_dir(int $cutData = 0): string {
      return dbx_get_base_dir($cutData);
   }

   public function get_file_dir(): string {
      return dbx_get_file_dir();
   }

   public function os_path(string $path): string {
      return dbx_os_path_file($path);
   }

   public function json_response(array $data, bool $withRuntime = false): void {
      if ($withRuntime) {
         $runtime = number_format($this->current_php_runtime(), 3, '.', '');
         $data['dbx_php_runtime'] = $runtime;
         $data['_dbx_runtime'] = array('php' => $runtime);
         $this->send_runtime_headers();
      }
 
      if (!headers_sent()) {
         header('Content-Type: application/json; charset=utf-8');
      }
 
      echo json_encode($data, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
      exit;
   }

   public function timer($section,$info='') {
      global $dbx_run_timer;
   
      $empty  = array();
      $time   = microtime(true);
      $memory = memory_get_peak_usage();
       
    
      if (!isset($dbx_run_timer[$section])) { 
         //dbx_debug("#TIMER NEW SET"); 
         $dbx_run_timer[$section]['start_time']  =$time;
         $dbx_run_timer[$section]['end_time']    =-1;
         $dbx_run_timer[$section]['start_memory']=$memory;
         $dbx_run_timer[$section]['end_memory']  =-1;
         $dbx_run_timer[$section]['time']        =-1;
         $dbx_run_timer[$section]['memory']      =-1;
         $dbx_run_timer[$section]['info']        =$info;
         $this->timer_state[$section] = array(
            'running'              => 1,
            'segment_start_time'   => $time,
            'segment_start_memory' => $memory,
            'segments'             => 0,
         );
      } else {
         $state = $this->timer_state[$section] ?? array();
         $running = (int) ($state['running'] ?? (($dbx_run_timer[$section]['end_time'] ?? -1) == -1 ? 1 : 0));
 
         if ($running) {
            //dbx_debug("#TIMER ADD SET");
            $segment_start_time   = (float) ($state['segment_start_time'] ?? $dbx_run_timer[$section]['start_time'] ?? $time);
            $segment_start_memory = (int) ($state['segment_start_memory'] ?? $dbx_run_timer[$section]['start_memory'] ?? $memory);
            $time_sum             = max(0, (float) ($dbx_run_timer[$section]['time'] ?? 0));
            $memory_sum           = max(0, (int) ($dbx_run_timer[$section]['memory'] ?? 0));
 
            $dbx_run_timer[$section]['end_time']  = $time;
            $dbx_run_timer[$section]['end_memory']= $memory;
            $dbx_run_timer[$section]['time']      = $time_sum + max(0, $time - $segment_start_time);
            $dbx_run_timer[$section]['memory']    = $memory_sum + max(0, $memory - $segment_start_memory);
            $this->timer_state[$section] = array(
               'running'              => 0,
               'segment_start_time'   => $segment_start_time,
               'segment_start_memory' => $segment_start_memory,
               'segments'             => (int) ($state['segments'] ?? 0) + 1,
            );
         } elseif ($info !== '') {
            if (($dbx_run_timer[$section]['info'] ?? '') === '') {
               $dbx_run_timer[$section]['info'] = $info;
            }
 
            $dbx_run_timer[$section]['end_time']    = -1;
            $dbx_run_timer[$section]['end_memory']  = -1;
            $this->timer_state[$section] = array(
               'running'              => 1,
               'segment_start_time'   => $time,
               'segment_start_memory' => $memory,
               'segments'             => (int) ($state['segments'] ?? 0),
            );
         }
      } 
      //dbx_debug("#TIMER ($section)",$dbx_run_timer);
    
   }

   public function skin_ids(): array {
      return array('hell', 'gelb', 'rot', 'gruen', 'blau', 'dunkel');
   }

   public function normalize_skin(string $skin = ''): string {
      $skin = strtolower(trim($skin));
 
      $map = array(
         'blue'   => 'blau',
         'blau'   => 'blau',
         'green'  => 'gruen',
         'gruen'  => 'gruen',
         'grün'   => 'gruen',
         'red'    => 'rot',
         'rot'    => 'rot',
         'black'  => 'dunkel',
         'dark'   => 'dunkel',
         'dunkel' => 'dunkel',
         'yellow' => 'gelb',
         'gelb'   => 'gelb',
         'light'  => 'hell',
         'hell'   => 'hell',
         'white'  => 'hell',
      );
 
      if ($skin !== '' && isset($map[$skin])) {
         $skin = $map[$skin];
      }
 
      if ($skin === '' || !in_array($skin, $this->skin_ids(), true)) {
         $cfg = strtolower(trim((string) $this->get_config('dbx', 'default_color', 'blau')));
         $skin = $map[$cfg] ?? $cfg;
      }
 
      if (!in_array($skin, $this->skin_ids(), true)) {
         $skin = 'blau';
      }
 
      return $skin;
   }

   public function get_skin(): string {
      return $this->normalize_skin((string) $this->get_system_var('dbx_color', ''));
   }

   public function get_skin_css(): string {
      $skin   = $this->get_skin();
      $design = (string) $this->get_system_var('dbx_activ_design', $this->get_system_var('dbx_design', 'dbxapp'));
 
      return 'dbx/design/' . $design . '/css/skin-' . $skin . '.css';
   }

   public function get_skin_class(): string {
      $skin = $this->get_skin();
      $cls  = 'skin-' . $skin;
 
      if ($skin === 'dunkel') {
         $cls .= ' theme-dark';
      }
 
      return $cls;
   }

   public function load_content_cache_classes(): void {
      static $loaded = false;
      if ($loaded) {
         return;
      }
 
      require_once dbx_os_path_file(dbx_get_base_dir() . 'dbx/modules/dbxContent/include/dbxContent_bootstrap_sync.php');
      $loaded = true;
   }

   public function get_content_permalink_mode(): string {
      $file = $this->os_path($this->get_base_dir() . 'dbx/modules/dbxContent/include/dbxContentLng.class.php');
      if (is_file($file)) {
         require_once $file;
      }
 
      return class_exists('\dbx\dbxContent\dbxContentLng')
         ? \dbx\dbxContent\dbxContentLng::permalinkMode()
         : 'content';
   }

   public function find_executable_path(string $command): string {
      static $cache = array();
 
      $command = trim($command);
      if ($command === '' || !preg_match('/^[a-zA-Z0-9_.-]+$/', $command)) {
         return '';
      }
 
      if (array_key_exists($command, $cache)) {
         return $cache[$command];
      }
 
      $lookup = stripos(PHP_OS_FAMILY, 'Windows') === 0
         ? 'where ' . $command . ' 2>NUL'
         : 'command -v ' . $command . ' 2>/dev/null';
 
      $result = trim((string)@shell_exec($lookup));
      $path = $result !== '' ? strtok($result, "\r\n") : '';
      $cache[$command] = is_string($path) ? trim($path) : '';
 
      return $cache[$command];
   }

   public function log_missing($missing = '') {
      $missing = trim((string)$missing);
      if ($missing === '') {
         return 0;
      }
 
      if (strlen($missing) > 250) {
         $missing = substr($missing, 0, 250);
      }
 
      try {
         $db = $this->get_system_obj('dbxDB');
         if (!is_object($db)) {
            return 0;
         }
 
         $uid = (int)$this->user();
         $rec = $db->select1('dbxMissing', array('missing' => $missing), 'id,count', 0);
 
         if (is_array($rec) && (int)($rec['id'] ?? 0) > 0) {
            $id = (int)$rec['id'];
            $db->update('dbxMissing', array(
               'count' => ((int)($rec['count'] ?? 0)) + 1,
            ), $id, 0, 1, 1, 0);
            return $id;
         }
 
         $ok = $db->insert('dbxMissing', array(
            'missing' => $missing,
            'count'   => 1,
            'owner'   => $uid,
         ), 0, 1, 1, 0);
 
         return $ok ? (int)$db->get_insert_id() : 0;
      } catch (\Throwable $e) {
         if (function_exists('dbx_write_php_error_log')) {
            dbx_write_php_error_log(get_class($e), $e->getMessage(), $e->getFile(), $e->getLine());
         }
      }
 
      return 0;
   }

   public function sys_msg($status = '', $about = '', $rid = '', $why = '', $what = '') {
      if ($this->sys_msg_running) {
         return 0;
      }
 
      $this->sys_msg_running = true;
 
      try {
         $trace  = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2);
         $caller = $trace[1] ?? null;
         $file   = $caller['file'] ?? '';
         $line   = (int)($caller['line'] ?? 0);
 
         $status = strtolower(trim((string)$status));
         if ($status === '') {
            $status = 'info';
         }
 
         $level_map = array(
            'debug'    => 5,
            'info'     => 10,
            'login'    => 15,
            'notice'   => 15,
            'warning'  => 20,
            'warn'     => 20,
            'security' => 30,
            'error'    => 40,
            'fatal'    => 50,
         );
 
         $level = $level_map[$status] ?? 10;
         if ($status === 'warn') {
            $status = 'warning';
         }
 
         $sysMsgLevel = strtolower(trim((string) $this->get_config('dbx', 'sys_msg_level', 'all')));
         if ($sysMsgLevel === '') {
            $sysMsgLevel = 'all';
         }
 
         $minLevel = 0;
         if ($sysMsgLevel === 'error') {
            $minLevel = 40;
         } elseif ($sysMsgLevel === 'warning' || $sysMsgLevel === 'warn') {
            $minLevel = 20;
         }
 
         if ($level < $minLevel) {
            return 0;
         }
 
         $modul  = $this->get_modul_var('dbx_modul', $this->get_system_var('dbx_activ_modul' , 'dbx', '*'), rules: '*');
         $action = $this->get_modul_var('dbx_run1' , $this->get_system_var('dbx_activ_action', ''   , '*'), rules: '*');
         $work   = $this->get_modul_var('dbx_run2' , '', '*');
 
         $data_json = '';
         if (is_array($what) || is_object($what)) {
            $data_json = json_encode($what, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
            $what_text = $data_json ?: '';
         } else {
            $what_text = (string)$what;
         }
 
         $message_parts = array();
         if ((string)$about !== '') $message_parts[] = (string)$about;
         if ((string)$why   !== '') $message_parts[] = 'why=' . (string)$why;
         if ($what_text     !== '') $message_parts[] = 'what=' . $what_text;
         if ((string)$rid   !== '') $message_parts[] = 'rid=' . (string)$rid;
         $message = implode(' | ', $message_parts);
 
         $record = array(
            'xuser'       => $this->user('id'),
            'level'       => $level,
            'status'      => $status,
            'about'       => (string)$about,
            'rid'         => (string)$rid,
            'why'         => (string)$why,
            'what'        => $what_text,
            'message'     => $message,
            'modul'       => (string)$modul,
            'action'      => (string)$action,
            'work'        => (string)$work,
            'source_file' => (string)$file,
            'source_line' => $line,
            'data_json'   => $data_json,
         );
 
         $oDB = $this->get_system_obj('dbxDB');
         $prevReport = (int)$oDB->_report_error;
         $oDB->_report_error = 0;
         $ok  = $oDB->insert('dbxSysMsg', $record, 0, 1, 0, 0);
         $oDB->_report_error = $prevReport;
         $insertId = $ok ? $oDB->get_insert_id() : 0;
 
         dbx()->debug("##SYS-MSG### ok=($ok) id=($insertId) Level=($level) Status=($status) Modul=($modul) Action=($action) Work=($work) About=($about) RID=($rid) Why=($why) What=($what_text)");
 
         return (int)$insertId;
      } finally {
         $this->sys_msg_running = false;
      }
   }

   public function norep($norep,$i=0) {
      $norep=str_replace("\r",'',$norep);
      $norep_id='norep_'.$this->next_id();
      $_SESSION['dbx']['norep'][$norep_id]=$norep;
      return '['.$norep_id.']';
   }

   public function next_id(int $add = 1): int {
      // Aktuellen Zählerwert aus der "Remember"-Datenstruktur abrufen
      $i = $this->get_remember_var('dbx_next_i', 0, 'dbx');
      
      // Zähler um den angegebenen Wert erhöhen
      $i += $add;
   
      // Aktualisierten Zählerwert in die "Remember"-Datenstruktur speichern
      $this->set_remember_var('dbx_next_i', $i, 'dbx');
   
      // Neuen Zählerwert zurückgeben
      return $i;
   }

   public function is_modul($modul) {
       $retval=false;
       if ($modul) {
         $modul_class_file=dbx_get_base_dir()."dbx/modules/$modul/".$modul.".class.php";
         if (file_exists($modul_class_file)) $retval=true;
       }
       return $retval;
   }

   public function is_design($design,$page='default') {
      $admin=$this->can('admin');
      $firstchar=substr($design,0,1);
      if (!$admin && $firstchar == '_') return false;
      if (!$admin && $firstchar == '-') return false;
    
      $design_tpl=dbx_get_base_dir()."dbx/design/$design/htm/$page.htm";
      if (file_exists($design_tpl)) return true;
      if ($page != 'default') {
         $design_tpl=dbx_get_base_dir()."dbx/design/$design/htm/default.htm";
         if (file_exists($design_tpl)) return true;      
      }
      
      return false;
   }

   public function redirect($redirect, $timer = 0) {
       $timer = ($timer * 1000);
       $base  = $this->get_base_url();
       $ajax  = $this->get_system_var('dbx_ajax', 0, 'int');
    
       dbx()->debug("run redirect ($redirect)");
    
       if (!str_contains($redirect, '://')) 
          $redir = $base . $redirect;
       else 
          $redir = $redirect;
    
       dbx()->debug("#dbx_redirect  Call=($redirect)  redir=($redir) Ajax=($ajax) timer=($timer)");
    
       $redir_js = json_encode($redir);
   
       if (!$timer) {
          $script = "<script>window.location.replace($redir_js);</script>";
       } else {
          $script = "<script>setTimeout(function() { window.location.replace($redir_js); }, $timer);</script>";
       }
    
       return $script;
   }

   public function set_cookie_var($cookie,$key,$val) {
     $_SESSION['dbx']['cookie'][$cookie][$key]=$val;
   }

   public function has_text($string,$find) {
      return strpos('~'.$string,$find);
   }

   public function html($html) {
      return htmlentities($html, ENT_QUOTES);
   }

   public function esc($value): string {
      return htmlspecialchars(
         (string)$value,
         ENT_QUOTES | ENT_SUBSTITUTE,
         'UTF-8'
      );
   }

   public function search_defaults(array $overrides = array()): array {
      $defaults = array(
         'placeholder' => '🔍',
         'title'       => 'Suchen',
         'tooltip'     => '',
         'errormsg'    => '',
         'input_class' => 'form-control-sm dbx-grid-search',
         'data_role'   => 'search',
         'wrap_class'  => '',
         'wrap_style'  => '',
         'extra_attrs' => '',
      );
 
      if (array_key_exists('placeholder', $overrides) && trim((string) $overrides['placeholder']) === '') {
         unset($overrides['placeholder']);
      }
 
      return array_merge($defaults, $overrides);
   }

   public function search_html(array $opts = array()): string {
      $opts = $this->search_defaults($opts);
      $i = (int) ($opts['i'] ?? 0);
      $name = (string) ($opts['name'] ?? '');
      $label = trim((string) ($opts['label'] ?? ''));
      $tooltip = trim((string) ($opts['tooltip'] ?? '')) !== ''
         ? (string) $opts['tooltip']
         : (string) ($opts['title'] ?? 'Suchen');
 
      $data = array(
         'name'         => $this->esc($name),
         'value'        => $this->esc((string) ($opts['value'] ?? '')),
         'placeholder'  => $this->esc((string) ($opts['placeholder'] ?? '🔍')),
         'title'        => $this->esc((string) ($opts['title'] ?? 'Suchen')),
         'tooltip'      => $this->esc($tooltip),
         'errormsg'     => $this->esc((string) ($opts['errormsg'] ?? '')),
         'class'        => $this->esc((string) ($opts['class'] ?? '')),
         'input_class'  => $this->esc((string) ($opts['input_class'] ?? 'form-control-sm dbx-grid-search')),
         'wrap_class'   => $this->esc((string) ($opts['wrap_class'] ?? '')),
         'wrap_style'   => $this->esc((string) ($opts['wrap_style'] ?? '')),
         'data_role'    => $this->esc((string) ($opts['data_role'] ?? 'search')),
         'extra_attrs'  => (string) ($opts['extra_attrs'] ?? ''),
      );
 
      $html = $this->get_system_obj('dbxTPL')->get_tpl('dbx|search', $data, 'htm', $i);
 
      if ($label === '') {
         return $html;
      }
 
      $fieldId = $this->esc($name !== '' ? $name . '_' . $i : 'dbx_search_' . $i);
      $style = $this->esc((string) ($opts['style'] ?? ''));
 
      return '<div class="fld-frame dbx-search-field" style="' . $style . '">'
         . '<label for="' . $fieldId . '" class="control-label">' . $this->esc($label) . '</label>'
         . $html
         . '</div>';
   }

   public function timestamp($add_sec=0) {
       list($usec, $sec) = explode(" ",microtime());
       $time= ((float)  $usec + (float)$sec);
       $time=  (float) ($time + ($add_sec));
       return $time;
   }

   public function time_diff($starttime=0,$endtime=0) {
     if (!$starttime) $starttime=$this->timestamp();
     if (!$endtime)   $endtime  =$this->timestamp();
     return ($endtime-$starttime);
   }

   public function part_select($vor,$nach,$part) {
     $leng= strlen($vor);
     $pos1= strpos($part, $vor);
   
     if ($pos1 === false) {
       return '';
     }
   
     $part= substr($part, ($pos1+$leng));
     $pos2= strpos($part, $nach);
   
     if ($pos2 === false) {
       return '';
     }
   
     $part= substr($part, 0,$pos2);
   
     return $part;
   }

   public function parse_url($data) {
     if (!is_array($data)) {
       $first=substr($data,0,1);
       if ($data && $first != '=') {
          if (strpos($data,'=')) {
            parse_str($data,$xdata);
            $data=$xdata;
          }
       }
     }
     return $data;
   }

   public function is_int_value($value) {
      if (is_int($value)) return 1;
      if (is_string($value) && filter_var($value, FILTER_VALIDATE_INT) !== false) return 1;
      return 0;
   }

   public function new_password($minlength, $special = '-_!') {
       $passwort  = '';
       $syllabels = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789' . $special;
       $len       = strlen($syllabels) - 1;
       
       // Sicherheit: Prüfen, ob Mindestlänge gültig ist
       if ($minlength < 1) return '';
   
       // Box mit zufälligen Zeichen füllen
       $box = '';
       for ($i = 0; $i < 300; $i++) {
           $ch = $syllabels[mt_rand(0, $len)];
           if (ctype_lower($ch) && mt_rand(0, 4) == 1) {
               $ch = strtoupper($ch); // Etwa 20 % der Kleinbuchstaben in Großbuchstaben umwandeln
           }
           $box .= $ch;
       }
   
       // Passwort aus der Box zusammenstellen
       for ($i = 0; $i < $minlength; $i++) {
           $passwort .= $box[mt_rand(0, 299)];
       }
   
       return $passwort;
   }

   public function debug_timer($max=0) {
      Global $dbx_run_timer;
      if (isset($dbx_run_timer['system']['time'])) {
         $time=$dbx_run_timer['system']['time'];
         if ($time > $max) { 
            $this->debug("#RUN-TIMER",$dbx_run_timer);
         } else {
            $this->debug("dbx System run time=($time)");
         }  
      }
   }

   public function current_php_runtime(): float {
      global $dbx_run_timer;
 
      if (isset($dbx_run_timer['system']['time']) && is_numeric($dbx_run_timer['system']['time']) && (float) $dbx_run_timer['system']['time'] >= 0) {
         return (float) $dbx_run_timer['system']['time'];
      }
 
      if (isset($dbx_run_timer['system']['start_time']) && is_numeric($dbx_run_timer['system']['start_time'])) {
         return max(0.0, microtime(true) - (float) $dbx_run_timer['system']['start_time']);
      }
 
      return 0.0;
   }

   public function current_memory_bytes(): int {
      global $dbx_run_timer;
 
      if (isset($dbx_run_timer['system']['memory']) && is_numeric($dbx_run_timer['system']['memory']) && (float) $dbx_run_timer['system']['memory'] >= 0) {
         return (int) round((float) $dbx_run_timer['system']['memory']);
      }
 
      if (isset($dbx_run_timer['system']['start_memory'], $dbx_run_timer['system']['end_memory'])
          && is_numeric($dbx_run_timer['system']['start_memory'])
          && is_numeric($dbx_run_timer['system']['end_memory'])) {
         return max(0, (int) round((float) $dbx_run_timer['system']['end_memory'] - (float) $dbx_run_timer['system']['start_memory']));
      }
 
      return 0;
   }

   public function send_runtime_headers(): void {
      if (headers_sent()) {
         return;
      }
 
      $runtime = $this->current_php_runtime();
      header('X-DBX-PHP-Runtime: ' . number_format($runtime, 3, '.', ''));
      header('Server-Timing: dbxphp;dur=' . number_format($runtime * 1000, 3, '.', '') . ';desc="DBX PHP Runtime"', false);
   }

   public function store_performance_timer(): int {
      try {
         $file = dbx_os_path_file(dbx_get_base_dir() . 'dbx/modules/dbx/include/dbxPerformanceTimer.class.php');
         if (!is_file($file)) {
            return 0;
         }
 
         include_once $file;
         if (!class_exists('dbxPerformanceTimer')) {
            return 0;
         }
 
         $timer = new \dbxPerformanceTimer();
         if (!method_exists($timer, 'store')) {
            return 0;
         }
 
         return (int) $timer->store();
      } catch (\Throwable $e) {
         if (function_exists('dbx_write_php_error_log')) {
            dbx_write_php_error_log(get_class($e), $e->getMessage(), $e->getFile(), $e->getLine());
         }
         return 0;
      }
   }

   public function debug2($line) {
      $file = dbx_get_file_dir() . "dbxDebug2.txt";
      $file = dbx_os_path_file($file);
      file_put_contents($file, $line, FILE_APPEND);
   }

   public function debug($txt, $data1 = '', $data2 = '', $data3 = '') {
      $activ = $this->get_remember_var('dbx_debug_activ', -1, 'dbx');
      if ($activ == -1) {
         $activ = 0;
         $debugActiv = dbx_get_file_dir() . "dbxDebugActiv.txt";
         $debugActiv = dbx_os_path_file($debugActiv);
         if (file_exists($debugActiv)) {
            $activ = 1;
         }
         $this->set_remember_var('dbx_debug_activ', $activ, 'dbx');
      }
 
      if (!$activ) {
         return;
      }
 
      $vars = '';
      $file = dbx_get_file_dir() . "dbxDebug.txt";
      $file = dbx_os_path_file($file);
 
      foreach (array($data1, $data2, $data3) as $data) {
         if (is_array($data)) {
            $vars .= print_r($data, true);
         } else {
            if ($data > '') {
               $vars .= $data . "\n";
            }
         }
      }
 
      $txt .= "\n" . $vars . "\n";
      file_put_contents($file, $txt, FILE_APPEND);
   }

   private function get_SysClassOverrideName(string $class): string {
      if (str_starts_with($class, 'dbx')) {
         $suffix = substr($class, 3);
         return 'my' . ($suffix ?: $class);
      }
      return 'my' . $class;
   }

   private function ensure_SysClassOverride(string $class, string $myClass, string $baseClass): string {
      if ($baseClass === "\\dbxUndefClass" || !class_exists($baseClass, false)) {
         return '';
      }
 
      $moduleDir = dbx_os_path_file(dbx_get_base_dir() . 'dbx/modules/myX/');
      $sysDir    = dbx_os_path_file($moduleDir . 'sysclass/');
      $file      = dbx_os_path_file($sysDir . $myClass . '.class.php');
 
      if (!is_dir($sysDir)) {
         mkdir($sysDir, 0777, true);
      }
 
      $cfgDir = dbx_os_path_file($moduleDir . 'cfg/');
      if (!is_dir($cfgDir)) {
         mkdir($cfgDir, 0777, true);
      }
 
      $cfgFile = dbx_os_path_file($cfgDir . 'config.php');
      if (!file_exists($cfgFile)) {
         file_put_contents($cfgFile, "<?php\n\$config['version']='1';\n\$config['activ']='1';\n\$config['groups']='*';\n");
      }
 
      $moduleFile = dbx_os_path_file($moduleDir . 'myX.class.php');
      if (!file_exists($moduleFile)) {
         file_put_contents($moduleFile, "<?php\nnamespace dbx\\myX;\n\nclass myX {\n   public function run() {\n      return 'myX system module';\n   }\n}\n");
      }
 
      if (!file_exists($file)) {
         $content  = "<?php\n";
         $content .= "/**\n";
         $content .= " * Auto-generated DBX system class override.\n";
         $content .= " * Requested class: $class\n";
         $content .= " * Override class: $myClass\n";
         $content .= " */\n";
         $content .= "class $myClass extends $class {\n";
         $content .= "}\n";
         file_put_contents($file, $content);
      }
 
      return $file;
   }
}

function dbx(): dbxApi {
   static $api = null;
   if ($api === null) {
      $api = new dbxApi();
   }
   return $api;
}
 

function ge_stichtag() {
    $heute  = new DateTime();
    $grenze = new DateTime('2025-06-01');
    return $heute >= $grenze;
}
 

function dbx_copy_recursive($src, $dst) {
    $src = rtrim($src, '/\\');
    $dst = rtrim($dst, '/\\');
 
    if (!is_dir($src)) {
        dbx()->debug("dbx_copy_recursive Error DIR");
        return 0;
    }
 
    if (!file_exists($dst)) {
        if (!mkdir($dst, 0777, true)) {
            dbx()->debug("dbx_copy_recursive mkdir Error($dst)");
            return 0;
        }
    }
 
    $items = scandir($src);
    foreach ($items as $item) {
        if ($item === '.' || $item === '..') {
            continue;
        }
 
        $srcPath = $src . DIRECTORY_SEPARATOR . $item;
        $dstPath = $dst . DIRECTORY_SEPARATOR . $item;
 
        if (is_dir($srcPath)) {
            // Rekursiv für Verzeichnisse
            if (!dbx_copy_recursive($srcPath, $dstPath)) {
                dbx()->debug("dbx_copy_recursive Error A");
                return 0;
            }
        } else {
            // Datei kopieren (überschreiben erlaubt)
            if (!copy($srcPath, $dstPath)) {
                dbx()->debug("dbx_copy_recursive Error B");
 
                return 0;
            }
        }
    }
 
    return 1;
}
 
 
 

function dbx_DateTime($date_time='now',$calc=0,$special='') {
   $timezone = 'Europe/Berlin';
   $offset   = 0;  // Offset Sommer/Winter
 
   if ($date_time=='now') {
      $offset   = (60*60*$offset);
      $calc=($calc + $offset);
      $date_time = date("Y-m-d  H:i:s", (time()  + $calc));
   } else {
      $offset   = (60*60*$offset);
      $calc=($calc + $offset);
      $date_time = date("Y-m-d  H:i:s", (strtotime($date_time) + $calc ));
   }
    
   if ($special) {
      $time=strtotime($date_time);
      $date_time=date("Y-m-d  H:i:s", strtotime($special, $time));
   }
 
 
   $week_start  = strtotime('last Sunday', time());
   $week_end    = strtotime('next Sunday', time());
   
   $month_start = strtotime('first day of this month', time());
   $month_end   = strtotime('last day of this month', time());
   
   $year_start  = strtotime('first day of January', time());
   $year_end    = strtotime('last day of December', time());
 
    //$now_date = gmdate("Y-m-d  H:i:s", (time()  + $calc));
    return  $date_time;
}
 

function dbx_make_dir(string $path): int {
    // Prüfen, ob das Verzeichnis bereits existiert
    if (is_dir($path)) return 1;
 
    // Versuchen, das Verzeichnis rekursiv zu erstellen
    if (mkdir($path, 0777, true)) {
        return 1; // Erfolgreich erstellt
    }
 
    return 0; // Fehler beim Erstellen
}
 

function dbx_sendMail($from,$fromname,$to,$subject,$text,$type='html',$attach='',$archiv=0) {
    $from = array('email' => $from, 'name' => $fromname);
    return dbx()->send_mail($from, $to, (string) $subject, (string) $text, (string) $type, $attach);
}
 

function dbx_is_page($page,$design,$lng='') {
    $retval=false;
    $page_tpl=dbx_get_base_dir()."dbx/tpl/htm/$page.htm";
    if (file_exists($page_tpl)) $retval=true;
    return $retval;
}
 
 
 
 
 
   
 

function dbx_lng_current(): string {
   $lng = strtolower(trim((string) dbx()->get_system_var('dbx_lng', 'de')));
   return $lng !== '' ? $lng : 'de';
}

function dbx_accessible_lngs(): array {
   $raw = dbx()->get_config('dbx', 'accessible_lng', 'de');
   if ($raw === 'undef' || $raw === '' || $raw === null) {
      $raw = 'de';
   }
   if (is_array($raw)) {
      $out = array();
      foreach ($raw as $val) {
         $val = strtolower(trim((string) $val));
         if ($val !== '' && $val !== 'undef' && preg_match('/^[a-z]{2,3}$/', $val)) {
            $out[] = $val;
         }
      }
      return count($out) ? $out : array('de');
   }
 
   $parts = preg_split('/\s*,\s*/', (string) $raw, -1, PREG_SPLIT_NO_EMPTY);
   $out = array();
   if (is_array($parts)) {
      foreach ($parts as $val) {
         $val = strtolower(trim((string) $val));
         if ($val !== '' && $val !== 'undef' && preg_match('/^[a-z]{2,3}$/', $val)) {
            $out[] = $val;
         }
      }
   }
 
   return count($out) ? $out : array('de');
}

function dbx_lng_name(string $base, string $lng = ''): string {
   $base = trim($base);
   if ($base === '') {
      return '';
   }
 
   $lng = strtolower(trim($lng !== '' ? $lng : dbx_lng_current()));
   if ($lng === '') {
      return $base;
   }
 
   return $base . '_' . $lng;
}

function dbx_lng_resolve_file(string $dir, string $name, string $ext, string $lng = '', bool $fallback = true): string {
   $dir = str_replace('\\', '/', $dir);
   if ($dir !== '' && substr($dir, -1) !== '/') {
      $dir .= '/';
   }
 
   $name = strtolower(trim($name));
   $ext  = ltrim(strtolower(trim($ext)), '.');
   if ($name === '' || $ext === '') {
      return '';
   }
 
   $lng = strtolower(trim($lng !== '' ? $lng : dbx_lng_current()));
   if ($lng !== '') {
      $pathLng = $dir . $name . '_' . $lng . '.' . $ext;
      if (is_file($pathLng)) {
         return function_exists('dbx_os_path_file') ? dbx_os_path_file($pathLng) : $pathLng;
      }
   }
 
   if (!$fallback) {
      return '';
   }
 
   $pathDef = $dir . $name . '.' . $ext;
   if (is_file($pathDef)) {
      return function_exists('dbx_os_path_file') ? dbx_os_path_file($pathDef) : $pathDef;
   }
 
   return '';
}

function dbx_modul_translate($content,$modul='',$lng='') {
   if (!$modul) $modul=dbx()->get_system_var('dbx_activ_modul','dbx');
   if (!$lng)     $lng=dbx()->get_system_var('dbx_lng','de');
   $dir_file=dbx_get_base_dir()."dbx/modules/$modul/translate.php";
   $dir_file=dbx_os_path_file($dir_file);
   if (file_exists($dir_file)) {
      include $dir_file;
   }
   return $content;
}

function dbx_replace_first($search_str, $replacement_str, $src_str){
  return (false !== ($pos = strpos($src_str, $search_str))) ? substr_replace($src_str, $replacement_str, $pos, strlen($search_str)) : $src_str;
}
 

function dbx_convertArrayToPHPCode(array $array, string $prefix): string {
   $code = "";
 
   foreach ($array as $key => $value) {
       // Generiere den Schlüssel (numerisch oder als String)
       $keyPart = is_numeric($key) ? "[$key]" : "['" . addslashes($key) . "']";
 
       if (is_array($value)) {
           // Rekursive Verarbeitung für verschachtelte Arrays
           $code .= dbx_convertArrayToPHPCode($value, $prefix . $keyPart);
       } else {
           // Wert formatieren
           if (is_string($value)) {
               // Strings escapen (inklusive Backslashes)
               $formattedValue = "'" . addslashes($value) . "'";
           } elseif (is_bool($value)) {
               // Booleans in `true` oder `false` konvertieren
               $formattedValue = $value ? 'true' : 'false';
           } elseif ($value === null) {
               // `null` als Wert setzen
               $formattedValue = 'null';
           } else {
               // Andere Datentypen (z. B. Zahlen) direkt verwenden
               $formattedValue = $value;
           }
 
           // PHP-Code-Zuweisung generieren
           $code .= "$prefix$keyPart = $formattedValue;\n";
       }
   }
 
   return $code;
}
 

function dbx_convert_charset(string $in, string $charset, string $incharset = 'UTF-8'): string {
   // Nur konvertieren, wenn Zielkodierung von Eingabekodierung abweicht
   if ($charset !== $incharset) {
       // Spezielle Behandlung für deutsche Umlaute und scharfes S
       $umlaute = [
           'ä' => chr(228), 'ö' => chr(246), 'ü' => chr(252), 'ß' => chr(223),
           'Ä' => chr(196), 'Ö' => chr(214), 'Ü' => chr(220)
       ];
       $in = str_replace(array_keys($umlaute), array_values($umlaute), $in);
 
       // Kodierung mit automatischer Erkennung der Eingabekodierung konvertieren
       $in = mb_convert_encoding(
           $in,
           $charset,
           mb_detect_encoding($in, "UTF-8, $charset, ISO-8859-1, ISO-8859-15", true)
       );
   }
 
   return $in;
}
 

function dbx_add_modul(string $modul, string $action, string $work = ''): string {
   // Grundstruktur mit Modul und Aktion aufbauen
   $content = '[modul=' . $modul . ']dbx_run1=' . $action;
 
   // Falls 'work' definiert ist, hinzufügen
   if (!empty($work)) {
       $content .= '&dbx_run2=' . $work;
   }
 
   // Abschluss des Modul-Strings
   $content .= '[/modul]';
   return $content;
}
 
 

function dbx_validate_var($danger_value, $rules = 'parameter', $varname = 'undef'): bool {
   // Wenn keine Validierung erforderlich ist, einfach true zurückgeben
   if ($rules == '*') return true;
   // Validator-Objekt aus dem Cache holen
   $oValidator = dbx()->get_system_obj('dbxValidator'); // #cache for speed
   // Validierung durchführen
   return $oValidator->validate($danger_value, $rules, $varname);
}
 
 
 
 

// Session
 
//  Session - - - - - - - - - - - - - - - - - - - - - - - - -

function dbx_make_seed(){
    list($usec, $sec) = explode(' ', microtime());
    return (float) $sec + ((float) $usec * 100000);
}

function dbx_load_cookie($cookie) {
   $data=array();
   if (isset($_COOKIE[$cookie])) $data = json_decode($_COOKIE[$cookie], true);
   $_SESSION['dbx']['cookie'][$cookie]=$data;
}
 
 
function dbx_save_cookie($cookie,$hh=12) {
   $data=$_SESSION['dbx']['cookie'][$cookie];
   setcookie($cookie, json_encode($data), time()+3600*$hh,'/');
}
 
function dbx_delete_cookie($cookie) {
  setcookie($cookie, '', time() - 3600, '/');
}
 
 
function dbx_get_cookie_val($cookie,$key,$default='') {
  $val=$default;
  if (isset($_SESSION['dbx']['cookie'][$cookie][$key])) {
     $val=$_SESSION['dbx']['cookie'][$cookie][$key];
  }
  return $val;
}
 
 
// Format Value
function dbx_get_Date($date, $io, $default = ''): string {
   //dbx_debug("dbx_get_Date($date) io=($io) defalut=($default)"); 
   if (!$date || $date===null) $date=''; 
   $date = trim($date);
 
   // Ensure the date only contains valid characters.
   if (!preg_match('#^[0-9./-]+$#', $date)) {
       dbx()->set_system_var('dbx_validate_error', 1);
       return $default;
   }
 
   // Check date length.
   if (strlen($date) !== 10) {
       dbx()->set_system_var('dbx_validate_error', 1);
       return $default;
   }
 
   // Determine delimiter and split the date.
   $delimiter = '';
   if (strpos($date, '-') !== false) {
       $delimiter = '-';
   } elseif (strpos($date, '.') !== false) {
       $delimiter = '.';
   } elseif (strpos($date, '/') !== false) {
       $delimiter = '/';
   }
 
   if (!$delimiter) {
       dbx()->set_system_var('dbx_validate_error', 1);
       return $default;
   }
 
   $parts = explode($delimiter, $date);
 
   // Ensure valid parts based on delimiter.
   if (count($parts) !== 3) {
       dbx()->set_system_var('dbx_validate_error', 1);
       return $default;
   }
 
   [$first, $second, $third] = $parts;
 
   // Determine the format (DD.MM.YYYY or YYYY-MM-DD).
   if ($delimiter === '-') {
       [$year, $month, $day] = [$first, $second, $third];
   } else {
       [$day, $month, $year] = [$first, $second, $third];
   }
 
   // Validate the extracted date.
   if (!checkdate((int)$month, (int)$day, (int)$year)) {
       dbx()->set_system_var('dbx_validate_error', 1);
       return $default;
   }
 
   // Format date based on the desired output.
   if ($io === 'web') {
       return sprintf('%02d.%02d.%04d', $day, $month, $year);
   } elseif ($io === 'php') {
       return sprintf('%04d-%02d-%02d', $year, $month, $day);
   }
 
   // Default return in case of unsupported $io value.
   dbx()->set_system_var('dbx_validate_error', 1);
   return $default;
}
 
 
function dbx_get_webDate($date,$default='') {
 $date=dbx_get_Date($date,'web');
 if (!$date) $date=$default;
 return $date;
}
 
function dbx_get_phpDate($date,$default='') {
 $date=dbx_get_Date($date,'php');
 if (!$date) $date=$default;
 return $date;
}
 
 
 
function dbx_get_webDateTime($date_time,$default='') {
 $date=substr($date_time, 0, 10);
 $time=substr($date_time,11,  8);
 $date=dbx_get_Date($date,'web');
 return $date.' '.$time;
}
 
 
// Secure
 
function dbx_is_Login() {
   return dbx()->user('id');
}

function dbx_set_CurrentUser($key,$value) {
   if ($key != '*') {
      $_SESSION['dbx']['current_user'][$key]=$value;
   } else {
     $_SESSION['dbx']['current_user']=$value;
   }
}
function dbx_is_decimal($value) {
   if (trim($value)=='') return FALSE;
   $lang   = strlen($value);
   $okcahr = '-0123456789.,';
   for ($i = 0; $i < $lang; $i++) {
     $char = $value[$i];
     $ok = strrpos($okcahr, $char);
     if ($ok === FALSE) return FALSE;
   }
   return TRUE;
}
 
 
 
 
// Time
 
 
function dbx_get_Today($days=0) {
  $today = getdate();
  $date=$today['year'].'-'.$today['mon'].'-'.$today['mday'];
  //return $date;
 
  $date_t = strtotime($date.' UTC');
  return gmdate('Y-m-d',$date_t + ($days*86400));
 
 
}
 
function dbx_get_Microtime() {
  list($usec, $sec) = explode(' ',microtime());
  return ((float)$usec + (float)$sec);
}
 
// File Upload
 
function dbx_upload() {
   $oUpload=dbx()->get_system_obj('dbxUpload');
 
}
 
 
// Mail
 
 
 
 
 
 
function dbx_html2txt($txt) {
   $txt = dbx_html2src($txt);
   $txt = str_replace('<br/>',"\n", $txt );
   $txt = str_replace('<br>' ,"\n", $txt );
   return $txt;
}
 
function dbx_txt2html($txt) {
   $txt = str_replace("\n",'<br/>',$txt);
   return $txt;
}
 
function dbx_html2src($html_in) {
  $html_in=stripslashes($html_in);
  $html_in = str_replace ('&nbsp;' , ' ', $html_in);
  $html_in = str_replace ('&amp;'  , '&', $html_in);
  $html_in = str_replace ('&quot;' , '"', $html_in);
  $html_in = str_replace ('&#039;' , "'", $html_in);
  $html_in = str_replace ('&lt;'   , '<', $html_in);
  $html_in = str_replace ('&gt;'   , '>', $html_in);
  $html_in = str_replace ('%7B'    , '{', $html_in);
  $html_in = str_replace ('%7D'    , '}', $html_in);
 
  $html_in = str_replace ('&uuml;', 'ü', $html_in);
  $html_in = str_replace ('&ouml;', 'ö', $html_in);
  $html_in = str_replace ('&auml;', 'ä', $html_in);
  $html_in = str_replace ('&Uuml;', 'Ü', $html_in);
  $html_in = str_replace ('&Ouml;', 'Ö', $html_in);
  $html_in = str_replace ('&Auml;', 'Ä', $html_in);
 
  return $html_in;
}
 
 
 
// dbx Util
 
 
function dbx_interpreter($content) {
   $int=dbx()->get_system_obj('dbxInterpreter');
   $content=$int->run($content);
   return $content;
}
 
 
 
// crypt / decrypt
 
// use \phpseclib3\Crypt\AES; // wird am anfang gemacht.

function dbx_decrypt($content, $xkey = '', $master = '') {
    try {
        if (!$master) {
            $master = dbx()->get_config('dbx', 'crypt');
            if (!$master) {
                throw new Exception("Master key is not set.");
            }
        }
 
        if (!$xkey) {
            $xkey = 'jkgj89bz7b789345%$&8t5';
        }
 
        $crypt_key = md5($xkey . $master);
        $key = substr($crypt_key, 0, 16);
        $iv = substr($crypt_key, -16);
 
        //dbx_debug("decrypt ($xkey) ($master) Key=($key) IV=($iv)");
 
        $aes = new AES('cbc');
        $aes->setKey($key);
        $aes->setIV($iv);
 
        $decrypt_content = $aes->decrypt($content);
 
        return $decrypt_content;
    } catch (Exception $e) {
        dbx()->debug("Decryption error: " . $e->getMessage());
        return false;
    }
}

function dbx_crypt($content, $xkey = '', $master = '') {
    try {
 
        if (!$master) {
            $master = dbx()->get_config('dbx', 'crypt');
            if (!$master) {
                throw new Exception("Master key is not set.");
            }
        }
 
        if (!$xkey) {
            $xkey = 'jkgj89bz7b789345%$&8t5';
        }
 
        $crypt_key = md5($xkey . $master);
        $key = substr($crypt_key, 0, 16);
        $iv = substr($crypt_key, -16);
 
        //dbx_debug("crypt ($xkey) ($master) Key=($key) IV=($iv)");
 
        $aes = new AES('cbc');
        $aes->setKey($key);
        $aes->setIV($iv);
 
        $crypt_content = $aes->encrypt($content);
 
        return $crypt_content;
    } catch (Exception $e) {
        dbx()->debug("Encryption error: " . $e->getMessage());
        return false;
    }
}