Files
tsumugu/backend/app/mailpack.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

176 lines
5.8 KiB
Python

"""Pure mail identity and attachment extraction for a complete export.
A preview cutoff does not belong here. Duplicate attachment names stay distinct.
"""
from __future__ import annotations
import hashlib
import re
from dataclasses import dataclass, field
from email.parser import BytesParser
_UID_PREFIX = "uid:"
class MailIdentityError(Exception):
def __init__(self, message: str) -> None:
super().__init__(message)
self.message = message
@dataclass(frozen=True)
class AttachmentBytes:
filename: str
media_type: str
data: bytes
sha256: str
@dataclass
class ParsedMail:
message_id: str
subject: str
sender: str
recipient: str
copy: str
text: str
attachments: list[AttachmentBytes] = field(default_factory=list)
missing: list[str] = field(default_factory=list)
def header_message_id(raw: bytes) -> str:
message = BytesParser().parsebytes(raw)
return str(message.get("Message-ID") or "").strip()
def identities_match(found: str | None, expected: str | None) -> bool:
"""A stored uid fallback matches only a message that still has no Message-ID."""
expected_text = (expected or "").strip()
found_text = (found or "").strip()
if expected_text.casefold().startswith(_UID_PREFIX):
return found_text == ""
if not expected_text or not found_text:
return False
return _bare(expected_text) == _bare(found_text)
def choose_message(candidate: bytes | None, alternates: list[bytes], expected: str) -> bytes:
"""Keep the stored message when it still matches. Otherwise accept one unambiguous hit."""
if candidate is not None and identities_match(header_message_id(candidate), expected):
return candidate
if (expected or "").strip().casefold().startswith(_UID_PREFIX):
raise MailIdentityError("Die gespeicherte Nachricht lässt sich nicht eindeutig wiederfinden.")
matches = [raw for raw in alternates if identities_match(header_message_id(raw), expected)]
if len(matches) == 1:
return matches[0]
if len(matches) > 1:
raise MailIdentityError("Die Nachrichtenidentität ist mehrdeutig. Es wurde keine E-Mail übernommen.")
raise MailIdentityError("Die gespeicherte Nachricht lässt sich nicht eindeutig wiederfinden.")
def parse_mail(raw: bytes) -> ParsedMail:
message = BytesParser().parsebytes(raw)
attachments: list[AttachmentBytes] = []
missing: list[str] = []
used: set[str] = set()
index = 0
for part in message.walk():
if part.is_multipart():
continue
filename = part.get_filename()
disposition = (part.get_content_disposition() or "").lower()
if not filename and disposition != "attachment":
continue
index += 1
label = _header_text(filename) if filename else f"anlage-{index}.bin"
payload = part.get_payload(decode=True)
if not isinstance(payload, (bytes, bytearray)):
missing.append(label or f"Anlage {index}")
continue
name = _unique_filename(label or f"anlage-{index}.bin", used)
data = bytes(payload)
attachments.append(
AttachmentBytes(
filename=name,
media_type=(part.get_content_type() or "application/octet-stream")[:120],
data=data,
sha256=hashlib.sha256(data).hexdigest(),
)
)
text = _body_text(message)
return ParsedMail(
message_id=str(message.get("Message-ID") or "").strip(),
subject=_header_text(message.get("Subject")) or "(ohne Betreff)",
sender=_header_text(message.get("From")),
recipient=_header_text(message.get("To")),
copy=_header_text(message.get("Cc")),
text=text,
attachments=attachments,
missing=missing,
)
def _bare(value: str) -> str:
return value.strip().strip("<>").strip().casefold()
def _header_text(value) -> str:
if value is None:
return ""
text = str(value).replace("\r", " ").replace("\n", " ")
return re.sub(r"\s+", " ", text).strip()
def _unique_filename(name: str, used: set[str]) -> str:
cleaned = name.replace("\\", "/").split("/")[-1].strip() or "anlage.bin"
cleaned = cleaned[:180]
if cleaned not in used:
used.add(cleaned)
return cleaned
stem, dot, ext = cleaned.rpartition(".")
if not dot:
stem, ext = cleaned, ""
else:
ext = f".{ext}"
number = 2
while True:
candidate = f"{stem} ({number}){ext}"
if candidate not in used:
used.add(candidate)
return candidate
number += 1
def _body_text(message) -> str:
plain: list[str] = []
html: list[str] = []
parts = message.walk() if message.is_multipart() else [message]
for part in parts:
if part.is_multipart() or part.get_content_disposition() == "attachment" or part.get_filename():
continue
kind = part.get_content_type()
payload = part.get_payload(decode=True)
if isinstance(payload, (bytes, bytearray)):
charset = part.get_content_charset() or "utf-8"
text = bytes(payload).decode(charset, errors="replace").strip()
else:
raw = part.get_payload()
text = raw.strip() if isinstance(raw, str) else ""
if kind == "text/plain":
plain.append(text)
elif kind == "text/html":
html.append(_html_text(text))
body = "\n".join(chunk for chunk in plain if chunk).strip()
if not body:
body = "\n".join(chunk for chunk in html if chunk).strip()
return body
def _html_text(value: str) -> str:
text = re.sub(r"(?is)<(script|style)\b.*?>.*?</\1>", " ", value)
text = re.sub(r"(?i)<br\s*/?>", "\n", text)
text = re.sub(r"(?i)</p>", "\n", text)
text = re.sub(r"<[^>]+>", " ", text)
return re.sub(r"[ \t]{2,}", " ", text).strip()