"""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)