Lies Paperless-Dateien aus dem Ablageordner, wenn die Vorschau keine anzeigbare Datei liefert.
Deploy Development / deploy (push) Failing after 39s

Eine unbekannte Dokumentnummer wird als solche gemeldet.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
LarsandCursor committed 2026-10-17 07:12:35 +02:00
1 parent 4420790707
commit b328385561
6 files changed
+114 -5

No files matched your search

+1
View File
@@ -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
+86 -4
View File
@@ -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 ""
+22
View File
@@ -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
+2
View File
@@ -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:
+2
View File
@@ -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:
+1 -1
View File
@@ -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.