Files
tsumugu/backend/app/retrieval.py
T
LarsandCursor 7626c56f3d
Deploy Development / deploy (push) Successful in 27s
Test Suite / pytest-backend (push) Failing after 1m10s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 10s
Lade eine uebernommene E-Mail bei Bedarf vollstaendig, damit Anzeige und Export nicht an der Vorschau haengen.
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-17 18:59:18 +02:00

187 lines
7.0 KiB
Python

"""Complete content retrieval for export.
Preview and original stay apart. A reference uses its own access, never an
arbitrary latest connector. Missing capability is reported, not replaced.
"""
from __future__ import annotations
from dataclasses import dataclass, field
from uuid import UUID
from app.core.errors import Problem
from app.mailpack import ParsedMail, identities_match, parse_mail
from app.media.storage import asset_path, read_bytes
from app.sources import COMPLETE_MAIL_LIMIT, pull_paperless_original, pull_rfc822
EXPORT_BYTE_LIMIT = COMPLETE_MAIL_LIMIT
_TOO_LARGE = (
"Die vollständige Nachricht überschreitet die Exportgrenze. "
"Eine gekürzte Vorschau wird nicht als Original übernommen."
)
@dataclass(frozen=True)
class RetrievalFailure:
code: str
message: str
choices: tuple[dict, ...] = ()
@dataclass(frozen=True)
class FilePayload:
filename: str
media_type: str
data: bytes
sha256: str
@dataclass
class MailPayload:
raw: bytes
parsed: ParsedMail
notices: list[str] = field(default_factory=list)
def load_external(conn, actor_id: UUID, element_id: UUID, assigned: UUID | None) -> FilePayload | MailPayload | RetrievalFailure:
ref = conn.execute(
"SELECT source, external_id, detail FROM external_references WHERE element_id = %s",
(element_id,),
).fetchone()
if ref is None:
return RetrievalFailure("missing", "Die Quellenreferenz fehlt.")
source = ref["source"]
detail = ref["detail"] or {}
if source == "paperless":
return _load_paperless(conn, actor_id, ref["external_id"], detail, assigned)
if source == "imap":
return _load_imap(conn, actor_id, ref["external_id"], detail, assigned)
if source == "url":
return RetrievalFailure("capability", "Für eine Webadresse ist kein Originalabruf vorgesehen.")
return RetrievalFailure("capability", "Für diese Quelle ist kein Originalabruf vorgesehen.")
def load_file(conn, element_id: UUID, media_root: str) -> FilePayload | RetrievalFailure:
asset = conn.execute(
"""
SELECT id, original_filename, content_type, sha256, status
FROM media_assets WHERE element_id = %s
""",
(element_id,),
).fetchone()
if asset is None or asset["status"] != "active":
return RetrievalFailure("missing", "Die Originaldatei ist nicht mehr vorhanden.")
try:
data = read_bytes(asset_path(media_root, asset["id"]))
except Problem:
return RetrievalFailure("missing", "Die Originaldatei ist nicht mehr vorhanden.")
if len(data) > EXPORT_BYTE_LIMIT:
return RetrievalFailure("too_large", "Die Originaldatei ist für den Export zu groß.")
return FilePayload(asset["original_filename"], asset["content_type"], data, asset["sha256"])
def _load_paperless(conn, actor_id: UUID, external_id: str, detail: dict, assigned: UUID | None):
stored = _uuid(detail.get("connector_id"))
resolved = _resolve_connector(conn, actor_id, "paperless", stored, assigned)
if isinstance(resolved, RetrievalFailure):
return resolved
try:
data, media, name = pull_paperless_original(
resolved["settings"]["base_url"].rstrip("/"),
resolved["secret"],
str(external_id),
EXPORT_BYTE_LIMIT,
)
except Problem as exc:
return _from_problem(exc)
if len(data) > EXPORT_BYTE_LIMIT:
return RetrievalFailure("too_large", "Die Originaldatei ist für den Export zu groß.")
return FilePayload(name or f"paperless-{external_id}", media, data, "")
def _load_imap(conn, actor_id: UUID, external_id: str, detail: dict, assigned: UUID | None):
stored = _uuid(detail.get("connector_id"))
resolved = _resolve_connector(conn, actor_id, "imap", stored, assigned)
if isinstance(resolved, RetrievalFailure):
return resolved
mailbox = str(detail.get("mailbox") or "").strip()
uid = detail.get("uid")
if isinstance(uid, str) and uid.isdigit():
uid = int(uid)
if not mailbox or isinstance(uid, bool) or not isinstance(uid, int) or uid < 1:
return RetrievalFailure("identity", "Für diese E-Mail fehlt die Zuordnung zu Fach und Nachricht.")
try:
raw = pull_rfc822(resolved["settings"], resolved["secret"], mailbox, uid, str(external_id), EXPORT_BYTE_LIMIT)
except Problem as exc:
return _from_problem(exc)
if len(raw) > EXPORT_BYTE_LIMIT:
return RetrievalFailure("too_large", _TOO_LARGE)
parsed = parse_mail(raw)
if not identities_match(parsed.message_id, str(external_id)):
return RetrievalFailure("identity", "Die gefundene Nachricht ist nicht die referenzierte E-Mail.")
if parsed.missing:
names = ", ".join(parsed.missing[:5])
return RetrievalFailure("attachment", f"Eine Anlage der E-Mail ließ sich nicht vollständig lesen: {names}.")
return MailPayload(raw, parsed)
def _resolve_connector(conn, actor_id: UUID, kind: str, stored: UUID | None, assigned: UUID | None):
rows = conn.execute(
"""
SELECT id, kind, name, settings, secret
FROM connectors
WHERE owner_id = %s AND kind = %s
ORDER BY name, id
""",
(actor_id, kind),
).fetchall()
if stored is not None and assigned is None:
match = next((row for row in rows if row["id"] == stored), None)
if match is None:
return RetrievalFailure("missing", "Der gespeicherte Zugang für diese Quelle ist nicht mehr vorhanden.")
return match
chosen = assigned or stored
if chosen is not None:
match = next((row for row in rows if row["id"] == chosen), None)
if match is None:
return RetrievalFailure(
"assignment",
"Der gewählte Zugang gehört nicht zu diesem Konto oder passt nicht zur Quelle.",
)
return match
if len(rows) == 1:
return rows[0]
if not rows:
return RetrievalFailure("missing", "Für diese Quelle ist kein Zugang vorhanden.")
return RetrievalFailure(
"ambiguous",
"Für diese Quelle ist kein eindeutiger Zugang zugeordnet. Die Zuordnung muss bewusst gewählt werden.",
tuple({"id": str(row["id"]), "name": row["name"]} for row in rows),
)
def _uuid(value) -> UUID | None:
if not value:
return None
try:
return UUID(str(value))
except ValueError:
return None
def _from_problem(exc: Problem) -> RetrievalFailure:
text = exc.detail
lowered = text.casefold()
if "exportgrenze" in lowered or "zu groß" in lowered:
code = "too_large"
elif "mehrdeutig" in lowered or "nicht eindeutig" in lowered or "nicht die referenzierte" in lowered:
code = "identity"
elif "nicht erreichbar" in lowered or "abgelehnt" in lowered:
code = "unreachable"
elif "vorschau wird nicht" in lowered or "nicht verfügbar" in lowered or "gibt es" in lowered:
code = "missing"
else:
code = "missing"
return RetrievalFailure(code, text)