diff --git a/backend/app/core/settings.py b/backend/app/core/settings.py index f08008a..ada9d75 100644 --- a/backend/app/core/settings.py +++ b/backend/app/core/settings.py @@ -22,6 +22,7 @@ class Settings(BaseSettings): app_url: str = "http://localhost:5173" allowed_origins: str = "http://localhost:5173,http://localhost:3094" media_root: str = "data/media" + paperless_media_root: str = "" seed_demo: bool = False session_ttl_hours: int = 336 upload_max_bytes: int = 20 * 1024 * 1024 diff --git a/backend/app/sources.py b/backend/app/sources.py index a23737d..4e8ffdf 100644 --- a/backend/app/sources.py +++ b/backend/app/sources.py @@ -7,6 +7,7 @@ import json import ssl from email.header import decode_header from email.parser import BytesParser +from pathlib import Path from urllib.error import HTTPError, URLError from urllib.parse import urlencode, urlparse from urllib.request import Request, urlopen @@ -14,7 +15,9 @@ from uuid import UUID from psycopg.types.json import Json -from app.core.errors import not_found, unprocessable +from app.core.errors import Problem, not_found, unprocessable +from app.core.settings import get_settings +from app.media.storage import sniff def save_connector(conn, owner_id: UUID, kind: str, name: str, settings: dict, secret: str) -> dict: @@ -161,13 +164,22 @@ def paperless_content(conn, owner_id: UUID, document_id: str) -> tuple[bytes, st raise unprocessable("Paperless ist für dieses Konto nicht verbunden.") base = row["settings"]["base_url"].rstrip("/") token = row["secret"] + misses = 0 for suffix in ("preview", "download"): fetched = _paperless_file(base, token, f"/api/documents/{document_id}/{suffix}/") if fetched is None: + misses += 1 continue - data, media, name = fetched - if media.startswith("application/pdf") or media.startswith("image/"): - return data, media, name or f"paperless-{document_id}.pdf" + viewable = _viewable(fetched[0], fetched[1], fetched[2], document_id) + if viewable is not None: + return viewable + meta = _paperless_metadata(base, token, document_id) + if meta is None and misses == 2: + raise unprocessable("Dieses Dokument gibt es in Paperless nicht.") + if meta is not None: + local = _paperless_from_disk(document_id, meta) + if local is not None: + return local raise unprocessable("Paperless stellt diese Datei nicht zum Ansehen bereit.") @@ -197,6 +209,76 @@ def _paperless_file(base: str, token: str, path: str) -> tuple[bytes, str, str] raise unprocessable("Paperless ist nicht erreichbar.") from exc +def _viewable(data: bytes, media: str, name: str, document_id: str) -> tuple[bytes, str, str] | None: + media = media.split(";")[0].strip().lower() + if not (media.startswith("application/pdf") or media.startswith("image/")): + try: + media = sniff(data) + except Problem: + return None + if media.startswith("application/pdf") or media.startswith("image/"): + return data, media, name or f"paperless-{document_id}.pdf" + return None + + +def _paperless_metadata(base: str, token: str, document_id: str) -> dict | None: + request = Request( + f"{base}/api/documents/{document_id}/metadata/", + headers={"Authorization": f"Token {token}", "Accept": "application/json"}, + ) + try: + with urlopen(request, timeout=20) as response: + payload = json.loads(response.read().decode("utf-8")) + except HTTPError as exc: + if exc.code == 404: + return None + if exc.code in {401, 403}: + raise unprocessable("Paperless hat den Schlüssel abgelehnt.") from exc + raise unprocessable("Paperless hat die Datei nicht bereitgestellt.") from exc + except (URLError, TimeoutError, json.JSONDecodeError) as exc: + raise unprocessable("Paperless ist nicht erreichbar.") from exc + return payload if isinstance(payload, dict) else None + + +def _paperless_from_disk(document_id: str, meta: dict) -> tuple[bytes, str, str] | None: + root = get_settings().paperless_media_root.strip() + if not root: + return None + candidates: list[tuple[str, str]] = [] + archive_name = meta.get("archive_media_filename") + if meta.get("has_archive_version") and isinstance(archive_name, str) and archive_name.strip(): + candidates.append(("archive", archive_name)) + original_name = meta.get("media_filename") + if isinstance(original_name, str) and original_name.strip(): + candidates.append(("originals", original_name)) + for kind, relative in candidates: + data = read_paperless_file(root, kind, relative) + if data is None: + continue + viewable = _viewable(data, "application/octet-stream", Path(relative).name, document_id) + if viewable is not None: + return viewable + return None + + +def read_paperless_file(media_root: str, kind: str, relative: str) -> bytes | None: + if kind not in {"archive", "originals"}: + return None + raw = relative.replace("\\", "/").strip() + if not raw or raw.startswith("/") or ".." in Path(raw).parts: + return None + base = (Path(media_root) / "documents" / kind).resolve() + target = (base / raw).resolve() + if target != base and base not in target.parents: + return None + if not target.is_file(): + return None + data = target.read_bytes() + if len(data) > 40 * 1024 * 1024: + raise unprocessable("Die Datei ist zum Ansehen in Tsumugu zu groß.") + return data + + def _filename(disposition: str | None) -> str: if not disposition: return "" diff --git a/backend/tests/test_paperless_files.py b/backend/tests/test_paperless_files.py new file mode 100644 index 0000000..e7c7a12 --- /dev/null +++ b/backend/tests/test_paperless_files.py @@ -0,0 +1,22 @@ +"""The Paperless disk fallback stays inside the archive directory.""" + +from __future__ import annotations + +from app.sources import read_paperless_file + + +def test_reads_the_archive_pdf(tmp_path): + target = tmp_path / "documents" / "archive" / "2026" / "brief.pdf" + target.parent.mkdir(parents=True) + target.write_bytes(b"%PDF-1.1 sample") + assert read_paperless_file(str(tmp_path), "archive", "2026/brief.pdf") == b"%PDF-1.1 sample" + + +def test_rejects_paths_outside_the_archive(tmp_path): + secret = tmp_path / "documents" / "secret.pdf" + secret.parent.mkdir(parents=True) + secret.write_bytes(b"%PDF-1.1 secret") + (tmp_path / "documents" / "archive").mkdir() + assert read_paperless_file(str(tmp_path), "archive", "../secret.pdf") is None + assert read_paperless_file(str(tmp_path), "archive", "/etc/passwd") is None + assert read_paperless_file(str(tmp_path), "other", "2026/brief.pdf") is None diff --git a/docker-compose.dev-env.yml b/docker-compose.dev-env.yml index 3d3b577..26d5ccc 100644 --- a/docker-compose.dev-env.yml +++ b/docker-compose.dev-env.yml @@ -33,9 +33,11 @@ services: APP_URL: "${APP_URL:-https://dev.tsumugu.jinkendo.de}" ALLOWED_ORIGINS: "${ALLOWED_ORIGINS:-https://dev.tsumugu.jinkendo.de,http://192.168.2.49:3094,http://localhost:3094}" MEDIA_ROOT: /data/media + PAPERLESS_MEDIA_ROOT: /paperless-media SEED_DEMO: "${SEED_DEMO:-false}" volumes: - dev-tsumugu-media:/data/media + - ${PAPERLESS_MEDIA_HOST:-/media/lars/paperless/media}:/paperless-media:ro ports: - "127.0.0.1:${TSUMUGU_BACKEND_PORT:-8094}:8000" depends_on: diff --git a/docker-compose.yml b/docker-compose.yml index 74492dd..1be53eb 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -35,9 +35,11 @@ services: APP_URL: "${APP_URL:-https://tsumugu.jinkendo.de}" ALLOWED_ORIGINS: "${ALLOWED_ORIGINS:-https://tsumugu.jinkendo.de}" MEDIA_ROOT: /data/media + PAPERLESS_MEDIA_ROOT: /paperless-media SEED_DEMO: "${SEED_DEMO:-false}" volumes: - tsumugu-media:/data/media + - ${PAPERLESS_MEDIA_HOST:-/media/lars/paperless/media}:/paperless-media:ro ports: - "127.0.0.1:${TSUMUGU_BACKEND_PORT:-8007}:8000" depends_on: diff --git a/docs/DEPLOYMENT.md b/docs/DEPLOYMENT.md index e46b92a..0008421 100644 --- a/docs/DEPLOYMENT.md +++ b/docs/DEPLOYMENT.md @@ -35,7 +35,7 @@ Gearbeitet wird auf `develop`. Production entsteht nur durch einen Merge-Commit Fehlt beim ersten Lauf die Host-`.env`, legt der Workflow sie an. Development bekommt die dokumentierten Dev-Defaults. Production bekommt ein zufälliges `DB_PASSWORD`, das nur in `/home/lars/docker/tsumugu/.env` steht und nicht ins Log geschrieben wird. Spätere Läufe überschreiben eine vorhandene `.env` nicht. `git reset --hard` lässt die Datei liegen, weil sie nicht im Repo ist. -Der Backend-Container migriert beim Start, entfernt Konten mit Herkunft `fixture` und bedient danach den API-Prozess. Der Host-Port des Backends bleibt an `127.0.0.1` gebunden; von außen ist nur das Frontend erreichbar, das `/api/` im Compose-Netz weiterreicht. Eigene Dateien liegen im Volume `dev-tsumugu-media` bzw. `tsumugu-media`. +Der Backend-Container migriert beim Start, entfernt Konten mit Herkunft `fixture` und bedient danach den API-Prozess. Der Host-Port des Backends bleibt an `127.0.0.1` gebunden; von außen ist nur das Frontend erreichbar, das `/api/` im Compose-Netz weiterreicht. Eigene Dateien liegen im Volume `dev-tsumugu-media` bzw. `tsumugu-media`. Der Paperless-Ablageordner `/media/lars/paperless/media` wird nur lesend nach `/paperless-media` gereicht. Tsumugu öffnet daraus eine Datei erst, wenn die Paperless-API für genau dieses Dokument einen relativen Pfad nennt und die Vorschau über HTTP keine anzeigbare Datei liefert. Testdaten legt nur die Pflicht-Suite an, und nur in einer Datenbank `tsumugu_pytest`, die der Lauf danach verwirft. Dev- und Prod-Datenbanken werden von der Suite nicht beschrieben. `SEED_DEMO` bleibt in beiden Compose-Dateien aus. Steht es in Produktion trotzdem auf wahr, startet das Backend nicht. Ein Push nach `develop` führt die Suite vor dem Deploy aus. Das erste Konto auf einer leeren Umgebung wird über die Anmeldeseite zum Betreiber und legt weitere Nutzer an.