dbxEdit_fd.class.php

Go to the documentation of this file.

<?php
namespace dbx\dbxAdmin;

class dbxEdit_fd
{
    private $_admin_modul = 'dbxAdmin';
    private $_fd_field = 'dbxAdmin|ddedit-field';
 
    public function run()
    {
        $work = dbx()->get_modul_request_var('dbx_run2', '');
 
        switch ($work) {
            case 'create_form_fd':
                return $this->create_form_fd();
 
            case 'delete_field':
                return $this->delete_field();
 
            case 'save_field_order':
                return $this->save_field_order();
 
            case 'create_from_dd':
                return $this->create_from_dd();
 
            case '':
            case 'editor':
            default:
                return $this->run_editor();
        }
    }
 
    private function run_editor()
    {
        list($modul, $fd) = $this->fd_params_from_request();
 
        if (!$modul) {
            return $this->alert('warning', 'Kein Modul angegeben.');
        }
 
        if (!$fd) {
            return $this->create_from_dd();
        }
 
        $model = $this->load_model($modul, $fd);
        if (!$model) {
            return $this->alert('danger', 'FD nicht gefunden oder nicht lesbar: ' . dbx()->esc($modul . '|' . $fd));
        }
 
        $instance_id = $this->instance_id($modul . '_' . $fd);
        $work_target_id = 'dbx_fdedit_work_' . $instance_id;
        $fields = array_values((array)($model['fields'] ?? array()));
        $work_content = count($fields)
            ? $this->create_form_fd($modul, $fd, '0', $model)
            : $this->create_form_fd($modul, $fd, 'new', $model);
 
        $data = array(
            'i'                  => $instance_id,
            'modul'              => $modul,
            'fd'                 => $fd,
            'message'            => '',
            'work_target_id'     => $work_target_id,
            'create_from_dd_url' => $this->build_url('create_from_dd', $modul, $fd),
            'work_content'       => $work_content,
            'fields_order_report'=> $this->create_fields_order_report($modul, $fd, $model, $work_target_id),
        );
 
        $help = dbx()->get_include_obj('dbxAdminHelp', 'dbxAdmin');
        $oTPL = dbx()->get_system_obj('dbxTPL');
        $reloadAction = $oTPL->get_tpl('dbx|button-bar-reload-ajax', array(
            'bar_reload_href'    => '?dbx_modul=dbxAdmin&dbx_run1=edit_fd&modul=' . rawurlencode($modul) . '&fd=' . rawurlencode($fd),
            'bar_reload_target'  => 'dbx_fdedit_' . $instance_id,
            'bar_reload_replace' => 'target',
        ));
        $barData = $help->moduleBarTemplateData('edit_fd', $reloadAction);
        $barData['bar_title'] = 'FD bearbeiten: ' . $modul . '|' . $fd;
        $barData['bar_class'] = 'dbx-module-bar dbx-ddedit-head';
        $data = array_merge($data, $barData);
 
        return $oTPL->get_tpl($this->_admin_modul . '|fdedit-frame', $data);
    }
 
    private function create_form_fd($modul = '', $fd = '', $field_pos = null, $model = array())
    {
        if (!$modul || !$fd) {
            list($modul, $fd) = $this->fd_params_from_request();
        }
 
        if ($field_pos === null) {
            $field_pos = dbx()->get_modul_request_var('field_pos', 'new');
        }
 
        if (!$model) {
            $model = $this->load_model($modul, $fd);
        }
 
        if (!$model) {
            return $this->alert('danger', 'FD nicht gefunden: ' . dbx()->esc($modul . '|' . $fd));
        }
 
        $fields = array_values((array)($model['fields'] ?? array()));
        $is_new = ((string)$field_pos === 'new');
 
        if ($is_new) {
            $data = $this->default_field_record();
        } else {
            $pos = (int)$field_pos;
            if (!isset($fields[$pos]) || !is_array($fields[$pos])) {
                return $this->alert('warning', 'Feldposition nicht gefunden: ' . dbx()->esc((string)$field_pos));
            }
            $data = $fields[$pos];
        }
 
        $data['modul'] = $modul;
        $data['dd'] = $fd;
        $data['field_pos'] = (string)$field_pos;
        $data['old_name'] = (string)($data['name'] ?? '');
 
        $oForm = dbx()->get_system_obj('dbxForm');
        $oForm->init('fdedit_field_' . $this->safe_id($modul . '_' . $fd . '_' . (string)$field_pos), 'ddedit-field-form');
        $oForm->_fd = $this->_fd_field;
        $oForm->_data = $data;
        $oForm->_action = $this->build_url('create_form_fd', $modul, $fd, array('field_pos' => (string)$field_pos));
        $oForm->_msg_info = $is_new
            ? 'Bearbeite neues Feld fuer FD ' . $fd . '.'
            : 'Bearbeite Feld ' . (string)($data['name'] ?? $field_pos) . '.';
        $oForm->add_flds();
 
        if ($oForm->submit()) {
            if (!$oForm->errors()) {
                $field = $this->merge_record($data, $oForm->_post, $this->field_keys());
                $field = $this->strip_editor_keys($field);
 
                $message = '';
                if (!$this->validate_field_record($field, $fields, $is_new ? -1 : (int)$field_pos, $message)) {
                    $oForm->_msg_error = $message;
                    return $oForm->run();
                }
 
                if ($is_new) {
                    $fields[] = $field;
                    $field_pos = count($fields) - 1;
                    $is_new = false;
                } else {
                    $fields[(int)$field_pos] = $field;
                }
 
                $model['fields'] = array_values($fields);
                $ok = $this->save_model($modul, $fd, $model);
 
                if ($ok) {
                    $field['modul'] = $modul;
                    $field['dd'] = $fd;
                    $field['field_pos'] = (string)$field_pos;
                    $field['old_name'] = (string)($field['name'] ?? '');
 
                    $oForm->_data = $field;
                    $oForm->_action = $this->build_url('create_form_fd', $modul, $fd, array('field_pos' => (string)$field_pos));
                    $oForm->_msg_success = 'Feld ' . (string)($field['name'] ?? $field_pos) . ' in FD ' . $fd . ' gespeichert.';
                } else {
                    $oForm->_msg_error = 'Feld ' . (string)($field['name'] ?? $field_pos) . ' konnte in FD ' . $fd . ' nicht gespeichert werden.';
                }
            } else {
                $oForm->_msg_error = 'Feld ' . (string)($data['name'] ?? $field_pos) . ' bitte pruefen.';
            }
        }
 
        $delete_url = $this->build_url('delete_field', $modul, $fd, array('field_pos' => (string)$field_pos));
 
        return str_replace(
            '&dbx_run2=delete_field&modul={modul}&dd={dd}&field_pos={field_pos}',
            dbx()->esc($delete_url),
            $oForm->run()
        );
    }
 
    private function create_fields_order_report($modul, $fd, $model, $target_id = '')
    {
        $rows = array();
        foreach (array_values((array)($model['fields'] ?? array())) as $pos => $field) {
            if (!is_array($field)) {
                continue;
            }
 
            $row = $this->field_row_defaults();
            foreach ($field as $key => $value) {
                $row[$key] = is_array($value) ? implode(',', $value) : (string)$value;
            }
 
            $row['modul'] = $modul;
            $row['dd'] = $fd;
            $row['fd'] = $fd;
            $row['field_pos'] = (string)$pos;
            $row['sort_no'] = (string)($pos + 1);
            $row['target_id'] = $target_id;
            $row['form_url'] = $this->build_url('create_form_fd', $modul, $fd, array('field_pos' => (string)$pos));
            $rows[] = $row;
        }
 
        $data = array(
            'modul'         => $modul,
            'fd'            => $fd,
            'dd'            => $fd,
            'count'         => count($rows),
            'target_id'     => $target_id,
            'new_field_url' => $this->build_url('create_form_fd', $modul, $fd, array('field_pos' => 'new')),
        );
 
        $oReport = dbx()->get_system_obj('dbxReport');
        $oReport->init('fdedit_fields_order_' . $this->safe_id($modul . '_' . $fd), 'fdedit-fields-order-report');
        $oReport->_mode = 'tpl';
        $oReport->_data = $data;
        $oReport->_replaces = $data;
        $oReport->_rdata = $rows;
        $oReport->_rcount = count($rows);
        $oReport->_rrows = 'auto';
        $oReport->_pages = false;
 
        return $oReport->run();
    }
 
    private function delete_field()
    {
        list($modul, $fd) = $this->fd_params_from_request();
        $field_pos = (int)dbx()->get_modul_request_var('field_pos', -1);
 
        $model = $this->load_model($modul, $fd);
        if (!$model) {
            return $this->alert('danger', 'FD nicht gefunden.');
        }
 
        $fields = array_values((array)($model['fields'] ?? array()));
        if (!isset($fields[$field_pos])) {
            return $this->alert('warning', 'Feld nicht gefunden.');
        }
 
        $name = (string)($fields[$field_pos]['name'] ?? $field_pos);
        unset($fields[$field_pos]);
        $model['fields'] = array_values($fields);
 
        if ($this->save_model($modul, $fd, $model)) {
            return $this->alert('success', 'Feld geloescht: ' . dbx()->esc($name));
        }
 
        return $this->alert('danger', 'Feld konnte nicht geloescht werden: ' . dbx()->esc($name));
    }
 
    private function save_field_order()
    {
        list($modul, $fd) = $this->fd_params_from_request();
        $order = $this->parse_order(dbx()->get_modul_request_var('order', array()));
 
        $model = $this->load_model($modul, $fd);
        if (!$model) {
            dbx()->json_response(array('ok' => 0, 'msg' => 'FD nicht gefunden.'));
        }
 
        $new = $this->reorder_records(array_values((array)($model['fields'] ?? array())), $order);
        if ($new === false) {
            dbx()->json_response(array('ok' => 0, 'msg' => 'Ungueltige Reihenfolge.'));
        }
 
        $model['fields'] = $new;
        $ok = $this->save_model($modul, $fd, $model);
 
        dbx()->json_response(array(
            'ok'    => $ok ? 1 : 0,
            'msg'   => $ok ? 'FD-Feldreihenfolge gespeichert.' : 'FD-Feldreihenfolge konnte nicht gespeichert werden.',
            'count' => count($new),
        ));
 
        return '';
    }
 
    private function create_from_dd()
    {
        list($modul, $fd) = $this->fd_params_from_request();
        $message = '';
 
        $source_modul = $this->sanitize_name(dbx()->get_modul_request_var('source_modul', $modul ?: 'dbx'));
        $source_dd = $this->sanitize_name(dbx()->get_modul_request_var('source_dd', ''));
        $target_modul = $this->sanitize_name(dbx()->get_modul_request_var('target_modul', $modul ?: 'dbx'));
        $target_fd = $this->sanitize_name(dbx()->get_modul_request_var('target_fd', $fd));
        $overwrite = (string)dbx()->get_modul_request_var('overwrite', '') === '1';
 
        if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] === 'POST') {
            if (!$source_modul || !$source_dd || !$target_modul || !$target_fd) {
                $message = $this->alert('danger', 'Bitte Quell-DD und Ziel-FD vollstaendig angeben.');
            } elseif ($this->fd_file_exists($target_modul, $target_fd) && !$overwrite) {
                $message = $this->alert('warning', 'FD existiert bereits. Zum Ueberschreiben bitte die Checkbox aktivieren.');
            } else {
                $oDD = dbx()->get_system_obj('dbxDD');
                $dd_model = $oDD->get_dd_model($source_modul . '|' . $source_dd);
                $fields = is_array($dd_model['fields'] ?? null) ? array_values($dd_model['fields']) : array();
 
                if (!count($fields)) {
                    $message = $this->alert('danger', 'Quell-DD hat keine Felddefinitionen oder konnte nicht gelesen werden.');
                } else {
                    $ok = $this->save_model($target_modul, $target_fd, array('fields' => $fields));
                    if ($ok) {
                        $url = '?dbx_modul=' . $this->_admin_modul .
                               '&dbx_run1=edit_fd&modul=' . rawurlencode($target_modul) .
                               '&fd=' . rawurlencode($target_fd);
                        $message = $this->alert(
                            'success',
                            'FD ' . dbx()->esc($target_modul . '|' . $target_fd) . ' wurde aus DD ' .
                            dbx()->esc($source_modul . '|' . $source_dd) . ' erstellt. ' .
                            '<a class="btn btn-sm btn-primary ms-2" href="' . dbx()->esc($url) .
                            '">FD bearbeiten</a>'
                        );
                    } else {
                        $message = $this->alert('danger', 'FD konnte nicht geschrieben werden.');
                    }
                }
            }
        }
 
        $data = array(
            'i'                 => $this->instance_id('create_fd_' . $target_modul . '_' . $target_fd),
            'action'            => '?dbx_modul=' . $this->_admin_modul . '&dbx_run1=edit_fd&dbx_run2=create_from_dd&modul=' . rawurlencode($target_modul) . '&fd=' . rawurlencode($target_fd),
            'message'           => $message,
            'source_modul'      => $source_modul,
            'source_dd'         => $source_dd,
            'target_modul'      => $target_modul,
            'target_fd'         => $target_fd,
            'overwrite_checked' => $overwrite ? 'checked' : '',
        );
 
        $oTPL = dbx()->get_system_obj('dbxTPL');
        return $oTPL->get_tpl($this->_admin_modul . '|fdedit-create-from-dd', $data);
    }
 
    private function load_model($modul, $fd)
    {
        if (!$modul || !$fd) {
            return array();
        }
 
        $file = $this->fd_file_path($modul, $fd);
        if (!is_file($file) || !is_readable($file)) {
            return array();
        }
 
        $fields = array();
        $field = array();
        include $file;
 
        return array('fields' => is_array($fields) ? array_values($fields) : array());
    }
 
    private function save_model($modul, $fd, $model)
    {
        if (!$modul || !$fd || !is_array($model)) {
            return 0;
        }
 
        $fields = is_array($model['fields'] ?? null) ? array_values($model['fields']) : array();
        $dir = dbx_get_base_dir() . 'dbx/modules/' . $modul . '/fd/';
        if (function_exists('dbx_os_path_file')) {
            $dir = dbx_os_path_file($dir);
        }
 
        if (!is_dir($dir) && !mkdir($dir, 0775, true)) {
            return 0;
        }
 
        $file = $this->fd_file_path($modul, $fd);
        $this->backup_fd_file($modul, $fd);
 
        $content = "<?php\n\n";
        foreach ($fields as $field) {
            if (!is_array($field)) {
                continue;
            }
            $field = $this->normalize_field_for_write($field);
            $content .= "\$field = array();\n";
            foreach ($field as $key => $value) {
                $content .= "\$field[" . var_export((string)$key, true) . "]=" . var_export($value, true) . ";\n";
            }
            $content .= "\$fields[]=\$field;\n\n";
        }
 
        return file_put_contents($file, $content) !== false ? 1 : 0;
    }
 
    private function normalize_field_for_write($field)
    {
        $field = $this->strip_editor_keys($field);
        $oDD = dbx()->get_system_obj('dbxDD');
        if (is_object($oDD) && method_exists($oDD, 'normalize_dd_field')) {
            return $oDD->normalize_dd_field($field);
        }
 
        $out = array();
        foreach ($this->field_keys() as $key) {
            if (array_key_exists($key, $field)) {
                $out[$key] = $field[$key];
            }
        }
        return $out;
    }
 
    private function backup_fd_file($modul, $fd)
    {
        $file = $this->fd_file_path($modul, $fd);
        if (!is_file($file)) {
            return;
        }
 
        $dir = dirname($file) . DIRECTORY_SEPARATOR . '_backup';
        if (!is_dir($dir)) {
            mkdir($dir, 0775, true);
        }
 
        if (is_dir($dir)) {
            copy($file, $dir . DIRECTORY_SEPARATOR . $fd . '.' . date('Ymd-His') . '.fd.php');
        }
    }
 
    private function fd_params_from_request()
    {
        $modul = $this->sanitize_name(dbx()->get_modul_request_var('modul', ''));
        $fd = $this->sanitize_name(dbx()->get_modul_request_var('fd', ''));
 
        if (!$fd) {
            $fd = $this->sanitize_name(dbx()->get_modul_request_var('dd', ''));
        }
 
        if (!$modul) {
            $modul = $this->sanitize_name(dbx()->get_modul_request_var('xmodul', ''));
        }
 
        if (!$modul) {
            $modul = $this->sanitize_name($this->get_system_var('dbx_activ_modul', 'dbx'));
        }
 
        return array($modul, $fd);
    }
 
    private function fd_file_exists($modul, $fd)
    {
        return is_file($this->fd_file_path($modul, $fd));
    }
 
    private function fd_file_path($modul, $fd)
    {
        $file = dbx_get_base_dir() . 'dbx/modules/' . $modul . '/fd/' . $fd . '.fd.php';
        return function_exists('dbx_os_path_file') ? dbx_os_path_file($file) : $file;
    }
 
    private function build_url($run2, $modul, $fd, $extra = array())
    {
        $url = '?dbx_modul=' . $this->_admin_modul .
               '&dbx_run1=edit_fd' .
               '&dbx_run2=' . rawurlencode($run2) .
               '&modul=' . rawurlencode($modul) .
               '&fd=' . rawurlencode($fd);
 
        foreach ((array)$extra as $key => $value) {
            $url .= '&' . rawurlencode((string)$key) . '=' . rawurlencode((string)$value);
        }
 
        return $url;
    }
 
    private function get_system_var($name, $default = '')
    {
        if (function_exists('dbx')) {
            $obj = dbx();
            if (is_object($obj) && method_exists($obj, 'get_system_var')) {
                $value = $obj->get_system_var($name);
                if ($value !== null && $value !== '') {
                    return $value;
                }
            }
        }
        return $default;
    }
 
    private function merge_record($old, $post, $keys)
    {
        $record = is_array($old) ? $old : array();
        foreach ((array)$keys as $key) {
            if (array_key_exists($key, (array)$post)) {
                $record[$key] = $this->normalize_value($post[$key]);
            }
        }
        return $record;
    }
 
    private function strip_editor_keys($record)
    {
        unset($record['modul'], $record['dd'], $record['fd'], $record['field_pos'], $record['old_name']);
        return $record;
    }
 
    private function normalize_value($value)
    {
        if (is_array($value)) {
            return implode(',', array_map('trim', $value));
        }
        return trim((string)$value);
    }
 
    private function parse_order($raw)
    {
        if (is_array($raw)) {
            return array_values(array_map('intval', $raw));
        }
 
        $raw = trim((string)$raw);
        if ($raw === '') {
            return array();
        }
 
        if (substr($raw, 0, 1) === '[') {
            $decoded = json_decode($raw, true);
            if (is_array($decoded)) {
                return array_values(array_map('intval', $decoded));
            }
        }
 
        $parts = preg_split('/[|,\s;]+/', $raw);
        return is_array($parts) ? array_values(array_map('intval', $parts)) : array();
    }
 
    private function reorder_records($records, $order)
    {
        $records = array_values((array)$records);
        $count = count($records);
        if (!$count) {
            return array();
        }
        if (count($order) !== $count) {
            return false;
        }
 
        $seen = array();
        $new = array();
        foreach ($order as $pos) {
            $pos = (int)$pos;
            if ($pos < 0 || $pos >= $count || isset($seen[$pos])) {
                return false;
            }
            $seen[$pos] = 1;
            $new[] = $records[$pos];
        }
        return $new;
    }
 
    private function validate_field_record($field, $fields, $self_pos, &$message)
    {
        $name = trim((string)($field['name'] ?? ''));
        if (!$this->is_identifier($name)) {
            $message = 'Ungueltiger Feldname: ' . $name;
            return false;
        }
 
        $names = array();
        foreach (array_values((array)$fields) as $pos => $old) {
            if ((int)$pos === (int)$self_pos) {
                continue;
            }
 
            $old_name = strtolower(trim((string)($old['name'] ?? '')));
            if ($old_name !== '') {
                $names[$old_name] = 1;
            }
        }
 
        if (isset($names[strtolower($name)])) {
            $message = 'Feldname doppelt: ' . $name;
            return false;
        }
 
        return true;
    }
 
    private function is_identifier($name)
    {
        return (bool)preg_match('/^[A-Za-z_][A-Za-z0-9_]*$/', (string)$name);
    }
 
    private function sanitize_name($name)
    {
        $name = trim((string)$name);
        return preg_match('/^[A-Za-z0-9_]+$/', $name) ? $name : '';
    }
 
    private function safe_id($value)
    {
        $value = preg_replace('/[^A-Za-z0-9_]+/', '_', (string)$value);
        $value = trim($value, '_');
        return $value ?: 'x';
    }
 
    private function instance_id($seed)
    {
        return $this->safe_id($seed . '_' . substr(md5((string)$seed), 0, 6));
    }
 
    private function alert($type, $msg)
    {
        $type = preg_replace('/[^a-z]/', '', (string)$type);
        if (!$type) {
            $type = 'info';
        }
        return '<div class="alert alert-' . $type . '">' . $msg . '</div>';
    }
 
    private function field_keys()
    {
        $oDD = dbx()->get_system_obj('dbxDD');
        if (is_object($oDD) && method_exists($oDD, 'dd_field_schema_keys')) {
            return array_merge(array('modul', 'dd', 'fd', 'field_pos', 'old_name'), $oDD->dd_field_schema_keys());
        }
 
        return array(
            'modul',
            'dd',
            'fd',
            'field_pos',
            'old_name',
            'name',
            'type',
            'index',
            'length',
            'default',
            'label',
            'rules',
            'tooltip',
            'errormsg',
            'placeholder',
            'convert',
            'protect',
            'group',
            'mask',
            'data',
            'options',
            'tpl',
            'js',
            'prompt',
        );
    }
 
    private function default_field_record()
    {
        return array(
            'name'        => '',
            'type'        => 'varchar',
            'index'       => '',
            'length'      => '255',
            'default'     => '',
            'label'       => '',
            'rules'       => 'text',
            'tooltip'     => '',
            'errormsg'    => '',
            'placeholder' => '',
            'convert'     => '',
            'protect'     => '0',
            'group'       => '',
            'mask'        => '',
            'data'        => '',
            'options'     => '',
            'tpl'         => 'text-label',
            'js'          => '',
            'prompt'      => '',
        );
    }
 
    private function field_row_defaults()
    {
        return array(
            'modul'     => '',
            'dd'        => '',
            'fd'        => '',
            'field_pos' => '',
            'name'      => '',
            'type'      => '',
            'index'     => '',
            'length'    => '',
            'label'     => '',
        );
    }
}
 
?>