Bump version to 0.9.6.8.22

CURRENT_STATUS.md

@@ -2,11 +2,13 @@
 
 ## Version
 
-**Bratonien Tools 0.9.6.2**
+**Bratonien Tools 0.9.6.8.19**
+
+Zielplattform der produktiven NC-Connector-Synchronisierung ist derzeit **Piwigo 16.4.0**.
 
 ## NC Connector
 
-Der NC Connector besitzt nur noch einen produktiven Verbindungsweg: **Nextcloud per WebDAV**.
+Der NC Connector besitzt einen produktiven Verbindungsweg: **Nextcloud per WebDAV**.
 
 ### Verbindungsmodell
 
@@ -14,30 +16,87 @@ Der NC Connector besitzt nur noch einen produktiven Verbindungsweg: **Nextcloud
 - `source_mode=webdav-placeholder`
 - Nextcloud-Adresse, Benutzer und Passwort/App-Passwort werden pro Verbindung verschlüsselt gespeichert.
 - Piwigo-API und Benutzername/Passwort-Fallback werden ebenfalls pro Verbindung gespeichert.
-- Der Assistent zeigt ausschließlich die Verzeichnisse, auf die der angemeldete Nextcloud-Benutzer per WebDAV zugreifen kann.
-- Mehrere Verzeichnisse können pro Verbindung ausgewählt werden.
+- Der Assistent zeigt ausschließlich Verzeichnisse, auf die der angemeldete Nextcloud-Benutzer per WebDAV zugreifen kann.
+- Ein leerer `webdav_path` ist ein gültiger Root und bedeutet den Dateibereich des authentifizierten Nextcloud-Benutzers.
+
+### Root-Verhalten
+
+Bei `webdav_path=""` wird die technische Nextcloud-Benutzerebene nicht als Piwigo-Album angelegt.
+
+Direkte Unterordner des Nextcloud-Benutzerroots werden als Top-Level-Piwigo-Alben gespiegelt. Direkt im Root liegende Einzelbilder verbleiben auf Root-Ebene des verbindungseigenen Shadow Trees und werden durch die bestehende Orphan-Logik behandelt.
+
+Es gibt keine fest verdrahteten Album-Namen.
 
 ### Laufzeit
 
-Der gemeinsame Runner verarbeitet ausschließlich WebDAV-Verbindungen:
+Der gemeinsame Runner verarbeitet WebDAV-Verbindungen in dieser Reihenfolge:
 
 1. `runtime/reconcile-webdav.php`
-2. `runtime/cleanup-webdav-piwigo.php`
-3. `runtime/sync-webdav.sh` für jede vorhandene WebDAV-Konfiguration
+2. `runtime/repair-webdav-orphans.php`
+3. `runtime/cleanup-webdav-piwigo.php`
+4. `runtime/sync-webdav.sh` für jede vorhandene WebDAV-Konfiguration
 
 Die verbindungsspezifischen Runtime-Konfigurationen liegen unter `/etc/bratonien-tools/nc-connector/`. Zustandsdaten liegen unter `/var/lib/bratonien-tools/nc-connector/connection-ID`.
 
-### Shadow Tree und Piwigo
+Der Reconcile- und Shell-Pfad unterstützt den leeren WebDAV-Root ausdrücklich und gibt ihn als `--root ""` an den Platzhalter-Builder weiter.
 
-`runtime/lib/build_webdav_placeholder_source.py` bildet die ausgewählten Nextcloud-Inhalte als lokale Platzhalterquelle ab. `runtime/lib/shadow_tree.py` erzeugt daraus die Dateisystemstruktur, die Piwigo als physische Site sieht.
+### Platzhalterquelle und Shadow Tree
 
-Jede WebDAV-Verbindung besitzt ihre eigene Piwigo-Site. `runtime/lib/piwigo-sync.php` übergibt genau diese Site an `bratonien.nc.syncProductive` und `bratonien.nc.syncOrphans`. Es gibt keinen zusätzlichen Sync auf Site 1.
+`runtime/lib/build_webdav_placeholder_source.py` bildet die Nextcloud-Inhalte als lokale Platzhalterquelle ab. Für Bilder existieren physische 1×1-Platzhalterdateien; die Originale werden dabei nicht dauerhaft heruntergeladen.
 
-Der Shadow Tree dient ausschließlich dazu, Piwigo die Alben und Bilder als Dateisystemstruktur bereitzustellen. Albumlogik, Dateisynchronisierung und die daraus folgenden Piwigo-Datensätze bleiben Aufgabe von Piwigo.
+`runtime/lib/shadow_tree.py` erzeugt atomar die Dateisystemstruktur, die Piwigo als physische Site sieht. Shadow-Verzeichnisse werden so angelegt, dass der Webserver die für die On-Demand-Materialisierung nötigen Dateisystemoperationen ausführen kann.
+
+Jede WebDAV-Verbindung besitzt ihre eigene Piwigo-Site. Es gibt keinen zusätzlichen Sync auf Site 1.
+
+### Piwigo-Synchronisierung
+
+`runtime/lib/piwigo-sync.php` bevorzugt `bratonien.nc.syncProductive` für Piwigo 16.4.0. Wenn für die Verbindung keine Piwigo-API eingerichtet ist, wird der gespeicherte Administrator-/Webmaster-Benutzername/Passwort-Fallback verwendet und Piwigos nativer `site_update` ausgeführt.
+
+Danach wird `bratonien.nc.syncOrphans` für die konkrete WebDAV-Site ausgeführt.
+
+Der Shadow Tree stellt Piwigo ausschließlich die physische Album-/Bildstruktur bereit. Albumdatensätze, Bilddatensätze, Bild-Kategorie-Verknüpfungen und Piwigo-Derivate bleiben Aufgabe von Piwigo.
+
+### On-Demand-Materialisierung vor `i.php`
+
+Die produktive WebDAV-Derivaterzeugung sitzt vor Piwigos `i.php`.
+
+`include/webdav_materialize_runtime.inc.php` löst aus dem Piwigo-Bildpfad die konkrete Verbindung, den ausgewählten Nextcloud-Root und den relativen WebDAV-Pfad auf.
+
+Für ein noch nicht vorhandenes Derivat läuft `webdav-derivative.php`:
+
+1. Zugriffsprüfung für das Piwigo-Bild;
+2. Download des Originals aus Nextcloud in eine temporäre Datei;
+3. temporäres Bereitstellen des Originals am exakten von Piwigo erwarteten Quellpfad;
+4. Aufruf des nativen Piwigo-`i.php`;
+5. Piwigo erzeugt sein normales Derivat;
+6. Wiederherstellung des Shadow-/Platzhalterzustands;
+7. Auslieferung des Piwigo-Derivats.
+
+Das Original verbleibt in Nextcloud. Es gibt keine dauerhafte vollständige Originalkopie in Piwigo.
+
+### Orphan-Logik
+
+Direkt im WebDAV-Site-Root liegende Bilder werden nicht künstlich in ein Album gezwungen. Sie werden durch `bratonien.nc.syncOrphans` als Piwigo-Orphans synchronisiert.
+
+`runtime/repair-webdav-orphans.php` läuft vor den verbindungsspezifischen Syncs und repariert historische WebDAV-Orphan-Zustände.
+
+### Private Top-Level-Alben
+
+Da die technische Nextcloud-Benutzerebene nicht mehr als Elternalbum existiert, können WebDAV-Unterordner echte private Top-Level-Piwigo-Alben sein. Beim Connector-Fallback-Sync sorgt `bratonien_tools_preserve_connector_top_level_access()` dafür, dass der verwendete Piwigo-Administrator auf diese privaten Top-Level-Alben zugreifen kann. Nach Änderungen wird der Benutzer-Cache invalidiert.
+
+Die allgemeine bestehende Funktion `bratonien_tools_preserve_private_album_access()` in `include/album_shares.inc.php` bleibt davon getrennt.
+
+### Administrations-Dashboard
+
+Piwigo 16.4.0 zeigt die Album-Kachel im Standardtemplate nur bei `NB_ALBUMS > 1` an. Dadurch verschwand die Kachel nach dem korrekten Entfernen der künstlichen Nextcloud-Benutzerebene, sobald nur noch ein echtes Album vorhanden war.
+
+Bratonien Tools setzt für die Verwaltungsübersicht einen Template-Prefilter und ändert ausschließlich diese Anzeigebedingung auf `NB_ALBUMS > 0`. Die Albumzahl selbst stammt weiterhin unverändert aus Piwigos `get_pwg_general_statitics()`.
 
 ### Bildauslieferung
 
-Die Dateien im Shadow Tree sind Platzhalter. `include/webdav_image_runtime.inc.php` erkennt die WebDAV-Zuordnung und ersetzt die Bildquelle bei der Auslieferung durch den zugehörigen Nextcloud-Inhalt. `webdav-image.php` streamt die Bilddaten serverseitig, ohne Nextcloud-Zugangsdaten an den Browser weiterzugeben.
+Fehlende Piwigo-Derivate werden durch den On-Demand-Gate erzeugt. Bereits vorhandene Derivate werden direkt aus Piwigos eigenem Derivat-Cache ausgeliefert.
+
+Für direkte Originalanforderungen existiert weiterhin die serverseitige WebDAV-Originalauslieferung. Nextcloud-Zugangsdaten werden dem Browser nicht offengelegt.
 
 ### Löschen
 
@@ -45,18 +104,37 @@ Eine WebDAV-Verbindung kann unabhängig von ihrer Reihenfolge gelöscht werden.
 
 ### Diagnose
 
-Der Status wird pro Verbindung geführt. Fehler enthalten Zeitpunkt, betroffene Verbindung, Prozesszustand und technische Details. Die Administration zeigt keine lokalen Datenbank-, Storage- oder Mount-Einstellungen mehr an.
+Der WebDAV-Derivative-Gate schreibt Request-bezogene `[BRAT-WD ...]`-Diagnoseeinträge. Der Verbindungsstatus wird pro Verbindung geführt. Runtime-Probleme lassen sich zusätzlich über `bratonien-nc-connector.service` nachvollziehen.
 
-## Entfernte Connector-Komponenten
+## Aktuell relevante Dateien
 
-Nicht mehr Bestandteil des Plugins sind lokale Nextcloud-Datenbankanbindungen, PostgreSQL-Reader, Source-/Activity-Views, Storage-Mappings, Host-Mounts, lokale Reconcile-/Sync-Skripte, Cutover-/Migrationswerkzeuge und der frühere Simulations-Webservice `bratonien.nc.sync`.
+- `main.inc.php` – Plugin-Hooks, Connector-Sync-Hilfen, Dashboard-Prefilter
+- `include/webdav_materialize_runtime.inc.php` – WebDAV-Quellauflösung und Materialisierung
+- `webdav-derivative.php` – On-Demand-Gate vor Piwigos `i.php`
+- `webdav-image.php` – direkte WebDAV-Originalauslieferung
+- `include/nc_productive_ws.inc.php` – direkter Piwigo-Core-Sync für 16.4.0
+- `include/nc_orphan_ws.inc.php` – Root-Orphan-Synchronisierung
+- `runtime/reconcile-webdav.php` – Runtime-Reconcile einschließlich leerem WebDAV-Root
+- `runtime/repair-webdav-orphans.php` – Orphan-Reparatur
+- `runtime/cleanup-webdav-piwigo.php` – Bereinigung verwaister Piwigo-Sites
+- `runtime/sync-webdav.sh` – verbindungsspezifischer Sync
+- `runtime/run-all.sh` – gemeinsamer Runner
+- `runtime/lib/build_webdav_placeholder_source.py` – WebDAV-Scan und Platzhalterquelle
+- `runtime/lib/shadow_tree.py` – atomarer Shadow Tree
+- `runtime/lib/piwigo-sync.php` – Piwigo-API/Fallback-Sync
+
+## Nicht mehr das produktive WebDAV-Modell
+
+Nicht mehr maßgeblich für die produktive WebDAV-Derivaterzeugung ist das frühere Modell, bei dem Bild-URLs einfach auf einen separaten WebDAV-Bildstream umgebogen wurden oder der Connector selbst einen parallelen vollständigen Derivatbestand verwalten sollte.
+
+Maßgeblich ist: **physischer Platzhalter + On-Demand-Original + natives Piwigo-`i.php` + Wiederherstellung des Platzhalters**.
 
 ## Prüfpflicht vor Merge
 
-Jede Änderung wird vor dem Merge mindestens mit folgenden GitHub-Actions-Prüfungen validiert:
+Die GitHub-Actions-Konfiguration prüft mindestens:
 
 - PHP-Syntax für 8.2, 8.3, 8.4 und 8.5
-- Prüfung auf doppelte globale `bratonien_tools_*`-Funktionen
+- doppelte globale `bratonien_tools_*`-Funktionen
 - JavaScript-Syntax
 - Python-Syntax/Compile
 - Shell-Syntax mit `bash -n`

README.md

@@ -2,7 +2,7 @@
 
 Modulares Piwigo-Plugin für Administration, Bildverarbeitung, geschützte Freigaben, Fotoauswahl und die Anbindung von Nextcloud an Piwigo.
 
-Aktuelle Plugin-Version: **0.9.6.2**
+Aktuelle Plugin-Version: **0.9.6.8.19**
 
 ## Grundprinzip
 
@@ -12,18 +12,43 @@ Für die Administration gilt: Der normale Nutzer sieht Aufgaben, Entscheidungen
 
 ## NC Connector
 
-Der NC Connector bindet ausdrücklich ausgewählte Nextcloud-Inhalte ausschließlich per WebDAV an Piwigo an.
+Der NC Connector bindet ausdrücklich ausgewählte Nextcloud-Inhalte per WebDAV an Piwigo an. Nextcloud bleibt dabei die Quelle der Originaldateien; Piwigo verwaltet Alben, Bilder und seine eigenen Derivate.
 
 ### Datenmodell
 
-- Nextcloud bleibt die Quelle der Originaldateien.
-- Originalbilder werden nicht dauerhaft in eine zweite Bibliothek unter Piwigo kopiert.
-- Ein Shadow Tree erzeugt die für Piwigo benötigte Ordnerstruktur.
+- Nextcloud bleibt die verbindliche Quelle der Originaldateien.
+- Originalbilder werden nicht dauerhaft als zweite vollständige Bibliothek unter Piwigo gespeichert.
+- Eine lokale Platzhalterquelle enthält physische 1×1-Dateien, damit Piwigo die Bilder regulär als Dateisysteminhalte erkennen kann.
+- Ein Shadow Tree bildet daraus die von Piwigo erwartete Galerie-Ordnerstruktur.
 - Ordner werden als physische Piwigo-Alben synchronisiert.
-- Root-Dateien können als Piwigo-Orphans registriert werden.
+- Direkt im ausgewählten Nextcloud-Root liegende Einzelbilder werden über die vorhandene Orphan-Logik behandelt.
 - Neu importierte physische Connector-Alben werden privat angelegt.
 - Entfernte Quellen verschwinden aus Shadow Tree und Piwigo; die Nextcloud-Originale bleiben erhalten.
 
+### Nextcloud-Root ohne künstliches Benutzeralbum
+
+Ein leerer `webdav_path` ist ein gültiger Root und bedeutet den Dateibereich des authentifizierten Nextcloud-Benutzers.
+
+Dabei wird der Nextcloud-Benutzername nicht als künstliche Album-Ebene angelegt. Beispiel:
+
+```text
+Nextcloud
+/
+├── 400 Auswahl/
+├── Zweites Album/
+├── einzelbild-1.jpg
+└── einzelbild-2.jpg
+```
+
+wird in Piwigo logisch als
+
+```text
+400 Auswahl
+Zweites Album
+```
+
+abgebildet. Die direkt im Root liegenden Einzelbilder werden separat durch die Orphan-Synchronisierung erfasst.
+
 ### Voraussetzungen
 
 Benötigt werden nur:
@@ -35,30 +60,53 @@ Benötigt werden nur:
 
 Nicht benötigt werden Nextcloud-Datenbankzugriff, `occ`-Adminzugriff, Storage-IDs, Backend-Pfade, zusätzliche Host-Mounts, FUSE, davfs oder rclone.
 
-### WebDAV-Ablauf
+### WebDAV-Scan und Shadow Tree
 
 1. Der Assistent prüft Nextcloud und liest die sichtbaren Verzeichnisse per WebDAV.
 2. Ausgewählte Verzeichnisse werden rekursiv per PROPFIND eingelesen.
 3. Ordner, Dateiname, Nextcloud-Datei-ID, MIME-Typ, Größe, ETag und WebDAV-Pfad werden erfasst.
 4. `runtime/lib/build_webdav_placeholder_source.py` erzeugt eine lokale Platzhalterquelle ohne dauerhafte Originalkopie.
-5. `runtime/lib/shadow_tree.py` baut daraus den verbindungseigenen Shadow Tree.
+5. `runtime/lib/shadow_tree.py` baut atomar den verbindungseigenen Shadow Tree.
 6. Der WebDAV-Galeriebaum liegt unter `_data/bratonien-tools/nc-webdav-gallery/connection-ID`.
 7. Jede WebDAV-Verbindung wird als eigene physische Piwigo-Site registriert.
 8. Piwigos Dateisynchronisierung erhält ausschließlich diese verbindungseigene Site.
-9. Die WebDAV-Bildzuordnung ersetzt beim Ausliefern Platzhalter-URLs durch die echte Nextcloud-Bildquelle.
-10. `webdav-image.php` streamt benötigte Bilder serverseitig; Zugangsdaten werden dem Browser nicht offengelegt.
+
+### On-Demand-Bildauslieferung und Piwigo-Derivate
+
+Die produktive Bildauslieferung sitzt vor Piwigos `i.php`.
+
+`include/webdav_materialize_runtime.inc.php` erkennt anhand des Piwigo-Bildpfads die zugehörige WebDAV-Verbindung, den Nextcloud-Root und den relativen WebDAV-Pfad. Der Hook `get_derivative_url` leitet fehlende WebDAV-Derivate an `webdav-derivative.php` um.
+
+Wenn ein benötigtes Piwigo-Derivat noch nicht existiert:
+
+1. `webdav-derivative.php` prüft den Piwigo-Zugriff auf das Bild.
+2. Das Original wird temporär direkt aus Nextcloud geladen.
+3. Die physische 1×1-Platzhalterdatei bzw. der Shadow-Link am von Piwigo erwarteten Quellpfad wird für die Dauer der Erzeugung ersetzt.
+4. Piwigos eigenes `i.php` erzeugt das normale Piwigo-Derivat.
+5. Danach wird der temporäre Originalzustand entfernt und der Platzhalter-/Shadow-Zustand wiederhergestellt.
+6. Das von Piwigo erzeugte Derivat wird ausgeliefert und künftig normal aus Piwigos Derivat-Cache verwendet.
+
+Damit bleibt Piwigo für Größen, Derivate und Lazy-Loading verantwortlich. Der Connector hält keinen parallelen eigenen vollständigen Derivat-Cache vor.
+
+Für Fälle, in denen Piwigo direkt die Originalquelle benötigt, steht weiterhin die serverseitige WebDAV-Auslieferung zur Verfügung. Nextcloud-Zugangsdaten werden nicht an den Browser weitergegeben.
 
 ### Piwigo-Synchronisierung
 
-Der Connector verwendet die vorhandene Piwigo-Dateisynchronisierung für die verbindungseigene WebDAV-Site. Der Shadow Tree ist die Dateisystemdarstellung, die Piwigo für Alben und Bilder benötigt.
+Der Connector verwendet die vorhandene Piwigo-Dateisynchronisierung für die verbindungseigene WebDAV-Site. Der Shadow Tree ist ausschließlich die Dateisystemdarstellung, die Piwigo für Alben und Bilder benötigt.
 
-`runtime/lib/piwigo-sync.php` ruft dafür `bratonien.nc.syncProductive` auf. Die Methode führt den Piwigo-Core-Sync für die konkrete Site aus. `bratonien.nc.syncOrphans` arbeitet ebenfalls nur auf der übergebenen WebDAV-Site.
+`runtime/lib/piwigo-sync.php` bevorzugt die Webservice-Methode `bratonien.nc.syncProductive`. Ist keine Piwigo-API für die Verbindung eingerichtet, wird der vorhandene Administrator-/Webmaster-Benutzername/Passwort-Fallback verwendet und Piwigos nativer `site_update` ausgeführt.
+
+Nach der regulären Dateisynchronisierung läuft `bratonien.nc.syncOrphans` für direkt im Site-Root liegende Einzelbilder.
 
 Die produktive Synchronisierung ist aktuell auf **Piwigo 16.4.0** abgestimmt.
 
-### Piwigo-Zugang
+### Private Top-Level-Alben
 
-Der Zugang wird pro Verbindung gespeichert. Bevorzugt wird eine Piwigo-API. Wird keine API eingerichtet, kann ein Administrator-/Webmaster-Benutzer mit Passwort als Fallback verwendet werden.
+Durch das Überspringen der technischen Nextcloud-Benutzerebene können WebDAV-Unterordner zu echten Top-Level-Piwigo-Alben werden. Für den Connector-Sync wird deshalb der Zugriff des verwendeten Piwigo-Administrators auf neu erzeugte private Top-Level-Alben erhalten und der Benutzer-Cache anschließend invalidiert.
+
+### Administrations-Dashboard
+
+Piwigo 16.4.0 blendet seine Album-Statistik standardmäßig bei exakt einem Album aus (`NB_ALBUMS > 1`). Bratonien Tools passt ausschließlich diese Dashboard-Anzeige auf `NB_ALBUMS > 0` an. Dadurch wird auch ein einzelnes korrekt angelegtes Album in der Verwaltungsübersicht angezeigt.
 
 ### Statusanzeige
 
@@ -78,11 +126,14 @@ Aktive WebDAV-Verbindungen werden über den gemeinsamen Runner verarbeitet:
 
 Verbindungsspezifische Konfigurationen liegen unter `/etc/bratonien-tools/nc-connector/`, State-Daten unter `/var/lib/bratonien-tools/nc-connector/connection-ID`.
 
-Der Lauf besteht aus:
+Der gemeinsame Lauf besteht aktuell aus:
 
-1. WebDAV-Verbindungen reconciliieren;
-2. verwaiste WebDAV-Piwigo-Inhalte bereinigen;
-3. jede vorhandene WebDAV-Verbindung synchronisieren.
+1. `runtime/reconcile-webdav.php` – gespeicherte Verbindungen in Runtime-Konfigurationen überführen;
+2. `runtime/repair-webdav-orphans.php` – vorhandene WebDAV-Orphan-Zustände reparieren;
+3. `runtime/cleanup-webdav-piwigo.php` – verwaiste WebDAV-Piwigo-Daten bereinigen;
+4. `runtime/sync-webdav.sh` – jede vorhandene WebDAV-Verbindung synchronisieren.
+
+Der verbindungsspezifische Lauf erzeugt Platzhalterquelle und Shadow Tree, führt Piwigos Sync und Orphan-Sync aus und enthält weiterhin die vorhandenen Preview-/Derivative-Schritte. Die produktive Auslieferung fehlender WebDAV-Derivate erfolgt jedoch über den On-Demand-Gate vor `i.php`.
 
 ## Bildcache
 
@@ -133,26 +184,29 @@ Der integrierte Updater liest den Zielstand aus GitHub, bindet ein Update an ein
 
 ## Wichtige Dateien und Verzeichnisse
 
-- `main.inc.php` – Plugin-Einstieg und Runtime-Hooks
+- `main.inc.php` – Plugin-Einstieg, Hooks, Connector-Sync-Hilfen und Dashboard-Prefilter
 - `admin.php` – zentraler Admin-Controller
 - `include/nc_connector.inc.php` – WebDAV-Verbindungsmodell
 - `include/nc_connector_wizard.inc.php` – Verbindungsassistent
 - `include/nc_connector_wizard_webdav_flow.inc.php` – WebDAV-Wizardablauf
 - `include/nc_connector_delete_safe.inc.php` – Löschen einschließlich WebDAV-Piwigo-Inhalten
-- `include/nc_productive_ws.inc.php` – Piwigo-Core-Dateisync
+- `include/nc_productive_ws.inc.php` – direkter Piwigo-Core-Dateisync für Piwigo 16.4.0
 - `include/nc_orphan_ws.inc.php` – Orphan-Synchronisierung der konkreten WebDAV-Site
-- `include/webdav_image_runtime.inc.php` – WebDAV-Bildzuordnung und URL-Filter
-- `webdav-image.php` – berechtigungsgeprüfter WebDAV-Bildstream
-- `runtime/reconcile-webdav.php` – WebDAV-Runtime-Reconcile
+- `include/webdav_materialize_runtime.inc.php` – WebDAV-Quellauflösung und On-Demand-Materialisierung
+- `include/webdav_image_runtime.inc.php` – vorhandene WebDAV-Bildzuordnung/Originalauslieferung
+- `webdav-derivative.php` – Gate vor `i.php` für fehlende WebDAV-Derivate
+- `webdav-image.php` – serverseitige WebDAV-Originalauslieferung
+- `runtime/reconcile-webdav.php` – WebDAV-Runtime-Reconcile, einschließlich gültigem leerem Root
+- `runtime/repair-webdav-orphans.php` – Reparatur vorhandener Orphan-Zustände
 - `runtime/cleanup-webdav-piwigo.php` – Bereinigung verwaister WebDAV-Piwigo-Sites
 - `runtime/sync-webdav.sh` – Ablauf einer WebDAV-Verbindung
 - `runtime/run-all.sh` – gemeinsamer WebDAV-Runner
-- `runtime/lib/build_webdav_placeholder_source.py` – rekursiver WebDAV-Scan und Platzhalterquelle
-- `runtime/lib/shadow_tree.py` – atomarer Shadow Tree
+- `runtime/lib/build_webdav_placeholder_source.py` – rekursiver WebDAV-Scan und physische Platzhalterquelle
+- `runtime/lib/shadow_tree.py` – atomarer, Piwigo-kompatibler Shadow Tree
 - `runtime/lib/piwigo-sync.php` – Piwigo-Sync mit API/Fallback
 - `main-cache-build.php` – allgemeiner Piwigo-Derivat-/Cache-Builder
 - `include/self_update.inc.php` – Self-Updater
-- `include/album_shares.inc.php` – geschützte Albumfreigaben
+- `include/album_shares.inc.php` – geschützte Albumfreigaben und private Albumzugriffe
 - `include/public_selection.inc.php` – Fotoauswahl
 - `include/batch_titles.inc.php` – fortlaufende Titel
 - `include/watermark_*.inc.php` – Wasserzeichen-Engine
@@ -167,5 +221,6 @@ Der integrierte Updater liest den Zielstand aus GitHub, bindet ein Update an ein
 - Wizard-Geheimnisse werden nicht im Browser-Web-Storage persistiert;
 - produktive Piwigo-API ist versionsgebunden;
 - Originalbilder werden vom Connector nicht gelöscht;
-- WebDAV-Originalbilder werden nicht dauerhaft lokal gespeichert;
+- WebDAV-Originalbilder werden nur bei Bedarf temporär lokal materialisiert;
+- temporäre Originale werden nach der Piwigo-Derivaterzeugung wieder entfernt;
 - Update-Pakete werden an Commit und Hash gebunden.

main.inc.php

@@ -1,7 +1,7 @@
 <?php
 /*
 Plugin Name: Bratonien Tools
-Version: 0.9.6.8.15
+Version: 0.9.6.8.22
 Description: Erweiterbare Administrationswerkzeuge fuer die Bratonien-Piwigo-Installation.
 Plugin URI: https://github.com/Terranom674/Piwigo_Bratonien_Tools
 Author: Bratonien
@@ -34,7 +34,9 @@ add_event_handler('element_set_global_action', 'bratonien_tools_batch_titles_app
 add_event_handler('init', 'bratonien_tools_prepare_connector_private_import', EVENT_HANDLER_PRIORITY_NEUTRAL - 30);
 add_event_handler('init', 'bratonien_tools_prepare_private_album_permissions', EVENT_HANDLER_PRIORITY_NEUTRAL - 20);
 add_event_handler('init', 'bratonien_tools_preserve_private_album_access', EVENT_HANDLER_PRIORITY_NEUTRAL - 10);
+add_event_handler('init', 'bratonien_tools_preserve_connector_top_level_access', EVENT_HANDLER_PRIORITY_NEUTRAL - 9);
 add_event_handler('init', 'bratonien_tools_album_shares_init');
+add_event_handler('loc_end_intro', 'bratonien_tools_fix_admin_album_stat_tile');
 add_event_handler('delete_categories', 'bratonien_tools_album_shares_on_delete_categories');
 add_event_handler('ws_add_methods', 'bratonien_tools_register_nc_orphan_ws_methods');
 add_event_handler('ws_add_methods', 'bratonien_tools_register_nc_productive_ws_methods');
@@ -85,6 +87,57 @@ function bratonien_tools_prepare_private_album_permissions()
   bratonien_tools_grant_private_album_access($category_id, (int)$user['id']);
 }
 
+function bratonien_tools_preserve_connector_top_level_access()
+{
+  global $user;
+
+  if (
+    !defined('IN_ADMIN')
+    || ($_SERVER['REQUEST_METHOD'] ?? '') !== 'POST'
+    || (string)($_GET['page'] ?? '') !== 'site_update'
+    || (string)($_POST['bratonien_connector'] ?? '') !== '1'
+    || empty($user['id'])
+  )
+  {
+    return;
+  }
+
+  $site_id = (int)($_GET['site'] ?? 0);
+  $user_id = (int)$user['id'];
+  if ($site_id < 1 || $user_id < 1)
+  {
+    return;
+  }
+
+  register_shutdown_function(function () use ($site_id, $user_id) {
+    $query = '\nSELECT id\n  FROM '.CATEGORIES_TABLE.'\n  WHERE site_id = '.$site_id.'\n    AND dir IS NOT NULL\n    AND id_uppercat IS NULL\n    AND status = \'private\'\n;';
+    $result = pwg_query($query);
+    $changed = false;
+    while ($row = pwg_db_fetch_assoc($result))
+    {
+      $category_id = (int)$row['id'];
+      if ($category_id < 1)
+      {
+        continue;
+      }
+
+      $access_query = '\nSELECT 1\n  FROM '.USER_ACCESS_TABLE.'\n  WHERE user_id = '.$user_id.'\n    AND cat_id = '.$category_id.'\n  LIMIT 1\n;';
+      if (pwg_db_num_rows(pwg_query($access_query)) > 0)
+      {
+        continue;
+      }
+
+      bratonien_tools_grant_private_album_access($category_id, $user_id);
+      $changed = true;
+    }
+
+    if ($changed && function_exists('invalidate_user_cache'))
+    {
+      invalidate_user_cache(true);
+    }
+  });
+}
+
 function bratonien_tools_grant_private_album_access($category_id, $user_id)
 {
   $category_id = (int)$category_id;
@@ -94,13 +147,7 @@ function bratonien_tools_grant_private_album_access($category_id, $user_id)
     return;
   }
 
-  $query = '
-SELECT 1
-  FROM '.USER_ACCESS_TABLE.'
-  WHERE user_id = '.$user_id.'
-    AND cat_id = '.$category_id.'
-  LIMIT 1
-;';
+  $query = '\nSELECT 1\n  FROM '.USER_ACCESS_TABLE.'\n  WHERE user_id = '.$user_id.'\n    AND cat_id = '.$category_id.'\n  LIMIT 1\n;';
   $result = pwg_query($query);
   if (pwg_db_num_rows($result) > 0)
   {
@@ -116,6 +163,23 @@ SELECT 1
   );
 }
 
+function bratonien_tools_fix_admin_album_stat_tile()
+{
+  global $template;
+
+  if (!defined('IN_ADMIN'))
+  {
+    return;
+  }
+
+  $template->set_prefilter('intro', 'bratonien_tools_prefilter_admin_album_stat_tile');
+}
+
+function bratonien_tools_prefilter_admin_album_stat_tile($source)
+{
+  return str_replace('{if $NB_ALBUMS > 1}', '{if $NB_ALBUMS > 0}', $source);
+}
+
 function bratonien_tools_admin_menu($menu)
 {
   $menu[] = array(

runtime/lib/build_webdav_placeholder_source.py

@@ -25,6 +25,7 @@ from pathlib import Path, PurePosixPath
 
 DAV = "DAV:"
 OC = "http://owncloud.org/ns"
+NC = "http://nextcloud.org/ns"
 SUPPORTED_IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".gif", ".webp"}
 # 1x1 transparent GIF, 34 bytes. The filename keeps the remote extension;
 # the placeholder exists only so Piwigo can discover the logical image entry.
@@ -54,6 +55,27 @@ def safe_local_name(name: str) -> str:
     return name
 
 
+def parse_image_dimensions(prop: ET.Element) -> tuple[int, int]:
+    for property_name in ("file-metadata-size", "metadata-photos-size"):
+        raw = prop.findtext(f"{{{NC}}}{property_name}", default="").strip()
+        if not raw:
+            continue
+        try:
+            value = json.loads(raw)
+        except (TypeError, ValueError, json.JSONDecodeError):
+            continue
+        if not isinstance(value, dict):
+            continue
+        try:
+            width = int(value.get("width", 0) or 0)
+            height = int(value.get("height", 0) or 0)
+        except (TypeError, ValueError):
+            continue
+        if width > 0 and height > 0:
+            return width, height
+    return 0, 0
+
+
 class WebDavClient:
     def __init__(self, base_url: str, user: str, password: str, timeout: int = 30) -> None:
         self.base_url = base_url.rstrip("/")
@@ -77,9 +99,11 @@ class WebDavClient:
         url = self.collection_url(relative)
         body = (
             '<?xml version="1.0"?>'
-            '<d:propfind xmlns:d="DAV:" xmlns:oc="http://owncloud.org/ns">'
+            '<d:propfind xmlns:d="DAV:" xmlns:oc="http://owncloud.org/ns" xmlns:nc="http://nextcloud.org/ns">'
             '<d:prop><d:displayname/><d:resourcetype/><d:getcontenttype/>'
-            '<d:getcontentlength/><d:getetag/><oc:fileid/></d:prop></d:propfind>'
+            '<d:getcontentlength/><d:getetag/><oc:fileid/>'
+            '<nc:file-metadata-size/><nc:metadata-photos-size/>'
+            '</d:prop></d:propfind>'
         ).encode("utf-8")
         request = urllib.request.Request(url, data=body, method="PROPFIND")
         request.add_header("Authorization", self.auth_header)
@@ -122,6 +146,7 @@ class WebDavClient:
             fileid_text = prop.findtext(f"{{{OC}}}fileid", default="").strip()
             resource_type = prop.find(f"{{{DAV}}}resourcetype")
             is_dir = resource_type is not None and resource_type.find(f"{{{DAV}}}collection") is not None
+            width, height = parse_image_dimensions(prop)
             item = {
                 "display_name": display,
                 "fileid": int(fileid_text) if fileid_text.isdigit() else 0,
@@ -129,6 +154,8 @@ class WebDavClient:
                 "content_type": prop.findtext(f"{{{DAV}}}getcontenttype", default=""),
                 "size": int(prop.findtext(f"{{{DAV}}}getcontentlength", default="0") or 0),
                 "etag": prop.findtext(f"{{{DAV}}}getetag", default="").strip('"'),
+                "width": width,
+                "height": height,
             }
             if href_path == base_path:
                 current = item
@@ -197,6 +224,8 @@ def build_root(
                 "content_type": str(child.get("content_type", "")),
                 "size": int(child.get("size", 0)),
                 "etag": str(child.get("etag", "")),
+                "width": int(child.get("width", 0) or 0),
+                "height": int(child.get("height", 0) or 0),
             }
     return files, folders, skipped
 

runtime/lib/precache-webdav-previews.php

@@ -32,7 +32,7 @@ function fetch_remote_blob($url, $user, $password)
     CURLOPT_HTTPAUTH => CURLAUTH_BASIC,
     CURLOPT_USERPWD => $user.':'.$password,
     CURLOPT_FAILONERROR => false,
-    CURLOPT_USERAGENT => 'Bratonien-Tools-WebDAV-Precache/0.9.6.1',
+    CURLOPT_USERAGENT => 'Bratonien-Tools-WebDAV-Precache/0.9.6.8.21',
   ));
   $body = curl_exec($ch);
   $errno = curl_errno($ch);

runtime/lib/sync-webdav-metadata.php

@@ -0,0 +1,106 @@
+#!/usr/bin/env php
+<?php
+if (PHP_SAPI !== 'cli')
+{
+  fwrite(STDERR, "CLI only\n");
+  exit(1);
+}
+
+$options = getopt('', array('piwigo-root:', 'connection-id:', 'mapping:'));
+$piwigo_root = rtrim((string)($options['piwigo-root'] ?? ''), '/');
+$connection_id = (int)($options['connection-id'] ?? 0);
+$mapping_file = (string)($options['mapping'] ?? '');
+
+if ($piwigo_root === '' || $connection_id < 1 || $mapping_file === '' || !is_readable($mapping_file))
+{
+  fwrite(STDERR, "Parameter --piwigo-root, --connection-id und --mapping werden benoetigt.\n");
+  exit(1);
+}
+
+$mapping = json_decode((string)file_get_contents($mapping_file), true);
+if (!is_array($mapping) || !isset($mapping['files']) || !is_array($mapping['files']))
+{
+  fwrite(STDERR, "WebDAV-Mapping ist ungueltig.\n");
+  exit(1);
+}
+
+$dimensions = array();
+foreach ($mapping['files'] as $path => $entry)
+{
+  if (!is_array($entry) || (string)($entry['kind'] ?? '') !== 'file') continue;
+  $width = (int)($entry['width'] ?? 0);
+  $height = (int)($entry['height'] ?? 0);
+  if ($width < 1 || $height < 1) continue;
+  $dimensions[str_replace('\\', '/', (string)$path)] = array($width, $height);
+}
+
+if (!$dimensions)
+{
+  fwrite(STDERR, "WebDAV-Mapping enthaelt keine Originalabmessungen.\n");
+  exit(1);
+}
+
+define('PHPWG_ROOT_PATH', $piwigo_root.'/');
+$_SERVER['REMOTE_ADDR'] = '127.0.0.1';
+$_SERVER['SERVER_ADDR'] = '127.0.0.1';
+$_SERVER['SERVER_NAME'] = 'localhost';
+$_SERVER['HTTP_HOST'] = 'localhost';
+$_SERVER['SERVER_PORT'] = '80';
+$_SERVER['REQUEST_METHOD'] = 'GET';
+$_SERVER['REQUEST_URI'] = '/';
+$_SERVER['SCRIPT_NAME'] = '/plugins/bratonien_tools/runtime/lib/sync-webdav-metadata.php';
+$_SERVER['PHP_SELF'] = $_SERVER['SCRIPT_NAME'];
+$_SERVER['QUERY_STRING'] = '';
+$_SERVER['HTTP_USER_AGENT'] = 'Bratonien-WebDAV-Metadata/0.9.6.8.20';
+$_SERVER['HTTPS'] = 'off';
+
+require_once(PHPWG_ROOT_PATH.'include/common.inc.php');
+
+$checked = 0;
+$updated = 0;
+$missing = 0;
+$result = pwg_query('SELECT id, path, width, height FROM '.IMAGES_TABLE.' ORDER BY id');
+while ($row = pwg_db_fetch_assoc($result))
+{
+  $path = (string)($row['path'] ?? '');
+  if ($path === '') continue;
+
+  $absolute = $path;
+  if (strpos($absolute, '/') !== 0)
+  {
+    $absolute = PHPWG_ROOT_PATH.ltrim(preg_replace('#^\./#', '', $absolute), '/');
+  }
+
+  $normalized_shadow = str_replace('\\', '/', $absolute);
+  if (strpos($normalized_shadow, '/nc-webdav-gallery/connection-'.$connection_id.'/') === false) continue;
+
+  $checked++;
+  $resolved = realpath($absolute);
+  if ($resolved === false)
+  {
+    $missing++;
+    continue;
+  }
+
+  $key = str_replace('\\', '/', $resolved);
+  if (!isset($dimensions[$key]))
+  {
+    $missing++;
+    continue;
+  }
+
+  list($width, $height) = $dimensions[$key];
+  if ((int)$row['width'] === $width && (int)$row['height'] === $height) continue;
+
+  pwg_query('UPDATE '.IMAGES_TABLE.' SET width='.$width.', height='.$height.' WHERE id='.(int)$row['id']);
+  $updated++;
+}
+
+if ($updated > 0)
+{
+  if (function_exists('update_category')) update_category('all');
+  if (function_exists('invalidate_user_cache')) invalidate_user_cache(true);
+}
+
+echo 'WebDAV-Metadaten: bilder='.$checked.' aktualisiert='.$updated.' ohne_masse='.$missing."\n";
+exit($missing > 0 ? 1 : 0);

runtime/sync-webdav.sh

@@ -66,11 +66,13 @@ compact_output() {
 failure() {
     local code="$1" command="$2" line="$3"
     trap - ERR
-    write_status error "WebDAV-Shadow-Tree fehlgeschlagen" "Exit-Code: $code; Zeile: $line; Befehl: $command"
+    write_status error "WebDAV-Synchronisierung fehlgeschlagen" "Exit-Code: $code; Zeile: $line; Befehl: $command"
     exit "$code"
 }
 trap 'failure $? "$BASH_COMMAND" "$LINENO"' ERR
 
+write_status running "WebDAV-Synchronisierung läuft"
+
 ROOT_ARGS=()
 while IFS= read -r line; do
     [[ -z "$line" || "$line" == \#* ]] && continue
@@ -96,28 +98,6 @@ python3 "$SCRIPT_DIR/lib/shadow_tree.py" \
     --state "$SHADOW_MAP_FILE"
 
 trap - ERR
-PREVIEW_CACHE="$PIWIGO_ROOT/_data/bratonien-tools/nc-webdav-preview/connection-$CONNECTION_ID"
-PREVIEW_OUTPUT=""
-PREVIEW_EXIT=0
-if PREVIEW_OUTPUT="$(php "$SCRIPT_DIR/lib/precache-webdav-previews.php" \
-    --mapping="$WEBDAV_MAPPING_FILE" \
-    --base-url="$WEBDAV_BASE_URL" \
-    --user="$WEBDAV_USER" \
-    --password-file="$WEBDAV_PASSWORD_FILE" \
-    --cache-dir="$PREVIEW_CACHE" 2>&1)"; then
-    PREVIEW_EXIT=0
-else
-    PREVIEW_EXIT=$?
-fi
-[[ -z "$PREVIEW_OUTPUT" ]] || printf '%s\n' "$PREVIEW_OUTPUT"
-if [[ "$PREVIEW_EXIT" -ne 0 ]]; then
-    DETAIL="Exit-Code: $PREVIEW_EXIT"
-    if [[ -n "$PREVIEW_OUTPUT" ]]; then
-        DETAIL+="; Ausgabe: $(printf '%s\n' "$PREVIEW_OUTPUT" | compact_output)"
-    fi
-    write_status error "WebDAV-Vorschaubilder konnten beim Einlesen nicht erzeugt werden" "$DETAIL"
-    exit "$PREVIEW_EXIT"
-fi
 
 if [[ "${PIWIGO_SYNC_ENABLED:-0}" == "1" ]]; then
     PIWIGO_OUTPUT=""
@@ -162,28 +142,29 @@ if [[ "${PIWIGO_SYNC_ENABLED:-0}" == "1" ]]; then
         exit "$PIWIGO_EXIT"
     fi
 
-    DERIVATIVE_OUTPUT=""
-    DERIVATIVE_EXIT=0
-    if DERIVATIVE_OUTPUT="$(php "$SCRIPT_DIR/lib/build-webdav-derivatives.php" \
+    METADATA_OUTPUT=""
+    METADATA_EXIT=0
+    if METADATA_OUTPUT="$(php "$SCRIPT_DIR/lib/sync-webdav-metadata.php" \
         --piwigo-root="$PIWIGO_ROOT" \
-        --connection-id="$CONNECTION_ID" 2>&1)"; then
-        DERIVATIVE_EXIT=0
+        --connection-id="$CONNECTION_ID" \
+        --mapping="$WEBDAV_MAPPING_FILE" 2>&1)"; then
+        METADATA_EXIT=0
     else
-        DERIVATIVE_EXIT=$?
+        METADATA_EXIT=$?
     fi
-    [[ -z "$DERIVATIVE_OUTPUT" ]] || printf '%s\n' "$DERIVATIVE_OUTPUT"
-    if [[ "$DERIVATIVE_EXIT" -ne 0 ]]; then
-        DETAIL="Exit-Code: $DERIVATIVE_EXIT"
-        if [[ -n "$DERIVATIVE_OUTPUT" ]]; then
-            DETAIL+="; Ausgabe: $(printf '%s\n' "$DERIVATIVE_OUTPUT" | compact_output)"
+    [[ -z "$METADATA_OUTPUT" ]] || printf '%s\n' "$METADATA_OUTPUT"
+    if [[ "$METADATA_EXIT" -ne 0 ]]; then
+        DETAIL="Exit-Code: $METADATA_EXIT"
+        if [[ -n "$METADATA_OUTPUT" ]]; then
+            DETAIL+="; Ausgabe: $(printf '%s\n' "$METADATA_OUTPUT" | compact_output)"
         fi
-        write_status error "Piwigo-Derivate für WebDAV-Bilder konnten nicht erzeugt werden" "$DETAIL"
-        exit "$DERIVATIVE_EXIT"
+        write_status error "Piwigo-Bildabmessungen konnten nicht mit den WebDAV-Metadaten abgeglichen werden" "$DETAIL"
+        exit "$METADATA_EXIT"
     fi
 
     if grep -q 'Piwigo-Synchronisierung per API erfolgreich' <<<"$PIWIGO_OUTPUT"; then
         write_status ok \
-            "WebDAV eingelesen, Piwigo synchronisiert und Derivate erzeugt" \
+            "WebDAV eingelesen und Piwigo synchronisiert" \
             "" \
             "api" \
             "ok" \
@@ -192,7 +173,7 @@ if [[ "${PIWIGO_SYNC_ENABLED:-0}" == "1" ]]; then
             "Fallback wurde nicht benötigt"
     elif grep -q 'Piwigo-Datenbanksynchronisierung per Benutzername/Passwort-Fallback erfolgreich' <<<"$PIWIGO_OUTPUT"; then
         write_status ok \
-            "WebDAV eingelesen, Piwigo über Fallback synchronisiert und Derivate erzeugt" \
+            "WebDAV eingelesen und Piwigo über Fallback synchronisiert" \
             "" \
             "fallback" \
             "not_used" \
@@ -200,8 +181,8 @@ if [[ "${PIWIGO_SYNC_ENABLED:-0}" == "1" ]]; then
             "ok" \
             "Benutzername/Passwort-Fallback erfolgreich"
     else
-        write_status ok "WebDAV eingelesen, Piwigo synchronisiert und Derivate erzeugt"
+        write_status ok "WebDAV eingelesen und Piwigo synchronisiert"
     fi
 else
-    write_status ok "WebDAV eingelesen und Vorschaubilder erzeugt; Registrierung erfolgt über den bestehenden produktiven Piwigo-Sync"
+    write_status ok "WebDAV eingelesen; Registrierung erfolgt über den bestehenden produktiven Piwigo-Sync"
 fi