187 lines
7.0 KiB
Python
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)
|