edwiki-git-sync.php

Überträgt Wiki-Seiten und struct-Daten nach GitHub (Branch stable). Nötig, weil gitbacked nur beim Speichern im Wiki committet: Per FTP oder mit edwiki-import.php eingespielte Seiten bleiben sonst liegen, und die struct-Daten stehen nur in der SQLite-Datenbank.

Ablage: neben doku.php im Wiki-Hauptordner, darf dort dauerhaft bleiben. Aufruf: https://<wiki>/edwiki-git-sync.php (als Admin angemeldet). Herunterladen: auf den Dateinamen über dem Code klicken.

Ablauf

  1. Seite aufrufen: Das Skript erneuert den struct-Export nach data/struct/ (schemas.json, assignments.json, data/<schema>.json) und zeigt an, was übertragen würde (git status).
  2. Jetzt übertragen: git add → commit → push origin stable. Committet werden nur data/pages/, data/struct/ und data/.gitignore.
  3. Liegt edwiki-import.php daneben, steht auf jeder Ergebnisseite unten ein Button Zurück zu edwiki-import.php (einfacher Link; vermeidet das erneute Absenden des Formulars über „Zurück“ im Browser). Abschalten: Konstante EDWIKI_IMPORT auf einen leeren Text setzen.

Hinweise

Änderungen

Datum Änderung
19.11.2026 Button „Zurück zu edwiki-import.php“ auf allen Seiten (Claude).
edwiki-git-sync.php
<?php
 
/**
 * edwiki – Wiki-Seiten und struct-Daten nach GitHub übertragen
 *
 * 1. Seiten: gitbacked committet nur beim Speichern im Wiki. Per FTP
 *    hochgeladene (vor allem neue) Seiten bleiben sonst liegen.
 * 2. struct-Daten: liegen in der SQLite-Datenbank und kommen sonst nie nach
 *    GitHub. Das Skript exportiert sie als lesbare JSON-Dateien nach
 *    data/struct/ (Schemas, Zuweisungen, aktuelle Werte je Schema).
 *
 * Benutzung:
 *   1. Datei ins DokuWiki-Hauptverzeichnis legen (neben doku.php). Sie darf dort bleiben.
 *   2. Im Wiki als Admin anmelden.
 *   3. https://…/edwiki-git-sync.php aufrufen – erneuert den Export und zeigt an,
 *      was übertragen würde.
 *   4. „Jetzt übertragen“ klicken.
 *
 * Committet werden nur data/pages/, data/struct/ und data/.gitignore.
 * Nur Wiki-Admins können das Skript benutzen.
 *
 * Liegt edwiki-import.php daneben, zeigt jede Seite unten einen Button
 * „Zurück zu edwiki-import.php“ (einfacher Link, kein erneutes Absenden).
 */
 
if (!defined('DOKU_INC')) define('DOKU_INC', __DIR__ . '/');
require_once DOKU_INC . 'inc/init.php';
 
use dokuwiki\plugin\struct\meta\Assignments;
use dokuwiki\plugin\struct\meta\Schema;
use dokuwiki\plugin\struct\meta\Search;
 
global $INPUT, $USERINFO;
 
header('Content-Type: text/html; charset=utf-8');
header('X-Robots-Tag: noindex');
 
/** Repository wie in gitbacked (repoPath ./data) */
$repo = DOKU_INC . 'data';
/** Branch auf GitHub */
$branch = 'stable';
/** Was committet wird (relativ zum Repository) */
$paths = ['pages/', 'struct/', '.gitignore'];
/** Import-Skript, zu dem der Rück-Button führt (leer = kein Button) */
const EDWIKI_IMPORT = 'edwiki-import.php';
 
/**
 * Git-Befehl im Repository ausführen
 *
 * @param string[] $args Argumente (werden einzeln escaped)
 * @return array [Exit-Code, Ausgabe]
 */
function edwiki_git(array $args)
{
    global $repo;
    $cmd = 'git -C ' . escapeshellarg($repo);
    foreach ($args as $arg) $cmd .= ' ' . escapeshellarg($arg);
    $proc = proc_open($cmd . ' 2>&1', [1 => ['pipe', 'w']], $pipes);
    if (!is_resource($proc)) return [1, 'proc_open nicht möglich'];
    $out = stream_get_contents($pipes[1]);
    fclose($pipes[1]);
    $code = proc_close($proc);
    return [$code, rtrim((string)$out)];
}
 
/**
 * Button zurück zum Import-Skript – nur, wenn es neben diesem Skript liegt
 */
function edwiki_back()
{
    if (EDWIKI_IMPORT === '' || !is_file(DOKU_INC . EDWIKI_IMPORT)) return '';
    return '<p class="back"><a href="' . hsc(EDWIKI_IMPORT) . '"><button type="button">Zurück zu '
        . hsc(EDWIKI_IMPORT) . '</button></a></p>';
}
 
function edwiki_page($title, $body)
{
    $body .= edwiki_back();
    echo '<!doctype html><html lang="de"><head><meta charset="utf-8"><title>' . hsc($title) . '</title>'
        . '<style>body{font-family:sans-serif;max-width:60em;margin:2em auto;padding:0 1em}'
        . 'pre{background:#f4f4f4;padding:1em;overflow:auto;max-height:30em}'
        . '.ok{color:#060}.err{color:#a00}button{font-size:1.1em;padding:.4em 1.2em}'
        . '.back{margin-top:2em;border-top:1px solid #ccc;padding-top:1em}</style>'
        . '</head><body><h1>' . hsc($title) . '</h1>' . $body . '</body></html>';
    exit;
}
 
/**
 * JSON-Datei schreiben (stabil formatiert, damit Git-Diffs lesbar bleiben)
 */
function edwiki_write_json($file, $data)
{
    io_makeFileDir($file);
    $json = json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
    return io_saveFile($file, $json . "\n");
}
 
/**
 * struct-Daten nach data/struct/ exportieren
 *
 * @return array [Anzahl Schemas, Anzahl Datensätze, Fehlermeldungen]
 */
function edwiki_export_struct()
{
    global $repo;
    $dir = $repo . '/struct';
    $errors = [];
    if (plugin_isdisabled('struct')) return [0, 0, ['struct-Plugin nicht aktiv']];
 
    $schemas = [];
    $rows = 0;
    $written = [];
    foreach (Schema::getAll() as $table) {
        try {
            $schema = new Schema($table);
            $definition = json_decode($schema->toJSON(), true);
            unset($definition['id']); // ändert sich bei jeder Schema-Version
            $schemas[$table] = $definition;
 
            $search = new Search();
            $search->addSchema($table);
            $search->addColumn('*');
            $search->addSort('%pageid%', true);
            $result = $search->getRows();
            $pids = $search->getPids();
 
            $data = [];
            foreach ($result as $i => $values) {
                $entry = [];
                foreach ($values as $value) {
                    $raw = $value->getRawValue();
                    $entry[$value->getColumn()->getLabel()] = $raw;
                }
                $key = $pids[$i] ?? (string)$i;
                $data[$key] = $entry;
            }
            ksort($data, SORT_STRING);
            edwiki_write_json("$dir/data/$table.json", $data);
            $written["$table.json"] = true;
            $rows += count($data);
        } catch (\Throwable $e) {
            $errors[] = "$table: " . $e->getMessage();
        }
    }
    ksort($schemas, SORT_STRING);
    edwiki_write_json("$dir/schemas.json", $schemas);
 
    $patterns = Assignments::getInstance(true)->getAllPatterns();
    usort($patterns, fn($a, $b) => [$a['tbl'], $a['pattern']] <=> [$b['tbl'], $b['pattern']]);
    edwiki_write_json("$dir/assignments.json", $patterns);
 
    // Dateien gelöschter Schemas entfernen
    foreach (glob("$dir/data/*.json") ?: [] as $file) {
        if (!isset($written[basename($file)])) @unlink($file);
    }
 
    return [count($schemas), $rows, $errors];
}
 
/**
 * data/.gitignore um /struct/ ergänzen, falls nötig
 */
function edwiki_gitignore()
{
    global $repo;
    $file = $repo . '/.gitignore';
    $text = (string)@file_get_contents($file);
    if (preg_match('#^!/struct/?\s*$#m', $text)) return;
    $text = rtrim($text) . "\n!/struct/\n";
    file_put_contents($file, $text);
}
 
// nur Admins
if (!auth_isadmin()) {
    http_response_code(403);
    edwiki_page('Kein Zugriff', '<p class="err">Bitte zuerst im Wiki als Administrator anmelden und die Seite neu laden.</p>');
}
if (!is_dir($repo . '/.git')) {
    edwiki_page('Fehler', '<p class="err">Kein Git-Repository unter <code>' . hsc($repo) . '</code> gefunden.</p>');
}
 
// Export immer zuerst erneuern
edwiki_gitignore();
[$schemaCount, $rowCount, $exportErrors] = edwiki_export_struct();
$exportInfo = '<p>struct-Export erneuert: <strong>' . $schemaCount . '</strong> Schemas, <strong>'
    . $rowCount . '</strong> Datensätze → <code>data/struct/</code></p>';
if ($exportErrors) {
    $exportInfo .= '<p class="err">Fehler beim Export:</p><pre>' . hsc(implode("\n", $exportErrors)) . '</pre>';
}
 
// was liegt an?
[, $status] = edwiki_git(array_merge(['status', '--porcelain', '--untracked-files=all', '--'], $paths));
$lines = $status === '' ? [] : explode("\n", $status);
 
if (!$INPUT->post->bool('run') || !checkSecurityToken()) {
    $body = '<p>Repository: <code>' . hsc($repo) . '</code>, Branch <code>' . hsc($branch) . '</code></p>' . $exportInfo;
    if (!$lines) {
        $body .= '<p class="ok">Alles ist bereits übertragen – nichts zu tun.</p>';
    } else {
        $new = count(array_filter($lines, fn($l) => str_starts_with($l, '??')));
        $body .= '<p><strong>' . count($lines) . '</strong> Änderungen (davon ' . $new . ' neue Dateien):</p>'
            . '<pre>' . hsc($status) . '</pre>'
            . '<form method="post"><input type="hidden" name="sectok" value="' . hsc(getSecurityToken()) . '">'
            . '<input type="hidden" name="run" value="1">'
            . '<button type="submit">Jetzt übertragen</button></form>'
            . '<p><small>?? = neu, M = geändert, D = gelöscht</small></p>';
    }
    edwiki_page('Wiki nach GitHub übertragen', $body);
}
 
if (!$lines) edwiki_page('Nichts zu tun', $exportInfo . '<p class="ok">Alles ist bereits übertragen.</p>');
 
// übertragen (Commit-Nachricht nur ASCII: der Server entfernt sonst Umlaute)
$log = '';
$ok = true;
$user = $USERINFO['name'] ?? $INPUT->server->str('REMOTE_USER');
$mail = $USERINFO['mail'] ?? '';
$steps = [
    array_merge(['add', '--all', '--'], $paths),
    ['-c', 'user.name=' . $user, '-c', 'user.email=' . $mail,
        'commit', '-m', 'Wiki-Seiten und struct-Export uebertragen (' . count($lines) . ' Aenderungen) by ' . $user],
    ['push', 'origin', $branch],
];
foreach ($steps as $step) {
    [$code, $out] = edwiki_git($step);
    $log .= '$ git ' . implode(' ', $step) . "\n" . $out . "\n\n";
    if ($code !== 0) {
        $ok = false;
        break;
    }
}
 
edwiki_page(
    $ok ? 'Übertragen' : 'Fehler beim Übertragen',
    $exportInfo
    . ($ok ? '<p class="ok">Fertig. Seiten und struct-Daten sind auf GitHub.</p>'
        : '<p class="err">Ein Schritt ist fehlgeschlagen, siehe Ausgabe. Die Wiki-Seiten selbst sind unverändert.</p>')
    . '<pre>' . hsc($log) . '</pre>'
);