From b01cf2c2079be149057d516a2332b010690cb4e6 Mon Sep 17 00:00:00 2001 From: flfeders Date: Fri, 2 Oct 2026 15:27:07 +0200 Subject: [PATCH 1/3] fix(updater): retain two verified backup generations --- docs/selfhost-updates.md | 39 +++- scripts/selfhost-update.py | 161 ++++++++++++++- .../update/tests/host_storage_integration.py | 17 +- scripts/update/tests/test_backup_retention.py | 190 ++++++++++++++++++ scripts/update/tests/test_updater.py | 33 +++ 5 files changed, 434 insertions(+), 6 deletions(-) create mode 100644 scripts/update/tests/test_backup_retention.py diff --git a/docs/selfhost-updates.md b/docs/selfhost-updates.md index ae13add7..f93a7ae0 100644 --- a/docs/selfhost-updates.md +++ b/docs/selfhost-updates.md @@ -222,6 +222,42 @@ Aufträge liegen dauerhaft und root-lesbar unter `.updates/service/`. Nach einem 7. Compose-Datei und `.env` einzeln atomar ersetzen. In `.env` wird ausschließlich `FEDEO_VERSION` verändert; `.env.example` und Setup-Skript werden erneuert. Den laufenden Updater ersetzt dieser Vorgang nicht. 8. Infrastruktur starten, Bucket-Einrichtung ausführen und Migrationen explizit in einem benannten Einmalcontainer starten. Beim anschließenden regulären Backend-Start läuft dessen bestehende Migrationsprüfung nochmals; bereits angewendete Migrationen werden dabei übersprungen. 9. Stack mit `up --wait` starten. Backend-/Frontend-Image-IDs und Healthchecks sowie öffentlich gemeldete Version und Commit prüfen. Erst dann den Release als installiert speichern. +10. Nach erfolgreichem Abschluss die **zwei neuesten Sicherungen erfolgreicher Updates** behalten und ältere reguläre Update-Sicherungen entfernen. Beide behaltenen Sicherungen werden zuvor vollständig gegen ihre SHA-256-Manifeste geprüft. Die Sicherungen enthalten jeweils den Stand **vor** dem zugehörigen Update. Auftragsprotokolle und Release-Dateien bleiben erhalten; `backup-pruned.json` dokumentiert entfernte Sicherungen. Fehlgeschlagene, unterbrochene und manuell wiederhergestellte Aufträge sowie separate Speichermigrationssicherungen werden nicht automatisch bereinigt. + +### Backup-Aufbewahrung und bereits belegte Hosts + +Die automatische Bereinigung läuft unter derselben Sperre wie das Update und erst +nach erfolgreicher öffentlicher Funktionsprüfung. Eine unvollständige oder beschädigte +aufzubewahrende Sicherung verhindert das Löschen älterer Sicherungen. Links, fremde +Dateien, eingehängte Verzeichnisse und von Containern verwendete Backup-Pfade werden +nicht gelöscht. Docker-Images, Container, Volumes und aktive Daten gehören nicht zu +dieser Bereinigung. + +Ein Fehler bei der Bereinigung stoppt die aktualisierte Anwendung nicht und macht +ein erfolgreiches Update nicht nachträglich zum Wiederherstellungsfall. Das +Updateprotokoll enthält eine Meldung; `.updates/backup-retention.json` dokumentiert +das Ergebnis. Eine unterbrochene Löschung kann bei der nächsten Bereinigung anhand +ihres Löschprotokolls fortgesetzt werden. Die zwei behaltenen Generationen werden +dabei erneut geprüft. + +Für bestehende Hosts, deren Platte bereits durch alte Sicherungen belegt ist, +die neuen Host-Dienstdateien installieren und zunächst die Vorschau ausführen: + +```bash +sudo python3 /usr/local/lib/fedeo-updater/selfhost-update.py prune-backups --directory /opt/fedeo --dry-run +sudo python3 /usr/local/lib/fedeo-updater/selfhost-update.py prune-backups --directory /opt/fedeo +``` + +Dieser Befehl verwendet dieselbe Aufbewahrungsregel und Prüfsummenprüfung, benötigt +keinen Image-Download und verändert den aktuellen Update-Status nicht. Laufende +Aufträge und offene Wiederherstellungen blockieren ihn. Der letzte erfolgreiche +Updateauftrag muss zum installierten Release und zur aktuellen Compose-Datei passen. +`check` und fehlgeschlagene Updates löschen keine Sicherungen, auch nicht bei +Platzmangel. Für jedes neue Update muss weiterhin Platz für neue Images und eine +zusätzliche vollständige Sicherung verfügbar sein; die automatische Aufbewahrung +ersetzt keine externe Datensicherung. Der Host-Updater wird durch ein Anwendungsupdate +nicht selbst ersetzt: bestehende andere Instanzen benötigen ebenfalls die neuen +Host-Dienstdateien. Status und Phasen werden atomar in `.updates/status.json` und pro Auftrag in `status.json` gespeichert. `events.jsonl` enthält den Verlauf, `commands.log` Fehlermeldungen der Werkzeuge. Das Verzeichnis hat Modus `0700`; Status- und Konfigurationsdateien werden mit `0600` angelegt. Backups und Werkzeugausgaben enthalten vertrauliche Daten und dürfen nicht ungefiltert an eine Oberfläche ausgeliefert werden. Backups werden nicht automatisch gelöscht. @@ -264,7 +300,8 @@ cd ../frontend && node --test tests/selfhost-updates.test.cjs Die Update-Tests verwenden den echten Compose-Parser und einen simulierten Docker-Daemon. Sie prüfen u. a. Erfolg, Prüfsummen, Release-Auswahl, unveränderte Konfiguration, Speicherplatz, parallele Aufträge, Backupfehler, Migrationsfehler, falsche laufende Versionen und unterbrochene Aufträge. Die Matrix-Tests prüfen Stilllegung, Daten-/Container-Erhalt, Backup vor Änderung der Neustartrichtlinien, Fehler und Unterbrechungen sowie die weitere Ablehnung unbekannter Dienste. Ein vollständiger Test mit realem PostgreSQL-/MinIO-/Matrix-Restore auf einer separaten Selfhost-Testinstanz ist vor dem Produktionseinsatz zusätzlich erforderlich. `python3 -B scripts/update/tests/host_storage_integration.py` prüft zusätzlich -MinIO-Migration, Speicherübernahme, zwei Anwendungsupdates und Restore der +MinIO-Migration, Speicherübernahme, drei Anwendungsupdates, automatische Aufbewahrung +von zwei Sicherungsgenerationen und Restore der regulären SeaweedFS-Updatesicherung mit echten Docker-Containern. Anwendung und Release-/HTTP-Antworten sind isolierte Testdaten. Benötigte Images und Aufbau stehen in `scripts/storage/README.md`. Die fachliche Abnahme des veröffentlichten diff --git a/scripts/selfhost-update.py b/scripts/selfhost-update.py index fbe102e7..ba4eb898 100644 --- a/scripts/selfhost-update.py +++ b/scripts/selfhost-update.py @@ -17,6 +17,7 @@ from pathlib import Path import re import shutil import signal +import stat import subprocess import sys import time @@ -34,6 +35,8 @@ LEGACY_MATRIX_SERVICES = {"matrix-db", "matrix-synapse", "matrix-redis", "matrix "matrix-livekit", "matrix-rtc-jwt", "matrix-turn", "matrix-well-known"} CORE_SERVICES = {"backend", "frontend", "db", "traefik", "node-exporter"} IMAGE_ID = re.compile(r"sha256:[a-f0-9]{64}\Z") +UPDATE_JOB = re.compile(r"[0-9]{8}-[0-9]{6}-[a-f0-9]{8}\Z") +BACKUPS_TO_KEEP = 2 def compose_strings(value, *, escape=False): @@ -882,6 +885,137 @@ class Updater: raise time.sleep(2) + def _backup_manifest(self, job, mounts, *, verify=False): + """Only updater-owned regular backup files may be retained or removed.""" + directory = job / "backup" + device = self.home.stat().st_dev + for path in (job, directory): + info = path.lstat() + if not stat.S_ISDIR(info.st_mode) or info.st_dev != device: + raise UpdateError("Backup-Verzeichnis ist kein reguläres lokales Verzeichnis.") + if any(path == directory or directory in path.parents or path in directory.parents for path in mounts): + raise UpdateError("Backup ist eingehängt oder wird von einem Container verwendet.") + files = set() + size = 0 + for parent, directories, names in os.walk(directory, followlinks=False): + for name in directories + names: + path = Path(parent) / name + info = path.lstat() + if info.st_dev != device or not (stat.S_ISDIR(info.st_mode) or stat.S_ISREG(info.st_mode)): + raise UpdateError("Backup enthält Links, besondere Dateien oder fremde Dateisysteme.") + if stat.S_ISREG(info.st_mode): + files.add(str(path.relative_to(directory))) + size += info.st_blocks * 512 + marker = job / "backup-pruned.json" + if marker.is_symlink() or (marker.exists() and not stat.S_ISREG(marker.lstat().st_mode)): + raise UpdateError("Backup-Löschprotokoll muss eine reguläre Datei sein.") + pending = read_json(marker, {}) + if pending.get("status") == "deleting" and not verify: + # Resume an interrupted deletion using the manifest saved before removing any file. + manifest = pending["manifest"] + else: + manifest = read_json(directory / "complete.json") + checksums = manifest["sha256"] + required = {"database.dump", "globals.sql", "files.tar", "files.list", "containers.json", + "config/.env", "config/docker-compose.yml"} + if manifest.get("storageProvider") == "seaweedfs": + required |= {"storage-image.tar", "config/.updates/storage-provider.json"} + if (not isinstance(checksums, dict) or not required <= checksums.keys() + or manifest.get("database") != "database.dump" or manifest.get("files") != "files.tar"): + raise UpdateError("Unvollständiges Backup-Prüfmanifest.") + for name, digest in checksums.items(): + path = Path(name) + if (path.is_absolute() or ".." in path.parts or str(path) != name or name == "complete.json" + or not re.fullmatch(r"[a-f0-9]{64}", str(digest))): + raise UpdateError("Ungültiger Pfad oder Prüfsumme im Backup-Manifest.") + if not files <= (checksums.keys() | {"complete.json"}): + raise UpdateError("Backup enthält unbekannte Dateien.") + if verify: + if files != checksums.keys() | {"complete.json"}: + raise UpdateError("Eine Datei der aufzubewahrenden Sicherung fehlt.") + for name, digest in checksums.items(): + if file_sha(directory / name) != digest: + raise UpdateError("Prüfsumme einer aufzubewahrenden Sicherung stimmt nicht.") + return manifest, size + + def _prune_backups(self, *, dry_run=False): + """Caller holds the update lock. Never select migration or failed-job backups.""" + jobs = [] + for job in self.home.iterdir(): + if not UPDATE_JOB.fullmatch(job.name) or job.is_symlink() or not job.is_dir(): + continue + status_path = job / "status.json" + if status_path.is_symlink() or not status_path.is_file(): + continue + state = read_json(job / "status.json", {}) + if (state.get("command") == "apply" and state.get("status") == "succeeded" + and state.get("phase") == "complete" and state.get("recoveryRequired") is False + and state.get("maintenance") is False and state.get("job") == str(job) + and state.get("backup") == str(job / "backup") + and ((job / "backup").exists() or (job / "backup").is_symlink())): + started = datetime.datetime.fromisoformat(state["startedAt"]) + if started.tzinfo is None: + raise UpdateError("Backup-Auftrag hat keine eindeutige Zeitangabe.") + jobs.append((started, job, state)) + jobs.sort(key=lambda item: (item[0], item[1].name), reverse=True) + report = {"status": "preview" if dry_run else "complete", "keep": BACKUPS_TO_KEEP, + "checkedAt": now(), "retained": [], "removed": [], "planned": [], "skipped": []} + if not jobs: + return report + installed = read_json(self.home / "installed.json", {}) + latest = jobs[0][2] + if (installed.get("manifest", {}).get("version") != latest.get("version") + or installed.get("manifest", {}).get("commit") != latest.get("revision") + or installed.get("composeSha256") != file_sha(self.root / "docker-compose.yml")): + raise UpdateError("Neueste erfolgreiche Sicherung gehört nicht zum installierten Stand; nichts gelöscht.") + # Include same-device bind mounts, which os.path.ismount alone cannot detect. + mounts = [] + for line in Path("/proc/self/mountinfo").read_text().splitlines(): + value = re.sub(r"\\([0-7]{3})", lambda m: chr(int(m[1], 8)), line.split()[4]) + path = Path(value) + if path != Path("/") and (path == self.home or self.home in path.parents): + mounts.append(path) + for cid in self.runner.run(["docker", "ps", "--all", "--quiet"]).split(): + for mount in self.inspect(cid).get("Mounts", []): + path = Path(mount["Source"]).resolve() + # A read-only host-root metrics mount does not consume backup data. + if path == Path("/") and not mount.get("RW", True): + continue + mounts.append(path) + # Check both retained generations before deleting any older generation. + for _, job, _ in jobs[:BACKUPS_TO_KEEP]: + self._backup_manifest(job, mounts, verify=True) + report["retained"].append(str(job / "backup")) + for _, job, _ in jobs[BACKUPS_TO_KEEP:]: + try: + manifest, size = self._backup_manifest(job, mounts) + item = {"backup": str(job / "backup"), "bytes": size} + if dry_run: + report["planned"].append(item) + continue + marker = {"status": "deleting", "startedAt": now(), "manifest": manifest, + "retained": report["retained"], **item} + write_json(job / "backup-pruned.json", marker) + shutil.rmtree(job / "backup") + write_json(job / "backup-pruned.json", {**marker, "status": "removed", "completedAt": now()}) + report["removed"].append(item) + except (OSError, ValueError, KeyError, TypeError, UpdateError) as error: + report["skipped"].append({"job": str(job), "reason": str(error) if isinstance(error, UpdateError) else type(error).__name__}) + if report["skipped"]: + report["status"] = "warning" + if not dry_run: + write_json(self.home / "backup-retention.json", report) + return report + + def prune_backups(self, *, dry_run=False): + with self.lock(): + state = read_json(self.home / "status.json", {}) + if (state.get("status") in ("queued", "running") or state.get("recoveryRequired") + or state.get("maintenance") or state.get("phase") == "storage_migration"): + raise UpdateError("Aktiven oder unterbrochenen Update-/Migrationsauftrag zuerst abschließen.") + self.runner = self.runner_factory(self.home / "backup-retention.log") + return self._prune_backups(dry_run=dry_run) + def apply(self, accept_compose): if not self.managed and not accept_compose: raise UpdateError("Compose-Datei ist noch nicht verwaltet oder wurde bearbeitet. compose.diff prüfen, Anpassungen in die Override-Datei übertragen und --accept-compose-replacement verwenden.") @@ -973,7 +1107,6 @@ class Updater: self.save("checked", status="checked") else: self.apply(accept_compose) - return {**self.state, "plan": plan} except BaseException as error: if self.state.get("maintenance") and not self.state.get("mutationStarted"): try: @@ -989,6 +1122,25 @@ class Updater: self.save(status="interrupted" if isinstance(error, (KeyboardInterrupt, SystemExit)) else "failed", error=str(error) if isinstance(error, UpdateError) else type(error).__name__) raise + # Retention is post-success maintenance, outside the update/recovery exception path. + # An I/O error or shutdown here must never stop the newly verified application. + if command == "apply": + try: + retention = self._prune_backups() + self.save(backupRetention=retention) + with self.runner.log.open("a") as log: + log.write(f"{now()} Backup-Aufbewahrung: {len(retention['retained'])} behalten, " + f"{len(retention['removed'])} entfernt, {len(retention['skipped'])} übersprungen.\n") + except Exception as error: + with contextlib.suppress(Exception): + warning = {"status": "warning", "checkedAt": now(), "keep": BACKUPS_TO_KEEP, + "error": str(error) if isinstance(error, UpdateError) else type(error).__name__} + write_json(self.home / "backup-retention.json", warning) + self.save(backupRetention=warning) + with self.runner.log.open("a") as log: + log.write(f"{now()} Backup-Bereinigung nicht abgeschlossen; Update erfolgreich. " + "Auf dem Host prune-backups --dry-run prüfen.\n") + return {**self.state, "plan": plan} def resolve(self, version): if not version or not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9.+-]{0,100}", version): @@ -1073,13 +1225,16 @@ def main(argv=None): print("Python ab Version 3.10 wird benötigt.", file=sys.stderr) return 1 parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("command", choices=("check", "apply", "status", "resolve", "adopt-storage")) + parser.add_argument("command", choices=("check", "apply", "status", "resolve", "adopt-storage", "prune-backups")) parser.add_argument("--directory", default=os.environ.get("FEDEO_DIR", "/opt/fedeo")) parser.add_argument("--version", help="Zielversion, z. B. 3.1.0; check wählt sonst den neuesten stabilen Release") parser.add_argument("--accept-compose-replacement", action="store_true", help="Zuvor geprüften Austausch einer nicht verwalteten Compose-Datei akzeptieren") + parser.add_argument("--dry-run", action="store_true", help="Nur für prune-backups: Sicherungen prüfen und Löschvorschau ausgeben") args = parser.parse_args(argv) if args.command == "apply" and not args.version: parser.error("apply benötigt eine explizite --version; zuerst check ausführen") + if args.dry_run and args.command != "prune-backups": + parser.error("--dry-run ist nur für prune-backups verfügbar") os.umask(0o077) signal.signal(signal.SIGTERM, lambda *_: sys.exit(143)) try: @@ -1090,6 +1245,8 @@ def main(argv=None): result = updater.resolve(args.version) elif args.command == "adopt-storage": result = updater.adopt_storage() + elif args.command == "prune-backups": + result = updater.prune_backups(dry_run=args.dry_run) else: result = updater.execute(args.command, args.version, args.accept_compose_replacement) print(json.dumps(result, ensure_ascii=False, indent=2)) diff --git a/scripts/update/tests/host_storage_integration.py b/scripts/update/tests/host_storage_integration.py index a4dd80d8..a1951261 100644 --- a/scripts/update/tests/host_storage_integration.py +++ b/scripts/update/tests/host_storage_integration.py @@ -1,5 +1,5 @@ #!/usr/bin/env python3 -"""Real migration -> adoption -> two updates, including a backup restore, on synthetic data. +"""Real migration -> adoption -> three updates, retention and restore on synthetic data. Requires local storage test images and registry:2; never contacts a FEDEO instance. Release HTTP/health responses are fixtures; Compose, registry, SDK, PostgreSQL, @@ -101,7 +101,8 @@ def run(): docker('push', image['repository'] + ':fixture') # Copy health, networking and SDK settings from the original fixture, but start the new image's migration script. updater.releases = Releases(config, images) - for version in ('3.4.0', '3.5.0'): + backups = [] + for version in ('3.4.0', '3.5.0', '3.6.0'): http.version = version checked = updater.execute('check', version) assert checked['plan']['storageProvider'] == 'seaweedfs' @@ -112,6 +113,15 @@ def run(): old_matrix = migration.inspect(retained) assert not old_matrix['State']['Running'] and old_matrix['HostConfig']['RestartPolicy']['Name'] == 'no' backup = Path(result['backup']) + backups.append(backup) + retention = result['backupRetention'] + assert retention['status'] == 'complete', retention + assert len(retention['retained']) == min(len(backups), 2) + if len(backups) == 3: + assert not backups[0].exists() + assert u.read_json(backups[0].parent / 'backup-pruned.json')['status'] == 'removed' + assert backups[1].is_dir() and backups[2].is_dir() + assert (root / '.updates/storage-migration/backup/complete.json').is_file() with tarfile.open(backup / 'files.tar') as archive: assert archive.extractfile('matrix/postgres/retained.txt').read() == b'retired Matrix' assert 'storage/config/s3.json' in archive.getnames() @@ -136,7 +146,8 @@ def run(): migration.helper('restore-verify', endpoint='http://' + restore_name + ':9000') finally: docker('rm', '-f', restore_name) - print(json.dumps({'result': 'passed', 'restoredUpdaterBackup': str(backup), 'evidence': str(root)}), flush=True) + print(json.dumps({'result': 'passed', 'retention': 'two_generations_verified', + 'restoredUpdaterBackup': str(backup), 'evidence': str(root)}), flush=True) except BaseException: print('Failure evidence: ' + str(root), flush=True) for path in sorted((root / '.updates').glob('*/commands.log')): diff --git a/scripts/update/tests/test_backup_retention.py b/scripts/update/tests/test_backup_retention.py new file mode 100644 index 00000000..47c980da --- /dev/null +++ b/scripts/update/tests/test_backup_retention.py @@ -0,0 +1,190 @@ +import json +from pathlib import Path +import shutil +import tempfile +import unittest +from unittest.mock import patch + +from test_updater import u + + +class RetentionRunner: + def __init__(self, log, owner): + self.log, self.owner = log, owner + + def run(self, command): + if command[:2] == ['docker', 'ps']: + return 'container' if self.owner.mounts else '' + if command[:2] == ['docker', 'inspect']: + return json.dumps([{'Mounts': self.owner.mounts}]) + raise AssertionError(command) + + +class RetentionTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + (self.root / 'docker-compose.yml').write_text('unchanged compose') + self.mounts = [] + self.updater = u.Updater(self.root, runner_factory=lambda log: RetentionRunner(log, self)) + self.jobs = [self.backup(i) for i in range(1, 5)] + latest = u.read_json(self.jobs[-1] / 'status.json') + u.write_json(self.updater.home / 'installed.json', { + 'manifest': {'version': latest['version'], 'commit': latest['revision']}, + 'composeSha256': u.file_sha(self.root / 'docker-compose.yml')}) + u.write_json(self.updater.home / 'status.json', latest) + + def backup(self, index, *, name=None, status='succeeded', command='apply'): + job = self.updater.home / (name or f'202601{index:02d}-120000-{index:08x}') + directory = job / 'backup' + directory.mkdir(parents=True) + files = ['database.dump', 'globals.sql', 'files.tar', 'files.list', 'containers.json', + 'config/.env', 'config/docker-compose.yml'] + for name in files: + path = directory / name + path.parent.mkdir(exist_ok=True) + path.write_text(f'{index}: {name}') + u.write_json(directory / 'complete.json', { + 'database': 'database.dump', 'files': 'files.tar', 'storageProvider': 'minio', + 'sha256': {name: u.file_sha(directory / name) for name in files}}) + u.write_json(job / 'status.json', { + 'command': command, 'status': status, 'phase': 'complete', 'job': str(job), + 'backup': str(directory), 'maintenance': False, 'recoveryRequired': False, + 'version': f'3.{index}.0', 'revision': str(index) * 40, + 'startedAt': f'2026-01-{index:02d}T12:00:00+00:00'}) + (job / 'commands.log').write_text('audit log stays') + return job + + def test_keep_two_and_preserve_failed_migration_and_audit_records(self): + special = [self.backup(5, status='failed'), self.backup(6, name='storage-migration'), + self.backup(7, name='foreign'), self.backup(8, command='check')] + report = self.updater.prune_backups() + self.assertEqual(report['status'], 'complete') + self.assertEqual(len(report['removed']), 2) + self.assertEqual(len(report['retained']), 2) + for job in self.jobs[:2]: + self.assertFalse((job / 'backup').exists()) + self.assertEqual(u.read_json(job / 'backup-pruned.json')['status'], 'removed') + self.assertTrue((job / 'commands.log').is_file()) + for job in self.jobs[2:] + special: + self.assertTrue((job / 'backup/complete.json').is_file()) + self.assertEqual(self.updater.prune_backups()['removed'], []) + + def test_dry_run_checks_but_does_not_delete_or_write_markers(self): + result = self.updater.prune_backups(dry_run=True) + self.assertEqual(len(result['planned']), 2) + self.assertFalse((self.updater.home / 'backup-retention.json').exists()) + for job in self.jobs: + self.assertTrue((job / 'backup').is_dir()) + self.assertFalse((job / 'backup-pruned.json').exists()) + + def test_corrupt_either_retained_generation_prevents_all_deletions(self): + for job in self.jobs[2:]: + with self.subTest(job=job.name): + path = job / 'backup/database.dump' + original = path.read_bytes() + path.write_bytes(b'corrupt') + with self.assertRaisesRegex(u.UpdateError, 'Prüfsumme'): + self.updater.prune_backups() + self.assertTrue(all((p / 'backup').exists() for p in self.jobs)) + path.write_bytes(original) + + def test_incomplete_retained_backup_prevents_deletion(self): + (self.jobs[-1] / 'backup/globals.sql').unlink() + with self.assertRaisesRegex(u.UpdateError, 'fehlt'): + self.updater.prune_backups() + self.assertTrue((self.jobs[0] / 'backup').exists()) + + def test_seaweedfs_requires_image_and_provider_snapshot(self): + path = self.jobs[-1] / 'backup/complete.json' + manifest = u.read_json(path) + manifest['storageProvider'] = 'seaweedfs' + u.write_json(path, manifest) + with self.assertRaisesRegex(u.UpdateError, 'Unvollständiges'): + self.updater.prune_backups() + self.assertTrue((self.jobs[0] / 'backup').exists()) + + def test_unknown_files_and_links_are_preserved(self): + (self.jobs[0] / 'backup/foreign.txt').write_text('do not delete') + outside = self.root / 'outside' + outside.write_text('keep') + (self.jobs[1] / 'backup/files.tar').unlink() + (self.jobs[1] / 'backup/files.tar').symlink_to(outside) + result = self.updater.prune_backups() + self.assertEqual(len(result['skipped']), 2) + self.assertEqual(result['removed'], []) + self.assertEqual(outside.read_text(), 'keep') + + def test_symlinked_backup_directory_is_not_followed(self): + backup = self.jobs[0] / 'backup' + outside = self.root / 'outside' + backup.rename(outside) + backup.symlink_to(outside, target_is_directory=True) + result = self.updater.prune_backups() + self.assertTrue(outside.is_dir()) + self.assertTrue(backup.is_symlink()) + self.assertEqual(len(result['skipped']), 1) + + def test_manifest_path_escape_is_rejected(self): + path = self.jobs[-1] / 'backup/complete.json' + manifest = u.read_json(path) + manifest['sha256']['../outside'] = 'a' * 64 + u.write_json(path, manifest) + with self.assertRaisesRegex(u.UpdateError, 'Ungültiger Pfad'): + self.updater.prune_backups() + self.assertTrue((self.jobs[0] / 'backup').exists()) + + def test_container_mount_protects_backup_but_metrics_root_mount_does_not(self): + self.mounts = [{'Source': '/', 'RW': False}, + {'Source': str(self.jobs[0] / 'backup/files.tar'), 'RW': False}] + result = self.updater.prune_backups() + self.assertEqual(len(result['skipped']), 1) + self.assertTrue((self.jobs[0] / 'backup').exists()) + self.assertFalse((self.jobs[1] / 'backup').exists()) + + def test_same_device_bind_mount_is_protected(self): + read_text = Path.read_text + mount = self.jobs[0] / 'backup/config' + def read(path, *args, **kwargs): + if path == Path('/proc/self/mountinfo'): + return f'1 2 3:4 / {mount} rw - ext4 /dev/test rw\n' + return read_text(path, *args, **kwargs) + with patch.object(Path, 'read_text', read): + result = self.updater.prune_backups() + self.assertEqual(len(result['skipped']), 1) + self.assertTrue((self.jobs[0] / 'backup').exists()) + + def test_partial_deletion_can_resume_without_touching_retained_backups(self): + original = shutil.rmtree + def fail(path, *args, **kwargs): + if path == self.jobs[0] / 'backup': + (path / 'complete.json').unlink() + (path / 'database.dump').unlink() + raise OSError('simulated disk error') + return original(path, *args, **kwargs) + with patch.object(u.shutil, 'rmtree', fail): + result = self.updater.prune_backups() + self.assertEqual(len(result['skipped']), 1) + self.assertEqual(u.read_json(self.jobs[0] / 'backup-pruned.json')['status'], 'deleting') + result = self.updater.prune_backups() + self.assertEqual(len(result['removed']), 1) + self.assertTrue(all((p / 'backup').exists() for p in self.jobs[2:])) + + def test_recovery_running_and_lock_block_cleanup(self): + for state in ({'recoveryRequired': True}, {'maintenance': True}, {'status': 'running'}, + {'phase': 'storage_migration'}): + with self.subTest(state=state): + u.write_json(self.updater.home / 'status.json', state) + with self.assertRaises(u.UpdateError): + self.updater.prune_backups() + u.write_json(self.updater.home / 'status.json', {'status': 'failed', 'recoveryRequired': False}) + with self.updater.lock(), self.assertRaises(u.UpdateError): + self.updater.prune_backups() + self.assertEqual(len(self.updater.prune_backups()['removed']), 2) + + def test_changed_installation_blocks_cleanup(self): + (self.root / 'docker-compose.yml').write_text('manually restored') + with self.assertRaisesRegex(u.UpdateError, 'installierten Stand'): + self.updater.prune_backups() + self.assertTrue(all((p / 'backup').exists() for p in self.jobs)) diff --git a/scripts/update/tests/test_updater.py b/scripts/update/tests/test_updater.py index b1b422e5..0cf16601 100644 --- a/scripts/update/tests/test_updater.py +++ b/scripts/update/tests/test_updater.py @@ -646,6 +646,39 @@ class UpdateTests(unittest.TestCase): self.assertFalse((self.root / '.updates/installed.json').exists()) self.assertEqual(self.runner.calls[-1][-3:], ['backend', 'frontend', 'traefik']) + def test_backup_retention_runs_only_after_successful_public_verification(self): + def prune(): + self.assertEqual(self.updater.status()['status'], 'succeeded') + self.assertTrue(any(url.endswith('/api/health') for url in self.http.requests)) + return {'retained': [], 'removed': [], 'skipped': []} + with patch.object(self.updater, '_prune_backups', side_effect=prune) as cleanup: + self.run_update() + cleanup.assert_called_once() + + def test_failed_update_never_prunes_backups(self): + self.http.bad_health = True + with patch.object(self.updater, '_prune_backups') as cleanup: + with self.assertRaises(u.UpdateError): + self.run_update() + cleanup.assert_not_called() + + def test_retention_error_does_not_fail_update_or_stop_the_new_application(self): + with patch.object(self.updater, '_prune_backups', side_effect=OSError('disk error')): + result = self.run_update() + self.assertEqual(result['status'], 'succeeded') + self.assertEqual(result['backupRetention']['status'], 'warning') + self.assertEqual(u.read_json(self.updater.home / 'backup-retention.json')['status'], 'warning') + self.assertFalse(result['recoveryRequired']) + self.assertEqual(sum('stop' in args for args in self.runner.calls), 1) + + def test_interrupt_during_retention_preserves_completed_update(self): + with patch.object(self.updater, '_prune_backups', side_effect=KeyboardInterrupt): + with self.assertRaises(KeyboardInterrupt): + self.run_update() + self.assertEqual(self.updater.status()['status'], 'succeeded') + self.assertFalse(self.updater.status()['recoveryRequired']) + self.assertEqual(sum('stop' in args for args in self.runner.calls), 1) + def test_resolve_requires_a_working_manually_recovered_installation(self): self.runner.fail = lambda args: 'migrate' in args with self.assertRaises(u.UpdateError): -- 2.49.1 From 64299843e2821adfe3f0d717a42e578488a9296c Mon Sep 17 00:00:00 2001 From: flfeders Date: Fri, 2 Oct 2026 16:06:31 +0200 Subject: [PATCH 2/3] fix(communication): adopt legacy general chat rooms safely --- backend/src/routes/communication.ts | 34 ++++++++---- backend/tests/communicationAccess.test.ts | 66 +++++++++++++++++++++++ 2 files changed, 89 insertions(+), 11 deletions(-) diff --git a/backend/src/routes/communication.ts b/backend/src/routes/communication.ts index a2d7cc63..e94ef16a 100644 --- a/backend/src/routes/communication.ts +++ b/backend/src/routes/communication.ts @@ -88,13 +88,13 @@ export default async function communicationRoutes(server: FastifyInstance) { .onConflictDoNothing() } - const ensureGeneralRoom = async (tenantId: number, creatorId: string) => { - let [room] = await server.db.select().from(communicationRooms) - .where(and(eq(communicationRooms.tenantId, tenantId), eq(communicationRooms.key, "allgemein"))) - .limit(1) + const ensureGeneralRoom = async (tenantId: number, creatorId: string) => server.db.transaction(async (tx) => { + const generalKey = and(eq(communicationRooms.tenantId, tenantId), eq(communicationRooms.key, "allgemein")) + let [room] = await tx.select().from(communicationRooms) + .where(generalKey).limit(1).for("update") if (!room) { - const [created] = await server.db.insert(communicationRooms).values({ + const [created] = await tx.insert(communicationRooms).values({ tenantId, key: "allgemein", name: "Allgemeiner Chat", @@ -104,16 +104,28 @@ export default async function communicationRoutes(server: FastifyInstance) { }).onConflictDoNothing().returning() room = created if (!room) { - [room] = await server.db.select().from(communicationRooms) - .where(and(eq(communicationRooms.tenantId, tenantId), eq(communicationRooms.key, "allgemein"))) - .limit(1) + [room] = await tx.select().from(communicationRooms) + .where(generalKey).limit(1).for("update") } } - if (room.type !== "general" || room.archived) chatError("Allgemeiner Chat ist nicht verfügbar", 409) - await addMembers(room.id, (await tenantUsers(tenantId)).map((user) => user.userId)) + // Old Matrix general-room endpoints omitted the type and persisted its default 'room'. + // Only unarchived, unbound tenant rooms may be adopted; a key collision must not grant access. + if (!room || !["general", "room"].includes(room.type) || room.archived + || room.entityType !== null || room.entityId !== null || room.entityUuid !== null) { + chatError("Allgemeiner Chat ist nicht verfügbar", 409) + } + if (room.type === "room") { + [room] = await tx.update(communicationRooms).set({ type: "general" }) + .where(eq(communicationRooms.id, room.id)).returning() + } + const users = await tx.select({ userId: authTenantUsers.user_id }).from(authTenantUsers) + .where(eq(authTenantUsers.tenant_id, tenantId)) + if (users.length) await tx.insert(communicationRoomMembers) + .values([...new Set(users.map(user => user.userId))].map(userId => ({ roomId: room.id, userId }))) + .onConflictDoNothing() return room - } + }) const requireRoom = async (req: any, tenantId: number, userId: string, roomKey: string) => { const [row] = await server.db.select({ room: communicationRooms }).from(communicationRooms) diff --git a/backend/tests/communicationAccess.test.ts b/backend/tests/communicationAccess.test.ts index a3f0483e..15211de9 100644 --- a/backend/tests/communicationAccess.test.ts +++ b/backend/tests/communicationAccess.test.ts @@ -1,5 +1,6 @@ import assert from "node:assert/strict" import test from "node:test" +import { randomUUID } from "node:crypto" import Fastify from "fastify" import communicationRoutes from "../src/routes/communication" import { assertCustomRoomKey } from "../src/modules/communication-access" @@ -10,6 +11,71 @@ test("custom room keys cannot impersonate system rooms", () => { assert.doesNotThrow(() => assertCustomRoomKey("baustelle")) }) +test("general chat accepts legacy room metadata without exposing protected rooms", { skip: !testDatabaseUrl }, async (t) => { + const fixture = await collaborationDatabase(), app = Fastify() + const user = randomUUID(), other = randomUUID(), legacyRoom = randomUUID(), otherTenantRoom = randomUUID() + try { + await fixture.pool.query("INSERT INTO tenants VALUES (1,'Legacy tenant',null),(2,'Other tenant',null)") + await fixture.pool.query("INSERT INTO auth_users(id,email) VALUES ($1,'user@example.test'),($2,'other@example.test')", [user, other]) + await fixture.pool.query("INSERT INTO auth_tenant_users(tenant_id,user_id) VALUES (1,$1),(1,$2),(2,$2)", [user, other]) + // Matrix's general-room endpoints supplied key/name but omitted type, defaulting to 'room'. + await fixture.pool.query(`INSERT INTO communication_rooms(id,tenant_id,key,name,topic,type,archived) + VALUES ($1,1,'allgemein','Allgemeiner Chat','Existing topic','room',false), + ($2,2,'allgemein','Allgemeiner Chat',null,'room',false)`, [legacyRoom, otherTenantRoom]) + await fixture.pool.query("INSERT INTO communication_room_members(room_id,user_id) VALUES ($1,$2)", [legacyRoom, other]) + await fixture.pool.query("INSERT INTO communication_messages(tenant_id,room_id,author_user_id,body) VALUES (1,$1,$2,'Existing history')", [legacyRoom, other]) + app.decorate("db", fixture.db) + app.addHook("preHandler", async (req: any) => { req.user = { tenant_id: 1, user_id: user }; req.hasPermission = () => false }) + await app.register(communicationRoutes) + + await t.test("concurrent legacy loads preserve the room, history and tenant boundary", async () => { + const responses = await Promise.all([app.inject("/communication/chat/rooms"), app.inject("/communication/chat/rooms")]) + for (const response of responses) { + assert.equal(response.statusCode, 200, response.body) + assert.equal(response.json().rooms.length, 1) + assert.equal(response.json().rooms[0].id, legacyRoom) + assert.equal(response.json().rooms[0].type, "general") + assert.equal(response.json().rooms[0].topic, "Existing topic") + } + const history = await app.inject("/communication/chat/rooms/allgemein/messages") + assert.equal(history.statusCode, 200, history.body) + assert.equal(history.json().messages[0].body, "Existing history") + assert.equal((await fixture.pool.query("SELECT count(*) FROM communication_room_members WHERE room_id=$1", [legacyRoom])).rows[0].count, "2") + assert.equal((await fixture.pool.query("SELECT type FROM communication_rooms WHERE id=$1", [otherTenantRoom])).rows[0].type, "room") + }) + + for (const candidate of [ + { type: "direct" }, { type: "project" }, { type: "room", entityType: "project", entityId: 42 }, + { type: "room", entityId: 42 }, { type: "room", entityUuid: other }, + { type: "general", entityType: "project", entityId: 42 }, + { type: "room", archived: true }, { type: "general", archived: true }, + ]) await t.test(`protected general-key collision is not converted: ${JSON.stringify(candidate)}`, async () => { + const roomId = randomUUID() + await fixture.pool.query("UPDATE communication_rooms SET key='preserved-legacy' WHERE id=$1", [legacyRoom]) + await fixture.pool.query(`INSERT INTO communication_rooms(id,tenant_id,key,name,type,archived,entity_type,entity_id,entity_uuid) + VALUES ($1,1,'allgemein','Protected',$2,$3,$4,$5,$6)`, + [roomId, candidate.type, candidate.archived || false, candidate.entityType || null, candidate.entityId || null, candidate.entityUuid || null]) + await fixture.pool.query("INSERT INTO communication_room_members(room_id,user_id) VALUES ($1,$2)", [roomId, other]) + try { + const response = await app.inject("/communication/chat/rooms") + assert.equal(response.statusCode, 409, response.body) + const stored = (await fixture.pool.query("SELECT type,archived FROM communication_rooms WHERE id=$1", [roomId])).rows[0] + assert.equal(stored.type, candidate.type) + assert.equal(stored.archived, candidate.archived || false) + assert.deepEqual((await fixture.pool.query("SELECT user_id FROM communication_room_members WHERE room_id=$1", [roomId])).rows.map(m => m.user_id), [other]) + } finally { + await fixture.pool.query("DELETE FROM communication_rooms WHERE id=$1", [roomId]) + } + }) + + await t.test("concurrent first use creates one general room", async () => { + const responses = await Promise.all([app.inject("/communication/chat/rooms"), app.inject("/communication/chat/rooms")]) + for (const response of responses) assert.equal(response.statusCode, 200, response.body) + assert.equal((await fixture.pool.query("SELECT count(*) FROM communication_rooms WHERE tenant_id=1 AND key='allgemein'")).rows[0].count, "1") + }) + } finally { await app.close(); await fixture.close() } +}) + test("chat routes protect existing memberships and assigned projects", { skip: !testDatabaseUrl }, async () => { const fixture = await collaborationDatabase() const app = Fastify() -- 2.49.1 From d7382e73198c2d5ead9655d03aa09818f4eb14c7 Mon Sep 17 00:00:00 2001 From: flfeders Date: Fri, 2 Oct 2026 16:09:04 +0200 Subject: [PATCH 3/3] feat(documents): prepare inbox suggestions and add entity assignments --- .../0077_scanner_inbox_preparation.sql | 13 ++ backend/db/migrations/meta/_journal.json | 7 + backend/db/schema/scanner_inbox.ts | 9 +- backend/src/index.ts | 2 + .../src/modules/scanner-inbox-assignments.ts | 70 +++++++ backend/src/modules/scanner-inbox.service.ts | 100 +++++++--- backend/src/modules/scanner-inbox.worker.ts | 27 +++ backend/src/routes/documentInbox.ts | 21 ++- backend/tests/scannerInbox.test.ts | 111 ++++++++++- docs/scanner-dokumentenablage.md | 20 +- frontend/components/MainNav.vue | 4 +- frontend/composables/useDocumentInboxCount.ts | 31 ++++ .../pages/organisation/dokumentenablage.vue | 173 ++++++++++++++++-- frontend/tests/document-inbox-count.test.cjs | 62 +++++++ frontend/tests/document-inbox.test.cjs | 129 ++++++++++++- 15 files changed, 707 insertions(+), 72 deletions(-) create mode 100644 backend/db/migrations/0077_scanner_inbox_preparation.sql create mode 100644 backend/src/modules/scanner-inbox-assignments.ts create mode 100644 backend/src/modules/scanner-inbox.worker.ts create mode 100644 frontend/composables/useDocumentInboxCount.ts create mode 100644 frontend/tests/document-inbox-count.test.cjs diff --git a/backend/db/migrations/0077_scanner_inbox_preparation.sql b/backend/db/migrations/0077_scanner_inbox_preparation.sql new file mode 100644 index 00000000..6aa5425b --- /dev/null +++ b/backend/db/migrations/0077_scanner_inbox_preparation.sql @@ -0,0 +1,13 @@ +ALTER TABLE "scanner_inbox_documents" + ADD COLUMN "suggestion_status" text NOT NULL DEFAULT 'pending', + ADD COLUMN "suggestion" jsonb, + ADD COLUMN "suggestion_message" text, + ADD COLUMN "suggestion_claim" uuid, + ADD COLUMN "suggestion_updated_at" timestamptz NOT NULL DEFAULT now(); +--> statement-breakpoint +ALTER TABLE "scanner_inbox_documents" ADD CONSTRAINT "scanner_inbox_suggestion_status_check" + CHECK ("suggestion_status" IN ('pending', 'processing', 'ready', 'failed')); +--> statement-breakpoint +CREATE INDEX "scanner_inbox_suggestion_queue_idx" + ON "scanner_inbox_documents" ("suggestion_status", "suggestion_updated_at", "received_at") + WHERE "filed_at" IS NULL; diff --git a/backend/db/migrations/meta/_journal.json b/backend/db/migrations/meta/_journal.json index 6a2bd3c1..91cac318 100644 --- a/backend/db/migrations/meta/_journal.json +++ b/backend/db/migrations/meta/_journal.json @@ -519,6 +519,13 @@ "when": 1790726400001, "tag": "0076_collaboration_federation", "breakpoints": true + }, + { + "idx": 74, + "version": "7", + "when": 1790899200000, + "tag": "0077_scanner_inbox_preparation", + "breakpoints": true } ] } diff --git a/backend/db/schema/scanner_inbox.ts b/backend/db/schema/scanner_inbox.ts index b048e4a2..30747e56 100644 --- a/backend/db/schema/scanner_inbox.ts +++ b/backend/db/schema/scanner_inbox.ts @@ -1,6 +1,7 @@ -import { bigint, boolean, index, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core" +import { bigint, boolean, index, jsonb, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core" import { tenants } from "./tenants" import { files } from "./files" +import { sql } from "drizzle-orm" export const scannerInboxConnections = pgTable("scanner_inbox_connections", { tenantId: bigint("tenant_id", { mode: "number" }).primaryKey().references(() => tenants.id, { onDelete: "cascade" }), @@ -18,7 +19,13 @@ export const scannerInboxDocuments = pgTable("scanner_inbox_documents", { checksum: text("checksum").notNull(), receivedAt: timestamp("received_at", { withTimezone: true }).notNull().defaultNow(), filedAt: timestamp("filed_at", { withTimezone: true }), + suggestionStatus: text("suggestion_status").notNull().default("pending"), + suggestion: jsonb("suggestion"), + suggestionMessage: text("suggestion_message"), + suggestionClaim: uuid("suggestion_claim"), + suggestionUpdatedAt: timestamp("suggestion_updated_at", { withTimezone: true }).notNull().defaultNow(), }, table => ({ filenameKey: uniqueIndex("scanner_inbox_documents_filename_key").on(table.tenantId, table.remoteFilename), receivedIdx: index("scanner_inbox_documents_received_idx").on(table.tenantId, table.receivedAt), + suggestionQueueIdx: index("scanner_inbox_suggestion_queue_idx").on(table.suggestionStatus, table.suggestionUpdatedAt, table.receivedAt).where(sql`${table.filedAt} IS NULL`), })) diff --git a/backend/src/index.ts b/backend/src/index.ts index 8865d0c5..3a2ea632 100644 --- a/backend/src/index.ts +++ b/backend/src/index.ts @@ -69,6 +69,7 @@ import {initS3} from "./utils/s3"; import { runBootstrap } from "./modules/bootstrap.service"; import { startCentralServicesHeartbeat } from "./modules/central-services-heartbeat.service"; import { startDocumentImportWorker } from "./modules/document-import/document-import.worker"; +import { startScannerInboxWorker } from "./modules/scanner-inbox.worker"; //Services @@ -97,6 +98,7 @@ async function main() { await runBootstrap(app); startCentralServicesHeartbeat(app); startDocumentImportWorker(app); + startScannerInboxWorker(app); app.addHook('preHandler', (req, reply, done) => { console.log(req.method) diff --git a/backend/src/modules/scanner-inbox-assignments.ts b/backend/src/modules/scanner-inbox-assignments.ts new file mode 100644 index 00000000..641a4f52 --- /dev/null +++ b/backend/src/modules/scanner-inbox-assignments.ts @@ -0,0 +1,70 @@ +import { and, asc, eq, ilike, isNull, sql, type SQL } from "drizzle-orm" +import type { AnyPgColumn, AnyPgTable } from "drizzle-orm/pg-core" +import type { FastifyInstance } from "fastify" +import { authProfiles, checks, contracts, createddocuments, customers, incominginvoices, inventoryitems, plants, products, projects, vehicles, vendors } from "../../db/schema" + +type Target = { label: string; table: AnyPgTable; id: AnyPgColumn; tenant: AnyPgColumn; name: AnyPgColumn; available: SQL; uuid?: boolean } +export const assignmentTargets: Record = { + project: { label: "Projekt", table: projects, id: projects.id, tenant: projects.tenant, name: projects.name, available: eq(projects.archived, false) }, + customer: { label: "Kunde", table: customers, id: customers.id, tenant: customers.tenant, name: customers.name, available: eq(customers.archived, false) }, + vendor: { label: "Lieferant", table: vendors, id: vendors.id, tenant: vendors.tenant, name: vendors.name, available: eq(vendors.archived, false) }, + vehicle: { label: "Fahrzeug", table: vehicles, id: vehicles.id, tenant: vehicles.tenant, name: vehicles.license_plate, available: eq(vehicles.archived, false) }, + plant: { label: "Objekt", table: plants, id: plants.id, tenant: plants.tenant, name: plants.name, available: eq(plants.archived, false) }, + contract: { label: "Vertrag", table: contracts, id: contracts.id, tenant: contracts.tenant, name: contracts.name, available: eq(contracts.archived, false) }, + product: { label: "Produkt", table: products, id: products.id, tenant: products.tenant, name: products.name, available: eq(products.archived, false) }, + createddocument: { label: "Ausgangsbeleg", table: createddocuments, id: createddocuments.id, tenant: createddocuments.tenant, name: createddocuments.documentNumber, available: eq(createddocuments.archived, false) }, + incominginvoice: { label: "Eingangsrechnung", table: incominginvoices, id: incominginvoices.id, tenant: incominginvoices.tenant, name: incominginvoices.reference, available: eq(incominginvoices.archived, false) }, + inventoryitem: { label: "Inventarartikel", table: inventoryitems, id: inventoryitems.id, tenant: inventoryitems.tenant, name: inventoryitems.name, available: eq(inventoryitems.archived, false) }, + check: { label: "Überprüfung", table: checks, id: checks.id, tenant: checks.tenant, name: checks.name, available: eq(checks.archived, false), uuid: true }, + authProfile: { label: "Mitarbeiter", table: authProfiles, id: authProfiles.id, tenant: authProfiles.tenant_id, name: authProfiles.full_name, + available: and(eq(authProfiles.active, true), isNull(authProfiles.customer_for_portal)), uuid: true }, +} +export const assignmentKinds = Object.entries(assignmentTargets).map(([value, target]) => ({ value, label: target.label })) +export type FileAssignments = Record +const invalidAssignment = () => Object.assign(new Error("Die gewählte Zuordnung ist nicht verfügbar."), { statusCode: 400 }) +const targetFor = (kind: string) => { + if (!Object.prototype.hasOwnProperty.call(assignmentTargets, kind)) throw invalidAssignment() + return assignmentTargets[kind] +} +export function assignmentId(kind: string, id: unknown) { + const target = targetFor(kind) + if (target.uuid) { + if (typeof id !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)) throw invalidAssignment() + return id + } + if (!/^[1-9]\d*$/.test(String(id)) || !Number.isSafeInteger(Number(id))) throw invalidAssignment() + return Number(id) +} +type Reader = Pick +export async function assignmentOptions(db: Reader, tenantId: number, kind: string, search = "") { + const target = targetFor(kind) + const name = sql`coalesce(nullif(${target.name}, ''), '#' || ${target.id}::text)` + const rows = await db.select({ id: target.id, name }).from(target.table) + .where(and(eq(target.tenant, tenantId), target.available, + search ? ilike(name, `%${search.replace(/[\\%_]/g, "\\$&")}%`) : undefined)) + .orderBy(asc(target.name), asc(target.id)).limit(100) + return rows.map(row => ({ id: String(row.id), name: row.name })) +} +export async function currentAssignments(db: Reader, tenantId: number, file: Record) { + const assignments = [] + for (const [kind, target] of Object.entries(assignmentTargets)) { + if (file[kind] == null) continue + const [entry] = await db.select({ name: target.name }).from(target.table) + .where(and(eq(target.id, file[kind]), eq(target.tenant, tenantId), target.available)).limit(1) + assignments.push({ kind, id: String(file[kind]), name: entry?.name || (entry ? `#${file[kind]}` : "Nicht mehr verfügbar"), available: Boolean(entry) }) + } + return assignments +} +export async function validateAssignments(tx: Reader, tenantId: number, assignments: FileAssignments) { + const changes: FileAssignments = {} + for (const [kind, value] of Object.entries(assignments)) { + const target = targetFor(kind) + if (value === null) { changes[kind] = null; continue } + const id = assignmentId(kind, value) + const [row] = await tx.select({ id: target.id }).from(target.table) + .where(and(eq(target.id, id), eq(target.tenant, tenantId), target.available)).for("share").limit(1) + if (!row) throw invalidAssignment() + changes[kind] = id + } + return changes +} diff --git a/backend/src/modules/scanner-inbox.service.ts b/backend/src/modules/scanner-inbox.service.ts index b00d35f6..b119812c 100644 --- a/backend/src/modules/scanner-inbox.service.ts +++ b/backend/src/modules/scanner-inbox.service.ts @@ -1,12 +1,13 @@ import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto" -import { and, asc, count, desc, eq, ilike, isNull, sql } from "drizzle-orm" +import { and, asc, count, desc, eq, ilike, inArray, isNull, sql } from "drizzle-orm" import type { FastifyInstance } from "fastify" import { DeleteObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3" import { files, filetags, folders, scannerInboxConnections, scannerInboxDocuments, tenants } from "../../db/schema" import { sanitizeFilename } from "../utils/filename" import { s3 } from "../utils/s3" import { secrets } from "../utils/secrets" -import { suggestDocumentFiling, validateFilingSuggestion, type FilingSuggestionResult } from "./scanner-inbox-suggestions" +import { suggestDocumentFiling, validateFilingSuggestion } from "./scanner-inbox-suggestions" +import { assignmentKinds, assignmentOptions, currentAssignments, validateAssignments, type FileAssignments } from "./scanner-inbox-assignments" export const SCANNER_UPLOAD_LIMIT = 100 * 1024 * 1024 export const SCANNER_DAV_PATH = "/scanner-inbox/" @@ -47,7 +48,6 @@ export function validateScannerFile(filename: string, body: Buffer) { } export function createScannerInboxService(db: FastifyInstance["db"], storage: ScannerStorage = objectStorage, analyze = suggestDocumentFiling) { - const pendingSuggestions = new Map>() const publicConnection = { username: scannerInboxConnections.username, active: scannerInboxConnections.active, @@ -93,13 +93,19 @@ export function createScannerInboxService(db: FastifyInstance["db"], storage: Sc isNull(scannerInboxDocuments.filedAt), eq(files.archived, false), search ? ilike(scannerInboxDocuments.remoteFilename, `%${search.replace(/[\\%_]/g, "\\$&")}%`) : undefined) const documents = await db.select({ id: files.id, name: scannerInboxDocuments.remoteFilename, - mimeType: files.mimeType, size: files.size, receivedAt: scannerInboxDocuments.receivedAt }) + mimeType: files.mimeType, size: files.size, receivedAt: scannerInboxDocuments.receivedAt, suggestionStatus: scannerInboxDocuments.suggestionStatus }) .from(scannerInboxDocuments).innerJoin(files, eq(files.id, scannerInboxDocuments.fileId)) .where(condition).orderBy(desc(scannerInboxDocuments.receivedAt), desc(files.id)).limit(limit).offset(offset) const [total] = await db.select({ value: count() }).from(scannerInboxDocuments) .innerJoin(files, eq(files.id, scannerInboxDocuments.fileId)).where(condition) return { documents, total: total.value } } + const openCount = async (tenantId: number) => { + const [row] = await db.select({ total: count() }).from(scannerInboxDocuments) + .innerJoin(files, eq(files.id, scannerInboxDocuments.fileId)) + .where(and(eq(scannerInboxDocuments.tenantId, tenantId), eq(files.tenant, tenantId), isNull(scannerInboxDocuments.filedAt), eq(files.archived, false))) + return row + } const filingOptions = async (tenantId: number) => { const [availableFolders, types] = await Promise.all([ db.select({ id: folders.id, name: folders.name, parent: folders.parent, @@ -108,33 +114,77 @@ export function createScannerInboxService(db: FastifyInstance["db"], storage: Sc db.select({ id: filetags.id, name: filetags.name }).from(filetags) .where(and(eq(filetags.tenant, tenantId), eq(filetags.archived, false))).orderBy(asc(filetags.name)), ]) - return { folders: availableFolders, types } + return { folders: availableFolders, types, assignmentKinds } } const suggestionDocument = async (tenantId: number, fileId: string) => { - const [document] = await db.select({ path: files.path, name: scannerInboxDocuments.remoteFilename, mimeType: files.mimeType, size: files.size }) + const [document] = await db.select({ path: files.path, name: scannerInboxDocuments.remoteFilename, mimeType: files.mimeType, size: files.size, + status: scannerInboxDocuments.suggestionStatus, suggestion: scannerInboxDocuments.suggestion, message: scannerInboxDocuments.suggestionMessage }) .from(scannerInboxDocuments).innerJoin(files, eq(files.id, scannerInboxDocuments.fileId)) .where(and(eq(scannerInboxDocuments.tenantId, tenantId), eq(files.tenant, tenantId), eq(files.id, fileId), isNull(scannerInboxDocuments.filedAt), eq(files.archived, false))).limit(1) if (!document?.path) throw scannerError(404, "Dokument nicht in der Ablage gefunden.") return document } - const suggestFiling = async (tenantId: number, fileId: string): Promise => { - // Check tenant ownership before reading storage or submitting anything to the AI provider. + const getSuggestion = async (tenantId: number, fileId: string) => { const document = await suggestionDocument(tenantId, fileId) - const key = `${tenantId}:${fileId}` - if (pendingSuggestions.has(key)) return pendingSuggestions.get(key)! - if (pendingSuggestions.size >= 4) throw scannerError(429, "Die KI verarbeitet gerade weitere Dokumente. Bitte gleich erneut versuchen.") - const operation = (async () => { - const result = await analyze(document, await filingOptions(tenantId)) - await suggestionDocument(tenantId, fileId) - const suggestion = validateFilingSuggestion(result, await filingOptions(tenantId)) - return { suggestion, message: suggestion ? undefined : result.message || "Keine passende Zuordnung verfügbar. Bitte manuell auswählen." } - })() - pendingSuggestions.set(key, operation) - try { return await operation } - finally { pendingSuggestions.delete(key) } + const suggestion = document.status === "ready" + ? validateFilingSuggestion({ suggestion: document.suggestion }, await filingOptions(tenantId)) : null + return { status: document.status, suggestion, message: document.status === "ready" && !suggestion + ? document.message || "Keine passende Zuordnung verfügbar. Bitte manuell auswählen." : document.message } } - const fileDocument = async (tenantId: number, userId: string, fileId: string, folderId: string | null, typeId: string) => db.transaction(async tx => { + const queueSuggestion = async (tenantId: number, fileId: string) => { + await suggestionDocument(tenantId, fileId) + await db.update(scannerInboxDocuments).set({ suggestionStatus: "pending", suggestion: null, suggestionMessage: null, + suggestionClaim: null, suggestionUpdatedAt: new Date() }) + .where(and(eq(scannerInboxDocuments.tenantId, tenantId), eq(scannerInboxDocuments.fileId, fileId), + isNull(scannerInboxDocuments.filedAt), inArray(scannerInboxDocuments.suggestionStatus, ["ready", "failed"]))) + return getSuggestion(tenantId, fileId) + } + const processNextSuggestion = async () => { + const claim = randomUUID() + // Claim without holding a transaction open while OCR/the provider runs. Expired claims survive restarts. + const claimed = await db.execute<{ fileId: string; tenantId: string }>(sql` + UPDATE scanner_inbox_documents AS job + SET suggestion_status = 'processing', suggestion_claim = ${claim}, suggestion_updated_at = now() + WHERE job.file_id = ( + SELECT pending.file_id FROM scanner_inbox_documents AS pending + JOIN files ON files.id = pending.file_id AND files.tenant = pending.tenant_id + JOIN tenants ON tenants.id = pending.tenant_id + WHERE pending.filed_at IS NULL AND files.archived = false + AND tenants.locked IS DISTINCT FROM 'maintenance_tenant' + AND (pending.suggestion_status = 'pending' OR + (pending.suggestion_status = 'processing' AND pending.suggestion_updated_at < now() - interval '5 minutes')) + ORDER BY pending.received_at, pending.file_id FOR UPDATE OF pending SKIP LOCKED LIMIT 1 + ) RETURNING job.file_id AS "fileId", job.tenant_id AS "tenantId"`) + const job = claimed.rows[0] + if (!job) return false + const tenantId = Number(job.tenantId) + const condition = and(eq(scannerInboxDocuments.fileId, job.fileId), eq(scannerInboxDocuments.tenantId, tenantId), + eq(scannerInboxDocuments.suggestionClaim, claim), isNull(scannerInboxDocuments.filedAt)) + try { + const document = await suggestionDocument(tenantId, job.fileId) + const { path, name, mimeType, size } = document + const result = await analyze({ path, name, mimeType, size }, await filingOptions(tenantId)) + await suggestionDocument(tenantId, job.fileId) + const suggestion = validateFilingSuggestion(result, await filingOptions(tenantId)) + await db.update(scannerInboxDocuments).set({ suggestionStatus: "ready", suggestion, + suggestionMessage: suggestion ? null : result.message || "Keine passende Zuordnung gefunden. Bitte manuell auswählen.", + suggestionClaim: null, suggestionUpdatedAt: new Date() }).where(condition) + } catch (error: any) { + const message = error?.statusCode === 503 ? "Die KI-Erkennung ist noch nicht konfiguriert. Bitte manuell zuordnen oder später erneut prüfen." + : "Die KI-Vorbereitung ist fehlgeschlagen. Bitte erneut prüfen oder manuell zuordnen." + await db.update(scannerInboxDocuments).set({ suggestionStatus: "failed", suggestion: null, suggestionMessage: message, + suggestionClaim: null, suggestionUpdatedAt: new Date() }).where(condition) + } + return true + } + const getAssignments = async (tenantId: number, fileId: string) => { + await suggestionDocument(tenantId, fileId) + const [file] = await db.select().from(files).where(and(eq(files.id, fileId), eq(files.tenant, tenantId), eq(files.archived, false))).limit(1) + if (!file) throw scannerError(404, "Dokument nicht gefunden.") + return currentAssignments(db, tenantId, file) + } + const fileDocument = async (tenantId: number, userId: string, fileId: string, folderId: string | null, typeId: string, assignments: FileAssignments = {}) => db.transaction(async tx => { const [tenant] = await tx.select({ locked: tenants.locked }).from(tenants) .where(eq(tenants.id, tenantId)).for("share") if (!tenant) throw scannerError(404, "Mandant nicht gefunden.") @@ -157,11 +207,12 @@ export function createScannerInboxService(db: FastifyInstance["db"], storage: Sc const [type] = await tx.select({ id: filetags.id }).from(filetags) .where(and(eq(filetags.id, typeId), eq(filetags.tenant, tenantId), eq(filetags.archived, false))).for("share") if (!type) throw scannerError(400, "Der gewählte Dokumenttyp ist nicht verfügbar.") + const assignmentChanges = await validateAssignments(tx, tenantId, assignments) const now = new Date() - await tx.update(files).set({ folder: folderId, type: typeId, updatedAt: now, updatedBy: userId }) + await tx.update(files).set({ ...assignmentChanges, folder: folderId, type: typeId, updatedAt: now, updatedBy: userId }) .where(and(eq(files.id, fileId), eq(files.tenant, tenantId))) // Keep the receipt so a scanner retry cannot recreate a document after filing. - await tx.update(scannerInboxDocuments).set({ filedAt: now }) + await tx.update(scannerInboxDocuments).set({ filedAt: now, suggestionClaim: null }) .where(and(eq(scannerInboxDocuments.fileId, fileId), eq(scannerInboxDocuments.tenantId, tenantId))) return { id: fileId, folder: folderId, type: typeId } }) @@ -225,7 +276,8 @@ export function createScannerInboxService(db: FastifyInstance["db"], storage: Sc throw error } } - return { connection, credentials, disable, authenticate, find, list, filingOptions, suggestFiling, fileDocument, probe, accept } + return { connection, credentials, disable, authenticate, find, list, openCount, filingOptions, getSuggestion, queueSuggestion, processNextSuggestion, + getAssignments, assignmentOptions: (tenantId: number, kind: string, search: string) => assignmentOptions(db, tenantId, kind, search), fileDocument, probe, accept } } export type ScannerInboxService = ReturnType diff --git a/backend/src/modules/scanner-inbox.worker.ts b/backend/src/modules/scanner-inbox.worker.ts new file mode 100644 index 00000000..eb73d0bf --- /dev/null +++ b/backend/src/modules/scanner-inbox.worker.ts @@ -0,0 +1,27 @@ +import type { FastifyInstance } from "fastify" +import { createScannerInboxService, type ScannerInboxService } from "./scanner-inbox.service" + +export function startScannerInboxWorker(server: FastifyInstance, service: Pick = createScannerInboxService(server.db)) { + let stopped = false + let timer: ReturnType | undefined + let running: Promise | undefined + const run = async () => { + try { + // One analysis per process; database claims coordinate multiple backend instances. + while (!stopped && await service.processNextSuggestion()) { /* drain the durable queue */ } + } catch { + server.log.error("KI-Vorbereitung der Dokumentenablage unterbrochen; erneuter Versuch folgt.") + } finally { + if (!stopped) { + timer = setTimeout(() => { running = run() }, 2000) + timer.unref() + } + } + } + server.addHook("onReady", async () => { running = run() }) + server.addHook("onClose", async () => { + stopped = true + clearTimeout(timer) + await running + }) +} diff --git a/backend/src/routes/documentInbox.ts b/backend/src/routes/documentInbox.ts index de9ee335..f2fcfd08 100644 --- a/backend/src/routes/documentInbox.ts +++ b/backend/src/routes/documentInbox.ts @@ -2,6 +2,7 @@ import { and, eq } from "drizzle-orm" import type { FastifyInstance } from "fastify" import { authProfiles } from "../../db/schema" import { createScannerInboxService, SCANNER_DAV_PATH, SCANNER_UPLOAD_LIMIT, type ScannerInboxService } from "../modules/scanner-inbox.service" +import { assignmentTargets, type FileAssignments } from "../modules/scanner-inbox-assignments" export default async function documentInboxRoutes(server: FastifyInstance, options: { service?: ScannerInboxService }) { const service = options.service || createScannerInboxService(server.db) @@ -25,18 +26,32 @@ export default async function documentInboxRoutes(server: FastifyInstance, optio return service.list(req.user.tenant_id!, limit, offset, query.search?.trim() || "") }) server.get("/document-inbox/filing-options", async req => service.filingOptions(req.user.tenant_id!)) + server.get("/document-inbox/count", async req => service.openCount(req.user.tenant_id!)) + server.get<{ Querystring: { kind: string; search?: string } }>("/document-inbox/assignment-options", { + schema: { querystring: { type: "object", required: ["kind"], properties: { + kind: { type: "string", enum: Object.keys(assignmentTargets) }, search: { type: "string", maxLength: 200 }, + } } }, + }, async req => service.assignmentOptions(req.user.tenant_id!, req.query.kind, req.query.search?.trim() || "")) + server.get<{ Params: { id: string } }>("/document-inbox/:id/assignments", { + schema: { params: { type: "object", required: ["id"], properties: { id: { type: "string", format: "uuid" } } } }, + }, async req => service.getAssignments(req.user.tenant_id!, req.params.id)) + server.get<{ Params: { id: string } }>("/document-inbox/:id/suggestion", { + schema: { params: { type: "object", required: ["id"], properties: { id: { type: "string", format: "uuid" } } } }, + }, async req => service.getSuggestion(req.user.tenant_id!, req.params.id)) server.post<{ Params: { id: string } }>("/document-inbox/:id/suggestion", { schema: { params: { type: "object", required: ["id"], properties: { id: { type: "string", format: "uuid" } } } }, - }, async req => service.suggestFiling(req.user.tenant_id!, req.params.id)) - server.post<{ Params: { id: string }; Body: { folder: string | null; type: string } }>("/document-inbox/:id/file", { + }, async (req, reply) => reply.code(202).send(await service.queueSuggestion(req.user.tenant_id!, req.params.id))) + server.post<{ Params: { id: string }; Body: { folder: string | null; type: string; assignments?: FileAssignments } }>("/document-inbox/:id/file", { schema: { params: { type: "object", required: ["id"], properties: { id: { type: "string", format: "uuid" } } }, body: { type: "object", required: ["folder", "type"], additionalProperties: false, properties: { folder: { anyOf: [{ type: "string", format: "uuid" }, { type: "null" }] }, type: { type: "string", format: "uuid" }, + assignments: { type: "object", additionalProperties: false, properties: Object.fromEntries(Object.keys(assignmentTargets).map(kind => + [kind, { anyOf: [{ type: "null" }, { type: "integer", minimum: 1, maximum: Number.MAX_SAFE_INTEGER }, { type: "string", minLength: 1, maxLength: 36 }] }])) }, } }, }, - }, async req => service.fileDocument(req.user.tenant_id!, req.user.user_id, req.params.id, req.body.folder, req.body.type)) + }, async req => service.fileDocument(req.user.tenant_id!, req.user.user_id, req.params.id, req.body.folder, req.body.type, req.body.assignments)) server.get("/document-inbox/scanner", async req => ({ connection: await service.connection(req.user.tenant_id!), path: SCANNER_DAV_PATH, maxFileSize: SCANNER_UPLOAD_LIMIT, })) diff --git a/backend/tests/scannerInbox.test.ts b/backend/tests/scannerInbox.test.ts index f1fe1104..f89475bd 100644 --- a/backend/tests/scannerInbox.test.ts +++ b/backend/tests/scannerInbox.test.ts @@ -193,10 +193,14 @@ test("scanner inbox integration: migration, persistence, isolation, retries and CREATE TABLE filetags (id uuid PRIMARY KEY, tenant bigint, name text, archived boolean DEFAULT false); CREATE TABLE folders (id uuid PRIMARY KEY, tenant bigint, name text, parent uuid, "standardFiletype" uuid, "standardFiletypeIsOptional" boolean DEFAULT true, archived boolean DEFAULT false); - CREATE TABLE auth_profiles (tenant_id bigint, user_id uuid, customer_for_portal bigint);`) + CREATE TABLE projects (id bigint PRIMARY KEY, tenant bigint, name text, archived boolean DEFAULT false); + CREATE TABLE customers (id bigint PRIMARY KEY, tenant bigint, name text, archived boolean DEFAULT false); + CREATE TABLE checks (id uuid PRIMARY KEY, tenant bigint, name text, archived boolean DEFAULT false); + CREATE TABLE auth_profiles (id uuid DEFAULT gen_random_uuid(), tenant_id bigint, user_id uuid, customer_for_portal bigint, + full_name text, active boolean DEFAULT true);`) const migrationRoot = path.resolve(__dirname, "../db/migrations") const journal = JSON.parse(await readFile(path.join(migrationRoot, "meta/_journal.json"), "utf8")) - const entries = ["0073_scanner_document_inbox", "0074_scanner_inbox_filing"].map(tag => journal.entries.find((item: any) => item.tag === tag)) + const entries = ["0073_scanner_document_inbox", "0074_scanner_inbox_filing", "0077_scanner_inbox_preparation"].map(tag => journal.entries.find((item: any) => item.tag === tag)) await mkdir(path.join(tempMigrations, "meta")) for (const entry of entries) { assert.ok(entry) @@ -213,14 +217,17 @@ test("scanner inbox integration: migration, persistence, isolation, retries and const analyses: any[] = [] let analysisGate: Promise | undefined let analysisStarted: (() => void) | undefined + let analysisFailure = false const service = createScannerInboxService(db, { async put(key, body) { stored.set(key, Buffer.from(body)); if (storageFailure) throw new Error("Simulated object store failure") }, async remove(key) { stored.delete(key) }, }, async (document, candidates) => { analyses.push({ document, candidates }) + const result = aiResult analysisStarted?.() await analysisGate - return aiResult + if (analysisFailure) throw new Error("Simulated AI failure") + return result }) const first = await service.credentials(1) const second = await service.credentials(2) @@ -265,6 +272,8 @@ test("scanner inbox integration: migration, persistence, isolation, retries and assert.equal(row.tenant, "1") assert.equal(row.mimeType, "application/pdf") assert.equal(row.extracted_text, null) + assert.equal((await pool.query("SELECT suggestion_status FROM scanner_inbox_documents WHERE file_id=$1", [row.id])).rows[0].suggestion_status, "pending") + assert.equal(analyses.length, 0, "the upload only queues preparation; it does not wait for OCR/AI") assert.deepEqual(stored.get(row.path), pdf) assert.equal((await PDFDocument.load(stored.get(row.path)!)).getPageCount(), 2) const listing = await app.inject({ method: "GET", url: "/api/document-inbox" }) @@ -332,17 +341,21 @@ test("scanner inbox integration: migration, persistence, isolation, retries and [targetFolder, targetType, foreignFolder, archivedFolder]) const fileInto = (id: string, folder: string | null = targetFolder, type: string = targetType, headers = {}) => app.inject({ method: "POST", url: `/api/document-inbox/${id}/file`, payload: { folder, type }, headers }) - const suggest = (id: string, headers = {}) => app.inject({ method: "POST", url: `/api/document-inbox/${id}/suggestion`, headers }) + const suggest = (id: string, headers = {}) => app.inject({ method: "GET", url: `/api/document-inbox/${id}/suggestion`, headers }) + const queue = (id: string, headers = {}) => app.inject({ method: "POST", url: `/api/document-inbox/${id}/suggestion`, headers }) await t.test("AI analysis is tenant scoped, validates destinations and never files a document", async () => { const id = (await service.list(1, 50, 0, "scan.pdf")).documents[0].id const before = (await pool.query("SELECT folder, type, extracted_text FROM files WHERE id=$1", [id])).rows[0] aiResult = { suggestion: { folderId: targetFolder, typeId: targetType, confidence: "high", reason: "Rechnung erkannt." } } assert.equal((await suggest(id, { "x-test-tenant": "2" })).statusCode, 404) assert.equal((await suggest("invalid")).statusCode, 400) - await pool.query("INSERT INTO auth_profiles VALUES (1, $1, 123)", [userId]) + await pool.query("INSERT INTO auth_profiles (tenant_id, user_id, customer_for_portal) VALUES (1, $1, 123)", [userId]) assert.equal((await suggest(id)).statusCode, 403) await pool.query("DELETE FROM auth_profiles") assert.equal(analyses.length, 0) + assert.equal((await suggest(id)).json().status, "pending") + assert.equal(analyses.length, 0, "reading the preview never starts analysis") + assert.equal(await service.processNextSuggestion(), true) const result = await suggest(id, { "x-test-admin": "false" }) assert.equal(result.statusCode, 200, result.body) assert.deepEqual(result.json().suggestion, aiResult.suggestion) @@ -352,6 +365,8 @@ test("scanner inbox integration: migration, persistence, isolation, retries and assert.deepEqual((await pool.query("SELECT folder, type, extracted_text FROM files WHERE id=$1", [id])).rows[0], before) assert.equal((await service.list(1, 50, 0, "scan.pdf")).total, 1) aiResult = { suggestion: { ...aiResult.suggestion!, folderId: foreignFolder } } + assert.equal((await queue(id)).statusCode, 202) + await service.processNextSuggestion() assert.equal((await suggest(id)).json().suggestion, null) }) await t.test("AI results are checked again if destination availability changes during analysis", async () => { @@ -360,15 +375,93 @@ test("scanner inbox integration: migration, persistence, isolation, retries and let finish!: () => void analysisGate = new Promise(resolve => { finish = resolve }) const started = new Promise(resolve => { analysisStarted = resolve }) - const pending = suggest(id).then(response => response) + await queue(id) + const pending = service.processNextSuggestion() await started await pool.query("UPDATE folders SET archived=true WHERE id=$1", [targetFolder]) finish() - assert.equal((await pending).json().suggestion, null) + await pending + assert.equal((await suggest(id)).json().suggestion, null) await pool.query("UPDATE folders SET archived=false WHERE id=$1", [targetFolder]) analysisGate = undefined analysisStarted = undefined }) + await t.test("prepared results persist, failed jobs wait for explicit retry and expired claims resume", async () => { + const id = (await service.list(1, 50, 0, "scan.pdf")).documents[0].id + const otherService = createScannerInboxService(db, undefined, async () => aiResult) + const before = analyses.length + assert.equal((await otherService.getSuggestion(1, id)).status, "ready") + assert.equal(analyses.length, before) + await queue(id) + analysisFailure = true + await service.processNextSuggestion() + analysisFailure = false + assert.equal((await suggest(id)).json().status, "failed") + assert.equal((await suggest(id)).json().suggestion, null) + const failedCount = analyses.length + await suggest(id) + assert.equal(analyses.length, failedCount) + await queue(id) + await pool.query("UPDATE scanner_inbox_documents SET suggestion_status='processing', suggestion_claim=$2, suggestion_updated_at=now()-interval '6 minutes' WHERE file_id=$1", [id, randomUUID()]) + aiResult = { suggestion: { folderId: targetFolder, typeId: targetType, confidence: "high", reason: "Vorbereitet nach Neustart." } } + await otherService.processNextSuggestion() + assert.equal((await suggest(id)).json().suggestion.reason, "Vorbereitet nach Neustart.") + }) + await t.test("an expired worker cannot overwrite a newer completed suggestion", async () => { + const id = (await service.list(1, 50, 0, "scan.pdf")).documents[0].id + await queue(id) + aiResult = { suggestion: { folderId: targetFolder, typeId: targetType, confidence: "high", reason: "Alter Vorschlag." } } + let finish!: () => void + analysisGate = new Promise(resolve => { finish = resolve }) + const started = new Promise(resolve => { analysisStarted = resolve }) + const pending = service.processNextSuggestion() + await started + await pool.query("UPDATE scanner_inbox_documents SET suggestion_updated_at=now()-interval '6 minutes' WHERE file_id=$1", [id]) + const otherService = createScannerInboxService(db, undefined, async () => ({ suggestion: { + folderId: null, typeId: alternativeType, confidence: "medium", reason: "Neuer Vorschlag.", + } })) + await otherService.processNextSuggestion() + finish() + await pending + assert.equal((await suggest(id)).json().suggestion.reason, "Neuer Vorschlag.") + analysisGate = undefined + analysisStarted = undefined + }) + await t.test("entity choices and filing reject foreign, archived and wrong-type IDs atomically", async () => { + await pool.query("INSERT INTO projects VALUES (11, 1, 'Umbau', false), (12, 2, 'Fremdes Projekt', false), (13, 1, 'Archiv', true)") + await pool.query("INSERT INTO customers VALUES (21, 1, 'Musterkunde', false), (22, 2, 'Fremder Kunde', false)") + const checkId = randomUUID() + const profileId = randomUUID() + await pool.query("INSERT INTO checks VALUES ($1, 1, 'Prüfung', false)", [checkId]) + await pool.query("INSERT INTO auth_profiles (id, tenant_id, full_name) VALUES ($1, 1, 'Test Mitarbeiter')", [profileId]) + const choices = await app.inject({ method: "GET", url: "/api/document-inbox/assignment-options?kind=project&search=Umbau" }) + assert.deepEqual(choices.json(), [{ id: "11", name: "Umbau" }]) + assert.equal((await app.inject({ method: "GET", url: "/api/document-inbox/assignment-options?kind=unknown" })).statusCode, 400) + const id = (await service.list(1, 50, 0, "scan.pdf")).documents[0].id + for (const assignments of [{ project: "12" }, { project: "13" }, { project: randomUUID() }, { project: "11", customer: "22" }, { check: 11 }, { authProfile: randomUUID() }]) { + const res = await app.inject({ method: "POST", url: `/api/document-inbox/${id}/file`, payload: { folder: targetFolder, type: targetType, assignments } }) + assert.equal(res.statusCode, 400, res.body) + } + assert.deepEqual((await pool.query("SELECT folder, type, project, customer FROM files WHERE id=$1", [id])).rows[0], { folder: null, type: null, project: null, customer: null }) + await pool.query("UPDATE files SET project=11 WHERE id=$1", [id]) + assert.deepEqual((await app.inject({ method: "GET", url: `/api/document-inbox/${id}/assignments` })).json(), [{ kind: "project", id: "11", name: "Umbau", available: true }]) + assert.equal((await app.inject({ method: "GET", url: `/api/document-inbox/${id}/assignments`, headers: { "x-test-tenant": "2" } })).statusCode, 404) + await service.fileDocument(1, userId, id, targetFolder, targetType, { project: null, customer: "21", check: checkId, authProfile: profileId }) + assert.deepEqual((await pool.query('SELECT project, customer, "check", auth_profile FROM files WHERE id=$1', [id])).rows[0], { project: null, customer: '21', check: checkId, auth_profile: profileId }) + // Restore the fixture so existing retry/filing tests can exercise this same original document. + await pool.query('UPDATE files SET folder=null, type=null, customer=null, "check"=null, auth_profile=null WHERE id=$1', [id]) + await pool.query("UPDATE scanner_inbox_documents SET filed_at=null WHERE file_id=$1", [id]) + }) + await t.test("menu count includes only this tenant's open, unarchived documents", async () => { + const res = await app.inject({ method: "GET", url: "/api/document-inbox/count" }) + assert.equal(res.json().total, (await service.list(1, 50, 0, "")).total) + const other = await app.inject({ method: "GET", url: "/api/document-inbox/count", headers: { "x-test-tenant": "2" } }) + assert.equal(other.json().total, 1) + const id = (await service.list(1, 50, 0, "failed.pdf")).documents[0].id + await pool.query("UPDATE files SET archived=true WHERE id=$1", [id]) + assert.equal((await service.openCount(1)).total, res.json().total - 1) + await pool.query("UPDATE files SET archived=false WHERE id=$1", [id]) + }) await t.test("filing options and destinations exclude other tenants and archived entries", async () => { const options = await app.inject({ method: "GET", url: "/api/document-inbox/filing-options" }) assert.equal(options.statusCode, 200) @@ -388,7 +481,7 @@ test("scanner inbox integration: migration, persistence, isolation, retries and await pool.query("UPDATE tenants SET locked='maintenance_tenant' WHERE id=1") assert.equal((await fileInto(id)).statusCode, 423) await pool.query("UPDATE tenants SET locked=null WHERE id=1") - await pool.query("INSERT INTO auth_profiles VALUES (1, $1, 123)", [userId]) + await pool.query("INSERT INTO auth_profiles (tenant_id, user_id, customer_for_portal) VALUES (1, $1, 123)", [userId]) assert.equal((await fileInto(id)).statusCode, 403) assert.equal((await app.inject({ method: "GET", url: "/api/document-inbox/filing-options" })).statusCode, 403) await pool.query("DELETE FROM auth_profiles") @@ -444,7 +537,7 @@ test("scanner inbox integration: migration, persistence, isolation, retries and assert.equal((await app.inject({ method, url, headers: { "x-test-admin": "false" } })).statusCode, 403) } assert.equal((await app.inject({ method: "GET", url: "/api/document-inbox", headers: { "x-test-admin": "false" } })).statusCode, 200) - await pool.query("INSERT INTO auth_profiles VALUES (1, $1, 123)", [userId]) + await pool.query("INSERT INTO auth_profiles (tenant_id, user_id, customer_for_portal) VALUES (1, $1, 123)", [userId]) assert.equal((await app.inject({ method: "GET", url: "/api/document-inbox" })).statusCode, 403) await pool.query("DELETE FROM auth_profiles") }) diff --git a/docs/scanner-dokumentenablage.md b/docs/scanner-dokumentenablage.md index fecb1a2c..fc26839f 100644 --- a/docs/scanner-dokumentenablage.md +++ b/docs/scanner-dokumentenablage.md @@ -1,15 +1,16 @@ # Epson-Scanner und Dokumentenablage -Unter **Organisation → Dokumentenablage** erscheinen noch nicht abgelegte Scanner-Dateien des aktiven Mandanten, neueste zuerst. Die Seite aktualisiert sich alle zehn Sekunden; Suche, Vorschau und Herunterladen sind verfügbar. Jede übertragene Datei wird unverändert als ein Dokument gespeichert. Ein mehrseitiges PDF bleibt ein Dokument. Der Empfang führt keine Texterkennung, Seitentrennung oder Rechnungsverarbeitung aus. +Unter **Organisation → Dokumentenablage** erscheinen noch nicht abgelegte Scanner-Dateien des aktiven Mandanten, neueste zuerst. Die Seite aktualisiert sich alle zehn Sekunden; Suche, Vorschau und Herunterladen sind verfügbar. Ein Badge am Menüeintrag zählt die offenen, nicht archivierten Dokumente unabhängig von der aktuellen Suche. Es aktualisiert sich alle zehn Sekunden und unmittelbar nach dem Ablegen. Jede übertragene Datei wird unverändert als ein Dokument gespeichert. Ein mehrseitiges PDF bleibt ein Dokument. Nach dem erfolgreichen Empfang wird die KI-Zuordnung im Hintergrund vorbereitet; der Scanner muss darauf nicht warten. Seitentrennung und Rechnungsverarbeitung werden nicht ausgelöst. ## In Dateien ablegen 1. Auf den Dateinamen, **Vorschau** oder **Ablegen** klicken. Das Modal zeigt das Original und rechts die Zuordnung. -2. Beim Öffnen wird ein KI-Vorschlag für Ordner und Dokumenttyp aus dem Dokumentinhalt angefordert. Ein gültiger Vorschlag füllt die Auswahlfelder vor und zeigt eine kurze Begründung. Bereits manuell geänderte Werte werden nicht überschrieben. **KI-Vorschlag einsetzen** übernimmt ihn bei Bedarf wieder in die Felder; **Erneut prüfen** fordert eine neue Analyse an. +2. Das Modal lädt den bereits vorbereiteten KI-Vorschlag für Ordner und Dokumenttyp. Läuft die Vorbereitung noch, zeigt es den Fortschritt und lädt das Ergebnis automatisch nach. Ein gültiger Vorschlag füllt die Auswahlfelder vor und zeigt eine kurze Begründung. Bereits manuell geänderte Werte werden nicht überschrieben. **KI-Vorschlag einsetzen** übernimmt ihn bei Bedarf wieder in die Felder; **Erneut prüfen** stellt eine abgeschlossene oder fehlgeschlagene Analyse erneut in die Warteschlange. 3. Den vorgeschlagenen vorhandenen FEDEO-Dateiordner oder **Dateien (Hauptebene)** und **Dokumenttyp** prüfen und bei Bedarf ändern. Unterordner erscheinen mit ihrem vollständigen Pfad. Neue Typen lassen sich unter **Stammdaten → Dateitypen** anlegen. Ein vorgeschriebener Ordnertyp ist nicht änderbar. -4. Erst **Übernehmen und ablegen** speichert Ordner und Typ am bestehenden Original. Danach verschwindet das Dokument aus dem Eingang und ist unter **Dateien** im gewählten Ordner verfügbar. Es wird keine Kopie erzeugt und keine Rechnungsverarbeitung ausgelöst. +4. Optional unter **Zuordnungen** einen Bereich und einen Eintrag auswählen und mit **Zuordnung hinzufügen** vormerken. Wie auf der Dateiseite stehen Projekt, Kunde, Lieferant, Fahrzeug, Objekt, Vertrag, Produkt, Ausgangsbeleg, Eingangsrechnung, Inventarartikel, Überprüfung und Mitarbeiter zur Verfügung. Mehrere Bereiche können gleichzeitig zugeordnet werden, jeweils ein Eintrag pro Bereich. Die Einträge lassen sich nach Namen suchen; bestehende Zuordnungen werden angezeigt und können entfernt werden. +5. Erst **Übernehmen und ablegen** speichert Ordner, Typ und vorgemerkte Zuordnungen gemeinsam am bestehenden Original. Danach verschwindet das Dokument aus dem Eingang und ist unter **Dateien** im gewählten Ordner und mit den gewählten Verknüpfungen verfügbar. Es wird keine Kopie erzeugt und keine Rechnungsverarbeitung ausgelöst. -Nur aktive Ordner und Typen desselben Mandanten sind zulässig. Bei einem Fehler bleibt das Dokument im Eingang. Ein erneuter Scanner-Upload mit demselben Namen und Inhalt bestätigt weiterhin den ursprünglichen Empfang, ohne einen neuen Eingangseintrag anzulegen. +Nur aktive Ordner, Typen und Zuordnungsziele desselben Mandanten sind zulässig. Mitarbeiter müssen aktiv und interne Benutzer sein. Bei einem Fehler bleibt das Dokument im Eingang; auch die übrigen Änderungen werden nicht teilweise gespeichert. Ein erneuter Scanner-Upload mit demselben Namen und Inhalt bestätigt weiterhin den ursprünglichen Empfang, ohne einen neuen Eingangseintrag oder Analyseauftrag anzulegen. ### KI-Vorschläge @@ -17,7 +18,9 @@ Die Analyse nutzt die bestehende zentrale FEDEO-KI-Anbindung oder den konfigurie Für die Analyse werden höchstens die ersten fünf PDF-Seiten bzw. die erste Bildseite lokal gelesen (Poppler/Tesseract; JPEG, PNG und TIFF werden für die OCR aufbereitet). Diese Werkzeuge sind im Backend-Image enthalten. Es werden maximal 24.000 Textzeichen und eine begrenzte Auswahl passender Ordner und Typen an die KI geschickt. Die Analyse ist auf Dateien bis 25 MiB begrenzt; die Texterkennung und die einzelnen KI-Anfragen haben Zeitlimits von jeweils 45 Sekunden. Fehlen lesbarer Text, passende Stammdaten oder eine KI-Konfiguration, bleibt die manuelle Zuordnung verfügbar. -Vorschläge und erkannter Text verändern weder das Original noch dessen Klassifizierung. Die Vorschau hält Ergebnisse während des Seitenbesuchs im Speicher, um erneute Analysen beim Wiederöffnen zu vermeiden; ein Mandantenwechsel verwirft sie. Gleichzeitige Analysen desselben Dokuments werden im Backend zusammengefasst, maximal vier Analysen laufen gleichzeitig pro Backend-Prozess. Die fachliche Qualität der KI-Vorschläge sollte bei der Inbetriebnahme mit eigenen Beispieldokumenten geprüft werden. +Vorschläge und erkannter Text verändern weder das Original noch dessen Klassifizierung. Der Auftrag entsteht zusammen mit dem Eingangseintrag in der Datenbank. Das Backend verarbeitet offene Aufträge automatisch, auch ohne geöffnete Dokumentenablage. Vorschlag, Status und eine gegebenenfalls nötige Fehlermeldung werden dauerhaft am Eingangseintrag gespeichert; beim Wiederöffnen wird keine neue Analyse ausgelöst. Erkannter Volltext wird hierfür nicht gespeichert. Vorhandene offene Dokumente werden nach der Migration ebenfalls vorbereitet. + +Pro Backend-Prozess läuft eine Analyse gleichzeitig. Datenbanksperren und Auftragskennungen koordinieren mehrere Instanzen. Neue Aufträge werden spätestens beim nächsten Durchlauf nach zwei Sekunden berücksichtigt, wenn kein älterer Auftrag mehr läuft. Nach einem Prozessabbruch werden seit fünf Minuten nicht abgeschlossene Aufträge erneut übernommen; verspätete Ergebnisse eines alten Auftrags können das neuere Ergebnis nicht überschreiben. Abgelegte, archivierte und Dokumente von Mandanten im Wartungsmodus werden nicht neu gestartet. Fehlgeschlagene Analysen lassen sich im Modal erneut anfordern; die manuelle Ablage bleibt möglich. Die fachliche Qualität der KI-Vorschläge sollte bei der Inbetriebnahme mit eigenen Beispieldokumenten geprüft werden. ## Einrichtung @@ -36,7 +39,7 @@ Nach der Dateinamenprüfung sendet der ES-580W zunächst einen leeren `PUT` mit ## Schnittstelle und Betrieb -- Datenbankmigrationen `0073_scanner_document_inbox` und `0074_scanner_inbox_filing` werden über die reguläre Drizzle-Migration eingespielt. Keine neuen Umgebungsvariablen oder zusätzlichen Dienste sind erforderlich; der vorhandene S3-kompatible Dateispeicher wird genutzt. +- Datenbankmigrationen `0073_scanner_document_inbox`, `0074_scanner_inbox_filing` und `0077_scanner_inbox_preparation` werden über die reguläre Drizzle-Migration eingespielt. Keine neuen Umgebungsvariablen oder zusätzlichen Dienste sind erforderlich; der vorhandene S3-kompatible Dateispeicher wird genutzt. Die Hintergrundverarbeitung startet mit dem Backend. - Der Scanner-Endpunkt liegt außerhalb der Browser-JWT-Anmeldung unter `/scanner-inbox/` und verwendet HTTP Basic mit eigenen zufälligen Zugangsdaten. Ausschließlich über HTTPS veröffentlichen. Passwörter werden nur als SHA-256-Hash gespeichert. - Unterstützt werden `OPTIONS`, `PROPFIND` (Depth 0/1), `HEAD` und `PUT /scanner-inbox/`. Ein authentifiziertes `GET` auf den Empfangsordner (mit oder ohne abschließenden Schrägstrich) liefert für die Epson-Vorprüfung `200` mit leerem Inhalt. Dokumente lassen sich damit nicht herunterladen. Der Empfangsordner existiert bereits; Unterordner, Lesen von Dateien, Löschen, Umbenennen und Überschreiben über den Scanner-Zugang sind nicht vorgesehen. Dies ist ein begrenzter WebDAV-Upload-Eingang, kein allgemeines Netzlaufwerk. Ein PROPFIND des Ordners gibt keine Dokumentenliste preis. - `PUT` enthält genau eine vollständige Datei als Rohdaten, ohne Multipart-Formular. PDF, JPEG, PNG und TIFF werden anhand von Dateiendung und Signatur geprüft, maximal 100 MiB. Keine Prüfung der gesamten Dokumentstruktur auf Beschädigungen. @@ -44,8 +47,9 @@ Nach der Dateinamenprüfung sendet der ES-580W zunächst einen leeren `PUT` mit - Fehlende/ungültige/deaktivierte Zugangsdaten: `401`; ungültiger Pfad oder leerer Upload ohne explizite Schreibprobe (`Content-Length: 0`): `400`; zu groß: `413`; falsches Format: `415`; Mandantenwartung: `423`. Bei Speicherfehlern gibt es keine Erfolgsbestätigung und keinen unvollständigen Ablageeintrag. Der Scanner kann erneut senden. - Der Reverse Proxy muss die genannten HTTP-Methoden, den Authorization-Header und Uploads bis 100 MiB zulassen. Bei einem abgeschnittenen Pfadpräfix sollte er `X-Forwarded-Prefix` setzen (Traefik StripPrefix erledigt dies). HTTPS endet üblicherweise am bestehenden Proxy. - Die Browser-API unter `/api/document-inbox` erfordert die normale FEDEO-Anmeldung und einen aktiven Mandanten. Portalbenutzer sind ausgeschlossen. Scanner-Zugänge verwalten nur Administratoren. Die Originale sind außerdem über die bestehende Dateiverwaltung zugänglich. -- `GET /api/document-inbox/filing-options` liefert verfügbare Ordner und Typen. `POST /api/document-inbox/:id/file` mit JSON `{ "folder": "", "type": "" }` klassifiziert das Original und markiert den Eingang atomar als abgelegt. Für die Hauptebene ist `folder` als JSON-`null` zu senden. Ein bereits abgelegtes Dokument ergibt `409`; zwischenzeitlich archivierte oder fremde Ziele werden abgewiesen. Dateiänderungen enthalten Zeitpunkt und Benutzer. -- `POST /api/document-inbox/:id/suggestion` liefert `{ "suggestion": { "folderId": "", "typeId": "", "confidence": "high|medium", "reason": "…" } }` oder einen leeren Vorschlag mit Erklärung. Nur offene, nicht archivierte Dokumente des aktiven Mandanten sind analysierbar. Die Anfrage legt nichts ab; dafür bleibt der separate `/file`-Aufruf erforderlich. +- `GET /api/document-inbox/count` liefert `{ "total": 3 }` für den aktiven Mandanten. `GET /api/document-inbox/filing-options` liefert verfügbare Ordner, Typen und `assignmentKinds`. `GET /api/document-inbox/assignment-options?kind=project&search=Beispiel` liefert bis zu 100 passende Ziele mit `id` und `name`; `GET /api/document-inbox/:id/assignments` die bereits bestehenden Verknüpfungen des Dokuments. +- `POST /api/document-inbox/:id/file` mit JSON `{ "folder": "", "type": "", "assignments": { "project": 123, "customer": 456 } }` klassifiziert das Original, speichert die optionalen Verknüpfungen und markiert den Eingang atomar als abgelegt. Weggelassene Zuordnungen bleiben erhalten; JSON-`null` entfernt eine vorhandene Zuordnung. Die Schlüssel entsprechen den Dateifeldern; `check` und `authProfile` verwenden UUIDs, die übrigen Bereiche numerische IDs. Für die Hauptebene ist `folder` als JSON-`null` zu senden. Ein bereits abgelegtes Dokument ergibt `409`; zwischenzeitlich archivierte oder fremde Ziele werden abgewiesen. Dateiänderungen enthalten Zeitpunkt und Benutzer. +- `GET /api/document-inbox/:id/suggestion` liest den gespeicherten Status `pending`, `processing`, `ready` oder `failed` und liefert bei Erfolg beispielsweise `{ "status": "ready", "suggestion": { "folderId": "", "typeId": "", "confidence": "high|medium", "reason": "…" } }`. Ohne passende Zuordnung ist `suggestion` gleich `null` und `message` erklärt den Grund. `POST /api/document-inbox/:id/suggestion` fordert eine erneute Vorbereitung an und antwortet mit `202` und demselben Statusformat, ohne auf die Analyse zu warten. Ein bereits wartender oder laufender Auftrag wird nicht dupliziert. Nur offene, nicht archivierte Dokumente des aktiven Mandanten sind zugänglich. Diese Anfragen legen nichts ab; dafür bleibt der separate `/file`-Aufruf erforderlich. ## Lokaler Funktionstest diff --git a/frontend/components/MainNav.vue b/frontend/components/MainNav.vue index 2ba98e66..9f37c0e9 100644 --- a/frontend/components/MainNav.vue +++ b/frontend/components/MainNav.vue @@ -8,6 +8,7 @@ const props = defineProps({ const route = useRoute() const auth = useAuthStore() +const { count: inboxCount } = useDocumentInboxCount() const { has } = usePermission() const tenantExtraModules = computed(() => { const modules = auth.activeTenantData?.extraModules @@ -55,7 +56,8 @@ const links = computed(() => { featureEnabled("files") ? { label: "Dokumentenablage", to: "/organisation/dokumentenablage", - icon: "i-heroicons-inbox-arrow-down" + icon: "i-heroicons-inbox-arrow-down", + badge: inboxCount.value > 0 ? String(inboxCount.value) : undefined, } : null, featureEnabled("files") ? { label: "Dateien", diff --git a/frontend/composables/useDocumentInboxCount.ts b/frontend/composables/useDocumentInboxCount.ts new file mode 100644 index 00000000..9b7842c8 --- /dev/null +++ b/frontend/composables/useDocumentInboxCount.ts @@ -0,0 +1,31 @@ +import { createSharedComposable } from "@vueuse/core" + +export const useDocumentInboxCount = createSharedComposable(() => { + const auth = useAuthStore() + const { $api } = useNuxtApp() + const count = ref(0) + const scope = computed(() => auth.user?.id && auth.activeTenant && !auth.profile?.customer_for_portal && auth.activeTenantData?.features?.files !== false + ? `${auth.user.id}:${auth.activeTenant}` : "") + let version = 0 + let disposed = false + let controller: AbortController | undefined + let timer: ReturnType | undefined + const refresh = async () => { + const request = ++version + clearTimeout(timer) + controller?.abort() + if (!scope.value || disposed) { count.value = 0; return } + controller = new AbortController() + try { + const result = await $api<{ total: number }>("/api/document-inbox/count", { signal: controller.signal }) + if (!disposed && request === version) count.value = Math.max(0, Number(result.total) || 0) + } catch { + if (request === version) count.value = 0 + } finally { + if (!disposed && request === version && scope.value) timer = setTimeout(refresh, 10000) + } + } + watch(scope, () => { count.value = 0; void refresh() }, { immediate: true, flush: "sync" }) + onScopeDispose(() => { disposed = true; version++; controller?.abort(); clearTimeout(timer) }) + return { count, refresh } +}) diff --git a/frontend/pages/organisation/dokumentenablage.vue b/frontend/pages/organisation/dokumentenablage.vue index b72cbf04..ce68b1a5 100644 --- a/frontend/pages/organisation/dokumentenablage.vue +++ b/frontend/pages/organisation/dokumentenablage.vue @@ -1,18 +1,21 @@