Korrigiere IMAP-Ordner, MIME-Ansicht und die gemeinsamen Leser, damit große Postfächer, Notizen und verspätete Quellenantworten zuverlässig bleiben.
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
34c4084a7c
commit
c29bd29f34
29 files changed
+2562
-410
No files matched your search
@@ -124,14 +124,18 @@ def view_mail(
|
||||
"message_to": parsed.recipient,
|
||||
"message_cc": parsed.copy,
|
||||
"text": parsed.text,
|
||||
"text_truncated": False,
|
||||
"complete": True,
|
||||
"html": parsed.html,
|
||||
"text_truncated": parsed.text_truncated,
|
||||
"complete": not parsed.missing,
|
||||
"notices": parsed.notices,
|
||||
"attachments": [
|
||||
{
|
||||
"index": index,
|
||||
"filename": item.filename,
|
||||
"filename": item.display_name or item.filename,
|
||||
"archive_name": item.filename,
|
||||
"content_type": item.media_type,
|
||||
"byte_size": len(item.data),
|
||||
"inline": item.inline,
|
||||
}
|
||||
for index, item in enumerate(parsed.attachments)
|
||||
],
|
||||
|
||||
+222
-49
@@ -211,11 +211,36 @@ def record_dispatch(
|
||||
raise unprocessable("Dieselbe Anlage ist mehrfach im Versand genannt.")
|
||||
container_row, page, scope = open_container(conn, actor, context, placement, "edit")
|
||||
host = _bound_element(conn, actor, host_id, page, scope)
|
||||
bump_version(conn, "elements", host_id, expected)
|
||||
known = {row["attachment_element_id"] for row in _uses(conn, scope, host_id)}
|
||||
if any(item not in known for item in attachment_ids):
|
||||
raise unprocessable("Mitversendet werden nur Anlagen dieses Schreibens.")
|
||||
counterpart_text = _counterpart(counterpart)
|
||||
edition_plans = []
|
||||
if capture_editions:
|
||||
edition_plans.append(_plan_edition(conn, actor, host, "host", 0, page, historical_gap, media_root, cleanup))
|
||||
ordered = [row for row in _uses(conn, scope, host_id) if row["attachment_element_id"] in set(attachment_ids)]
|
||||
position_of = {item: index for index, item in enumerate(attachment_ids)}
|
||||
ordered.sort(key=lambda row: position_of[row["attachment_element_id"]])
|
||||
for index, row in enumerate(ordered, start=1):
|
||||
element = _readable(conn, actor, row["attachment_element_id"], page)
|
||||
if element is None:
|
||||
raise not_found()
|
||||
edition_plans.append(
|
||||
_plan_edition(conn, actor, element, "attachment", index, page, historical_gap, media_root, cleanup)
|
||||
)
|
||||
evidence_plans = []
|
||||
for item in evidence:
|
||||
element = _readable(conn, actor, item["element_id"], page)
|
||||
if element is None:
|
||||
raise not_found()
|
||||
evidence_plans.append(
|
||||
_plan_evidence(
|
||||
conn, actor, element, item["role"], item.get("fold") or "keep", page, media_root, cleanup, container_row["home_scope_id"]
|
||||
)
|
||||
)
|
||||
container_row, page, scope = open_container(conn, actor, context, placement, "edit")
|
||||
host = _bound_element(conn, actor, host_id, page, scope)
|
||||
bump_version(conn, "elements", host_id, expected)
|
||||
dispatch = conn.execute(
|
||||
"""
|
||||
INSERT INTO dispatches (
|
||||
@@ -237,37 +262,11 @@ def record_dispatch(
|
||||
actor,
|
||||
),
|
||||
).fetchone()
|
||||
states = []
|
||||
if capture_editions:
|
||||
states.append(_capture_item(conn, actor, dispatch, host, "host", 0, page, historical_gap, media_root, cleanup))
|
||||
ordered = [row for row in _uses(conn, scope, host_id) if row["attachment_element_id"] in set(attachment_ids)]
|
||||
position_of = {item: index for index, item in enumerate(attachment_ids)}
|
||||
ordered.sort(key=lambda row: position_of[row["attachment_element_id"]])
|
||||
for index, row in enumerate(ordered, start=1):
|
||||
element = _readable(conn, actor, row["attachment_element_id"], page)
|
||||
if element is None:
|
||||
raise not_found()
|
||||
states.append(
|
||||
_capture_item(conn, actor, dispatch, element, "attachment", index, page, historical_gap, media_root, cleanup)
|
||||
)
|
||||
evidence_rows = []
|
||||
for item in evidence:
|
||||
evidence_rows.append(
|
||||
_add_evidence(
|
||||
conn,
|
||||
actor,
|
||||
container_row,
|
||||
page,
|
||||
scope,
|
||||
dispatch,
|
||||
item["element_id"],
|
||||
item["role"],
|
||||
item.get("fold") or "keep",
|
||||
media_root,
|
||||
cleanup,
|
||||
log=False,
|
||||
)
|
||||
)
|
||||
states = [_write_edition(conn, dispatch, plan) for plan in edition_plans]
|
||||
evidence_rows = [
|
||||
_write_evidence(conn, actor, container_row, page, scope, dispatch, plan, log=False)
|
||||
for plan in evidence_plans
|
||||
]
|
||||
completeness = _completeness(states) if capture_editions else "secured"
|
||||
conn.execute(
|
||||
"UPDATE dispatches SET completeness = %s, updated_at = now() WHERE id = %s",
|
||||
@@ -292,11 +291,16 @@ def add_dispatch_evidence(
|
||||
) -> dict:
|
||||
container_row, page, scope = open_container(conn, actor, context, placement, "edit")
|
||||
dispatch = _dispatch_in(conn, dispatch_id, scope)
|
||||
_bump_dispatch(conn, dispatch_id, expected)
|
||||
row = _add_evidence(
|
||||
conn, actor, container_row, page, scope, dispatch, element_id, role, fold, media_root, cleanup, log=True
|
||||
element = _readable(conn, actor, element_id, page)
|
||||
if element is None:
|
||||
raise not_found()
|
||||
plan = _plan_evidence(
|
||||
conn, actor, element, role, fold, page, media_root, cleanup, container_row["home_scope_id"], dispatch_id
|
||||
)
|
||||
return row
|
||||
container_row, page, scope = open_container(conn, actor, context, placement, "edit")
|
||||
dispatch = _dispatch_in(conn, dispatch_id, scope)
|
||||
_bump_dispatch(conn, dispatch_id, expected)
|
||||
return _write_evidence(conn, actor, container_row, page, scope, dispatch, plan, log=True)
|
||||
|
||||
|
||||
def detach_dispatch_evidence(
|
||||
@@ -760,7 +764,7 @@ def _identify_evidence(conn, actor, dispatch, element, page, media_root, cleanup
|
||||
if isinstance(loaded, RetrievalFailure):
|
||||
return False, loaded.message, None, None, [], None
|
||||
if isinstance(loaded, MailPayload):
|
||||
comparisons = _compare_mail(conn, actor, dispatch["id"], page, loaded)
|
||||
comparisons = _compare_mail(conn, actor, dispatch["id"], page, loaded) if dispatch is not None else []
|
||||
payload = FilePayload("nachweis.eml", "message/rfc822", loaded.raw, sha256(loaded.raw))
|
||||
return True, None, loaded.parsed.message_id or None, payload.sha256, comparisons, payload
|
||||
payload = FilePayload(loaded.filename, loaded.media_type, loaded.data, sha256(loaded.data))
|
||||
@@ -931,15 +935,179 @@ def _working_bytes(conn, actor, element, media_root: str):
|
||||
return None, "Für diesen Inhalt ist keine sicherbare Fassung vorgesehen.", None, None, None
|
||||
|
||||
|
||||
def _store_snapshot(conn, scope_id, actor, payload: FilePayload, media_root: str, cleanup: list[Path], dispatch_item_id: UUID | None = None, evidence_id: UUID | None = None) -> UUID:
|
||||
snapshot_id = uuid4()
|
||||
def _stage_snapshot(conn, media_root: str, data: bytes, cleanup: list) -> dict:
|
||||
"""Publish bytes only while the domain transaction is idle. The row comes later."""
|
||||
from app.sourceaccess import release_for_external
|
||||
|
||||
instance = instance_for_write(conn, media_root)
|
||||
snapshot_id = uuid4()
|
||||
object_key = f"dispatch/{snapshot_id}"
|
||||
content_revision = str(uuid4())
|
||||
adapter = adapter_for(instance)
|
||||
publish(adapter, object_key, payload.data)
|
||||
release_for_external(conn)
|
||||
publish(adapter, object_key, data)
|
||||
cleanup.append(StoredHandle(adapter, object_key))
|
||||
digest = sha256(payload.data)
|
||||
return {
|
||||
"id": snapshot_id,
|
||||
"instance": instance,
|
||||
"object_key": object_key,
|
||||
"content_revision": str(uuid4()),
|
||||
}
|
||||
|
||||
|
||||
def _plan_edition(conn, actor, element, role, position, page, historical_gap, media_root, cleanup) -> dict:
|
||||
dates = _dates(conn, element["id"])
|
||||
payload = None
|
||||
gap_reason = None
|
||||
note_document = None
|
||||
external_source = None
|
||||
external_id = None
|
||||
if historical_gap:
|
||||
state = "gap"
|
||||
gap_reason = _HISTORICAL_GAP
|
||||
else:
|
||||
payload, gap_reason, note_document, external_source, external_id = _working_bytes(
|
||||
conn, actor, element, media_root
|
||||
)
|
||||
state = "snapshot" if payload is not None else "gap"
|
||||
staged = _stage_snapshot(conn, media_root, payload.data, cleanup) if payload is not None else None
|
||||
return {
|
||||
"element": element,
|
||||
"role": role,
|
||||
"position": position,
|
||||
"dates": dates,
|
||||
"state": state,
|
||||
"payload": payload,
|
||||
"gap_reason": gap_reason,
|
||||
"note_document": note_document,
|
||||
"external_source": external_source,
|
||||
"external_id": external_id,
|
||||
"staged": staged,
|
||||
}
|
||||
|
||||
|
||||
def _write_edition(conn, dispatch, plan: dict) -> str:
|
||||
payload = plan["payload"]
|
||||
filename = payload.filename if payload is not None else None
|
||||
content_type = payload.media_type if payload is not None else None
|
||||
digest = sha256(payload.data) if payload is not None else None
|
||||
byte_size = len(payload.data) if payload is not None else None
|
||||
item = conn.execute(
|
||||
"""
|
||||
INSERT INTO dispatch_items (
|
||||
dispatch_id, role, position, element_id, title, document_on, filename,
|
||||
content_type, byte_size, content_sha256, source_state, gap_reason,
|
||||
note_document, external_source, external_id
|
||||
)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||||
RETURNING id
|
||||
""",
|
||||
(
|
||||
dispatch["id"],
|
||||
plan["role"],
|
||||
plan["position"],
|
||||
plan["element"]["id"],
|
||||
plan["element"]["title"],
|
||||
plan["dates"]["document_on"],
|
||||
filename,
|
||||
content_type,
|
||||
byte_size,
|
||||
digest,
|
||||
plan["state"],
|
||||
plan["gap_reason"],
|
||||
Json(plan["note_document"]) if plan["note_document"] is not None else None,
|
||||
plan["external_source"],
|
||||
plan["external_id"],
|
||||
),
|
||||
).fetchone()
|
||||
if plan["staged"] is not None and payload is not None:
|
||||
_record_snapshot(conn, dispatch["home_scope_id"], dispatch["recorded_by"], payload, plan["staged"], dispatch_item_id=item["id"])
|
||||
return plan["state"]
|
||||
|
||||
|
||||
def _plan_evidence(conn, actor, element, role, fold, page, media_root, cleanup, scope_id, dispatch_id=None) -> dict:
|
||||
if role not in EVIDENCE_ROLES:
|
||||
raise unprocessable("Die Rolle des Nachweises ist nicht vorgesehen.")
|
||||
if fold not in {"keep", "evidence"}:
|
||||
raise unprocessable("Die Darstellung des Nachweises ist nicht festgelegt.")
|
||||
if dispatch_id is not None and conn.execute(
|
||||
"SELECT id FROM dispatch_evidence WHERE dispatch_id = %s AND element_id = %s",
|
||||
(dispatch_id, element["id"]),
|
||||
).fetchone():
|
||||
raise unprocessable("Dieser Nachweis ist dem Versand bereits zugeordnet.")
|
||||
dispatch = {"id": dispatch_id} if dispatch_id is not None else None
|
||||
identified, gap_reason, message_id, digest, comparisons, snapshot = _identify_evidence(
|
||||
conn, actor, dispatch, element, page, media_root, cleanup, scope_id
|
||||
)
|
||||
staged = _stage_snapshot(conn, media_root, snapshot.data, cleanup) if snapshot is not None else None
|
||||
return {
|
||||
"element": element,
|
||||
"role": role,
|
||||
"fold": fold,
|
||||
"identified": identified,
|
||||
"gap_reason": gap_reason,
|
||||
"message_id": message_id,
|
||||
"digest": digest,
|
||||
"comparisons": comparisons,
|
||||
"snapshot": snapshot,
|
||||
"staged": staged,
|
||||
}
|
||||
|
||||
|
||||
def _write_evidence(conn, actor, container_row, page, scope, dispatch, plan: dict, log: bool) -> dict:
|
||||
snapshot = plan["snapshot"]
|
||||
comparisons = plan["comparisons"]
|
||||
if snapshot is not None and snapshot.media_type == "message/rfc822":
|
||||
from app.mailpack import parse_mail
|
||||
|
||||
comparisons = _compare_mail(conn, actor, dispatch["id"], page, MailPayload(snapshot.data, parse_mail(snapshot.data)))
|
||||
proof = conn.execute(
|
||||
"""
|
||||
INSERT INTO dispatch_evidence (
|
||||
dispatch_id, element_id, role, source_state, gap_reason, message_id,
|
||||
identity_sha256, comparisons, manual, created_by
|
||||
)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, true, %s)
|
||||
RETURNING *
|
||||
""",
|
||||
(
|
||||
dispatch["id"],
|
||||
plan["element"]["id"],
|
||||
plan["role"],
|
||||
"identified" if plan["identified"] else "gap",
|
||||
plan["gap_reason"],
|
||||
plan["message_id"],
|
||||
plan["digest"],
|
||||
Json(comparisons),
|
||||
actor,
|
||||
),
|
||||
).fetchone()
|
||||
if plan["staged"] is not None and snapshot is not None:
|
||||
_record_snapshot(
|
||||
conn,
|
||||
container_row["home_scope_id"],
|
||||
actor,
|
||||
snapshot,
|
||||
plan["staged"],
|
||||
evidence_id=proof["id"],
|
||||
)
|
||||
if plan["fold"] == "evidence":
|
||||
_set_binding_fold(conn, scope, plan["element"]["id"], "evidence")
|
||||
if log:
|
||||
_log(conn, dispatch["id"], actor, f"Nachweis ergänzt: {EVIDENCE_ROLES[plan['role']]}")
|
||||
audit(conn, actor, container_row["home_scope_id"], "dispatch_evidence", "element", plan["element"]["id"], page)
|
||||
return {
|
||||
"id": str(proof["id"]),
|
||||
"element_id": str(plan["element"]["id"]),
|
||||
"role": plan["role"],
|
||||
"role_label": EVIDENCE_ROLES[plan["role"]],
|
||||
"source_state": proof["source_state"],
|
||||
"gap_reason": plan["gap_reason"],
|
||||
"manual": True,
|
||||
"comparisons": comparisons,
|
||||
}
|
||||
|
||||
|
||||
def _record_snapshot(conn, scope_id, actor, payload: FilePayload, staged: dict, dispatch_item_id=None, evidence_id=None) -> UUID:
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO dispatch_snapshots (
|
||||
@@ -951,7 +1119,7 @@ def _store_snapshot(conn, scope_id, actor, payload: FilePayload, media_root: str
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'none')
|
||||
""",
|
||||
(
|
||||
snapshot_id,
|
||||
staged["id"],
|
||||
dispatch_item_id,
|
||||
evidence_id,
|
||||
scope_id,
|
||||
@@ -959,15 +1127,20 @@ def _store_snapshot(conn, scope_id, actor, payload: FilePayload, media_root: str
|
||||
display_filename(payload.filename),
|
||||
payload.media_type or "application/octet-stream",
|
||||
len(payload.data),
|
||||
digest,
|
||||
instance["id"],
|
||||
instance["generation"],
|
||||
object_key,
|
||||
content_revision,
|
||||
sha256(payload.data),
|
||||
staged["instance"]["id"],
|
||||
staged["instance"]["generation"],
|
||||
staged["object_key"],
|
||||
staged["content_revision"],
|
||||
LEGACY_PROFILE,
|
||||
),
|
||||
)
|
||||
return snapshot_id
|
||||
return staged["id"]
|
||||
|
||||
|
||||
def _store_snapshot(conn, scope_id, actor, payload: FilePayload, media_root: str, cleanup: list[Path], dispatch_item_id: UUID | None = None, evidence_id: UUID | None = None) -> UUID:
|
||||
staged = _stage_snapshot(conn, media_root, payload.data, cleanup)
|
||||
return _record_snapshot(conn, scope_id, actor, payload, staged, dispatch_item_id, evidence_id)
|
||||
|
||||
|
||||
def _snapshot_file(conn, media_root: str, dispatch_item_id: UUID | None = None, evidence_id: UUID | None = None) -> FilePayload:
|
||||
|
||||
@@ -695,9 +695,18 @@ def _emit_one(node, prefix, add, entries, loaded, notice_for, generated: str) ->
|
||||
links = [("EML-Original", eml)]
|
||||
try:
|
||||
parsed = payload.parsed if isinstance(payload, MailPayload) else parse_mail(raw)
|
||||
reading = _mail_reading_html(parsed)
|
||||
if reading is not None:
|
||||
reading_path = add(prefix + ["lesefassung.html"], reading)
|
||||
links.append(("Formatierte Lesefassung", reading_path))
|
||||
else:
|
||||
notice = "\n".join(part for part in [notice, "Eine formatierte Lesefassung liegt für diese Nachricht nicht vor. Die vereinfachte Textfassung steht in der Übersicht."] if part)
|
||||
for attachment in parsed.attachments:
|
||||
label = attachment.display_name or attachment.filename
|
||||
path = add(prefix + ["anlagen", attachment.filename], attachment.data)
|
||||
links.append((attachment.filename, path))
|
||||
links.append((label, path))
|
||||
if parsed.notices:
|
||||
notice = "\n".join(part for part in [notice, *parsed.notices] if part)
|
||||
except Exception:
|
||||
links.append(("Hinweis", eml))
|
||||
entries.append(_entry(node, eml, links, notice or None))
|
||||
@@ -1223,6 +1232,21 @@ def _note_markdown(node: ExportNode, body: str, generated: str) -> str:
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def _mail_reading_html(parsed) -> bytes | None:
|
||||
if not getattr(parsed, "html", ""):
|
||||
return None
|
||||
page = (
|
||||
"<!DOCTYPE html><html lang=\"de\"><head><meta charset=\"utf-8\">"
|
||||
"<meta http-equiv=\"Content-Security-Policy\" content=\"default-src 'none'; img-src data:; style-src 'none'; script-src 'none'\">"
|
||||
"<title>Lesefassung</title></head><body>"
|
||||
f"{parsed.html}"
|
||||
"<p>Vereinfachte Textfassung und das unveränderte EML-Original stehen daneben. "
|
||||
"Die Ansicht ist nicht pixelgleich zur Postfachdarstellung.</p>"
|
||||
"</body></html>"
|
||||
)
|
||||
return page.encode("utf-8")
|
||||
|
||||
|
||||
def _mail_markdown(node, mail: MailPayload, text_path: str, eml_path: str, attachments, notice: str, generated: str) -> str:
|
||||
parsed = mail.parsed
|
||||
lines = [f"# {node.title}", "", "Lesefassung. Das unveränderte Original ist die EML-Datei.", ""]
|
||||
@@ -1234,7 +1258,13 @@ def _mail_markdown(node, mail: MailPayload, text_path: str, eml_path: str, attac
|
||||
if parsed.copy:
|
||||
lines.append(f"- Kopie: {parsed.copy}")
|
||||
lines.append(f"- [EML-Original]({_href(_relative(text_path, eml_path))})")
|
||||
lines.extend(["", parsed.text or "Der Text steht im EML-Original.", ""])
|
||||
lines.extend([
|
||||
"",
|
||||
"Vereinfachte Textfassung. Sie ist nicht die formatierte Ansicht und nicht das EML-Original.",
|
||||
"",
|
||||
parsed.text or "Der Text steht im EML-Original.",
|
||||
"",
|
||||
])
|
||||
if attachments:
|
||||
lines.append("## Anlagen")
|
||||
lines.append("")
|
||||
|
||||
+311
-66
@@ -1,16 +1,32 @@
|
||||
"""Pure mail identity and attachment extraction for a complete export.
|
||||
|
||||
A preview cutoff does not belong here. Duplicate attachment names stay distinct.
|
||||
The same tree feeds preview, reading, attachment download and export.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import html
|
||||
import re
|
||||
from dataclasses import dataclass, field
|
||||
from email import policy
|
||||
from email.header import decode_header, make_header
|
||||
from email.message import EmailMessage
|
||||
from email.parser import BytesParser
|
||||
from email.utils import parsedate_to_datetime
|
||||
from html.parser import HTMLParser
|
||||
|
||||
_UID_PREFIX = "uid:"
|
||||
_POLICY = policy.default
|
||||
_ALLOWED_TAGS = {
|
||||
"a", "p", "br", "div", "span", "strong", "em", "b", "i", "u",
|
||||
"ul", "ol", "li", "table", "thead", "tbody", "tr", "th", "td",
|
||||
"blockquote", "pre", "code", "h1", "h2", "h3", "h4", "h5", "h6", "img",
|
||||
}
|
||||
_VOID_TAGS = {"br", "img"}
|
||||
_SAFE_LINK = re.compile(r"^(https?://|mailto:)", re.IGNORECASE)
|
||||
_DATA_IMAGE = re.compile(r"^data:image/(?:png|jpeg|gif|webp);base64,[a-z0-9+/=\s]+$", re.IGNORECASE)
|
||||
|
||||
|
||||
class MailIdentityError(Exception):
|
||||
@@ -25,6 +41,9 @@ class AttachmentBytes:
|
||||
media_type: str
|
||||
data: bytes
|
||||
sha256: str
|
||||
display_name: str = ""
|
||||
content_id: str = ""
|
||||
inline: bool = False
|
||||
|
||||
|
||||
@dataclass
|
||||
@@ -37,10 +56,14 @@ class ParsedMail:
|
||||
text: str
|
||||
attachments: list[AttachmentBytes] = field(default_factory=list)
|
||||
missing: list[str] = field(default_factory=list)
|
||||
html: str = ""
|
||||
notices: list[str] = field(default_factory=list)
|
||||
text_truncated: bool = False
|
||||
document_on: str | None = None
|
||||
|
||||
|
||||
def header_message_id(raw: bytes) -> str:
|
||||
message = BytesParser().parsebytes(raw)
|
||||
message = BytesParser(policy=_POLICY).parsebytes(raw)
|
||||
return str(message.get("Message-ID") or "").strip()
|
||||
|
||||
|
||||
@@ -69,67 +92,322 @@ def choose_message(candidate: bytes | None, alternates: list[bytes], expected: s
|
||||
raise MailIdentityError("Die gespeicherte Nachricht lässt sich nicht eindeutig wiederfinden.")
|
||||
|
||||
|
||||
def header_text(value) -> str:
|
||||
"""Decode encoded-words. A raw MIME header is not a display name."""
|
||||
if value is None:
|
||||
return ""
|
||||
raw = str(value).replace("\r", " ").replace("\n", " ")
|
||||
try:
|
||||
text = str(make_header(decode_header(raw)))
|
||||
except (UnicodeError, LookupError, ValueError):
|
||||
text = raw
|
||||
return re.sub(r"\s+", " ", text).strip()
|
||||
|
||||
|
||||
def parse_mail(raw: bytes) -> ParsedMail:
|
||||
message = BytesParser().parsebytes(raw)
|
||||
message = BytesParser(policy=_POLICY).parsebytes(raw)
|
||||
attachments: list[AttachmentBytes] = []
|
||||
missing: list[str] = []
|
||||
notices: list[str] = []
|
||||
used: set[str] = set()
|
||||
plain: list[str] = []
|
||||
html_parts: list[str] = []
|
||||
index = 0
|
||||
for part in message.walk():
|
||||
if part.is_multipart():
|
||||
for kind, part in _walk(message):
|
||||
if kind == "message":
|
||||
index += 1
|
||||
label = header_text(part.get_filename()) or f"nachricht-{index}.eml"
|
||||
data = _message_bytes(part)
|
||||
if data is None:
|
||||
missing.append(label)
|
||||
notices.append(f"Die angehängte Nachricht {label} ließ sich nicht vollständig lesen.")
|
||||
continue
|
||||
name = _unique_filename(label, used)
|
||||
attachments.append(_attachment(part, name, label, data, inline=False))
|
||||
continue
|
||||
filename = part.get_filename()
|
||||
disposition = (part.get_content_disposition() or "").lower()
|
||||
if not filename and disposition != "attachment":
|
||||
media = part.get_content_type()
|
||||
filename = part.get_filename()
|
||||
content_id = _content_id(part)
|
||||
body = media in {"text/plain", "text/html"} and disposition != "attachment" and not filename
|
||||
if body:
|
||||
text = _decoded_text(part)
|
||||
if text is None:
|
||||
notices.append("Ein Textteil ließ sich nicht sicher dekodieren.")
|
||||
continue
|
||||
if media == "text/plain":
|
||||
plain.append(text)
|
||||
else:
|
||||
html_parts.append(text)
|
||||
continue
|
||||
if not filename and disposition != "attachment" and not content_id:
|
||||
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)):
|
||||
label = header_text(filename) if filename else f"anlage-{index}.bin"
|
||||
data = _leaf_bytes(part)
|
||||
if data is None:
|
||||
missing.append(label or f"Anlage {index}")
|
||||
notices.append(f"Die Anlage {label or index} ließ sich nicht vollständig lesen.")
|
||||
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)
|
||||
inline = disposition == "inline" or bool(content_id)
|
||||
attachments.append(_attachment(part, name, label or name, data, inline=inline))
|
||||
simplified = "\n".join(chunk for chunk in plain if chunk).strip()
|
||||
rendered = ""
|
||||
if html_parts:
|
||||
rendered = sanitize_html("\n".join(html_parts), _inline_images(attachments))
|
||||
if not simplified:
|
||||
simplified = simplified_text("\n".join(html_parts))
|
||||
if missing:
|
||||
notices.append("Mindestens eine Anlage fehlt in der Aufbereitung.")
|
||||
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,
|
||||
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=simplified,
|
||||
attachments=attachments,
|
||||
missing=missing,
|
||||
html=rendered,
|
||||
notices=notices,
|
||||
document_on=_message_date(message.get("Date")),
|
||||
)
|
||||
|
||||
|
||||
def decode_transfer(payload: bytes, charset: str | None) -> str:
|
||||
return bytes(payload).decode(charset or "utf-8", errors="replace")
|
||||
|
||||
|
||||
def simplified_text(value: str) -> str:
|
||||
"""A recognizable plain reading. It is not the formatted view."""
|
||||
class Collector(HTMLParser):
|
||||
def __init__(self) -> None:
|
||||
super().__init__(convert_charrefs=True)
|
||||
self.parts: list[str] = []
|
||||
self.skip = 0
|
||||
|
||||
def handle_starttag(self, tag, attrs):
|
||||
name = tag.lower()
|
||||
if name in {"script", "style"}:
|
||||
self.skip += 1
|
||||
return
|
||||
if name in {"br", "p", "div", "tr", "li", "h1", "h2", "h3", "h4", "h5", "h6", "blockquote"}:
|
||||
self.parts.append("\n")
|
||||
elif name in {"td", "th"}:
|
||||
self.parts.append("\t")
|
||||
|
||||
def handle_endtag(self, tag):
|
||||
name = tag.lower()
|
||||
if name in {"script", "style"} and self.skip:
|
||||
self.skip -= 1
|
||||
return
|
||||
if name in {"p", "div", "tr", "li", "table", "h1", "h2", "h3", "h4", "h5", "h6"}:
|
||||
self.parts.append("\n")
|
||||
|
||||
def handle_data(self, data):
|
||||
if not self.skip:
|
||||
self.parts.append(data)
|
||||
|
||||
collector = Collector()
|
||||
try:
|
||||
collector.feed(value)
|
||||
collector.close()
|
||||
except Exception:
|
||||
return ""
|
||||
text = "".join(collector.parts)
|
||||
text = text.replace("\r", "")
|
||||
text = re.sub(r"[ \t]+\n", "\n", text)
|
||||
text = re.sub(r"\n{3,}", "\n\n", text)
|
||||
return text.strip()
|
||||
|
||||
|
||||
def sanitize_html(value: str, images: dict[str, str] | None = None) -> str:
|
||||
"""Keep a formatted reading. Scripts, active content and remote loads stay out."""
|
||||
images = images or {}
|
||||
|
||||
class Cleaner(HTMLParser):
|
||||
def __init__(self) -> None:
|
||||
super().__init__(convert_charrefs=True)
|
||||
self.parts: list[str] = []
|
||||
self.skip = 0
|
||||
|
||||
def handle_starttag(self, tag, attrs):
|
||||
name = tag.lower()
|
||||
if name in {"script", "style", "iframe", "object", "embed", "form", "link", "meta"}:
|
||||
self.skip += 1
|
||||
return
|
||||
if self.skip or name not in _ALLOWED_TAGS:
|
||||
return
|
||||
rendered = _clean_attrs(name, attrs, images)
|
||||
if rendered is None:
|
||||
return
|
||||
self.parts.append(f"<{name}{rendered}>")
|
||||
|
||||
def handle_endtag(self, tag):
|
||||
name = tag.lower()
|
||||
if name in {"script", "style", "iframe", "object", "embed", "form", "link", "meta"}:
|
||||
if self.skip:
|
||||
self.skip -= 1
|
||||
return
|
||||
if self.skip or name not in _ALLOWED_TAGS or name in _VOID_TAGS:
|
||||
return
|
||||
self.parts.append(f"</{name}>")
|
||||
|
||||
def handle_data(self, data):
|
||||
if not self.skip:
|
||||
self.parts.append(html.escape(data))
|
||||
|
||||
def handle_entityref(self, name):
|
||||
if not self.skip:
|
||||
self.parts.append(f"&{name};")
|
||||
|
||||
def handle_charref(self, name):
|
||||
if not self.skip:
|
||||
self.parts.append(f"&#{name};")
|
||||
|
||||
cleaner = Cleaner()
|
||||
try:
|
||||
cleaner.feed(value)
|
||||
cleaner.close()
|
||||
except Exception:
|
||||
return ""
|
||||
return "".join(cleaner.parts).strip()
|
||||
|
||||
|
||||
def _clean_attrs(tag: str, attrs, images: dict[str, str]) -> str | None:
|
||||
kept: list[str] = []
|
||||
for key, value in attrs:
|
||||
name = (key or "").lower()
|
||||
if name.startswith("on") or name in {"style", "srcset"}:
|
||||
continue
|
||||
if tag == "a" and name == "href":
|
||||
target = (value or "").strip()
|
||||
if not _SAFE_LINK.match(target):
|
||||
continue
|
||||
kept.append(f' href="{html.escape(target, quote=True)}"')
|
||||
elif tag == "img" and name == "src":
|
||||
source = (value or "").strip()
|
||||
if source.lower().startswith("cid:"):
|
||||
token = source[4:].strip().strip("<>")
|
||||
source = images.get(token.casefold(), "")
|
||||
if not _DATA_IMAGE.match(source):
|
||||
continue
|
||||
kept.append(f' src="{source}"')
|
||||
elif tag == "img" and name == "alt":
|
||||
kept.append(f' alt="{html.escape(value or "", quote=True)}"')
|
||||
elif name in {"colspan", "rowspan"} and str(value or "").isdigit():
|
||||
kept.append(f" {name}=\"{int(value)}\"")
|
||||
if tag == "img" and not any(item.startswith(" src=") for item in kept):
|
||||
return None
|
||||
if tag == "a":
|
||||
kept.append(' rel="noreferrer"')
|
||||
return "".join(kept)
|
||||
|
||||
|
||||
def _walk(message: EmailMessage):
|
||||
if message.get_content_maintype() == "message" and message.get_content_subtype() == "rfc822":
|
||||
yield "message", message
|
||||
return
|
||||
if message.is_multipart():
|
||||
for child in message.iter_parts():
|
||||
yield from _walk(child)
|
||||
return
|
||||
yield "leaf", message
|
||||
|
||||
|
||||
def _decoded_text(part: EmailMessage) -> str | None:
|
||||
try:
|
||||
payload = part.get_payload(decode=True)
|
||||
except Exception:
|
||||
return None
|
||||
if not isinstance(payload, (bytes, bytearray)):
|
||||
raw = part.get_payload()
|
||||
return raw.strip() if isinstance(raw, str) else None
|
||||
charset = part.get_content_charset() or "utf-8"
|
||||
try:
|
||||
return decode_transfer(bytes(payload), charset).strip()
|
||||
except LookupError:
|
||||
return decode_transfer(bytes(payload), "utf-8").strip()
|
||||
|
||||
|
||||
def _leaf_bytes(part: EmailMessage) -> bytes | None:
|
||||
try:
|
||||
payload = part.get_payload(decode=True)
|
||||
except Exception:
|
||||
return None
|
||||
if isinstance(payload, (bytes, bytearray)):
|
||||
return bytes(payload)
|
||||
return None
|
||||
|
||||
|
||||
def _message_bytes(part: EmailMessage) -> bytes | None:
|
||||
payload = part.get_payload()
|
||||
if isinstance(payload, list) and payload:
|
||||
inner = payload[0]
|
||||
if isinstance(inner, EmailMessage):
|
||||
return inner.as_bytes()
|
||||
data = _leaf_bytes(part)
|
||||
return data or None
|
||||
|
||||
|
||||
def _content_id(part: EmailMessage) -> str:
|
||||
token = str(part.get("Content-ID") or "").strip().strip("<>").strip()
|
||||
return token
|
||||
|
||||
|
||||
def _attachment(part: EmailMessage, filename: str, label: str, data: bytes, inline: bool) -> AttachmentBytes:
|
||||
return AttachmentBytes(
|
||||
filename=filename,
|
||||
media_type=(part.get_content_type() or "application/octet-stream")[:120],
|
||||
data=data,
|
||||
sha256=hashlib.sha256(data).hexdigest(),
|
||||
display_name=label or filename,
|
||||
content_id=_content_id(part),
|
||||
inline=inline,
|
||||
)
|
||||
|
||||
|
||||
def _inline_images(attachments: list[AttachmentBytes]) -> dict[str, str]:
|
||||
import base64
|
||||
|
||||
images: dict[str, str] = {}
|
||||
for item in attachments:
|
||||
if not item.content_id or not item.media_type.startswith("image/"):
|
||||
continue
|
||||
if len(item.data) > 1_500_000:
|
||||
continue
|
||||
subtype = item.media_type.split("/", 1)[1].split(";", 1)[0].lower()
|
||||
if subtype == "jpg":
|
||||
subtype = "jpeg"
|
||||
if subtype not in {"png", "jpeg", "gif", "webp"}:
|
||||
continue
|
||||
encoded = base64.b64encode(item.data).decode("ascii")
|
||||
images[item.content_id.casefold()] = f"data:image/{subtype};base64,{encoded}"
|
||||
return images
|
||||
|
||||
|
||||
def _message_date(value) -> str | None:
|
||||
if not value:
|
||||
return None
|
||||
try:
|
||||
return parsedate_to_datetime(str(value)).date().isoformat()
|
||||
except (TypeError, ValueError, OverflowError):
|
||||
return None
|
||||
|
||||
|
||||
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]
|
||||
cleaned = re.sub(r"[\r\n\x00]", "", cleaned)[:180] or "anlage.bin"
|
||||
if cleaned not in used:
|
||||
used.add(cleaned)
|
||||
return cleaned
|
||||
stem, dot, ext = cleaned.rpartition(".")
|
||||
if not dot:
|
||||
if not dot or not stem:
|
||||
stem, ext = cleaned, ""
|
||||
else:
|
||||
ext = f".{ext}"
|
||||
@@ -140,36 +418,3 @@ def _unique_filename(name: str, used: set[str]) -> str:
|
||||
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()
|
||||
+5
-1
@@ -1028,14 +1028,18 @@ def create_file(conn, actor: UUID, scope_id: UUID, title: str, filename: str, da
|
||||
content_type = sniff(data)
|
||||
target, rights_context = _placement(context, placement)
|
||||
require_container_edit(conn, actor, target, rights_context)
|
||||
element = _new_element(conn, actor, scope_id, title, "file")
|
||||
asset_id = uuid4()
|
||||
content_revision = str(uuid4())
|
||||
instance = instance_for_write(conn, media_root)
|
||||
object_key = str(asset_id)
|
||||
adapter = adapter_for(instance)
|
||||
from app.sourceaccess import release_for_external
|
||||
|
||||
release_for_external(conn)
|
||||
publish(adapter, object_key, data)
|
||||
rollback_files.append(StoredHandle(adapter, object_key))
|
||||
require_container_edit(conn, actor, target, rights_context)
|
||||
element = _new_element(conn, actor, scope_id, title, "file")
|
||||
digest = sha256(data)
|
||||
conn.execute(
|
||||
"""
|
||||
|
||||
+326
-57
@@ -21,7 +21,17 @@ from psycopg.types.json import Json
|
||||
from app.access.policy import Ctx
|
||||
from app.core.errors import Problem, not_found, unprocessable
|
||||
from app.core.settings import get_settings
|
||||
from app.mailpack import MailIdentityError, choose_message, identities_match, header_message_id
|
||||
from app.mailpack import (
|
||||
MailIdentityError,
|
||||
choose_message,
|
||||
decode_transfer,
|
||||
header_message_id,
|
||||
header_text,
|
||||
identities_match,
|
||||
parse_mail,
|
||||
sanitize_html,
|
||||
simplified_text,
|
||||
)
|
||||
from app.media.storage import sniff
|
||||
from app.sourcebind import resolve_for_read
|
||||
from app.sourceaccess import (
|
||||
@@ -291,12 +301,18 @@ def imap_preview(conn, owner_id: UUID, connector_id: UUID, mailbox: str, uid: in
|
||||
_check_mailbox(mailbox)
|
||||
if uid < 1:
|
||||
raise unprocessable("Die Nachricht ist ungültig.")
|
||||
client = _imap_login(row["settings"], row["secret"])
|
||||
settings = dict(row["settings"])
|
||||
secret = row["secret"]
|
||||
connector_id = row["id"]
|
||||
release_for_external(conn)
|
||||
client = _imap_login(settings, secret)
|
||||
try:
|
||||
_select_mailbox(client, mailbox)
|
||||
return _fetch_message(client, uid, mailbox)
|
||||
preview = _fetch_message(client, uid, mailbox)
|
||||
finally:
|
||||
_imap_logout(client)
|
||||
assert_still_owned(conn, connector_id, owner_id)
|
||||
return preview
|
||||
|
||||
|
||||
def _owned(conn, owner_id: UUID, connector_id: UUID) -> dict:
|
||||
@@ -402,7 +418,7 @@ def read_linked_mail(conn, actor_id: UUID, element: dict, context: Ctx | None, r
|
||||
borrowed = borrow_original(conn, actor_id, element, context, ref, "imap")
|
||||
|
||||
def fetch(row):
|
||||
return load_imap_original(conn, borrowed.owner_id, row["id"], mailbox, uid, external_id)
|
||||
return pull_rfc822(row["settings"], row["secret"], mailbox, uid, external_id, COMPLETE_MAIL_LIMIT)
|
||||
|
||||
return complete_borrow(conn, borrowed, fetch)
|
||||
|
||||
@@ -726,16 +742,10 @@ def _imap_page(client: imaplib.IMAP4, mailbox: str, query: str, before: int | No
|
||||
match = next((item for item in folders if item["name"] == chosen), None)
|
||||
if match is None or not match["selectable"]:
|
||||
raise unprocessable("Dieses Fach gibt es in dem Konto nicht.")
|
||||
try:
|
||||
status, _ = client.select(chosen, readonly=True)
|
||||
except imaplib.IMAP4.abort as exc:
|
||||
raise unprocessable("Die Verbindung zum Postfach ist abgebrochen.") from exc
|
||||
except TimeoutError as exc:
|
||||
raise unprocessable("Das Postfach hat nicht rechtzeitig geantwortet.") from exc
|
||||
except imaplib.IMAP4.error as exc:
|
||||
raise unprocessable("Dieses Fach lässt sich nicht öffnen.") from exc
|
||||
status, _data = _examine(client, chosen)
|
||||
if status != "OK":
|
||||
raise unprocessable("Dieses Fach lässt sich nicht öffnen.")
|
||||
exists = _untagged_int(client, "EXISTS")
|
||||
validity = _untagged_int(client, "UIDVALIDITY")
|
||||
restarted = False
|
||||
if claimed_validity is not None and validity is not None and int(claimed_validity) != validity:
|
||||
@@ -774,6 +784,8 @@ def _imap_page(client: imaplib.IMAP4, mailbox: str, query: str, before: int | No
|
||||
next_before = low
|
||||
else:
|
||||
next_before = None
|
||||
query_text = " ".join(query.split())
|
||||
contradictory = bool(exists and exists > 0 and not collected and not query_text and not incomplete)
|
||||
return {
|
||||
"mailbox": chosen,
|
||||
"items": collected,
|
||||
@@ -781,6 +793,8 @@ def _imap_page(client: imaplib.IMAP4, mailbox: str, query: str, before: int | No
|
||||
"incomplete": incomplete,
|
||||
"restarted": restarted,
|
||||
"uidvalidity": validity,
|
||||
"exists": exists,
|
||||
"contradictory": contradictory,
|
||||
}
|
||||
|
||||
|
||||
@@ -789,15 +803,34 @@ def _check_mailbox(mailbox: str) -> None:
|
||||
raise unprocessable("Der Fachname ist ungültig.")
|
||||
|
||||
|
||||
def _mailbox_argument(mailbox: str) -> str:
|
||||
"""IMAP atoms stay bare. Everything else is a quoted protocol string."""
|
||||
_check_mailbox(mailbox)
|
||||
protocol = _encode_utf7(mailbox) if any(ord(char) > 127 for char in mailbox) else mailbox
|
||||
if re.fullmatch(r"[A-Za-z0-9!#$%&'*+\-/=?^_`{|}~.]+", protocol):
|
||||
return protocol
|
||||
escaped = protocol.replace("\\", "\\\\").replace('"', '\\"')
|
||||
return f'"{escaped}"'
|
||||
|
||||
|
||||
def _examine(client: imaplib.IMAP4, mailbox: str):
|
||||
argument = _mailbox_argument(mailbox)
|
||||
try:
|
||||
return client.select(argument, readonly=True)
|
||||
except imaplib.IMAP4.abort as exc:
|
||||
raise unprocessable("Die Verbindung zum Postfach ist abgebrochen.") from exc
|
||||
except TimeoutError as exc:
|
||||
raise unprocessable("Das Postfach hat nicht rechtzeitig geantwortet.") from exc
|
||||
except imaplib.IMAP4.error as exc:
|
||||
raise unprocessable("Dieses Fach lässt sich nicht öffnen.") from exc
|
||||
|
||||
|
||||
def _select_mailbox(client: imaplib.IMAP4, mailbox: str) -> None:
|
||||
folders = _imap_mailboxes(client)
|
||||
match = next((item for item in folders if item["name"] == mailbox), None)
|
||||
if match is None or not match["selectable"]:
|
||||
raise unprocessable("Dieses Fach gibt es in dem Konto nicht.")
|
||||
try:
|
||||
status, _ = client.select(mailbox, readonly=True)
|
||||
except imaplib.IMAP4.error as exc:
|
||||
raise unprocessable("Dieses Fach lässt sich nicht öffnen.") from exc
|
||||
status, _data = _examine(client, mailbox)
|
||||
if status != "OK":
|
||||
raise unprocessable("Dieses Fach lässt sich nicht öffnen.")
|
||||
|
||||
@@ -837,6 +870,10 @@ def _fetch_header(client: imaplib.IMAP4, uid: int, mailbox: str) -> dict | None:
|
||||
}
|
||||
|
||||
|
||||
PREVIEW_BYTE_LIMIT = 8_000_000
|
||||
PREVIEW_TEXT_LIMIT = 200_000
|
||||
|
||||
|
||||
def _fetch_message(client: imaplib.IMAP4, uid: int, mailbox: str) -> dict:
|
||||
try:
|
||||
status, fetched = client.uid("FETCH", str(uid), "(BODY.PEEK[])")
|
||||
@@ -845,22 +882,36 @@ def _fetch_message(client: imaplib.IMAP4, uid: int, mailbox: str) -> dict:
|
||||
raw = _literal(fetched)
|
||||
if status != "OK" or raw is None:
|
||||
raise unprocessable("Die Nachricht lässt sich nicht lesen.")
|
||||
if len(raw) > 8_000_000:
|
||||
if len(raw) > PREVIEW_BYTE_LIMIT:
|
||||
return _oversized_message(client, uid, mailbox)
|
||||
message = BytesParser().parsebytes(raw)
|
||||
subject = _decode(message.get("Subject")) or "(ohne Betreff)"
|
||||
parsed = parse_mail(raw)
|
||||
return _preview_from_mail(uid, mailbox, parsed, limited=parsed.text_truncated)
|
||||
|
||||
|
||||
def _preview_from_mail(uid: int, mailbox: str, parsed, limited: bool) -> dict:
|
||||
text = parsed.text[:PREVIEW_TEXT_LIMIT]
|
||||
return {
|
||||
"uid": uid,
|
||||
"mailbox": mailbox,
|
||||
"title": subject[:200],
|
||||
"message_from": _decode(message.get("From"))[:200],
|
||||
"message_to": _decode(message.get("To"))[:500],
|
||||
"message_cc": _decode(message.get("Cc"))[:500],
|
||||
"title": (parsed.subject or "(ohne Betreff)")[:200],
|
||||
"message_from": parsed.sender[:200],
|
||||
"message_to": parsed.recipient[:500],
|
||||
"message_cc": parsed.copy[:500],
|
||||
"direction": _direction(mailbox),
|
||||
"document_on": _mail_date(message.get("Date")),
|
||||
"attachments": _message_attachments(message),
|
||||
"text": (_text := _message_text(message))[:200_000],
|
||||
"text_truncated": len(_text) > 200_000,
|
||||
"document_on": parsed.document_on,
|
||||
"attachments": [
|
||||
{
|
||||
"filename": item.display_name or item.filename,
|
||||
"archive_name": item.filename,
|
||||
"content_type": item.media_type,
|
||||
}
|
||||
for item in parsed.attachments[:40]
|
||||
],
|
||||
"text": text,
|
||||
"html": parsed.html,
|
||||
"text_truncated": limited or len(parsed.text) > PREVIEW_TEXT_LIMIT,
|
||||
"preview_limited": limited,
|
||||
"notices": parsed.notices,
|
||||
}
|
||||
|
||||
|
||||
@@ -887,10 +938,37 @@ def _direction(mailbox: str) -> str | None:
|
||||
|
||||
|
||||
def _oversized_message(client: imaplib.IMAP4, uid: int, mailbox: str) -> dict:
|
||||
"""Read named text parts. A cut-off multipart blob is not a message."""
|
||||
header = _fetch_header(client, uid, mailbox) or {}
|
||||
text = _partial_text(client, uid)
|
||||
if not header and not text:
|
||||
structure = _body_structure(client, uid)
|
||||
plain: list[str] = []
|
||||
html_parts: list[str] = []
|
||||
truncated = False
|
||||
notices = [
|
||||
"Die Vorschau ist begrenzt, weil die Nachricht sehr groß ist. "
|
||||
"Das Original bleibt die vollständige E-Mail."
|
||||
]
|
||||
if structure is None:
|
||||
notices.append("Die MIME-Struktur ließ sich nicht lesen. Rohfragmente werden nicht als Text gezeigt.")
|
||||
else:
|
||||
for part in _text_sections(structure):
|
||||
fetched, shortened = _fetch_section(client, uid, part["section"], PREVIEW_TEXT_LIMIT)
|
||||
if fetched is None:
|
||||
notices.append("Ein Textteil der großen Nachricht ließ sich nicht lesen.")
|
||||
continue
|
||||
truncated = truncated or shortened or part["octets"] > len(fetched)
|
||||
text = decode_transfer(fetched, part["charset"]).strip()
|
||||
if part["media"] == "text/plain":
|
||||
plain.append(text)
|
||||
else:
|
||||
html_parts.append(text)
|
||||
simplified = "\n".join(chunk for chunk in plain if chunk).strip()
|
||||
rendered = sanitize_html("\n".join(html_parts)) if html_parts else ""
|
||||
if not simplified and html_parts:
|
||||
simplified = simplified_text("\n".join(html_parts))
|
||||
if not header and not simplified and not rendered and structure is None:
|
||||
raise unprocessable("Die Nachricht lässt sich nicht lesen.")
|
||||
attachments = header.get("attachments") or (_structure_names(structure) if structure is not None else [])
|
||||
return {
|
||||
"uid": uid,
|
||||
"mailbox": mailbox,
|
||||
@@ -900,31 +978,185 @@ def _oversized_message(client: imaplib.IMAP4, uid: int, mailbox: str) -> dict:
|
||||
"message_cc": header.get("message_cc") or "",
|
||||
"direction": header.get("direction", _direction(mailbox)),
|
||||
"document_on": header.get("document_on"),
|
||||
"attachments": header.get("attachments") or [],
|
||||
"text": text,
|
||||
"text_truncated": True,
|
||||
"attachments": attachments,
|
||||
"text": simplified[:PREVIEW_TEXT_LIMIT],
|
||||
"html": rendered,
|
||||
"text_truncated": True or truncated,
|
||||
"preview_limited": True,
|
||||
"notices": notices,
|
||||
}
|
||||
|
||||
|
||||
def _partial_text(client: imaplib.IMAP4, uid: int) -> str:
|
||||
def _body_structure(client: imaplib.IMAP4, uid: int):
|
||||
try:
|
||||
status, fetched = client.uid("FETCH", str(uid), "(BODY.PEEK[TEXT]<0.200000>)")
|
||||
status, fetched = client.uid("FETCH", str(uid), "(BODYSTRUCTURE)")
|
||||
except imaplib.IMAP4.error:
|
||||
return ""
|
||||
return None
|
||||
if status != "OK":
|
||||
return ""
|
||||
return None
|
||||
blob = _literal(fetched)
|
||||
if blob is None:
|
||||
chunks: list[bytes] = []
|
||||
for part in fetched or []:
|
||||
if isinstance(part, tuple):
|
||||
chunks.extend(bytes(item) for item in part if isinstance(item, (bytes, bytearray)))
|
||||
elif isinstance(part, (bytes, bytearray)):
|
||||
chunks.append(bytes(part))
|
||||
blob = b" ".join(chunks)
|
||||
text = blob.decode("utf-8", "replace")
|
||||
start = text.find("(")
|
||||
if start < 0:
|
||||
return None
|
||||
try:
|
||||
node, _end = _parse_imap_list(text, start)
|
||||
except ValueError:
|
||||
return None
|
||||
return node
|
||||
|
||||
|
||||
def _parse_imap_list(text: str, index: int):
|
||||
if index >= len(text) or text[index] != "(":
|
||||
raise ValueError(text[index:index + 20])
|
||||
index += 1
|
||||
items = []
|
||||
while index < len(text):
|
||||
char = text[index]
|
||||
if char == ")":
|
||||
return items, index + 1
|
||||
if char in " \t\r\n":
|
||||
index += 1
|
||||
continue
|
||||
if char == "(":
|
||||
child, index = _parse_imap_list(text, index)
|
||||
items.append(child)
|
||||
continue
|
||||
if char == '"':
|
||||
token, index = _parse_imap_string(text, index)
|
||||
items.append(token)
|
||||
continue
|
||||
end = index
|
||||
while end < len(text) and text[end] not in " \t\r\n()":
|
||||
end += 1
|
||||
token = text[index:end]
|
||||
items.append(None if token.upper() == "NIL" else token)
|
||||
index = end
|
||||
raise ValueError("unclosed")
|
||||
|
||||
|
||||
def _parse_imap_string(text: str, index: int):
|
||||
index += 1
|
||||
chars: list[str] = []
|
||||
while index < len(text):
|
||||
char = text[index]
|
||||
if char == "\\":
|
||||
if index + 1 < len(text):
|
||||
chars.append(text[index + 1])
|
||||
index += 2
|
||||
continue
|
||||
if char == '"':
|
||||
return "".join(chars), index + 1
|
||||
chars.append(char)
|
||||
index += 1
|
||||
raise ValueError("string")
|
||||
|
||||
|
||||
def _text_sections(node, prefix: str = "") -> list[dict]:
|
||||
if not isinstance(node, list) or not node:
|
||||
return []
|
||||
if isinstance(node[0], list):
|
||||
children = []
|
||||
for item in node:
|
||||
if isinstance(item, list):
|
||||
children.append(item)
|
||||
else:
|
||||
break
|
||||
found = []
|
||||
for number, child in enumerate(children, start=1):
|
||||
section = f"{number}" if not prefix else f"{prefix}.{number}"
|
||||
found.extend(_text_sections(child, section))
|
||||
return found
|
||||
media = str(node[0] or "").upper()
|
||||
subtype = str(node[1] or "").upper()
|
||||
if media == "MESSAGE":
|
||||
return []
|
||||
if media != "TEXT" or subtype not in {"PLAIN", "HTML"}:
|
||||
return []
|
||||
disposition, params = _disposition(node)
|
||||
if disposition == "ATTACHMENT":
|
||||
return []
|
||||
body_params = _param_map(node[2]) if len(node) > 2 else {}
|
||||
octets = _imap_int(node[6]) if len(node) > 6 else 0
|
||||
return [{
|
||||
"section": prefix or "1",
|
||||
"media": f"text/{subtype.lower()}",
|
||||
"charset": body_params.get("charset") or "utf-8",
|
||||
"octets": octets,
|
||||
}]
|
||||
|
||||
|
||||
def _disposition(node: list) -> tuple[str, dict]:
|
||||
for item in node:
|
||||
if isinstance(item, list) and item and isinstance(item[0], str) and item[0].upper() in {"ATTACHMENT", "INLINE"}:
|
||||
params = _param_map(item[1]) if len(item) > 1 else {}
|
||||
return item[0].upper(), params
|
||||
return "", {}
|
||||
|
||||
|
||||
def _param_map(value) -> dict:
|
||||
if not isinstance(value, list):
|
||||
return {}
|
||||
pairs = {}
|
||||
index = 0
|
||||
while index + 1 < len(value):
|
||||
key = value[index]
|
||||
raw = value[index + 1]
|
||||
if isinstance(key, str):
|
||||
pairs[key.casefold()] = "" if raw is None else str(raw)
|
||||
index += 2
|
||||
return pairs
|
||||
|
||||
|
||||
def _imap_int(value) -> int:
|
||||
try:
|
||||
return int(value)
|
||||
except (TypeError, ValueError):
|
||||
return 0
|
||||
|
||||
|
||||
def _fetch_section(client: imaplib.IMAP4, uid: int, section: str, limit: int) -> tuple[bytes | None, bool]:
|
||||
spec = f"(BODY.PEEK[{section}]<0.{limit}>)"
|
||||
try:
|
||||
status, fetched = client.uid("FETCH", str(uid), spec)
|
||||
except imaplib.IMAP4.error:
|
||||
return None, False
|
||||
if status != "OK":
|
||||
return None, False
|
||||
raw = _literal(fetched)
|
||||
if not raw:
|
||||
return ""
|
||||
sample = raw[:200_000]
|
||||
try:
|
||||
message = BytesParser().parsebytes(b"Subject: x\r\n\r\n" + sample)
|
||||
text = _message_text(message)
|
||||
except Exception:
|
||||
text = ""
|
||||
if not text:
|
||||
text = sample.decode("utf-8", errors="replace")
|
||||
return text.strip()[:200_000]
|
||||
return None, False
|
||||
return raw[:limit], len(raw) >= limit
|
||||
|
||||
|
||||
def _structure_names(node) -> list[dict]:
|
||||
names = []
|
||||
|
||||
def visit(item):
|
||||
if not isinstance(item, list) or not item:
|
||||
return
|
||||
if isinstance(item[0], list):
|
||||
for child in item:
|
||||
if isinstance(child, list):
|
||||
visit(child)
|
||||
return
|
||||
_disposition_name, params = _disposition(item)
|
||||
body = _param_map(item[2]) if len(item) > 2 else {}
|
||||
raw = params.get("filename") or body.get("name") or ""
|
||||
label = header_text(raw)
|
||||
if label:
|
||||
names.append({"filename": label[:200]})
|
||||
|
||||
visit(node)
|
||||
return names[:40]
|
||||
|
||||
|
||||
def _literal(fetched) -> bytes | None:
|
||||
@@ -944,12 +1176,10 @@ def _structure_attachments(fetched) -> list[dict]:
|
||||
blob = b" ".join(chunks)
|
||||
names = re.findall(br'FILENAME"\s+"([^"\r\n]+)"', blob, flags=re.IGNORECASE)
|
||||
items = []
|
||||
seen: set[str] = set()
|
||||
for raw in names:
|
||||
name = raw.decode("utf-8", errors="replace").strip()[:200]
|
||||
if not name or name in seen:
|
||||
name = header_text(raw.decode("utf-8", errors="replace")).strip()[:200]
|
||||
if not name:
|
||||
continue
|
||||
seen.add(name)
|
||||
items.append({"filename": name})
|
||||
if len(items) == 40:
|
||||
break
|
||||
@@ -1039,6 +1269,32 @@ def _unquote(token: str) -> str:
|
||||
return token
|
||||
|
||||
|
||||
def _encode_utf7(value: str) -> str:
|
||||
"""Modified UTF-7 for a mailbox that is not already an ASCII protocol name."""
|
||||
pieces: list[str] = []
|
||||
pending: list[str] = []
|
||||
|
||||
def flush() -> None:
|
||||
if not pending:
|
||||
return
|
||||
raw = "".join(pending).encode("utf-16-be")
|
||||
token = base64.b64encode(raw).decode("ascii").rstrip("=").replace("/", ",")
|
||||
pieces.append(f"&{token}-")
|
||||
pending.clear()
|
||||
|
||||
for char in value:
|
||||
if char == "&":
|
||||
flush()
|
||||
pieces.append("&-")
|
||||
elif ord(char) < 128:
|
||||
flush()
|
||||
pieces.append(char)
|
||||
else:
|
||||
pending.append(char)
|
||||
flush()
|
||||
return "".join(pieces)
|
||||
|
||||
|
||||
def _decode_utf7(value: str) -> str:
|
||||
if "&" not in value:
|
||||
return value
|
||||
@@ -1255,13 +1511,17 @@ def _export_paperless(conn, actor_id: UUID, external_id: str, detail: dict, assi
|
||||
resolved = resolve_for_read(conn, actor_id, "paperless", ref, assigned)
|
||||
if resolved.row is None:
|
||||
return RetrievalFailure(resolved.code, resolved.message, resolved.choices)
|
||||
base = resolved.row["settings"]["base_url"].rstrip("/")
|
||||
token = resolved.row["secret"]
|
||||
connector_id = resolved.row["id"]
|
||||
owner_id = resolved.row["owner_id"]
|
||||
release_for_external(conn)
|
||||
try:
|
||||
data, media, name = pull_paperless_original(
|
||||
resolved.row["settings"]["base_url"].rstrip("/"),
|
||||
resolved.row["secret"],
|
||||
str(external_id),
|
||||
EXPORT_BYTE_LIMIT,
|
||||
)
|
||||
data, media, name = pull_paperless_original(base, token, str(external_id), EXPORT_BYTE_LIMIT)
|
||||
except Problem as exc:
|
||||
return failure_from_problem(exc)
|
||||
try:
|
||||
assert_still_owned(conn, connector_id, owner_id)
|
||||
except Problem as exc:
|
||||
return failure_from_problem(exc)
|
||||
if len(data) > EXPORT_BYTE_LIMIT:
|
||||
@@ -1282,8 +1542,17 @@ def _export_imap(conn, actor_id: UUID, external_id: str, detail: dict, assigned:
|
||||
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.")
|
||||
settings = dict(resolved.row["settings"])
|
||||
secret = resolved.row["secret"]
|
||||
connector_id = resolved.row["id"]
|
||||
owner_id = resolved.row["owner_id"]
|
||||
release_for_external(conn)
|
||||
try:
|
||||
raw = pull_rfc822(resolved.row["settings"], resolved.row["secret"], mailbox, uid, str(external_id), EXPORT_BYTE_LIMIT)
|
||||
raw = pull_rfc822(settings, secret, mailbox, uid, str(external_id), EXPORT_BYTE_LIMIT)
|
||||
except Problem as exc:
|
||||
return failure_from_problem(exc)
|
||||
try:
|
||||
assert_still_owned(conn, connector_id, owner_id)
|
||||
except Problem as exc:
|
||||
return failure_from_problem(exc)
|
||||
if len(raw) > EXPORT_BYTE_LIMIT:
|
||||
|
||||
@@ -0,0 +1,469 @@
|
||||
"""Corrections K1–K3 and K7. Synthetic only; no live mailbox or Paperless."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import imaplib
|
||||
|
||||
import psycopg
|
||||
import pytest
|
||||
from email.message import EmailMessage
|
||||
|
||||
import app.sources as sources
|
||||
from app.core.errors import unprocessable
|
||||
from app.mailpack import parse_mail
|
||||
from tests.support import Actor, register
|
||||
|
||||
|
||||
def test_mailbox_names_are_quoted_protocol_strings():
|
||||
client = imaplib.IMAP4.__new__(imaplib.IMAP4)
|
||||
client.sent = []
|
||||
client.state = "AUTH"
|
||||
client._encoding = "ascii"
|
||||
client.tagpre = b"T"
|
||||
client.tagnum = 1
|
||||
client.tagged_commands = {}
|
||||
client.untagged_responses = {}
|
||||
client.is_readonly = True
|
||||
client.literal = None
|
||||
client.debug = 0
|
||||
client._mesg = lambda *args: None
|
||||
client._log = lambda *args: None
|
||||
client.send = lambda data: client.sent.append(data)
|
||||
|
||||
value = "Sent Items"
|
||||
client._command("EXAMINE", sources._mailbox_argument(value))
|
||||
assert client.sent[-1] == b'T1 EXAMINE "Sent Items"\r\n'
|
||||
value = 'Ordner "A"\\B'
|
||||
client._command("EXAMINE", sources._mailbox_argument(value))
|
||||
assert client.sent[-1] == b'T2 EXAMINE "Ordner \\"A\\"\\\\B"\r\n'
|
||||
assert sources._mailbox_argument("INBOX") == "INBOX"
|
||||
with pytest.raises(Exception):
|
||||
sources._mailbox_argument("Sent\nItems")
|
||||
|
||||
|
||||
def test_parse_mail_keeps_names_html_and_attached_messages():
|
||||
inner = EmailMessage()
|
||||
inner["Subject"] = "Innen"
|
||||
inner.set_content("innen bleibt drin")
|
||||
inner.add_attachment(b"innen-pdf", maintype="application", subtype="pdf", filename="innen.pdf")
|
||||
outer = EmailMessage()
|
||||
outer["From"] = "Ada <ada@example.test>"
|
||||
outer["To"] = "Ben <ben@example.test>"
|
||||
outer["Subject"] = "=?utf-8?q?Aussen?="
|
||||
outer.set_content("aussen bleibt aussen")
|
||||
outer.add_attachment(b"%PDF-same", maintype="application", subtype="pdf", filename="lage.pdf")
|
||||
outer.add_attachment(b"%PDF-other", maintype="application", subtype="pdf", filename="lage.pdf")
|
||||
outer.add_attachment(inner, subtype="rfc822", filename="weitergeleitet.eml")
|
||||
html = (
|
||||
"<p>A & B</p><table><tr><td>Zelle</td><td>Zwei</td></tr></table>"
|
||||
"<script>alert(1)</script><img src=\"https://evil.test/a.png\">"
|
||||
"<a href=\"javascript:alert(1)\">x</a><img src=\"cid:logo@x\">"
|
||||
)
|
||||
mixed = EmailMessage()
|
||||
mixed["Subject"] = "HTML"
|
||||
mixed.set_content("nur text")
|
||||
mixed.add_alternative(html, subtype="html")
|
||||
logo = b"\x89PNG\r\n"
|
||||
mixed.add_attachment(logo, maintype="image", subtype="png", filename="logo.png", cid="<logo@x>")
|
||||
encoded = EmailMessage()
|
||||
encoded["Subject"] = "Namen"
|
||||
encoded.set_content("datei")
|
||||
encoded.add_attachment(
|
||||
b"pdf",
|
||||
maintype="application",
|
||||
subtype="pdf",
|
||||
filename="=?utf-8?q?Buero_Uebergabe=2Epdf?=",
|
||||
)
|
||||
|
||||
parsed = parse_mail(outer.as_bytes())
|
||||
assert parsed.subject == "Aussen"
|
||||
assert parsed.text == "aussen bleibt aussen"
|
||||
assert "innen" not in parsed.text
|
||||
names = [item.display_name for item in parsed.attachments]
|
||||
assert "weitergeleitet.eml" in names
|
||||
assert names.count("lage.pdf") == 2
|
||||
archives = [item.filename for item in parsed.attachments]
|
||||
assert len(set(archives)) == len(archives)
|
||||
attached = next(item for item in parsed.attachments if item.display_name == "weitergeleitet.eml")
|
||||
assert b"innen bleibt drin" in attached.data or b"Innen" in attached.data
|
||||
assert attached.sha256 == hashlib.sha256(attached.data).hexdigest()
|
||||
|
||||
view = parse_mail(mixed.as_bytes())
|
||||
assert "<table>" in view.html
|
||||
assert "<script" not in view.html
|
||||
assert "https://evil.test" not in view.html
|
||||
assert "javascript:" not in view.html
|
||||
assert "data:image/png;base64," in view.html
|
||||
assert "A & B" in view.html or "A & B" in view.html
|
||||
assert "Zelle" in view.html
|
||||
|
||||
named = parse_mail(encoded.as_bytes())
|
||||
assert named.attachments[0].display_name == "Buero Uebergabe.pdf"
|
||||
assert "=?utf-8?" not in named.attachments[0].display_name
|
||||
assert named.attachments[0].data == b"pdf"
|
||||
|
||||
|
||||
class QuotedIMAP:
|
||||
def __init__(self, *args, **kwargs):
|
||||
self.untagged_responses = {}
|
||||
|
||||
def login(self, username, secret):
|
||||
return "OK", [b"logged"]
|
||||
|
||||
def list(self):
|
||||
return "OK", [b'(\\HasNoChildren) "/" "Sent Items"']
|
||||
|
||||
def select(self, mailbox, readonly=False):
|
||||
assert readonly is True
|
||||
assert mailbox == '"Sent Items"'
|
||||
self.untagged_responses = {
|
||||
"EXISTS": [b"4200"],
|
||||
"UIDVALIDITY": [b"8"],
|
||||
"UIDNEXT": [b"2"],
|
||||
}
|
||||
return "OK", [b"4200"]
|
||||
|
||||
def uid(self, command, *args):
|
||||
if command == "SEARCH":
|
||||
return "OK", [b""]
|
||||
header = b"From: Ada <ada@example.test>\r\nSubject: Leer\r\nDate: Thu, 02 May 2024 08:00:00 +0000\r\n"
|
||||
return "OK", [(b"body", header), b")"]
|
||||
|
||||
def logout(self):
|
||||
return "BYE", [b""]
|
||||
|
||||
|
||||
def test_a_filled_folder_with_spaces_is_not_reported_empty(client, db, monkeypatch):
|
||||
monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", QuotedIMAP)
|
||||
ada = Actor(client, "ada-sent@example.test", "Ada Gesendet")
|
||||
register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
account = ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={
|
||||
"kind": "imap",
|
||||
"name": "Post",
|
||||
"host": "imap.example.test",
|
||||
"port": 993,
|
||||
"username": "ada@example.test",
|
||||
"password": "Postfach-Geheim",
|
||||
"security": "ssl",
|
||||
},
|
||||
status=201,
|
||||
)
|
||||
page = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/imap/messages",
|
||||
params={"connector_id": account["id"], "mailbox": "Sent Items"},
|
||||
)
|
||||
assert page["items"] == []
|
||||
assert page["contradictory"] is True
|
||||
assert page["exists"] == 4200
|
||||
assert "leer" not in str(page).casefold()
|
||||
|
||||
|
||||
def _multipart(text: str, name: str, payload: bytes) -> bytes:
|
||||
message = EmailMessage()
|
||||
message["From"] = "Ada <ada@example.test>"
|
||||
message["To"] = "Ben <ben@example.test>"
|
||||
message["Subject"] = "Grenze"
|
||||
message["Message-ID"] = "<grenze@example.test>"
|
||||
message.set_content(text)
|
||||
message.add_attachment(payload, maintype="application", subtype="pdf", filename=name)
|
||||
return message.as_bytes()
|
||||
|
||||
|
||||
class LimitIMAP:
|
||||
raw = b""
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
self.untagged_responses = {}
|
||||
|
||||
def login(self, username, secret):
|
||||
return "OK", [b"ok"]
|
||||
|
||||
def list(self):
|
||||
return "OK", [b'(\\HasNoChildren) "/" "INBOX"']
|
||||
|
||||
def select(self, mailbox, readonly=False):
|
||||
self.untagged_responses = {"UIDVALIDITY": [b"1"], "UIDNEXT": [b"3"], "EXISTS": [b"1"]}
|
||||
return "OK", [b"1"]
|
||||
|
||||
def uid(self, command, *args):
|
||||
spec = " ".join(str(part) for part in args[1:])
|
||||
if "BODY.PEEK[]" in spec and "<" not in spec:
|
||||
return "OK", [(b"rfc822", type(self).raw)]
|
||||
if "BODYSTRUCTURE" in spec:
|
||||
structure = (
|
||||
b'(("TEXT" "PLAIN" ("CHARSET" "utf-8") NIL NIL "7BIT" 12 1 NIL NIL NIL NIL)'
|
||||
b'("APPLICATION" "PDF" NIL NIL NIL "BASE64" 20 NIL '
|
||||
b'("ATTACHMENT" ("FILENAME" "=?utf-8?q?Buero_Uebergabe=2Epdf?=")) NIL NIL)'
|
||||
b' "MIXED" ("BOUNDARY" "b") NIL NIL NIL)'
|
||||
)
|
||||
return "OK", [(b"body", structure)]
|
||||
if "BODY.PEEK[1]" in spec:
|
||||
return "OK", [(b"part", b"gleicher text")]
|
||||
if "BODY.PEEK[2]" in spec:
|
||||
return "OK", [(b"part", b"nicht text")]
|
||||
header = (
|
||||
b"From: Ada <ada@example.test>\r\nTo: Ben <ben@example.test>\r\n"
|
||||
b"Subject: Grenze\r\nDate: Thu, 02 May 2024 08:00:00 +0000\r\n"
|
||||
)
|
||||
return "OK", [(b"body", header), b")"]
|
||||
|
||||
def logout(self):
|
||||
return "BYE", [b""]
|
||||
|
||||
|
||||
def test_preview_below_and_above_the_limit_uses_the_same_parts(client, db, monkeypatch):
|
||||
payload = b"%PDF-plan"
|
||||
small = _multipart("gleicher text", "Buero Uebergabe.pdf", payload)
|
||||
LimitIMAP.raw = small + b"X" * 50
|
||||
monkeypatch.setattr(sources, "PREVIEW_BYTE_LIMIT", len(small))
|
||||
monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", LimitIMAP)
|
||||
ada = Actor(client, "ada-limit@example.test", "Ada Grenze")
|
||||
register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
account = ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={
|
||||
"kind": "imap",
|
||||
"name": "Post",
|
||||
"host": "imap.example.test",
|
||||
"port": 993,
|
||||
"username": "ada@example.test",
|
||||
"password": "Postfach-Geheim",
|
||||
"security": "ssl",
|
||||
},
|
||||
status=201,
|
||||
)
|
||||
under = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/imap/message",
|
||||
params={"connector_id": account["id"], "mailbox": "INBOX", "uid": 1},
|
||||
)
|
||||
LimitIMAP.raw = small + b"Y"
|
||||
over = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/imap/message",
|
||||
params={"connector_id": account["id"], "mailbox": "INBOX", "uid": 1},
|
||||
)
|
||||
assert "gleicher text" in under["text"]
|
||||
assert "gleicher text" in over["text"]
|
||||
assert under["attachments"][0]["filename"] == "Buero Uebergabe.pdf"
|
||||
assert over["attachments"][0]["filename"] == "Buero Uebergabe.pdf"
|
||||
assert "Content-Transfer-Encoding" not in over["text"]
|
||||
assert "BASE64" not in over["text"].upper()
|
||||
assert over["preview_limited"] is True
|
||||
|
||||
|
||||
def test_upload_and_mail_fetch_leave_the_domain_transaction(client, db, monkeypatch):
|
||||
seen = []
|
||||
|
||||
import app.api.routes as routes
|
||||
import app.ops as ops
|
||||
from app.media.port import publish as real_publish
|
||||
|
||||
def watching(adapter, key, data):
|
||||
seen.append(("publish", ops_conn[0].info.transaction_status))
|
||||
return real_publish(adapter, key, data)
|
||||
|
||||
ops_conn = [None]
|
||||
real_create = ops.create_file
|
||||
|
||||
def wrapped_create(conn, *args, **kwargs):
|
||||
ops_conn[0] = conn
|
||||
return real_create(conn, *args, **kwargs)
|
||||
|
||||
monkeypatch.setattr(ops, "publish", watching)
|
||||
monkeypatch.setattr(routes, "create_file", wrapped_create)
|
||||
ada = Actor(client, "ada-idle@example.test", "Ada Leerlauf")
|
||||
register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Ablage"}, status=201)
|
||||
ada.request(
|
||||
"POST",
|
||||
"/api/v1/files",
|
||||
data={"title": "Scan", "context_kind": "case", "context_id": case["id"]},
|
||||
files={"upload": ("scan.pdf", b"%PDF-1.4\n", "application/pdf")},
|
||||
status=201,
|
||||
)
|
||||
assert seen[0][1] == psycopg.pq.TransactionStatus.IDLE
|
||||
|
||||
import app.sourceaccess as sourceaccess
|
||||
|
||||
phase = {"external": False, "status": None}
|
||||
real_release = sourceaccess.release_for_external
|
||||
|
||||
def spy_release(conn):
|
||||
real_release(conn)
|
||||
phase["external"] = True
|
||||
phase["status"] = conn.info.transaction_status
|
||||
|
||||
def spy_owned(*args, **kwargs):
|
||||
if phase["external"]:
|
||||
raise AssertionError("Datenbankzugriff im externen Abschnitt")
|
||||
return real_owned(*args, **kwargs)
|
||||
|
||||
def spy_pull(*args, **kwargs):
|
||||
assert phase["status"] == psycopg.pq.TransactionStatus.IDLE
|
||||
return _multipart("brief", "a.pdf", b"%PDF")
|
||||
|
||||
real_owned = sources._owned
|
||||
monkeypatch.setattr(sourceaccess, "release_for_external", spy_release)
|
||||
monkeypatch.setattr(sources, "_owned", spy_owned)
|
||||
monkeypatch.setattr(sources, "pull_rfc822", spy_pull)
|
||||
monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", QuotedIMAP)
|
||||
account = ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={
|
||||
"kind": "imap",
|
||||
"name": "Post",
|
||||
"host": "imap.example.test",
|
||||
"port": 993,
|
||||
"username": "ada@example.test",
|
||||
"password": "Postfach-Geheim",
|
||||
"security": "ssl",
|
||||
},
|
||||
status=201,
|
||||
)
|
||||
matter = ada.request("POST", "/api/v1/matters", json={"title": "Post"}, status=201)
|
||||
linked = ada.request(
|
||||
"POST",
|
||||
"/api/v1/external-refs",
|
||||
json={
|
||||
"title": "Brief",
|
||||
"source": "imap",
|
||||
"external_id": "<grenze@example.test>",
|
||||
"context": {"kind": "matter", "id": matter["id"]},
|
||||
"detail": {"connector_id": account["id"], "mailbox": "Sent Items", "uid": 4},
|
||||
},
|
||||
status=201,
|
||||
)
|
||||
opened = ada.request("GET", f"/api/v1/external-refs/{linked['id']}/mail")
|
||||
assert opened["text"]
|
||||
assert phase["status"] == psycopg.pq.TransactionStatus.IDLE
|
||||
|
||||
|
||||
def test_failed_conclusion_keeps_no_partial_file(client, db, monkeypatch):
|
||||
import app.ops as ops
|
||||
|
||||
def fail(*args, **kwargs):
|
||||
raise unprocessable("Abschluss fehlgeschlagen")
|
||||
|
||||
monkeypatch.setattr(ops, "_new_element", fail)
|
||||
ada = Actor(client, "ada-fail@example.test", "Ada Abschluss")
|
||||
register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Ablage"}, status=201)
|
||||
ada.request(
|
||||
"POST",
|
||||
"/api/v1/files",
|
||||
data={"title": "Scan", "context_kind": "case", "context_id": case["id"]},
|
||||
files={"upload": ("scan.pdf", b"%PDF-FAIL-CONCLUSION\n", "application/pdf")},
|
||||
status=422,
|
||||
)
|
||||
stored = db.execute("SELECT count(*) AS n FROM elements WHERE title = 'Scan'").fetchone()
|
||||
assert stored["n"] == 0
|
||||
from pathlib import Path
|
||||
from app.core.settings import get_settings
|
||||
|
||||
root = Path(get_settings().media_root)
|
||||
left = [path for path in root.rglob("*") if path.is_file() and b"PDF-FAIL-CONCLUSION" in path.read_bytes()]
|
||||
assert left == []
|
||||
|
||||
|
||||
def test_paperless_filters_change_the_hits(client, db, monkeypatch):
|
||||
catalog = []
|
||||
for number in range(1, 46):
|
||||
catalog.append({
|
||||
"id": number,
|
||||
"title": "Vertrag" if number % 5 == 0 else f"Schrift {number}",
|
||||
"content": "nurinhalt" if number == 41 else f"text {number}",
|
||||
"correspondent": 4 if number % 2 == 0 else 9,
|
||||
"document_type": 8 if number < 30 else 1,
|
||||
"tags": [2, 5] if number % 3 == 0 else [2],
|
||||
"created": "2024-06-01" if number > 20 else "2023-01-01",
|
||||
})
|
||||
|
||||
def fake_get(base, token, path, params):
|
||||
if path != "/api/documents/":
|
||||
return {"count": 1, "results": [{"id": 4, "name": "Haus"}]}
|
||||
matched = []
|
||||
for item in catalog:
|
||||
query = params.get("query") or ""
|
||||
title = params.get("title__icontains") or ""
|
||||
if query and query.casefold() not in f"{item['title']} {item['content']}".casefold():
|
||||
continue
|
||||
if title and title.casefold() not in item["title"].casefold():
|
||||
continue
|
||||
if params.get("correspondent__id") and str(item["correspondent"]) != params["correspondent__id"]:
|
||||
continue
|
||||
if params.get("document_type__id") and str(item["document_type"]) != params["document_type__id"]:
|
||||
continue
|
||||
if params.get("tags__id__all"):
|
||||
needed = {int(part) for part in params["tags__id__all"].split(",") if part}
|
||||
if not needed.issubset(set(item["tags"])):
|
||||
continue
|
||||
start = params.get("created__date__gte")
|
||||
end = params.get("created__date__lte")
|
||||
if start and item["created"] < start:
|
||||
continue
|
||||
if end and item["created"] > end:
|
||||
continue
|
||||
matched.append(item)
|
||||
page = int(params.get("page") or 1)
|
||||
start_at = (page - 1) * 20
|
||||
rows = matched[start_at:start_at + 20]
|
||||
return {
|
||||
"count": len(matched),
|
||||
"results": [{"id": item["id"], "title": item["title"], "created": item["created"]} for item in rows],
|
||||
}
|
||||
|
||||
monkeypatch.setattr(sources, "_paperless_get", fake_get)
|
||||
ada = Actor(client, "ada-sense@example.test", "Ada Sinn")
|
||||
register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
account = ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={"kind": "paperless", "name": "Archiv", "base_url": "https://paper.example.test", "token": "token-alpha"},
|
||||
status=201,
|
||||
)
|
||||
content = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/paperless/documents",
|
||||
params={"connector_id": account["id"], "q": "nurinhalt"},
|
||||
)
|
||||
assert [item["id"] for item in content["items"]] == ["41"]
|
||||
title = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/paperless/documents",
|
||||
params={"connector_id": account["id"], "title": "Vertrag"},
|
||||
)
|
||||
assert title["items"]
|
||||
assert all("Vertrag" in item["title"] for item in title["items"])
|
||||
assert all(item["id"] != "41" for item in title["items"])
|
||||
combined = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/paperless/documents",
|
||||
params={
|
||||
"connector_id": account["id"],
|
||||
"correspondent": "4",
|
||||
"document_type": "8",
|
||||
"tag": "2,5",
|
||||
"document_from": "2023-01-01",
|
||||
"document_to": "2024-12-31",
|
||||
},
|
||||
)
|
||||
plain = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/paperless/documents",
|
||||
params={"connector_id": account["id"], "cursor": "2"},
|
||||
)
|
||||
assert [item["id"] for item in combined["items"]] == ["6", "12", "18", "24"]
|
||||
assert [item["id"] for item in plain["items"]][0] == "21"
|
||||
@@ -180,9 +180,12 @@ def test_foreign_mailbox_stays_hidden(client, db, monkeypatch):
|
||||
class HugeIMAP(FakeIMAP):
|
||||
def uid(self, command, *args):
|
||||
spec = " ".join(str(part) for part in args[1:]) if len(args) > 1 else ""
|
||||
if command == "FETCH" and "BODY.PEEK[]" in spec:
|
||||
if command == "FETCH" and "BODY.PEEK[]" in spec and "<" not in spec:
|
||||
return "OK", [(b"rfc822", b"x" * 8_000_001)]
|
||||
if "BODY.PEEK[TEXT]" in spec:
|
||||
if "BODYSTRUCTURE" in spec:
|
||||
structure = b'("TEXT" "PLAIN" ("CHARSET" "utf-8") NIL NIL "7BIT" 40 1 NIL NIL NIL NIL)'
|
||||
return "OK", [(b"body", structure)]
|
||||
if "BODY.PEEK[1]" in spec:
|
||||
return "OK", [(b"text", "Kurzer Auszug der grossen Nachricht.".encode())]
|
||||
return super().uid(command, *args)
|
||||
|
||||
|
||||
@@ -31,6 +31,9 @@
|
||||
| [TSUMUGU_CONNECTOR_ABSCHLUSSKRITERIEN_2026-10-19.md](product/TSUMUGU_CONNECTOR_ABSCHLUSSKRITERIEN_2026-10-19.md) | Abschlusskriterien der Kapselung; Vorrang vor einem teilweise integrierten Zwischenstand | 19.10.2026 |
|
||||
| [TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md](product/TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md) | Kriterium, Nachweis und Ergebnis der Kapselung | 19.10.2026 |
|
||||
| [TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md](product/TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md) | Nacharbeit: IMAP-Seiten, Paperless-Suche, Markdown-Notiz | 19.10.2026 |
|
||||
| [TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md](product/TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md) | Korrektur K1–K7: IMAP-Ordner, MIME, Transaktion, Markdown, Leser, Paperless-Antworten | 20.10.2026 |
|
||||
| [TSUMUGU_IMAP_SENT_ITEMS_MIME_BEFUND_UND_FIXAUFTRAG_2026-10-20.md](product/TSUMUGU_IMAP_SENT_ITEMS_MIME_BEFUND_UND_FIXAUFTRAG_2026-10-20.md) | Befund zu Sent Items und MIME, unverändert übernommen | 20.10.2026 |
|
||||
| [TSUMUGU_CONNECTOR_NACHARBEIT_REVIEW_2026-10-20.md](product/TSUMUGU_CONNECTOR_NACHARBEIT_REVIEW_2026-10-20.md) | Review der Nacharbeit, unverändert übernommen | 20.10.2026 |
|
||||
| [TSUMUGU_CONNECTOR_BASIS_ERGEBNIS_2026-10-19.md](product/TSUMUGU_CONNECTOR_BASIS_ERGEBNIS_2026-10-19.md) | früherer Zwischenstand von Abschnitt A vor den Abschlusskriterien | 19.10.2026 |
|
||||
| [TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md](product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md) | Einstieg für die fachliche Weiterplanung | 17.10.2026 |
|
||||
| [TECHNICAL_SPEC_HANDOFF.md](product/TECHNICAL_SPEC_HANDOFF.md) | historischer Auftrag zur technischen Spezifikation | 16.10.2026 |
|
||||
|
||||
@@ -75,3 +75,19 @@ Ein Quellenmodul registriert sich mit `register_source` und liefert nur Fähigke
|
||||
## Laufzeit und Erweiterbarkeit
|
||||
|
||||
Der Netzwerkabruf wird vor dem externen Aufruf aus der offenen Fachtransaktion gelöst und danach auf Recht und Instanz geprüft. Große IMAP-Fächer lesen begrenzte UID-Fenster, nicht die gesamte Liste je Seite. Paperless-Seiten sind die eigene Seitennummer, keine weitergereichte Fortsetzungsadresse. Die Erweiterung um eine Quelle, eine Darstellung oder einen Editor braucht kein neues Rechtsschema. Eine neue Speicherart braucht eine Fabrik und bleibt an die gespeicherte Instanz gebunden. Es gibt keine zusätzliche Verschlüsselung und keinen weiteren Produkt-Speicher.
|
||||
|
||||
## Korrektur am 20.10.2026
|
||||
|
||||
Auftrag: [TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md](TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md). Die Befunde vom selben Tag bleiben unverändert. Die historische Suite oben bleibt unverändert. `tests/test_correction_k1_k7.py` lief danach mit 7 bestandenen Tests. Export, Connector-Nacharbeit und Connector-Basis liefen in derselben lokalen Testdatenbank mit 26 bestandenen Tests. Die Versandtests liefen mit 3 bestandenen Tests. Der Frontend-Build ist durchgelaufen. Kein Push und kein Deployment.
|
||||
|
||||
Die Bedienprüfung lief gegen eine lokale API mit nachgebildetem IMAP und einem verzögerten Paperless-Stellvertreter. Das ist keine Prüfung des bestehenden Postfachs und keine Dokumentabfrage der bestehenden Paperless-Instanz.
|
||||
|
||||
| Korrektur | Geändertes Verhalten | Nachweis | Ergebnis | Grenze |
|
||||
|---|---|---|---|---|
|
||||
| K1 Ordnernamen | Fachnamen, die kein IMAP-Atom sind, werden gequotet. `INBOX` bleibt ungequotet. Ein Fach mit gemeldetem Bestand und leerer abgeschlossener Liste gilt nicht als leer. | Synthetisch: `test_mailbox_names_are_quoted_protocol_strings`, `test_a_filled_folder_with_spaces_is_not_reported_empty`. Bedienung: der Stellvertreter erhielt `INBOX` und `"Sent Items"`; Sent Items zeigte Nachrichten und die Richtung Ausgang. | Synthetisch und in der Bedienung bestanden. | Das bestehende Postfach mit mehr als 4.000 Nachrichten wurde nicht gelesen. |
|
||||
| K2 MIME | Eine Auswertung für Vorschau, Leser und Export. Anzeigename und Archivname sind getrennt. HTML wird bereinigt; die Textfassung ist gekennzeichnet. Eine angehängte Nachricht bleibt eine Anlage. | Synthetisch: `test_parse_mail_keeps_names_html_and_attached_messages`, `test_preview_below_and_above_the_limit_uses_the_same_parts`. Bedienung: Tabelle, `A & B`, Dateiname `Buero Uebergabe.pdf`, keine Skripte, keine fremde Bildadresse, Textfassung sichtbar. | Synthetisch und am Stellvertreter bestanden. | Keine Nutzermail. Bytezahl und SHA-256 zwischen Download, ZIP und Originalanlage einer betroffenen Mail sind nicht verglichen. |
|
||||
| K3 Transaktion | IMAP-Lesen, Export und Dateiveröffentlichung laufen ohne offene Fachtransaktion. Der Fachabschluss folgt danach. Ein fehlgeschlagener Abschluss lässt weder den Eintrag noch die veröffentlichten Bytes stehen. | Synthetisch: `test_upload_and_mail_fetch_leave_the_domain_transaction` sah `IDLE` am Upload und am Mailabruf. `test_failed_conclusion_keeps_no_partial_file` ließ keinen Eintrag und keine Prüfbytes zurück. Die bestehenden Versandtests blieben grün. | Für diese beiden Grenzen bestanden. | Entzug während der Veröffentlichung und ein gleichzeitiger Versionskonflikt sind nicht eigens geprüft. |
|
||||
| K4 Markdown | Der Leser nutzt einen Markdown-Renderer für die Ebenen 1–6, verschachtelte Listen und den Listenstart. HTML, `javascript:`-Links und externe Bilder werden nicht ausgeführt. | Markup-Prüfung der Leserhülle. Bedienung: gespeicherte Notiz mit den genannten Strukturen, Vorschau aus dem Quelltext, Abbrechen stellt die Ansicht wieder her. Bei 360 und 390 px kein Überlauf, Schaltfläche 44 px. | Lesen und Quelltextvorschau bestanden. | Die formatierte Leiste öffnete diese Notiz nicht, weil sie den gespeicherten Text verändert hätte. Der Quelltext blieb maßgeblich. |
|
||||
| K5 Registrierung | Die Leserhülle ruft die registrierte Darstellung auf. Die Beispielquelle bringt Formular und Registrierung in ihrem eigenen Modul mit und erscheint in der Produktauslieferung nicht. | Die Leserhülle rendert die Testdarstellung und speichert über den registrierten Testeditor. Bedienung mit `?probe=1`: Beispielquelle verbinden, nach „Proben“ suchen, übernehmen, öffnen, erneut öffnen, Übergabepaket prüfen und herunterladen. Der Download antwortete mit 200; der Prüfstand nannte `Probenbrief/Probenbrief.txt`. | Bestanden in der Testoberfläche. | Die Beispielquelle ist kein Produktzugang. |
|
||||
| K6 Paperless-Antworten | Eine verspätete Suche oder Facette schreibt nicht in die inzwischen gewählte Instanz. Der Instanzwechsel leert Filter und Trefferliste. | Bedienung am Stellvertreter: Suche auf „Alt“ starten, zu „Neu“ wechseln, die späte Antwort abwarten. Zugang, leere Suche und Facette blieben bei Neu. Die anschließende Suche zeigte „Treffer Neu“. Schließen während einer laufenden Suche ließ die Vorgangsliste unverändert. | In der Bedienung bestanden. | Keine echte Paperless-Instanz. |
|
||||
| K7 Filter und reale Quellen | Der synthetische Paperless-Abruf filtert den Katalog nach Inhalt, Titel, Metadaten, Datum und Seite. | `test_paperless_filters_change_the_hits`: nur der Inhaltstreffer, nur Titel „Vertrag“, die kombinierte Teilmenge und die zweite Seite unterscheiden sich. | Synthetisch bestanden. | Weder die bestehende Paperless-Dokumentabfrage noch das bestehende Postfach wurden ausgeführt. Schema-Lesen vom 19.10. ersetzt das nicht. |
|
||||
@@ -0,0 +1,69 @@
|
||||
# Prüfung der Connector-Nacharbeit
|
||||
|
||||
**Stand:** 20.10.2026. Geprüfter Arbeitsstand: `C:/Dev/tsumugu`. Keine Änderung an Anwendung, Repositorydokumenten oder Datenbanken; kein Push oder Deployment.
|
||||
|
||||
## Ergebnis
|
||||
|
||||
Die Nacharbeit ist im Code vorhanden und ein deutlicher Fortschritt. Eine vollständige Abnahme des Auftrags ist noch nicht belegt. Die folgenden vier Restpunkte sind konkret eingegrenzt. Ein erneuter Architekturentwurf oder zusätzliche Produktfunktionen sind dafür nicht erforderlich.
|
||||
|
||||
## Was tatsächlich hinzugekommen ist
|
||||
|
||||
- Gemeinsame Quellenfreigabe über `sourceaccess.py`; der allgemeine E-Mail-Endpunkt verwendet das registrierte Modul statt eines fest eingebauten IMAP-Abrufs.
|
||||
- Paperless-Filter werden weitergereicht und auf Query, Titel, Korrespondent, Dokumenttyp, Tags, Dokumentdatum und Sortierung abgebildet. Ergebnisseiten und Stammdatenauswahl sind vorhanden.
|
||||
- IMAP verwendet begrenzte UID-Fenster, unterscheidet Suchfehler von leeren Ergebnissen und führt UIDVALIDITY sowie unvollständige Suchzustände mit.
|
||||
- Uploads und Versandfassungen verwenden `adapter_for`; die Lösch-/Bereinigungsobjekte können den zuständigen Adapter aufrufen.
|
||||
- MDXEditor ist lokal eingebunden. Notizen öffnen gerendert, lassen sich mit Formatierungsleiste bearbeiten und wechseln nach dem Speichern zurück zur Leseansicht.
|
||||
|
||||
## 1. Externe Abrufe laufen weiterhin teilweise innerhalb einer Fachtransaktion
|
||||
|
||||
**Beleg:** `backend/app/sourceaccess.py:125` beendet zunächst die Transaktion. Der IMAP-Callback in `backend/app/sources.py:387` ruft anschließend aber `load_imap_original` auf. Diese Funktion liest in `backend/app/sources.py:1123` über `_owned` erneut aus der Datenbank und startet damit vor `pull_rfc822` wieder eine Transaktion.
|
||||
|
||||
Auch `backend/app/sources.py:1251` und `:1272`, die Paperless-/IMAP-Originale für Export und Versandfassungen laden, lösen die Transaktion vor ihrem Netzwerkabruf nicht. Die Freigabeprüfung nach dem Abruf aus der gemeinsamen Lesestrecke wird dort ebenfalls nicht verwendet. Dateiveröffentlichungen in `ops.py` und `correspondence.py` erfolgen weiterhin zwischen Fachschreiboperationen.
|
||||
|
||||
**Eigener Nachweis:** Zwei isolierte Python-Prüfungen ohne DB und Netzwerk haben die tatsächlichen Funktionen mit kleinen Verbindungs-/Transportattrappen aufgerufen. Beim Einstieg in den externen Transport war der Status sowohl im IMAP-Lesepfad als auch im Paperless-Exportpfad `INTRANS`.
|
||||
|
||||
**Gezielte Nacharbeit:** Die freigegebenen Verbindungsdaten vor dem externen Teil vollständig auflösen. Im externen Teil keine DB-Nachfrage einbauen, die die Transaktion erneut eröffnet. Für Export und Versandfassung ebenfalls vorbereiten, extern lesen und danach erforderliche Rechte/Versionen erneut prüfen. Schreibabläufe ausdrücklich in vorbereitende und abschließende Phasen teilen; kein pauschales Zwischen-Commit als Ersatz für einen sicheren Ablauf. Die abschließende Korrektheit bei Fehler und Entzug testen.
|
||||
|
||||
## 2. Markdown-Editor und gespeicherte Leseansicht unterstützen unterschiedliche Formatierung
|
||||
|
||||
**Beleg:** `frontend/src/notes.jsx:154` aktiviert Überschriften ohne Einschränkung. Das installierte Plugin bietet Ebenen 1 bis 6 an. `frontend/src/markdown.jsx:61` rendert dagegen nur Ebenen 1 bis 3. Der Renderer behandelt eingerückte Listenelemente als gleichrangig und beginnt geordnete Listen stets bei 1.
|
||||
|
||||
**Eigener Nachweis:** Den tatsächlichen `MarkdownView` mit dem vorhandenen JSX-Werkzeug im Speicher übersetzt und mit React serverseitig gerendert. Kein Build und keine Dateischreiboperation im Repository nötig:
|
||||
|
||||
- `#### Unterpunkt` ergibt einen Absatz mit sichtbaren vier Rauten statt einer Überschrift.
|
||||
- `- Ebene 1` mit eingerücktem `- Ebene 2` ergibt zwei gleichrangige Listenelemente.
|
||||
- Eine mit `5.` beginnende geordnete Liste enthält kein `start`-Attribut und wird damit ab 1 angezeigt.
|
||||
|
||||
Der gespeicherte Quelltext wird durch diesen Befund nicht nachweislich verändert. Die Leseansicht stellt seine Bedeutung aber falsch dar.
|
||||
|
||||
**Gezielte Nacharbeit:** Einen zum Editor passenden sicheren Markdown-Renderer verwenden und den gemeinsamen unterstützten Umfang testen. Keine weitere Sammlung einzelner Regex-Sonderfälle. Überschriften, verschachtelte Listen und Listenstartwerte nach Bearbeiten, Speichern, erneutem Öffnen und Quelltextwechsel prüfen. Bisherige Schutzregeln zu HTML, gefährlichen Links und externen Medien erhalten.
|
||||
|
||||
## 3. Die Darstellungs-/Editor-Registrierung ist noch keine Registrierung ausführbarer Komponenten
|
||||
|
||||
**Beleg:** `frontend/src/sources/registry.jsx:29` registriert eine Zuordnung von Mediennamen auf Leserkennungen. `ReadingPane.jsx` entscheidet weiterhin anhand fest eingebauter Kennungen, welche Anzeige ausgeführt wird. Es importiert `NoteEditor` direkt und bindet ihn bei `element.kind === "note"` ein. Die `editors`-Struktur in `registry.jsx:160` ist eine feste Objektliste; ein neuer registrierter Editor wird daraus nicht dynamisch ausgeführt.
|
||||
|
||||
Dadurch lassen sich Quellen mit vorhandenen Standardformaten besser ergänzen. Ein neuer Leser oder Editor kann aber weiterhin Änderungen im allgemeinen Reader benötigen. Die Abschlussmatrix beschreibt diesen Teil weitergehend als der Code.
|
||||
|
||||
**Gezielte Nacharbeit:** Tatsächliche Komponenten und ihre gemeinsamen Lade-/Speicher-/Konfliktverträge registrieren. Die allgemeine Hülle muss die registrierte Komponente aufrufen. Die interne Notiz bleibt eine Notiz mit ihrem bisherigen Speicherweg; ihre fachliche Identität muss dafür nicht geändert werden.
|
||||
|
||||
**Abnahme:** Eine kleine zusätzliche Testdarstellung und einen Testeditor allein durch Module und Registrierung einhängen und über die echte Leserhülle ausführen. Kein neuer produktiver Connector erforderlich. Eine bloße Stringzuordnung genügt nicht.
|
||||
|
||||
## 4. Verspätete Paperless-Suchantworten können einen neueren Zustand überschreiben
|
||||
|
||||
**Beleg:** `frontend/src/pages/Sources.jsx:256` übernimmt nach jedem Suchaufruf ungeprüft `items`, `next_page` und `connector_id`. Währenddessen kann über das Auswahlfeld bei `:369` die Instanz gewechselt oder eine weitere Suche gestartet werden. Es fehlt eine Anfragenkennung beziehungsweise eine andere Sicherung gegen verspätete Antworten. Der IMAP-Picker hat eine solche Sicherung bereits.
|
||||
|
||||
**Auswirkung aus dem Codeablauf:** Eine langsame Suche A kann nach dem Wechsel auf B oder nach einer neueren Suche noch eintreffen und die aktuelle Trefferliste und Instanzauswahl zurücksetzen. Das ist ein belegter möglicher Ablauf; eine Browser-Reproduktion mit künstlicher Verzögerung wurde hier nicht ausgeführt.
|
||||
|
||||
**Gezielte Nacharbeit:** Such-, Vorschau- und Stammdatenantworten an Instanz und konkrete Anfrage binden. Überholte Antworten ignorieren beziehungsweise abbrechen. Nach Instanzwechsel fremde Filter-IDs zurücksetzen oder ausdrücklich neu validieren. Bewusst gewählte Treffer weiter anhand ihrer gespeicherten Instanz erhalten.
|
||||
|
||||
**Abnahme:** Antwort A künstlich verzögern, zu Instanz B beziehungsweise Suche B wechseln, A erst danach freigeben. Treffer, Vorschau, Filterzustand und Auswahl dürfen nicht auf A zurückspringen.
|
||||
|
||||
## Nachweisgrenzen
|
||||
|
||||
Die Abschlussmatrix nennt 82 bestandene Backend-Tests und einen erfolgreichen Frontend-Build. Diese vollständigen Läufe wurden bei dieser Prüfung nicht wiederholt. Die zusätzliche Prüfung war gezielt und lesend; sie hat keine echte Quelle und keine Datenbank angesprochen.
|
||||
|
||||
Der neue Paperless-Test belegt Parameterübertragung und Paging, sein Fake berechnet jedoch keine echte Filterwirkung: Er liefert dieselben Seitendaten unabhängig vom Suchinhalt. Die tatsächliche Filtersemantik an der Nutzerinstanz ist damit weiterhin offen. Laut Matrix wurde nur deren Schema gelesen.
|
||||
|
||||
Der bestehende dritte Source-Test prüft weiterhin die Frontend-Registrierung in Node und die Backend-Strecke. Er belegt keinen vollständigen Bedienablauf des dritten Connectors in der Oberfläche. Für den neuen Editor nennt die Matrix Browserprüfungen; eine zusätzliche eigene Browserprüfung wurde hier nicht vorgenommen.
|
||||
|
||||
Die reale Großordner-Abnahme bei IMAP und die Inhalts-/Filterabnahme bei Paperless bleiben nach dem vorliegenden Bericht offen. Bei Abschluss klar zwischen Codeänderung, synthetischem Nachweis und erfolgreichem Test an der echten Quelle unterscheiden.
|
||||
@@ -0,0 +1,84 @@
|
||||
# Sent Items und MIME-Aufbereitung: Befund und gezielter Cursor-Auftrag
|
||||
|
||||
**Stand:** 20.10.2026. Geprüft: `C:/Dev/tsumugu`. Keine Änderung an Anwendung oder Repository; keine echte Quelle und keine Datenbank angesprochen.
|
||||
|
||||
## Nutzerbeobachtung und Grenzen
|
||||
|
||||
Der Ordner „Sent Items“ enthält laut Outlook mehr als 4.000 Nachrichten, erscheint in Tsumugu aber leer. Einige E-Mails mit großen Anlagen wirken in Anzeige und Export verändert; die EML-Datei wird in Outlook korrekt dargestellt.
|
||||
|
||||
**Nutzerpräzisierung:** Betroffen sind Dateiname beziehungsweise Anzeige. Eine Veränderung heruntergeladener Dateiinhalte oder fehlende Anlagen wurde vom Nutzer nicht berichtet. Entsprechend liegt der Schwerpunkt auf korrekten Namen und Darstellung; die Byteprüfung ist eine zusätzliche Integritätskontrolle. Der unten separat reproduzierte Verlust angehängter EML-Dateien ist ein zusätzlicher Parserbefund, keine nachträgliche Umdeutung der Nutzerbeobachtung.
|
||||
|
||||
Diese beiden Beobachtungen sind ernst zu nehmen. Sie beweisen noch nicht, dass Outlook und Tsumugu denselben serverseitigen Ordner sehen oder dass extrahierte Binäranlagen verändert wurden. Die konkrete Nutzerquelle wurde hier nicht geprüft. Es wurden aber die folgenden Codefehler unabhängig reproduziert.
|
||||
|
||||
## Belegte Befunde
|
||||
|
||||
### 1. IMAP-Ordnernamen mit Leerzeichen sind nicht korrekt geschützt
|
||||
|
||||
`backend/app/sources.py:730` und `:798` übergeben den entquoteten Ordnernamen direkt an `client.select`. Die tatsächlich installierte Python-Bibliothek setzt diesen Parameter in den Befehl ein, ohne ihn automatisch zu quotieren.
|
||||
|
||||
Eine Prüfung ohne Socket mit dem tatsächlichen IMAP-Befehlsencoder ergab für `Sent Items`:
|
||||
|
||||
```text
|
||||
T1 EXAMINE Sent Items
|
||||
```
|
||||
|
||||
Für diesen Namen ist eine korrekte IMAP-Stringdarstellung erforderlich, beispielsweise `"Sent Items"`, einschließlich richtigem Escaping. Das ist ein belegter Protokollfehler, aber noch kein Nachweis, dass genau diese Serverantwort beim Nutzer zum Leerzustand führt. Ein strikt ablehnender Server sollte einen Fehler erzeugen; warum der Nutzer „leer“ sieht, muss zusätzlich entlang Serverantwort und UI verfolgt werden.
|
||||
|
||||
### 2. Der Sonderweg für große Mailvorschauen verliert den MIME-Kontext
|
||||
|
||||
`_fetch_message` wechselt bei mehr als 8.000.000 Rohbytes in `_oversized_message`. `_partial_text` holt einen Ausschnitt von `BODY.PEEK[TEXT]` und parst ihn mit einem künstlichen Subject-Header, aber ohne die ursprünglichen MIME-Header und Multipart-Grenzinformationen.
|
||||
|
||||
Ein synthetischer Multipart-Test an der echten `_partial_text`-Funktion zeigte MIME-Header und Base64-Anlageninhalt als Nachrichtentext. Dieser Befund erklärt eine größenabhängig kaputte Vorschau sehr konkret. Er beweist keine Veränderung der Originalanlage im Export; dessen vollständiger Abruf läuft anders.
|
||||
|
||||
### 3. Anzeige und Export verwenden eine verlustbehaftete Textfassung
|
||||
|
||||
`backend/app/mailpack.py::_html_text` entfernt HTML-Tags mit regulären Ausdrücken. Tabellenstruktur, Layout und Inline-Bilder bleiben dabei nicht erhalten; HTML-Entities werden nicht zuverlässig als Zeichen ausgegeben. Ein Test mit einer HTML-Mail lieferte `A & B` statt `A & B` und eine flache Zeichenfolge statt der Tabelle.
|
||||
|
||||
Der Export schreibt `mail.raw` als EML, die Lesefassung aber aus `mail.parsed.text`. Deshalb können EML und Lesefassung unterschiedlich aussehen. Das erklärt die Beobachtung einer Umformatierung, ohne daraus bereits einen Defekt der extrahierten PDF-/Bilddateien abzuleiten.
|
||||
|
||||
### 4. Angefügte EML-Nachrichten können unbemerkt fehlen
|
||||
|
||||
`parse_mail` überspringt alle Parts mit `is_multipart()`. Das trifft auch auf `message/rfc822` zu. Der anschließende Baumdurchlauf kann dafür den inneren Text einer angehängten E-Mail dem äußeren Nachrichtentext zuschlagen.
|
||||
|
||||
Eigener Test: Eine Nachricht mit `weitergeleitet.eml` als Anlage wurde mit **null Anlagen**, **keinem Fehlhinweis** und einer Mischung aus äußerem und innerem Text aufbereitet. Das betrifft auch den Export und seine Vollständigkeitsbehauptung.
|
||||
|
||||
### 5. Große Anlagen sind nicht grundsätzlich beschädigt
|
||||
|
||||
Eine synthetische gewöhnliche Base64-Anlage mit 9.000.000 Bytes wurde von `parse_mail` mit gleicher Länge und identischem SHA-256 extrahiert. Die konkrete Anlage des Nutzers muss deshalb anhand ihrer tatsächlichen MIME-Struktur und der heruntergeladenen Bytes geprüft werden; „groß“ allein ist noch keine Ursache.
|
||||
|
||||
### 6. MIME-kodierte Dateinamen werden je nach Zugriff verschieden angezeigt
|
||||
|
||||
Die Vorschau nutzt `_decode`, der vollständige Parser dagegen `_header_text`, das solche Header nicht dekodiert. Mit derselben synthetischen E-Mail wurde reproduziert:
|
||||
|
||||
- Vorschau: `Buero Uebergabe.pdf`.
|
||||
- Reader/Export: `=?utf-8?q?Buero_Uebergabe=2Epdf?=`.
|
||||
|
||||
Das passt unmittelbar zur Nutzerpräzisierung. MIME-/Headerdekodierung für Anzeigename und Exportnamen vereinheitlichen, einschließlich RFC-2231-Parametern. Einen sicheren Archiv-Dateinamen vom angezeigten Originalnamen trennen; notwendige Pfadbereinigung und Kollisionsbehandlung erhalten.
|
||||
|
||||
## Umsetzungsauftrag an Cursor
|
||||
|
||||
Erhalte die bestehende Connector-Architektur und die übrige Nacharbeit. Schließe gezielt diese Fehler, ohne neue Grundlagenanalyse oder zusätzliche Produktfunktionen.
|
||||
|
||||
1. Ordnernamen an allen IMAP-Auswahl-/Abrufstellen korrekt als Protokollstrings behandeln. Leerzeichen, Anführungszeichen, Backslash und erforderliche Zeichenkodierung testen. CR/LF weiter ablehnen. Rohname für die Protokolladresse und lesbares Label getrennt halten.
|
||||
2. Den echten betroffenen Ordner ausschließlich lesend diagnostizieren, soweit eine bestehende autorisierte Verbindung zugänglich ist: Konto/Host und vollständigen Ordnerpfad vergleichen, LIST-Zuordnung, EXAMINE-Status und EXISTS, UIDNEXT/UIDVALIDITY und begrenzte Suchantwort erfassen. Keine Credentials oder privaten Inhalte protokollieren. Outlook-Cache beziehungsweise ein anderer Ordner ist eine zu prüfende Möglichkeit, keine feststehende Erklärung.
|
||||
3. Wenn EXAMINE einen befüllten Ordner meldet, aber die Aufbereitung keine Einträge ergibt, Leerzustand nicht ungeprüft behaupten. Fehler, nicht abgeschlossene Suche, widersprüchliche Antworten und wirklich leer unterscheiden. Das große-Folder-Paging erhalten; nicht unbegrenzt alle Nachrichten laden.
|
||||
4. Die große Vorschau über korrekt ausgewählte Text-/HTML-MIME-Parts und deren Transfer-Encoding/Charset aufbauen. Keine beliebig abgeschnittene Multipart-Rohstruktur als fertigen Mailtext ausgeben. Falls eine vollständige Vorschau nicht möglich ist, klar als begrenzt kennzeichnen; MIME-Fragmente und Base64-Blöcke nicht als Nutztext ausgeben.
|
||||
5. Einen gemeinsamen MIME-Baum für Vorschau, Lesen, Anlagenabruf und Export auswerten. Alternative Körperdarstellungen, related/Inline-Ressourcen und echte Anlagen trennen. Angehängte E-Mails als eigene vollständige Anlage erhalten; deren Inhalt nicht in die äußere Nachricht einmischen. Doppelte Namen bleiben getrennt.
|
||||
6. EML-Originalbytes unverändert erhalten. Originalanlagen als korrekt transferdekodierte Nutzbytes liefern; keine Bild-/PDF-Neuerzeugung und keine Textdekodierung binärer Nutzdaten. Unbekannte oder nicht sicher dekodierbare MIME-Parts ausdrücklich als Grenze melden, statt unbemerkt Vollständigkeit zu behaupten.
|
||||
MIME-kodierte Dateinamen in Vorschau, Reader, Download und Export konsistent dekodieren. Anzeigename und sicherer Archiv-Dateiname bleiben unterscheidbar; technische Sicherheitsbereinigung darf keinen unverständlichen MIME-Header als Namen hinterlassen.
|
||||
7. Für HTML-Mails eine sichere formatierte Ansicht mit vorhandenen lokalen Inline-Ressourcen vorsehen. Skripte, aktive Inhalte und automatische externe Nachladezugriffe sperren. Eine vereinfachte Textfassung darf zusätzlich bestehen, muss als solche erkennbar sein. Keine Zusage pixelgleicher Outlook-Darstellung. Im Export Original-EML und Originalanlagen erhalten; eine formatierte Lesefassung sicher bereitstellen oder verbleibende Darstellungsgrenzen klar benennen. Nicht das unveränderte EML durch eine neu serialisierte Mail ersetzen.
|
||||
|
||||
## Konkrete Abnahme
|
||||
|
||||
- Sent Items mit Leerzeichen und mehr als 4.000 Nachrichten: derselbe serverseitige Ordner liefert erste Seite und spätere Treffer; Suche findet einen bekannten Treffer. Serverantwort und Anzeige passen zusammen. Zusätzlich Ordnernamen mit Quote/Backslash und ein echter leerer Ordner.
|
||||
- Dieselbe synthetische MIME-Struktur unterhalb und oberhalb der Vorschaugrenze: gleicher lesbarer Körper und gleiche Anlagenliste, abgesehen von einer ausdrücklich angegebenen Textkürzung. Kein sichtbarer MIME-/Base64-Rest.
|
||||
- HTML-Tabelle, Entities, Unicode-/kodierte Header und Dateinamen, quoted-printable und Base64, Inline-CID-Bild und angehängte EML prüfen. Innere EML bleibt als Anlage vollständig und getrennt. Nicht unterstützte Sonderformate als solche behandeln.
|
||||
- Für eine betroffene Nutzer-Mail EML lokal vergleichen. Danach jede extrahierte Anlage zwischen Tsumugu-Download, ZIP-Export und der aus derselben EML korrekt gespeicherten Anlage vergleichen: Bytezahl und SHA-256. Bericht trennt Dateiname, Darstellung und tatsächliche Byteabweichung.
|
||||
- Export meldet eine ausgelassene oder fehlerhafte Anlage; kein stiller Verlust. Die bestehende Regel „vollständige E-Mail einschließlich aller Anlagen trotz separat abgewähltem Vorkommen“ erhalten.
|
||||
- Tests synthetisch und an echten Quellen getrennt berichten. Nicht verfügbare Nutzerfälle bleiben offen. Keine produktive DB für Regressionstests, kein Push und kein Deployment.
|
||||
|
||||
## Primärquellen
|
||||
|
||||
- [RFC 9051 – IMAP4rev2](https://www.rfc-editor.org/rfc/rfc9051.html): Mailboxnamen, Protokollstrings, Auswahl und Identität. Weiterhin bestehende IMAP4rev1-Server unterstützen.
|
||||
- [Python – email.message](https://docs.python.org/3/library/email.message.html): MIME-Baum und `is_multipart()`, insbesondere `message/rfc822`. Details mit der eingesetzten Python-Version abgleichen.
|
||||
- [RFC 2045 – MIME](https://www.rfc-editor.org/rfc/rfc2045.html): Content-Type und Transfer-Encoding.
|
||||
@@ -0,0 +1,129 @@
|
||||
# Korrekturauftrag an Cursor: Connectoren, IMAP, Mailaufbereitung und Markdown
|
||||
|
||||
**Stand:** 20.10.2026
|
||||
**Repository:** `C:/Dev/tsumugu`
|
||||
**Zielort:** `docs/product/TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md`
|
||||
**Umfang:** Die nachstehend gebündelten Korrekturen und ihre lokale Abnahme sind beauftragt. Kein Push und kein Deployment.
|
||||
|
||||
## 1. Führender Auftrag und Befundquellen
|
||||
|
||||
Dieser Auftrag bündelt beide Prüfberichte vom 20.10.2026. Er ist der gemeinsame Umsetzungseinstieg; die Einzelberichte bleiben die Quellen für Reproduktion, Fundstellen und Nachweisgrenzen. Doppelte Aufgaben nur einmal lösen. Frühere bereits korrekt umgesetzte Funktionen erhalten.
|
||||
|
||||
**R – vorherige Prüfung:** [Connector-Nacharbeit: Review vom 20.10.2026](TSUMUGU_CONNECTOR_NACHARBEIT_REVIEW_2026-10-20.md)
|
||||
|
||||
- R1 = Abschnitt 1: externe Abrufe und Fachtransaktionen.
|
||||
- R2 = Abschnitt 2: unterschiedlicher Markdown-Umfang in Editor und Leser.
|
||||
- R3 = Abschnitt 3: nur nominelle Leser-/Editor-Registrierung.
|
||||
- R4 = Abschnitt 4: verspätete Paperless-Antworten.
|
||||
- R-N = Abschnitt „Nachweisgrenzen“: echte Filterwirkung und Bediennachweis des dritten Connectors.
|
||||
|
||||
**M – ergänzende Mailprüfung:** [Sent Items und MIME: Befund und Fixauftrag](TSUMUGU_IMAP_SENT_ITEMS_MIME_BEFUND_UND_FIXAUFTRAG_2026-10-20.md)
|
||||
|
||||
- M1 = Befund 1: ungeschützte IMAP-Ordnernamen mit Leerzeichen.
|
||||
- M2 = Befund 2: verlorener MIME-Kontext in großen Vorschauen.
|
||||
- M3 = Befund 3: verlustbehaftete HTML-Textfassung.
|
||||
- M4 = Befund 4: ausgelassene angehängte EML und vermischte Nachrichtentexte.
|
||||
- M5 = Befund 5: synthetischer Integritätsnachweis für eine normale große Anlage.
|
||||
- M6 = Befund 6: unterschiedliche Dekodierung von Dateinamen.
|
||||
|
||||
Die Berichte liegen bei Übergabe gemeinsam mit diesem Auftrag unter:
|
||||
|
||||
`C:/Users/lars/Documents/Codex/2026-10-17/lies-zuerst-c-dev-tsumugu-docs/outputs/`
|
||||
|
||||
Übernimm die drei Dokumente nach `docs/product`, damit die relativen Verweise dort funktionieren. Verlinke den gemeinsamen Auftrag in `docs/README.md` und der Planungsübergabe. Keine Änderungen an den historischen Befundbehauptungen, um inzwischen erfolgte Korrekturen zu verdecken; neue Ergebnisse ergänzen.
|
||||
|
||||
Lies außerdem `AGENTS.md`, die betroffenen bestätigten Entscheidungen in `docs/product/TSUMUGU_PRODUCT_SPEC.md`, die bisherigen Connector-Abschlusskriterien und den Source-/Storage-Vertrag. Die Architekturvorlagen liegen unter **`docs/reference/`**. Bestehende Gestaltung, Fachmodell und Fremdänderungen erhalten. Kein Neustart der Grundlagenarbeit.
|
||||
|
||||
## 2. Beobachtung, Befund und offene Ursache
|
||||
|
||||
- „Sent Items“ ist laut Nutzer in Outlook mit mehr als 4.000 Nachrichten befüllt, erscheint in Tsumugu aber leer. Die ungeschützte Übermittlung des Namens ist reproduziert; die tatsächliche Ursache des Leerzustands an dieser Nutzerquelle ist noch nicht abschließend nachgewiesen.
|
||||
- Der Nutzer hat die Anlagenbeobachtung präzisiert: **Dateiname beziehungsweise Anzeige verändert**. Er hat keine beschädigten heruntergeladenen Dateiinhalte und keine fehlenden Anlagen berichtet.
|
||||
- Die Auslassung angehängter EML ist ein zusätzlicher synthetisch reproduzierter Parserfehler. Sie ist keine Umdeutung der Nutzerbeobachtung.
|
||||
- Eine gewöhnliche Base64-Anlage mit 9.000.000 Bytes wurde synthetisch bytegleich extrahiert. Das beweist weder einen generellen Defekt großer Anlagen noch die Korrektheit aller MIME-Sonderfälle.
|
||||
- Die bisherigen 82 Tests und der Build sind gemeldete historische Ergebnisse. Sie ersetzen die gezielte Abnahme der folgenden Korrekturen nicht.
|
||||
|
||||
## 3. Gebündelte Korrekturen und Abnahme
|
||||
|
||||
### K1 – Sent Items und andere IMAP-Ordner korrekt öffnen
|
||||
|
||||
**Quellen:** M1, Nutzerbeobachtung im Mailbericht.
|
||||
|
||||
- Ordnernamen in allen Auswahl-/Abrufpfaden als korrekte IMAP-Protokollstrings behandeln: Leerzeichen, Quotes, Backslash und notwendige Zeichenkodierung. Rohname und sichtbares Label getrennt halten. CR/LF weiter ablehnen.
|
||||
- Den betroffenen Ordner über eine vorhandene autorisierte Verbindung lesend diagnostizieren, soweit erreichbar: Konto/Host und vollständigen Ordnerpfad, LIST-Zuordnung, EXAMINE-Status/EXISTS, UIDNEXT/UIDVALIDITY sowie begrenzte Suchantwort vergleichen. Keine privaten Inhalte oder Credentials protokollieren. Gleichen Ordner in Outlook und IMAP prüfen; nicht ungeprüft Outlook-Cache oder Ordnergröße zur Ursache erklären.
|
||||
- Bei widersprüchlichen Antworten, fehlgeschlagenem Abruf oder nicht abgeschlossener Suche keinen endgültigen Leerzustand melden. Begrenztes Paging erhalten.
|
||||
|
||||
**Abnahme:** Ordner mit Leerzeichen und mehr als 4.000 Nachrichten liefert die erste Seite und einen bekannten späteren Suchtreffer. Zusätzlich echte Leere, Suchfehler, UID-Lücken und Namen mit Quote/Backslash prüfen. Ist die echte Quelle nicht verfügbar, synthetischen Nachweis liefern und die reale Nutzerabnahme ausdrücklich offen lassen.
|
||||
|
||||
### K2 – MIME-Aufbereitung, Namen und Maildarstellung vereinheitlichen
|
||||
|
||||
**Quellen:** M2, M3, M4, M5, M6.
|
||||
|
||||
- Vorschau, vollständiges Lesen, Anlagenabruf und Export verwenden dieselbe fachlich korrekte MIME-Auswertung. Unterschiedliche Größenlimits dürfen keinen Wechsel zu einer falsch interpretierten Rohstruktur erzeugen.
|
||||
- Große Vorschauen gezielt aus passenden Text-/HTML-Parts und deren Transfer-Encoding/Charset gewinnen. Abgeschnittene Multipart-Fragmente nicht mit künstlichen Headern als fertige Mail parsen. Bei Begrenzung einen klaren Zustand liefern; keine MIME-Header oder Base64-Anlagen als Nachrichtentext anzeigen.
|
||||
- MIME-kodierte Header und Dateinamen in allen Ansichten konsistent dekodieren, einschließlich RFC-2231-Parametern. Angezeigten Originalnamen von sicherem Archiv-Dateinamen trennen; Pfadbereinigung und Kollisionsbehandlung erhalten.
|
||||
- Echte Anlagen, HTML-/Textalternativen und lokale Inline-Ressourcen unterscheiden. Angehängte `message/rfc822`-Nachrichten vollständig als eigene Anlage erhalten. Deren Text nicht in die äußere Nachricht mischen. Doppelte Dateinamen bleiben getrennt.
|
||||
- Eine sichere formatierte HTML-Mailansicht mit lokalen Inline-Ressourcen bereitstellen. Keine Skripte, aktiven Inhalte oder automatischen externen Nachladezugriffe. Eine zusätzliche vereinfachte Textfassung bleibt als solche erkennbar. Keine Zusage pixelgleicher Outlook-Darstellung.
|
||||
- Original-EML unverändert erhalten. Anlagen als korrekt transferdekodierte Original-Nutzbytes ausgeben, keine PDF-/Bild-Neuerzeugung. Export enthält weiterhin die vollständige EML und alle Anlagen; eine formatierte Lesefassung sicher bereitstellen oder verbleibende Darstellungsgrenzen klar benennen. Fehlerhafte oder ausgelassene Teile nicht still als vollständig melden.
|
||||
|
||||
**Abnahme:** Dieselbe MIME-Struktur unter und über der bisherigen 8-MB-Vorschaugrenze; konsistente Körperdarstellung und Anlagenliste. Zusätzlich kodierte Dateinamen, HTML-Tabelle/Entities, Unicode, Base64/quoted-printable, Inline-CID-Bild, doppelte Namen und angehängte EML. Für eine betroffene Nutzer-Mail die Namen und Darstellung direkt vergleichen. Bytezahl und SHA-256 der extrahierten Anlagen zwischen Download, ZIP und korrekt aus derselben EML gespeicherter Anlage als Integritätskontrolle vergleichen. Separat abgewählte Anlage-Vorkommen dürfen weiterhin nicht die Anlagen der exportierten E-Mail entfernen.
|
||||
|
||||
### K3 – Externe Arbeit und Fachtransaktion wirklich trennen
|
||||
|
||||
**Quelle:** R1.
|
||||
|
||||
- Verbindungsdaten vor dem externen Abruf vollständig auflösen. Im externen Abschnitt keine DB-Nachfrage einbauen, die unmittelbar wieder eine Transaktion eröffnet.
|
||||
- IMAP-Lesen, Quellenexport und Abruf für Versandfassungen über dieselben belastbaren Zugriffsgrenzen führen. Nach externer Arbeit erforderliche aktuelle Rechte, Instanz und Version erneut prüfen.
|
||||
- Upload-/Snapshot-Veröffentlichung mit sicheren vorbereitenden und abschließenden DB-Phasen sowie nachvollziehbarer Bereinigung ausführen. Ein pauschales Zwischen-Commit ersetzt keinen korrekten Schreibablauf. Bestandsreferenzen, Generationen und gesicherte Versandbytes erhalten.
|
||||
|
||||
**Abnahme:** An den tatsächlichen Transport-/Speichergrenzen nachweisen, dass keine Fachtransaktion offen ist; nicht nur prüfen, ob eine Hilfsfunktion vorher `commit` aufruft. Entzug, konkurrierende Änderung, externer Fehler und abschließender DB-Fehler führen zu keiner unberechtigten Ausgabe oder scheinbar vollständig gespeicherten Teilfassung. Keine neue Kryptografie.
|
||||
|
||||
### K4 – Gespeicherte Markdown-Ansicht entspricht dem Editor
|
||||
|
||||
**Quelle:** R2.
|
||||
|
||||
- Einen sicheren, zum Editor passenden Markdown-Renderer einsetzen. Keine weiteren Regex-Sonderfälle als Ersatz für korrekte Markdown-Struktur.
|
||||
- Vom Editor angebotene Überschriften, verschachtelte Listen und Anfangswerte geordneter Listen im Leser korrekt darstellen. Quelltext außerhalb des unterstützten visuellen Umfangs verlustfrei erhalten.
|
||||
- Notiz öffnet gerendert; Bearbeiten, Speichern, Abbrechen und Konflikterhalt funktionieren weiterhin. Gemeinsamer Notizinhalt bleibt gemeinsam, lokale Anmerkungen lokal.
|
||||
|
||||
**Abnahme:** Überschriften 1–6, verschachtelte Listen, Liste ab 5, Zitate, Links und Code im Editor, nach Speichern, nach Wiederöffnung und nach Quelltextwechsel vergleichen. Quelltext/Export ohne Inhaltsverlust, schädliches HTML/Links und externe Medien weiterhin geschützt.
|
||||
|
||||
### K5 – Ausführbare Leser und Editoren registrieren
|
||||
|
||||
**Quelle:** R3; ergänzend R-N.
|
||||
|
||||
- Tatsächliche Anzeige-/Editorkomponenten mit gemeinsamen Lade-, Speicher-, Abbruch- und Konfliktverträgen registrieren. Die allgemeine Leserhülle ruft die registrierte Komponente auf.
|
||||
- Eine Zuordnung neuer Mediennamen auf weiterhin fest eingebaute Leserzweige genügt nicht. Neue Leser-/Editorbausteine dürfen keine Änderung an Akten-/Vorgangsseiten oder am allgemeinen Reader verlangen.
|
||||
- Interne Notizen behalten ihren bisherigen Speicherweg und ihre Identität. Kein künstlicher externer Notiz-Connector und keine neue MD-Dateischreibfunktion.
|
||||
|
||||
**Abnahme:** Eine zusätzliche Testdarstellung und einen Testeditor nur durch ihre Module und Registrierung integrieren und tatsächlich über die Leserhülle bedienen. Vorhandenen dritten Test-Connector in der Testoberfläche einrichten, suchen, öffnen, einbinden, erneut öffnen und exportieren. Keine weiteren produktiven Dienste erforderlich; ein reiner Registry-Test in Node genügt nicht.
|
||||
|
||||
### K6 – Paperless-Antworten an die aktuelle Anfrage binden
|
||||
|
||||
**Quelle:** R4.
|
||||
|
||||
- Überholte Such-, Vorschau- und Stammdatenantworten beim Instanz-/Suchwechsel ignorieren oder abbrechen. Sie dürfen weder Ergebnisse noch Instanzauswahl zurücksetzen.
|
||||
- Fremde Filter-IDs beim Instanzwechsel zurücksetzen oder ausdrücklich neu validieren. Bewusste Auswahl weiterhin unter gespeicherter Instanz und Ressourcen-ID erhalten.
|
||||
|
||||
**Abnahme:** Antwort A verzögern, zu Instanz beziehungsweise Suche B wechseln, danach A zustellen. Ergebnisse, Vorschau, Filter und Zugang bleiben bei B. Dasselbe für mehrfache schnelle Wechsel und Schließen der Ansicht prüfen.
|
||||
|
||||
### K7 – Noch fehlende Nachweise sauber schließen
|
||||
|
||||
**Quelle:** R-N; reale Abnahme im Mailbericht.
|
||||
|
||||
- Paperless-Tests müssen Filterwirkung auf unterscheidbaren Testdaten belegen, zusätzlich zur Parameterübertragung: Suchwort nur im Inhalt, getrennte Titeleingrenzung, kombinierte Metadaten-/Datumsfilter und mehrere Seiten. Ein Fake, der unabhängig von den Parametern dieselben Treffer liefert, belegt keine Suchsemantik.
|
||||
- Reale Paperless-Abnahme an der vorhandenen autorisierten Instanz lesend ausführen, soweit verfügbar. Schemaauslesen und tatsächliche Dokumentabfrage sind verschiedene Nachweise.
|
||||
- Reale IMAP-Abnahme aus K1 und konkrete problematische Mail aus K2 prüfen, soweit verfügbar. Nicht verfügbare Anschlüsse oder fehlende konkrete Beispieldaten als offen benennen; keine Credentials beschaffen oder Inhalte extern veröffentlichen.
|
||||
|
||||
**Abnahme:** Der Abschlussbericht trennt je Punkt Umsetzung, synthetischen Funktionsnachweis, Bediennachweis und tatsächlichen Quellencheck. Ein nicht ausgeführter Realtest erhält keinen Status „bestanden“.
|
||||
|
||||
## 4. Durchführung und Abschluss
|
||||
|
||||
1. Aktuellen Code gezielt gegen K1–K7 prüfen. Bereits behobene Punkte mit ihrem konkreten Nachweis übernehmen; keine Änderungen nur zum Nachbauen alter Fundstellen. Zeilenangaben in den Berichten beziehen sich auf den damaligen Stand.
|
||||
2. Mit den unmittelbar störenden Mailproblemen K1/K2 beginnen und die nötigen gemeinsamen Änderungen aus K3/K5 einbeziehen. Bestehende Funktionen weiterverwenden. Die übrigen Korrekturen gehören zum selben Auftrag und werden nicht still zurückgestellt.
|
||||
3. Passende Regressionstests gezielt ergänzen, dann relevante Gesamttests und Frontend-Build ausführen. Bestandene breite Läufe ohne neue Änderung oder offene Sorge nicht ständig wiederholen. Keine produktive DB für automatisierte Tests.
|
||||
4. Betroffene UI auf Desktop und bei 390/360 px prüfen: Fokus, Tastatur, Fehler, Laden, Leerzustand und Abbruch. Gewählte Gestaltung und kompakte Inhaltslisten erhalten.
|
||||
5. Bestehende Abschlussmatrix und betroffene API-/Architekturdokumentation gezielt nachführen. Keine neue vollständige Grundlagen-Spezifikation.
|
||||
|
||||
Liefere abschließend eine kurze Matrix mit **K1–K7, geändertem Verhalten, konkretem Nachweis, Ergebnis und verbleibender Grenze**. Bei Blockern deren Auswirkung benennen, während unabhängige Korrekturen weiterlaufen. Ein funktionierender Zwischenstand darf als solcher übergeben werden; den gesamten Auftrag erst bei erfüllten Kriterien als abgeschlossen melden.
|
||||
|
||||
Weiterhin außerhalb dieses Auftrags: Finanzfunktionen, KI, bidirektionale Paperless-Synchronisation, neue SaaS-/Runtime-/Kryptografieplattform und produktive weitere Speicheranbieter. Kein Push, Deployment, externer Versand oder Eingriff in andere Produkte.
|
||||
@@ -21,6 +21,8 @@ Diese Datei sichert bestätigte Anforderungen, den Quellenabgleich und das näch
|
||||
|
||||
**Implementierungsnachweis 19.10.2026, ohne neue Fachversion:** Die lesende Connector-/Storage-Grundlage ist lokal umgesetzt. Das ist ein Implementierungsnachweis zum Vertrag v0.1, keine neue bestätigte Produktentscheidung und keine Aufhebung von F-02b oder F-02c. Die erste Source-Lieferung bleibt lesend. Bidirektionale Feldsynchronisation bleibt der spätere Ausbau. Die Nacharbeit an großen IMAP-Fächern, der Paperless-Suche und der internen Markdown-Notiz ist beauftragt und lokal umgesetzt: [TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md](TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md). Eine Notiz bleibt ein interner Gegenstand. Beim Öffnen erscheint zuerst die gesetzte Markdown-Fassung. Mit Bearbeitungsrecht folgt eine formatierte Bearbeitung mit Formatierungsleiste und umschaltbarem Markdown-Quelltext. Weicht die formatierte Ansicht vom gespeicherten Markdown ab, bleibt der Quelltext maßgeblich. Die Abschlusskriterien in [TSUMUGU_CONNECTOR_ABSCHLUSSKRITERIEN_2026-10-19.md](TSUMUGU_CONNECTOR_ABSCHLUSSKRITERIEN_2026-10-19.md) haben Vorrang vor einem nur teilweise integrierten Zwischenstand. Nachweis, Grenzen und die Matrix stehen in [TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md](TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md). Der frühere Zwischenstand bleibt in [TSUMUGU_CONNECTOR_BASIS_ERGEBNIS_2026-10-19.md](TSUMUGU_CONNECTOR_BASIS_ERGEBNIS_2026-10-19.md).
|
||||
|
||||
**Implementierungsnachweis 20.10.2026, ohne neue Fachversion:** Die Korrektur K1–K7 ist lokal umgesetzt: [TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md](TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md). IMAP-Fachnamen mit Leerzeichen, Anführungszeichen oder Backslash gehen als gequotete Protokollargumente an den Server. Die gemeinsame MIME-Auswertung trennt Anzeigenamen und Archivnamen und liefert eine bereinigte HTML-Ansicht neben einer gekennzeichneten Textfassung. Externe Abrufe und die Veröffentlichung von Dateibytes laufen außerhalb der offenen Fachtransaktion; der fachliche Abschluss folgt danach. Der Markdown-Leser stellt die Ebenen 1–6, verschachtelte Listen und den Listenstart dar. Neue Leser hängen an der Registrierung. Verspätete Paperless-Antworten ändern nicht die inzwischen gewählte Instanz. F-02b und F-02c bleiben offen. Eine echte Postfach- und Dokumentprüfung an den bestehenden Zugängen ist nicht erfolgt.
|
||||
|
||||
## 2. Gesicherter fachlicher Kern
|
||||
|
||||
**Bestätigt durch aktuellen Auftrag und/oder ursprüngliche Nutzeraussagen:**
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
# Tsumugu – Übergabe zur fachlichen Weiterplanung
|
||||
|
||||
**Nachtrag 20.10.2026:** Der Korrekturauftrag K1–K7 ist lokal umgesetzt und nicht deployed. Auftrag, Mailbefund und Review stehen in [TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md](TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md). Die Nachweise und die offenen echten Quellenprüfungen stehen am Ende der [Abschlussmatrix](TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md). Ein lebendes Postfach und eine echte Paperless-Dokumentabfrage bleiben offen.
|
||||
|
||||
**Nachtrag 19.10.2026:** Die Connector-/Storage-Grundlage ist gegen die Abschlusskriterien geschlossen. Die Matrix steht in [TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md](TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md). Die Nacharbeit an großen IMAP-Fächern, der Paperless-Suche und der internen Markdown-Notiz ist lokal umgesetzt; Auftrag und Grenzen stehen in [TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md](TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md). F-02b und F-02c bleiben erhalten; eine bidirektionale Paperless-Schreibsynchronisation startet dieser Auftrag nicht. Der übrige Text dieser Übergabe beschreibt den Stand vom 17. und 18.10.2026.
|
||||
|
||||
**Stand:** 17.10.2026 · **Zweck:** Einstieg in einen neuen fachlichen Planungschat nach Auswahl des Designkonzepts. Keine neue Produktentscheidung und kein zusätzlicher Implementierungsauftrag.
|
||||
|
||||
Generated
+302
@@ -10,6 +10,7 @@
|
||||
"pdfjs-dist": "^4.10.38",
|
||||
"react": "18.3.1",
|
||||
"react-dom": "18.3.1",
|
||||
"react-markdown": "9.1.0",
|
||||
"react-router-dom": "6.28.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
@@ -3868,12 +3869,28 @@
|
||||
"integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@types/react": {
|
||||
"version": "19.3.0",
|
||||
"resolved": "https://registry.npmjs.org/@types/react/-/react-19.3.0.tgz",
|
||||
"integrity": "sha512-N0rFCuH9YoxG9/m61l9MfpJKfmLOVU0em7ipIz6TRgSSkvReLB9vL85GB+yr8Bs5leqpvg96JSwF4ZS1s4viQg==",
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"csstype": "^3.2.2"
|
||||
}
|
||||
},
|
||||
"node_modules/@types/unist": {
|
||||
"version": "3.0.3",
|
||||
"resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz",
|
||||
"integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@ungap/structured-clone": {
|
||||
"version": "1.4.0",
|
||||
"resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.4.0.tgz",
|
||||
"integrity": "sha512-1mEZtMKPM09vDmQt5y7YvmN2+DFTP7Tg0EWXdic8/C6VRnpb33e4ghisCIE3WZjsE2N8mf+QV1Zqh7ZFYLWInQ==",
|
||||
"license": "ISC"
|
||||
},
|
||||
"node_modules/@vitejs/plugin-react": {
|
||||
"version": "4.3.4",
|
||||
"resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.3.4.tgz",
|
||||
@@ -3940,6 +3957,16 @@
|
||||
"node": ">=10"
|
||||
}
|
||||
},
|
||||
"node_modules/bail": {
|
||||
"version": "2.0.2",
|
||||
"resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz",
|
||||
"integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==",
|
||||
"license": "MIT",
|
||||
"funding": {
|
||||
"type": "github",
|
||||
"url": "https://github.com/sponsors/wooorm"
|
||||
}
|
||||
},
|
||||
"node_modules/base64-js": {
|
||||
"version": "1.5.1",
|
||||
"resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
|
||||
@@ -4142,6 +4169,16 @@
|
||||
"@codemirror/view": "^6.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/comma-separated-tokens": {
|
||||
"version": "2.0.3",
|
||||
"resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
|
||||
"integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==",
|
||||
"license": "MIT",
|
||||
"funding": {
|
||||
"type": "github",
|
||||
"url": "https://github.com/sponsors/wooorm"
|
||||
}
|
||||
},
|
||||
"node_modules/compute-scroll-into-view": {
|
||||
"version": "2.0.4",
|
||||
"resolved": "https://registry.npmjs.org/compute-scroll-into-view/-/compute-scroll-into-view-2.0.4.tgz",
|
||||
@@ -4161,6 +4198,12 @@
|
||||
"integrity": "sha512-aK6BbWfhf4U/wCcLHKPJl/xa6VkVstRaPywWtMKGwuOLc/wZTyQYuoxgvZnNsBvv7Kg3YTBQYYBCggcviQczuA==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/csstype": {
|
||||
"version": "3.2.3",
|
||||
"resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
|
||||
"integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/d": {
|
||||
"version": "1.0.2",
|
||||
"resolved": "https://registry.npmjs.org/d/-/d-1.0.2.tgz",
|
||||
@@ -4451,6 +4494,12 @@
|
||||
"type": "^2.7.2"
|
||||
}
|
||||
},
|
||||
"node_modules/extend": {
|
||||
"version": "3.0.2",
|
||||
"resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
|
||||
"integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/fault": {
|
||||
"version": "2.0.1",
|
||||
"resolved": "https://registry.npmjs.org/fault/-/fault-2.0.1.tgz",
|
||||
@@ -4506,6 +4555,56 @@
|
||||
"node": ">=6"
|
||||
}
|
||||
},
|
||||
"node_modules/hast-util-to-jsx-runtime": {
|
||||
"version": "2.3.6",
|
||||
"resolved": "https://registry.npmjs.org/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.6.tgz",
|
||||
"integrity": "sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@types/estree": "^1.0.0",
|
||||
"@types/hast": "^3.0.0",
|
||||
"@types/unist": "^3.0.0",
|
||||
"comma-separated-tokens": "^2.0.0",
|
||||
"devlop": "^1.0.0",
|
||||
"estree-util-is-identifier-name": "^3.0.0",
|
||||
"hast-util-whitespace": "^3.0.0",
|
||||
"mdast-util-mdx-expression": "^2.0.0",
|
||||
"mdast-util-mdx-jsx": "^3.0.0",
|
||||
"mdast-util-mdxjs-esm": "^2.0.0",
|
||||
"property-information": "^7.0.0",
|
||||
"space-separated-tokens": "^2.0.0",
|
||||
"style-to-js": "^1.0.0",
|
||||
"unist-util-position": "^5.0.0",
|
||||
"vfile-message": "^4.0.0"
|
||||
},
|
||||
"funding": {
|
||||
"type": "opencollective",
|
||||
"url": "https://opencollective.com/unified"
|
||||
}
|
||||
},
|
||||
"node_modules/hast-util-whitespace": {
|
||||
"version": "3.0.0",
|
||||
"resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz",
|
||||
"integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@types/hast": "^3.0.0"
|
||||
},
|
||||
"funding": {
|
||||
"type": "opencollective",
|
||||
"url": "https://opencollective.com/unified"
|
||||
}
|
||||
},
|
||||
"node_modules/html-url-attributes": {
|
||||
"version": "3.0.1",
|
||||
"resolved": "https://registry.npmjs.org/html-url-attributes/-/html-url-attributes-3.0.1.tgz",
|
||||
"integrity": "sha512-ol6UPyBWqsrO6EJySPz2O7ZSr856WDrEzM5zMqp+FJJLGMW35cLYmmZnl0vztAZxRUoNZJFTCohfjuIJ8I4QBQ==",
|
||||
"license": "MIT",
|
||||
"funding": {
|
||||
"type": "opencollective",
|
||||
"url": "https://opencollective.com/unified"
|
||||
}
|
||||
},
|
||||
"node_modules/ieee754": {
|
||||
"version": "1.2.1",
|
||||
"resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
|
||||
@@ -4526,6 +4625,12 @@
|
||||
],
|
||||
"license": "BSD-3-Clause"
|
||||
},
|
||||
"node_modules/inline-style-parser": {
|
||||
"version": "0.2.7",
|
||||
"resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.7.tgz",
|
||||
"integrity": "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/intersection-observer": {
|
||||
"version": "0.10.0",
|
||||
"resolved": "https://registry.npmjs.org/intersection-observer/-/intersection-observer-0.10.0.tgz",
|
||||
@@ -4577,6 +4682,18 @@
|
||||
"url": "https://github.com/sponsors/wooorm"
|
||||
}
|
||||
},
|
||||
"node_modules/is-plain-obj": {
|
||||
"version": "4.1.0",
|
||||
"resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
|
||||
"integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
"node": ">=12"
|
||||
},
|
||||
"funding": {
|
||||
"url": "https://github.com/sponsors/sindresorhus"
|
||||
}
|
||||
},
|
||||
"node_modules/isomorphic.js": {
|
||||
"version": "0.2.5",
|
||||
"resolved": "https://registry.npmjs.org/isomorphic.js/-/isomorphic.js-0.2.5.tgz",
|
||||
@@ -4930,6 +5047,27 @@
|
||||
"url": "https://opencollective.com/unified"
|
||||
}
|
||||
},
|
||||
"node_modules/mdast-util-to-hast": {
|
||||
"version": "13.2.1",
|
||||
"resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz",
|
||||
"integrity": "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@types/hast": "^3.0.0",
|
||||
"@types/mdast": "^4.0.0",
|
||||
"@ungap/structured-clone": "^1.0.0",
|
||||
"devlop": "^1.0.0",
|
||||
"micromark-util-sanitize-uri": "^2.0.0",
|
||||
"trim-lines": "^3.0.0",
|
||||
"unist-util-position": "^5.0.0",
|
||||
"unist-util-visit": "^5.0.0",
|
||||
"vfile": "^6.0.0"
|
||||
},
|
||||
"funding": {
|
||||
"type": "opencollective",
|
||||
"url": "https://opencollective.com/unified"
|
||||
}
|
||||
},
|
||||
"node_modules/mdast-util-to-markdown": {
|
||||
"version": "2.2.0",
|
||||
"resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-2.2.0.tgz",
|
||||
@@ -5857,6 +5995,16 @@
|
||||
"integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/property-information": {
|
||||
"version": "7.2.0",
|
||||
"resolved": "https://registry.npmjs.org/property-information/-/property-information-7.2.0.tgz",
|
||||
"integrity": "sha512-IAtzIB6sUiWaJYrX9smp3V46pBGbBeLFRGdh25kg1334VcBlD8HzhPeNIWQH9zhGmo2itIe25EHt9dQP7G5hmg==",
|
||||
"license": "MIT",
|
||||
"funding": {
|
||||
"type": "github",
|
||||
"url": "https://github.com/sponsors/wooorm"
|
||||
}
|
||||
},
|
||||
"node_modules/react": {
|
||||
"version": "18.3.1",
|
||||
"resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
|
||||
@@ -5937,6 +6085,33 @@
|
||||
"integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/react-markdown": {
|
||||
"version": "9.1.0",
|
||||
"resolved": "https://registry.npmjs.org/react-markdown/-/react-markdown-9.1.0.tgz",
|
||||
"integrity": "sha512-xaijuJB0kzGiUdG7nc2MOMDUDBWPyGAjZtUrow9XxUeua8IqeP+VlIfAZ3bphpcLTnSZXz6z9jcVC/TCwbfgdw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@types/hast": "^3.0.0",
|
||||
"@types/mdast": "^4.0.0",
|
||||
"devlop": "^1.0.0",
|
||||
"hast-util-to-jsx-runtime": "^2.0.0",
|
||||
"html-url-attributes": "^3.0.0",
|
||||
"mdast-util-to-hast": "^13.0.0",
|
||||
"remark-parse": "^11.0.0",
|
||||
"remark-rehype": "^11.0.0",
|
||||
"unified": "^11.0.0",
|
||||
"unist-util-visit": "^5.0.0",
|
||||
"vfile": "^6.0.0"
|
||||
},
|
||||
"funding": {
|
||||
"type": "opencollective",
|
||||
"url": "https://opencollective.com/unified"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@types/react": ">=18",
|
||||
"react": ">=18"
|
||||
}
|
||||
},
|
||||
"node_modules/react-refresh": {
|
||||
"version": "0.14.2",
|
||||
"resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.14.2.tgz",
|
||||
@@ -6048,6 +6223,39 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"node_modules/remark-parse": {
|
||||
"version": "11.0.0",
|
||||
"resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-11.0.0.tgz",
|
||||
"integrity": "sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@types/mdast": "^4.0.0",
|
||||
"mdast-util-from-markdown": "^2.0.0",
|
||||
"micromark-util-types": "^2.0.0",
|
||||
"unified": "^11.0.0"
|
||||
},
|
||||
"funding": {
|
||||
"type": "opencollective",
|
||||
"url": "https://opencollective.com/unified"
|
||||
}
|
||||
},
|
||||
"node_modules/remark-rehype": {
|
||||
"version": "11.1.2",
|
||||
"resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-11.1.2.tgz",
|
||||
"integrity": "sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@types/hast": "^3.0.0",
|
||||
"@types/mdast": "^4.0.0",
|
||||
"mdast-util-to-hast": "^13.0.0",
|
||||
"unified": "^11.0.0",
|
||||
"vfile": "^6.0.0"
|
||||
},
|
||||
"funding": {
|
||||
"type": "opencollective",
|
||||
"url": "https://opencollective.com/unified"
|
||||
}
|
||||
},
|
||||
"node_modules/rollup": {
|
||||
"version": "4.64.7",
|
||||
"resolved": "https://registry.npmjs.org/rollup/-/rollup-4.64.7.tgz",
|
||||
@@ -6198,6 +6406,16 @@
|
||||
"node": ">=0.10.0"
|
||||
}
|
||||
},
|
||||
"node_modules/space-separated-tokens": {
|
||||
"version": "2.0.2",
|
||||
"resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz",
|
||||
"integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==",
|
||||
"license": "MIT",
|
||||
"funding": {
|
||||
"type": "github",
|
||||
"url": "https://github.com/sponsors/wooorm"
|
||||
}
|
||||
},
|
||||
"node_modules/static-browser-server": {
|
||||
"version": "1.0.3",
|
||||
"resolved": "https://registry.npmjs.org/static-browser-server/-/static-browser-server-1.0.3.tgz",
|
||||
@@ -6236,12 +6454,50 @@
|
||||
"integrity": "sha512-XXWIQt633/EpAFx8aZDOTjBzrCaGmhvEQlQo6MVPfa2OzO2cWo+4hV9h+6UkHYlXGfy+ODXKUdP7Pthmcu5ATw==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/style-to-js": {
|
||||
"version": "1.1.21",
|
||||
"resolved": "https://registry.npmjs.org/style-to-js/-/style-to-js-1.1.21.tgz",
|
||||
"integrity": "sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"style-to-object": "1.0.14"
|
||||
}
|
||||
},
|
||||
"node_modules/style-to-object": {
|
||||
"version": "1.0.14",
|
||||
"resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-1.0.14.tgz",
|
||||
"integrity": "sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"inline-style-parser": "0.2.7"
|
||||
}
|
||||
},
|
||||
"node_modules/tabbable": {
|
||||
"version": "6.5.0",
|
||||
"resolved": "https://registry.npmjs.org/tabbable/-/tabbable-6.5.0.tgz",
|
||||
"integrity": "sha512-wieBHXygIm7OyQOu5hQlkk62/WyCFYGlWg7L6/ZCUZwx0o398Zkn4pVmMyfYhfMG8kGrj/Krt8eIk6UKC6VzwA==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/trim-lines": {
|
||||
"version": "3.0.1",
|
||||
"resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
|
||||
"integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==",
|
||||
"license": "MIT",
|
||||
"funding": {
|
||||
"type": "github",
|
||||
"url": "https://github.com/sponsors/wooorm"
|
||||
}
|
||||
},
|
||||
"node_modules/trough": {
|
||||
"version": "2.2.0",
|
||||
"resolved": "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz",
|
||||
"integrity": "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==",
|
||||
"license": "MIT",
|
||||
"funding": {
|
||||
"type": "github",
|
||||
"url": "https://github.com/sponsors/wooorm"
|
||||
}
|
||||
},
|
||||
"node_modules/tslib": {
|
||||
"version": "2.8.1",
|
||||
"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
|
||||
@@ -6263,6 +6519,25 @@
|
||||
"diff": "^5.1.0"
|
||||
}
|
||||
},
|
||||
"node_modules/unified": {
|
||||
"version": "11.0.5",
|
||||
"resolved": "https://registry.npmjs.org/unified/-/unified-11.0.5.tgz",
|
||||
"integrity": "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@types/unist": "^3.0.0",
|
||||
"bail": "^2.0.0",
|
||||
"devlop": "^1.0.0",
|
||||
"extend": "^3.0.0",
|
||||
"is-plain-obj": "^4.0.0",
|
||||
"trough": "^2.0.0",
|
||||
"vfile": "^6.0.0"
|
||||
},
|
||||
"funding": {
|
||||
"type": "opencollective",
|
||||
"url": "https://opencollective.com/unified"
|
||||
}
|
||||
},
|
||||
"node_modules/unist-util-is": {
|
||||
"version": "6.0.1",
|
||||
"resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz",
|
||||
@@ -6276,6 +6551,19 @@
|
||||
"url": "https://opencollective.com/unified"
|
||||
}
|
||||
},
|
||||
"node_modules/unist-util-position": {
|
||||
"version": "5.0.0",
|
||||
"resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz",
|
||||
"integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@types/unist": "^3.0.0"
|
||||
},
|
||||
"funding": {
|
||||
"type": "opencollective",
|
||||
"url": "https://opencollective.com/unified"
|
||||
}
|
||||
},
|
||||
"node_modules/unist-util-position-from-estree": {
|
||||
"version": "2.0.0",
|
||||
"resolved": "https://registry.npmjs.org/unist-util-position-from-estree/-/unist-util-position-from-estree-2.0.0.tgz",
|
||||
@@ -6423,6 +6711,20 @@
|
||||
"node": ">=8"
|
||||
}
|
||||
},
|
||||
"node_modules/vfile": {
|
||||
"version": "6.0.3",
|
||||
"resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz",
|
||||
"integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@types/unist": "^3.0.0",
|
||||
"vfile-message": "^4.0.0"
|
||||
},
|
||||
"funding": {
|
||||
"type": "opencollective",
|
||||
"url": "https://opencollective.com/unified"
|
||||
}
|
||||
},
|
||||
"node_modules/vfile-message": {
|
||||
"version": "4.0.3",
|
||||
"resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz",
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
"pdfjs-dist": "^4.10.38",
|
||||
"react": "18.3.1",
|
||||
"react-dom": "18.3.1",
|
||||
"react-markdown": "9.1.0",
|
||||
"react-router-dom": "6.28.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
import React from "react";
|
||||
import { createServer } from "vite";
|
||||
import { renderToStaticMarkup } from "react-dom/server";
|
||||
|
||||
const server = await createServer({
|
||||
server: { middlewareMode: true },
|
||||
appType: "custom",
|
||||
logLevel: "error",
|
||||
});
|
||||
|
||||
try {
|
||||
await server.ssrLoadModule("/src/sources/builtin-views.jsx");
|
||||
const pane = await server.ssrLoadModule("/src/pages/ReadingPane.jsx");
|
||||
const fixture = await server.ssrLoadModule("/src/sources/fixture-view.jsx");
|
||||
fixture.installFixture();
|
||||
const html = renderToStaticMarkup(React.createElement(pane.ReadingPane, {
|
||||
binding: {
|
||||
id: "binding-1",
|
||||
element: {
|
||||
id: "element-1",
|
||||
kind: "file",
|
||||
title: "Probe",
|
||||
owner_subject_id: "account-1",
|
||||
version: 1,
|
||||
preview: { media: "fixture", text: "Dritter Baustein", available: true },
|
||||
dates: {},
|
||||
},
|
||||
rights: { edit: false, read: true },
|
||||
communication: {},
|
||||
annotations: [],
|
||||
},
|
||||
context: { kind: "matter", id: "matter-1" },
|
||||
onClose() {},
|
||||
onReload() {},
|
||||
}));
|
||||
if (!html.includes("data-stage=\"fixture\"") || !html.includes("Dritter Baustein")) {
|
||||
console.error(html);
|
||||
process.exitCode = 1;
|
||||
} else {
|
||||
console.log("reader shell rendered the registered fixture");
|
||||
}
|
||||
const registry = await server.ssrLoadModule("/src/sources/registry.jsx");
|
||||
const saved = await registry.editors.fixture.save();
|
||||
if (saved.notice !== "gespeichert") {
|
||||
console.error(saved);
|
||||
process.exitCode = 1;
|
||||
} else {
|
||||
console.log("registered fixture editor saved");
|
||||
}
|
||||
const markdown = await server.ssrLoadModule("/src/markdown.jsx");
|
||||
const source = [
|
||||
"# Eins",
|
||||
"## Zwei",
|
||||
"### Drei",
|
||||
"#### Vier",
|
||||
"##### Fuenf",
|
||||
"###### Sechs",
|
||||
"",
|
||||
"> Zitat",
|
||||
"",
|
||||
"- Ebene 1",
|
||||
" - Ebene 2",
|
||||
"",
|
||||
"5. Fuenfter",
|
||||
"",
|
||||
"[Hinweis](https://example.test/hinweis)",
|
||||
"",
|
||||
"`code`",
|
||||
"",
|
||||
"<script>alert(1)</script>",
|
||||
"",
|
||||
"[aktiv](javascript:alert(1))",
|
||||
"",
|
||||
"",
|
||||
].join("\n");
|
||||
const rendered = renderToStaticMarkup(React.createElement(markdown.MarkdownView, { text: source }));
|
||||
const required = ["<h1>", "<h2>", "<h3>", "<h4>", "<h5>", "<h6>", '<ol start="5">', "<blockquote>", 'href="https://example.test/hinweis"', "<code>", "Ebene 2"];
|
||||
const blocked = ["<script", "<img", 'href="javascript:'];
|
||||
const missing = required.filter((item) => !rendered.includes(item));
|
||||
const present = blocked.filter((item) => rendered.includes(item));
|
||||
if (missing.length || present.length) {
|
||||
console.error(JSON.stringify({ missing, present, rendered }));
|
||||
process.exitCode = 1;
|
||||
} else {
|
||||
console.log("markdown reader kept structure and blocked active content");
|
||||
}
|
||||
} finally {
|
||||
await server.close();
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
export function MailBody({ html, text, truncated, notices = [] }) {
|
||||
return (
|
||||
<div className="mail-reading">
|
||||
{html ? <div className="mail-letter__html" dangerouslySetInnerHTML={{ __html: html }} /> : null}
|
||||
<p className="muted">Vereinfachte Textfassung. Sie ist nicht die formatierte Ansicht.</p>
|
||||
{text ? <pre className="mail-letter__body">{text}</pre> : <p className="muted">Diese Nachricht hat keinen lesbaren Text.</p>}
|
||||
{truncated ? <p className="muted">Der Text ist gekürzt, weil die Nachricht sehr groß ist. Das Original bleibt die vollständige E-Mail.</p> : null}
|
||||
{notices.map((item) => <p key={item} className="notice">{item}</p>)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
export function MailAttachments({ files, current, onOpen }) {
|
||||
if (!files?.length) return <p className="muted">Keine Anhänge.</p>;
|
||||
return (
|
||||
<ul className="mail-files">
|
||||
{files.map((file) => (
|
||||
<li key={`${file.index ?? "name"}-${file.archive_name || file.filename}`}>
|
||||
{onOpen && Number.isInteger(file.index) ? (
|
||||
<button type="button" className={file.index === current ? "quiet is-current" : "quiet"} aria-pressed={file.index === current} onClick={() => onOpen(file)}>
|
||||
{file.filename}
|
||||
</button>
|
||||
) : file.filename}
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
);
|
||||
}
|
||||
@@ -4,6 +4,11 @@ import { BrowserRouter } from "react-router-dom";
|
||||
import { App } from "./App.jsx";
|
||||
import "./styles.css";
|
||||
|
||||
if (import.meta.env.DEV && new URLSearchParams(window.location.search).has("probe")) {
|
||||
const probe = await import("./sources/sample-source.js");
|
||||
probe.installSampleSource();
|
||||
}
|
||||
|
||||
createRoot(document.getElementById("root")).render(
|
||||
<React.StrictMode>
|
||||
<BrowserRouter>
|
||||
|
||||
+17
-86
@@ -1,91 +1,22 @@
|
||||
import { Fragment } from "react";
|
||||
import ReactMarkdown from "react-markdown";
|
||||
|
||||
function inline(text, keyPrefix) {
|
||||
const pattern = /(\*\*[^*]+\*\*|\*[^*]+\*|`[^`]+`|\[[^\]]+\]\(https?:\/\/[^)\s]+\))/g;
|
||||
const nodes = [];
|
||||
let last = 0;
|
||||
let index = 0;
|
||||
for (const match of text.matchAll(pattern)) {
|
||||
if (match.index > last) nodes.push(text.slice(last, match.index));
|
||||
const token = match[0];
|
||||
const key = `${keyPrefix}-${index}`;
|
||||
if (token.startsWith("**")) nodes.push(<strong key={key}>{token.slice(2, -2)}</strong>);
|
||||
else if (token.startsWith("*")) nodes.push(<em key={key}>{token.slice(1, -1)}</em>);
|
||||
else if (token.startsWith("`")) nodes.push(<code key={key}>{token.slice(1, -1)}</code>);
|
||||
else {
|
||||
const linked = token.match(/^\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)$/);
|
||||
if (linked) nodes.push(<a key={key} href={linked[2]} rel="noreferrer">{linked[1]}</a>);
|
||||
}
|
||||
last = match.index + token.length;
|
||||
index += 1;
|
||||
}
|
||||
if (last < text.length) nodes.push(text.slice(last));
|
||||
return nodes;
|
||||
const SAFE_LINK = /^(https?:\/\/|mailto:)/i;
|
||||
|
||||
function Link({ href, children }) {
|
||||
if (!SAFE_LINK.test(href || "")) return <span>{children}</span>;
|
||||
return <a href={href} rel="noreferrer">{children}</a>;
|
||||
}
|
||||
|
||||
function Image({ alt }) {
|
||||
return alt ? <span>{alt}</span> : null;
|
||||
}
|
||||
|
||||
export function MarkdownView({ text }) {
|
||||
const lines = String(text || "").replace(/\r\n/g, "\n").split("\n");
|
||||
const blocks = [];
|
||||
let list = null;
|
||||
let index = 0;
|
||||
function closeList() {
|
||||
if (!list) return;
|
||||
const items = list.items.map((item, itemIndex) => <li key={`${list.key}-${itemIndex}`}>{inline(item, `${list.key}-${itemIndex}`)}</li>);
|
||||
blocks.push(list.ordered ? <ol key={list.key}>{items}</ol> : <ul key={list.key}>{items}</ul>);
|
||||
list = null;
|
||||
}
|
||||
while (index < lines.length) {
|
||||
const line = lines[index];
|
||||
if (line.startsWith("```")) {
|
||||
closeList();
|
||||
const body = [];
|
||||
index += 1;
|
||||
while (index < lines.length && !lines[index].startsWith("```")) {
|
||||
body.push(lines[index]);
|
||||
index += 1;
|
||||
}
|
||||
blocks.push(<pre key={`code-${index}`}><code>{body.join("\n")}</code></pre>);
|
||||
index += 1;
|
||||
continue;
|
||||
}
|
||||
if (line.startsWith(">")) {
|
||||
closeList();
|
||||
const body = [];
|
||||
while (index < lines.length && lines[index].startsWith(">")) {
|
||||
body.push(lines[index].replace(/^>\s?/, ""));
|
||||
index += 1;
|
||||
}
|
||||
blocks.push(<blockquote key={`q-${index}`}>{body.map((item, itemIndex) => <p key={itemIndex}>{inline(item, `q-${index}-${itemIndex}`)}</p>)}</blockquote>);
|
||||
continue;
|
||||
}
|
||||
const heading = line.match(/^(#{1,3})\s+(.*)$/);
|
||||
const bullet = line.match(/^\s*[-*]\s+(.*)$/);
|
||||
const numbered = line.match(/^\s*\d+\.\s+(.*)$/);
|
||||
if (heading) {
|
||||
closeList();
|
||||
const Tag = heading[1].length === 1 ? "h3" : heading[1].length === 2 ? "h4" : "h5";
|
||||
blocks.push(<Tag key={`h-${index}`}>{inline(heading[2], `h-${index}`)}</Tag>);
|
||||
index += 1;
|
||||
continue;
|
||||
}
|
||||
if (bullet || numbered) {
|
||||
if (!list || list.ordered !== Boolean(numbered)) {
|
||||
closeList();
|
||||
list = { key: `l-${index}`, ordered: Boolean(numbered), items: [] };
|
||||
}
|
||||
list.items.push((bullet || numbered)[1]);
|
||||
index += 1;
|
||||
continue;
|
||||
}
|
||||
closeList();
|
||||
if (!line.trim()) {
|
||||
blocks.push(<Fragment key={`s-${index}`} />);
|
||||
index += 1;
|
||||
continue;
|
||||
}
|
||||
blocks.push(<p key={`p-${index}`}>{inline(line, `p-${index}`)}</p>);
|
||||
index += 1;
|
||||
}
|
||||
closeList();
|
||||
return <div className="markdown">{blocks}</div>;
|
||||
return (
|
||||
<div className="markdown">
|
||||
<ReactMarkdown components={{ a: Link, img: Image }}>
|
||||
{String(text || "")}
|
||||
</ReactMarkdown>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -1,9 +1,8 @@
|
||||
import { useContext, useEffect, useRef, useState } from "react";
|
||||
import { SessionContext } from "../session.js";
|
||||
import { documentToText, downloadMailPart, fetchExternal, fetchFile, fetchMailPart, isDirty, markDirty, textToDocument, api } from "../api.js";
|
||||
import { MarkdownView } from "../markdown.jsx";
|
||||
import { NoteEditor } from "../notes.jsx";
|
||||
import { SourceAssignment, noteEditor, representationOf } from "../sources/registry.jsx";
|
||||
import { SourceAssignment, representationOf, stageFor } from "../sources/registry.jsx";
|
||||
import "../sources/builtin-views.jsx";
|
||||
import { ErrorNote } from "./widgets.jsx";
|
||||
import { UnitDetail } from "./correspondence.jsx";
|
||||
import { dateCaption, DateField, DirectionChoice, DirectionColumn, directionValue, directionWord, formatDate, mailFacts, sourceLabel } from "./content.jsx";
|
||||
@@ -132,14 +131,14 @@ export function ReadingPane({ binding, context, backLabel, onClose, onReload, ca
|
||||
useEffect(() => {
|
||||
if (!element) return undefined;
|
||||
const kind = representationOf(element);
|
||||
if (kind === "note" || kind === "mail") setPhase("ready");
|
||||
if (stageFor(kind) || kind === "note" || kind === "mail") setPhase("ready");
|
||||
else if (kind === "locked" || kind === "unassigned" || !element.preview?.available) setPhase("missing");
|
||||
setError("");
|
||||
return undefined;
|
||||
}, [element?.id, element?.kind, element?.external?.source, element?.external?.resolution, element?.file?.protection_profile, element?.preview?.available]);
|
||||
|
||||
useEffect(() => {
|
||||
if (!element || representationOf(element) === "note" || representationOf(element) === "mail" || representationOf(element) === "locked" || representationOf(element) === "unassigned" || !element.preview?.available) return undefined;
|
||||
if (!element || stageFor(representationOf(element)) || representationOf(element) === "locked" || representationOf(element) === "unassigned" || !element.preview?.available) return undefined;
|
||||
let alive = true;
|
||||
let url = "";
|
||||
setPage(1);
|
||||
@@ -206,7 +205,7 @@ export function ReadingPane({ binding, context, backLabel, onClose, onReload, ca
|
||||
}, [element?.id, element?.kind, element?.external?.source, element?.external?.resolution, element?.file?.protection_profile, element?.preview?.available, context?.kind, context?.id]);
|
||||
|
||||
useEffect(() => {
|
||||
if (!element || representationOf(element) !== "mail") return undefined;
|
||||
if (!element || stageFor("mail") || representationOf(element) !== "mail") return undefined;
|
||||
if (shownIndex === null) {
|
||||
setPhase("ready");
|
||||
setPdf(null);
|
||||
@@ -275,7 +274,7 @@ export function ReadingPane({ binding, context, backLabel, onClose, onReload, ca
|
||||
}, [element?.id, element?.external?.source, shownIndex, letter, context?.kind, context?.id]);
|
||||
|
||||
useEffect(() => {
|
||||
if (!element || representationOf(element) !== "mail") return undefined;
|
||||
if (!element || stageFor("mail") || representationOf(element) !== "mail") return undefined;
|
||||
let alive = true;
|
||||
const params = new URLSearchParams();
|
||||
if (context?.kind && context?.id) {
|
||||
@@ -366,52 +365,8 @@ export function ReadingPane({ binding, context, backLabel, onClose, onReload, ca
|
||||
}
|
||||
}
|
||||
|
||||
async function saveNote(event) {
|
||||
event.preventDefault();
|
||||
setError("");
|
||||
try {
|
||||
const updated = await noteEditor.save({
|
||||
api,
|
||||
element,
|
||||
context,
|
||||
document: textToDocument(text),
|
||||
});
|
||||
pendingNote.current = text;
|
||||
editingRef.current = false;
|
||||
setEditingNote(false);
|
||||
markDirty(false);
|
||||
setNotice(updated.notice || "Der gemeinsame Text ist gespeichert.");
|
||||
onReload();
|
||||
} catch (err) {
|
||||
if (err.status === 409) {
|
||||
setError("Der Stand hat sich geändert. Der eingegebene Text bleibt stehen. Bitte neu laden.");
|
||||
return;
|
||||
}
|
||||
setError(err.message);
|
||||
}
|
||||
}
|
||||
|
||||
function beginNote() {
|
||||
pendingNote.current = "";
|
||||
editingRef.current = true;
|
||||
setText(documentToText(element.document));
|
||||
setNoteSession((current) => current + 1);
|
||||
setEditingNote(true);
|
||||
setError("");
|
||||
setNotice("");
|
||||
}
|
||||
|
||||
function cancelNote() {
|
||||
pendingNote.current = "";
|
||||
editingRef.current = false;
|
||||
setText(documentToText(element.document));
|
||||
setEditingNote(false);
|
||||
markDirty(false);
|
||||
setError("");
|
||||
}
|
||||
|
||||
function requestClose() {
|
||||
if (editingRef.current && isDirty() && !window.confirm("Ungespeicherte Eingaben verwerfen?")) return;
|
||||
if (isDirty() && !window.confirm("Ungespeicherte Eingaben verwerfen?")) return;
|
||||
markDirty(false);
|
||||
onClose();
|
||||
}
|
||||
@@ -538,6 +493,7 @@ export function ReadingPane({ binding, context, backLabel, onClose, onReload, ca
|
||||
const communication = binding.communication || {};
|
||||
const shownDirection = communication.direction || null;
|
||||
const kind = representationOf(element);
|
||||
const Stage = stageFor(kind);
|
||||
const isMail = kind === "mail";
|
||||
const locked = kind === "locked";
|
||||
const unassigned = kind === "unassigned";
|
||||
@@ -589,61 +545,8 @@ export function ReadingPane({ binding, context, backLabel, onClose, onReload, ca
|
||||
onDetach={() => {}}
|
||||
onUnfold={() => {}}
|
||||
/>
|
||||
{isMail ? (
|
||||
<article className="mail-letter">
|
||||
<p className="mail-letter__way"><DirectionColumn direction={shownDirection} />{directionWord(shownDirection) ? <span>{directionWord(shownDirection)}</span> : null}</p>
|
||||
<p><span>Von</span> {mailDetail.message_from || "Ohne Absender"}</p>
|
||||
<p><span>An</span> {mailDetail.message_to || "Ohne Empfänger"}</p>
|
||||
{mailDetail.message_cc ? <p><span>Kopie</span> {mailDetail.message_cc}</p> : null}
|
||||
{letter?.complete ? (
|
||||
<>
|
||||
<MailAttachments files={letter.attachments} current={shownIndex} onOpen={(file) => {
|
||||
setError("");
|
||||
setShownFor((current) => (
|
||||
current?.elementId === element.id && current.index === file.index ? null : { elementId: element.id, index: file.index }
|
||||
));
|
||||
}} />
|
||||
{shownFile ? <p className="mail-attachment__caption">Anlage: {shownFile.filename}</p> : null}
|
||||
{shownFile && phase === "loading" ? <p className="muted">Die Anlage wird geladen …</p> : null}
|
||||
{media === "image" && blobUrl ? (
|
||||
<img className="reader-image" alt={shownFile?.filename || element.title} src={blobUrl} style={{ width: `${Math.round(scale * 100)}%` }} />
|
||||
) : null}
|
||||
{media === "pdf" && pdf ? <canvas ref={canvasRef} className="reader-canvas" /> : null}
|
||||
{media === "pdf-frame" && blobUrl ? <iframe className="reader-frame" title={shownFile?.filename || element.title} src={blobUrl} /> : null}
|
||||
{media === "other" && blobUrl ? (
|
||||
<div className="reader-pane__state">
|
||||
<p>Diese Anlage lässt sich hier nicht als Seite zeigen.</p>
|
||||
<a href={blobUrl} target="_blank" rel="noreferrer">Anlage öffnen</a>
|
||||
</div>
|
||||
) : null}
|
||||
{letter.text ? <pre className="mail-letter__body">{letter.text}</pre> : (
|
||||
<p className="muted">Diese Nachricht hat keinen lesbaren Text. Die vollständige E-Mail bleibt abrufbar.</p>
|
||||
)}
|
||||
<button type="button" onClick={() => openMailPart("original", "nachricht.eml")}>Vollständige E-Mail</button>
|
||||
</>
|
||||
) : (
|
||||
<p className="muted">{error ? "Die vollständige Nachricht konnte nicht geladen werden." : "Die vollständige Nachricht wird geladen …"}</p>
|
||||
)}
|
||||
</article>
|
||||
) : null}
|
||||
{element.kind === "note" && noteEditor.available ? (
|
||||
editingNote && binding.rights.edit ? (
|
||||
<form className="reader-note" onSubmit={saveNote}>
|
||||
<NoteEditor key={noteSession} value={text} onChange={(value) => { setText(value); markDirty(true); }} />
|
||||
<p className="muted">Diese Änderung betrifft den gemeinsamen Inhalt der Notiz, nicht die hiesige Anmerkung. Gespeichert wird Markdown.</p>
|
||||
{notice ? <p className="notice">{notice}</p> : null}
|
||||
<div className="row">
|
||||
<button type="submit">Text speichern</button>
|
||||
<button type="button" className="quiet" onClick={cancelNote}>Abbrechen</button>
|
||||
</div>
|
||||
</form>
|
||||
) : (
|
||||
<div className="reader-note">
|
||||
{text.trim() ? <MarkdownView text={text} /> : <p className="muted">Die Notiz ist leer.</p>}
|
||||
{notice ? <p className="notice">{notice}</p> : null}
|
||||
{binding.rights.edit ? <button type="button" onClick={beginNote}>Bearbeiten</button> : <p className="muted">In diesem Kontext nur lesbar.</p>}
|
||||
</div>
|
||||
)
|
||||
{Stage ? (
|
||||
<Stage element={element} context={context} binding={binding} onReload={onReload} shownDirection={shownDirection} />
|
||||
) : null}
|
||||
<form className="stack reader-direction" onSubmit={(event) => event.preventDefault()}>
|
||||
<DirectionChoice
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
import { useEffect, useRef, useState } from "react";
|
||||
import { Link } from "react-router-dom";
|
||||
import { api, fetchBlob } from "../api.js";
|
||||
import { MailBody } from "../mail-view.jsx";
|
||||
import { SourceFrame, moduleFor, registerSourceModule, sourceModules } from "../sources/registry.jsx";
|
||||
|
||||
const SEARCH_LIMITS = {
|
||||
@@ -201,6 +202,9 @@ export function PaperlessPicker({ context, placement, chapterId = "", chapterTit
|
||||
const [previewUrl, setPreviewUrl] = useState("");
|
||||
const [pending, setPending] = useState(false);
|
||||
const [error, setError] = useState("");
|
||||
const searchRef = useRef(0);
|
||||
const previewRef = useRef(0);
|
||||
const facetRef = useRef(0);
|
||||
|
||||
useEffect(() => {
|
||||
api("/api/v1/connectors")
|
||||
@@ -217,13 +221,15 @@ export function PaperlessPicker({ context, placement, chapterId = "", chapterTit
|
||||
setFacets({ correspondents: [], document_types: [], tags: [] });
|
||||
return undefined;
|
||||
}
|
||||
const token = facetRef.current + 1;
|
||||
facetRef.current = token;
|
||||
let alive = true;
|
||||
api(`/api/v1/sources/paperless/facets?connector_id=${connectorId}`)
|
||||
.then((data) => {
|
||||
if (alive) setFacets(data);
|
||||
if (alive && token === facetRef.current) setFacets(data);
|
||||
})
|
||||
.catch((err) => {
|
||||
if (alive) setError(err.message);
|
||||
if (alive && token === facetRef.current) setError(err.message);
|
||||
});
|
||||
return () => {
|
||||
alive = false;
|
||||
@@ -253,6 +259,12 @@ export function PaperlessPicker({ context, placement, chapterId = "", chapterTit
|
||||
return params;
|
||||
}
|
||||
|
||||
function invalidate() {
|
||||
searchRef.current += 1;
|
||||
previewRef.current += 1;
|
||||
facetRef.current += 1;
|
||||
}
|
||||
|
||||
async function runSearch(event, page = "") {
|
||||
event?.preventDefault();
|
||||
setError("");
|
||||
@@ -260,12 +272,17 @@ export function PaperlessPicker({ context, placement, chapterId = "", chapterTit
|
||||
setError("Wähle zuerst den Paperless-Zugang.");
|
||||
return;
|
||||
}
|
||||
const token = searchRef.current + 1;
|
||||
searchRef.current = token;
|
||||
const asked = connectorId;
|
||||
try {
|
||||
const data = await api(`/api/v1/sources/paperless/documents?${paramsFor(page)}`);
|
||||
if (token !== searchRef.current) return;
|
||||
setItems(data.items || []);
|
||||
setNextPage(data.next_page || data.continuation || null);
|
||||
if (data.connector_id) setConnectorId(data.connector_id);
|
||||
if (!asked && data.connector_id) setConnectorId(data.connector_id);
|
||||
} catch (err) {
|
||||
if (token !== searchRef.current) return;
|
||||
setError(err.message);
|
||||
}
|
||||
}
|
||||
@@ -291,11 +308,15 @@ export function PaperlessPicker({ context, placement, chapterId = "", chapterTit
|
||||
setError("");
|
||||
if (previewUrl) URL.revokeObjectURL(previewUrl);
|
||||
setPreviewUrl("");
|
||||
const token = previewRef.current + 1;
|
||||
previewRef.current = token;
|
||||
const bound = item.connector_id || connectorId;
|
||||
try {
|
||||
const bound = item.connector_id || connectorId;
|
||||
const blob = await fetchBlob(`/api/v1/sources/paperless/documents/${item.id}/preview?connector_id=${bound}`);
|
||||
if (token !== previewRef.current) return;
|
||||
setPreviewUrl(URL.createObjectURL(blob));
|
||||
} catch (err) {
|
||||
if (token !== previewRef.current) return;
|
||||
setError(err.message);
|
||||
}
|
||||
}
|
||||
@@ -366,7 +387,16 @@ export function PaperlessPicker({ context, placement, chapterId = "", chapterTit
|
||||
{connectors.length > 1 ? (
|
||||
<label>
|
||||
Paperless-Zugang
|
||||
<select value={connectorId} onChange={(event) => { setConnectorId(event.target.value); setItems([]); setNextPage(null); }}>
|
||||
<select value={connectorId} onChange={(event) => {
|
||||
invalidate();
|
||||
if (previewUrl) URL.revokeObjectURL(previewUrl);
|
||||
setPreviewUrl("");
|
||||
setConnectorId(event.target.value);
|
||||
setFilters(EMPTY_FILTERS);
|
||||
setItems([]);
|
||||
setNextPage(null);
|
||||
setFacets({ correspondents: [], document_types: [], tags: [] });
|
||||
}}>
|
||||
<option value="">Zugang wählen</option>
|
||||
{connectors.map((item) => (
|
||||
<option key={item.id} value={item.id}>{item.name}</option>
|
||||
@@ -567,6 +597,7 @@ export function MailPicker({ context, placement, chapterId = "", chapterTitle =
|
||||
const [items, setItems] = useState([]);
|
||||
const [nextBefore, setNextBefore] = useState(null);
|
||||
const [incomplete, setIncomplete] = useState(false);
|
||||
const [contradictory, setContradictory] = useState(false);
|
||||
const [uidValidity, setUidValidity] = useState(null);
|
||||
const [notice, setNotice] = useState("");
|
||||
const [selectedKey, setSelectedKey] = useState("");
|
||||
@@ -587,6 +618,7 @@ export function MailPicker({ context, placement, chapterId = "", chapterTitle =
|
||||
if (token !== requestRef.current) return;
|
||||
setUidValidity(data.uidvalidity ?? null);
|
||||
setIncomplete(Boolean(data.incomplete));
|
||||
setContradictory(Boolean(data.contradictory));
|
||||
setNextBefore(data.next_before ?? data.continuation ?? null);
|
||||
if (data.restarted) {
|
||||
setItems(data.items || []);
|
||||
@@ -644,6 +676,7 @@ export function MailPicker({ context, placement, chapterId = "", chapterTitle =
|
||||
setItems([]);
|
||||
setNextBefore(null);
|
||||
setIncomplete(false);
|
||||
setContradictory(false);
|
||||
setNotice("");
|
||||
setSelectedKey("");
|
||||
setPreview(null);
|
||||
@@ -805,12 +838,14 @@ export function MailPicker({ context, placement, chapterId = "", chapterTitle =
|
||||
{accountId && !loading && !mailbox && !error ? <p className="muted">Dieses Konto hat keine lesbaren Fächer.</p> : null}
|
||||
{loading ? <p className="muted">{loading}</p> : null}
|
||||
{!loading && mailbox && !items.length && !error ? (
|
||||
<p className="muted">
|
||||
{incomplete
|
||||
? "In diesem Abschnitt gibt es keine Treffer. Die Suche ist noch nicht zu Ende."
|
||||
: query
|
||||
? "In diesem Fach gibt es dazu keine Nachricht."
|
||||
: "In diesem Fach gibt es keine Nachricht."}
|
||||
<p className={contradictory ? "notice" : "muted"}>
|
||||
{contradictory
|
||||
? "Das Fach meldet Nachrichten, aber es kam keine Liste an. Das Fach gilt deshalb nicht als leer."
|
||||
: incomplete
|
||||
? "In diesem Abschnitt gibt es keine Treffer. Die Suche ist noch nicht zu Ende."
|
||||
: query
|
||||
? "In diesem Fach gibt es dazu keine Nachricht."
|
||||
: "In diesem Fach gibt es keine Nachricht."}
|
||||
</p>
|
||||
) : null}
|
||||
<div className="mail-list">
|
||||
@@ -847,9 +882,7 @@ export function MailPicker({ context, placement, chapterId = "", chapterTitle =
|
||||
<MailFiles files={preview?.attachments || selected.attachments || []} />
|
||||
{previewError ? <p className="error">{previewError}</p> : null}
|
||||
{selected && !preview && !previewError ? <p className="muted">Vorschau wird geladen …</p> : null}
|
||||
{preview?.text ? <pre className="mail-letter__body">{preview.text}</pre> : null}
|
||||
{preview?.text_truncated ? <p className="muted">Der Text ist gekürzt, weil die Nachricht sehr groß ist.</p> : null}
|
||||
{preview && !preview.text ? <p className="muted">Diese Nachricht hat keinen lesbaren Text.</p> : null}
|
||||
{preview ? <MailBody html={preview.html} text={preview.text} truncated={preview.text_truncated} notices={preview.notices} /> : null}
|
||||
<ErrorNote error={error} />
|
||||
<button type="button" onClick={() => link(selected)} disabled={!selected.uid || adopting}>{adopting ? "Wird übernommen …" : "Übernehmen"}</button>
|
||||
</>
|
||||
|
||||
@@ -1,11 +1,17 @@
|
||||
import { useEffect, useRef, useState } from "react";
|
||||
import { Link } from "react-router-dom";
|
||||
import { api, documentToText, downloadFile, fetchExternal, markDirty, textToDocument } from "../api.js";
|
||||
import { MarkdownView } from "../markdown.jsx";
|
||||
import { stageFor } from "../sources/registry.jsx";
|
||||
import "../sources/builtin-views.jsx";
|
||||
import { NoteEditor } from "../notes.jsx";
|
||||
import { moduleFor } from "../sources/registry-core.js";
|
||||
import { Modal } from "./Modal.jsx";
|
||||
|
||||
function RegisteredNote(props) {
|
||||
const Stage = stageFor("note");
|
||||
return Stage ? <Stage {...props} /> : null;
|
||||
}
|
||||
|
||||
export function ErrorNote({ error }) {
|
||||
if (!error) return null;
|
||||
return <p className="error">{error}</p>;
|
||||
@@ -190,25 +196,7 @@ function Binding({ binding, context, canEdit, isOwner, onChange }) {
|
||||
</div>
|
||||
</header>
|
||||
<DateLine dates={dates} />
|
||||
{element.kind === "note" ? (
|
||||
editingNote && binding.rights.edit ? (
|
||||
<form onSubmit={saveNote} className="stack">
|
||||
<NoteEditor value={text} onChange={(value) => { setText(value); markDirty(true); }} />
|
||||
<p className="muted">Diese Änderung betrifft den gemeinsamen Inhalt der Notiz.</p>
|
||||
{notice ? <p className="notice">{notice}</p> : null}
|
||||
<div className="row">
|
||||
<button type="submit">Text speichern</button>
|
||||
<button type="button" className="quiet" onClick={() => { setText(documentToText(element.document)); setEditingNote(false); markDirty(false); }}>Abbrechen</button>
|
||||
</div>
|
||||
</form>
|
||||
) : (
|
||||
<div className="stack">
|
||||
{text.trim() ? <MarkdownView text={text} /> : <p className="muted">Die Notiz ist leer.</p>}
|
||||
{notice ? <p className="notice">{notice}</p> : null}
|
||||
{binding.rights.edit ? <button type="button" onClick={() => setEditingNote(true)}>Bearbeiten</button> : <p className="muted">In diesem Kontext nur lesbar.</p>}
|
||||
</div>
|
||||
)
|
||||
) : null}
|
||||
{element.kind === "note" ? <RegisteredNote element={element} context={context} binding={binding} onReload={onChange} /> : null}
|
||||
{element.kind === "file" && element.file ? (
|
||||
element.file.status === "active" ? (
|
||||
<button type="button" onClick={() => downloadFile(element.id, context, element.file.filename)}>
|
||||
|
||||
@@ -0,0 +1,284 @@
|
||||
import { useEffect, useRef, useState } from "react";
|
||||
import { api, documentToText, downloadMailPart, fetchExternal, fetchMailPart, markDirty, textToDocument } from "../api.js";
|
||||
import { MailAttachments, MailBody } from "../mail-view.jsx";
|
||||
import { MarkdownView } from "../markdown.jsx";
|
||||
import { NoteEditor } from "../notes.jsx";
|
||||
import { DirectionColumn, directionWord } from "../pages/content.jsx";
|
||||
import workerSrc from "pdfjs-dist/build/pdf.worker.min.mjs?url";
|
||||
import { editors, registerStage } from "./registry.jsx";
|
||||
|
||||
function previewKind(type, filename) {
|
||||
const media = (type || "").toLowerCase();
|
||||
const name = (filename || "").toLowerCase();
|
||||
if (media.startsWith("image/") || /\.(png|jpe?g|gif|webp)$/.test(name)) return "image";
|
||||
if (media.includes("pdf") || name.endsWith(".pdf")) return "pdf";
|
||||
return "other";
|
||||
}
|
||||
|
||||
export function NoteStage({ element, context, binding, onReload }) {
|
||||
const editor = editors.note;
|
||||
const [text, setText] = useState(() => documentToText(element.document));
|
||||
const [editing, setEditing] = useState(false);
|
||||
const [session, setSession] = useState(0);
|
||||
const [notice, setNotice] = useState("");
|
||||
const [error, setError] = useState("");
|
||||
const draft = useRef("");
|
||||
const editingRef = useRef(false);
|
||||
|
||||
useEffect(() => {
|
||||
if (editingRef.current) return undefined;
|
||||
const saved = documentToText(element.document);
|
||||
if (!draft.current || draft.current === saved) {
|
||||
draft.current = "";
|
||||
setText(saved);
|
||||
}
|
||||
return undefined;
|
||||
}, [element.id, element.version, element.document]);
|
||||
|
||||
async function save(event) {
|
||||
event.preventDefault();
|
||||
setError("");
|
||||
try {
|
||||
const updated = await editor.save({ api, element, context, document: textToDocument(text) });
|
||||
draft.current = text;
|
||||
editingRef.current = false;
|
||||
setEditing(false);
|
||||
markDirty(false);
|
||||
setNotice(updated.notice || "Der gemeinsame Text ist gespeichert.");
|
||||
onReload?.();
|
||||
} catch (err) {
|
||||
if (err.status === 409) {
|
||||
setError("Der Stand hat sich geändert. Der eingegebene Text bleibt stehen. Bitte neu laden.");
|
||||
return;
|
||||
}
|
||||
setError(err.message);
|
||||
}
|
||||
}
|
||||
|
||||
function begin() {
|
||||
draft.current = "";
|
||||
editingRef.current = true;
|
||||
setText(documentToText(element.document));
|
||||
setSession((current) => current + 1);
|
||||
setEditing(true);
|
||||
setError("");
|
||||
setNotice("");
|
||||
}
|
||||
|
||||
function cancel() {
|
||||
draft.current = "";
|
||||
editingRef.current = false;
|
||||
setText(documentToText(element.document));
|
||||
setEditing(false);
|
||||
markDirty(false);
|
||||
setError("");
|
||||
}
|
||||
|
||||
if (!editor?.available) return null;
|
||||
if (editing && binding?.rights?.edit) {
|
||||
return (
|
||||
<form className="reader-note" onSubmit={save}>
|
||||
<NoteEditor key={session} value={text} onChange={(value) => { setText(value); markDirty(true); }} />
|
||||
<p className="muted">Diese Änderung betrifft den gemeinsamen Inhalt der Notiz, nicht die hiesige Anmerkung. Gespeichert wird Markdown.</p>
|
||||
{error ? <p className="error">{error}</p> : null}
|
||||
{notice ? <p className="notice">{notice}</p> : null}
|
||||
<div className="row">
|
||||
<button type="submit">Text speichern</button>
|
||||
<button type="button" className="quiet" onClick={cancel}>Abbrechen</button>
|
||||
</div>
|
||||
</form>
|
||||
);
|
||||
}
|
||||
return (
|
||||
<div className="reader-note">
|
||||
{text.trim() ? <MarkdownView text={text} /> : <p className="muted">Die Notiz ist leer.</p>}
|
||||
{error ? <p className="error">{error}</p> : null}
|
||||
{notice ? <p className="notice">{notice}</p> : null}
|
||||
{binding?.rights?.edit ? <button type="button" onClick={begin}>Bearbeiten</button> : <p className="muted">In diesem Kontext nur lesbar.</p>}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
export function TextStage({ element, context }) {
|
||||
const [text, setText] = useState("");
|
||||
const [error, setError] = useState("");
|
||||
useEffect(() => {
|
||||
let alive = true;
|
||||
fetchExternal(element.id, context)
|
||||
.then(async (blob) => {
|
||||
if (alive) setText(await blob.text());
|
||||
})
|
||||
.catch((err) => {
|
||||
if (alive) setError(err.message || "Der Text ist nicht verfügbar.");
|
||||
});
|
||||
return () => {
|
||||
alive = false;
|
||||
};
|
||||
}, [element.id, context?.kind, context?.id]);
|
||||
return (
|
||||
<div>
|
||||
{error ? <p className="error">{error}</p> : null}
|
||||
<pre className="mail-letter__body">{text}</pre>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
export function MailStage({ element, context, shownDirection }) {
|
||||
const [letter, setLetter] = useState(null);
|
||||
const [error, setError] = useState("");
|
||||
const [shownFor, setShownFor] = useState(null);
|
||||
const [phase, setPhase] = useState("idle");
|
||||
const [media, setMedia] = useState("");
|
||||
const [blobUrl, setBlobUrl] = useState("");
|
||||
const [pdf, setPdf] = useState(null);
|
||||
const [page, setPage] = useState(1);
|
||||
const [pages, setPages] = useState(0);
|
||||
const canvasRef = useRef(null);
|
||||
const objectUrl = useRef("");
|
||||
const shownIndex = shownFor?.elementId === element?.id ? shownFor.index : null;
|
||||
const shownFile = (letter?.attachments || []).find((item) => item.index === shownIndex) || null;
|
||||
|
||||
useEffect(() => {
|
||||
let alive = true;
|
||||
const params = new URLSearchParams();
|
||||
if (context?.kind && context?.id) {
|
||||
params.set("context_kind", context.kind);
|
||||
params.set("context_id", context.id);
|
||||
}
|
||||
api(`/api/v1/external-refs/${element.id}/mail?${params}`)
|
||||
.then((data) => {
|
||||
if (alive) setLetter(data);
|
||||
})
|
||||
.catch((err) => {
|
||||
if (!alive) return;
|
||||
setLetter(null);
|
||||
setError(err.message || "Die Nachricht konnte nicht geladen werden.");
|
||||
});
|
||||
return () => {
|
||||
alive = false;
|
||||
};
|
||||
}, [element.id, element.external?.source, context?.kind, context?.id]);
|
||||
|
||||
useEffect(() => {
|
||||
if (shownIndex === null) return undefined;
|
||||
const file = (letter?.attachments || []).find((item) => item.index === shownIndex);
|
||||
if (!file) return undefined;
|
||||
let alive = true;
|
||||
setPhase("loading");
|
||||
fetchMailPart(element.id, context, `attachments/${file.index}`).then(async (blob) => {
|
||||
if (!alive) return;
|
||||
if (objectUrl.current) URL.revokeObjectURL(objectUrl.current);
|
||||
const url = URL.createObjectURL(blob);
|
||||
objectUrl.current = url;
|
||||
setBlobUrl(url);
|
||||
const kind = previewKind(blob.type || file.content_type, file.filename);
|
||||
if (kind === "image") {
|
||||
setMedia("image");
|
||||
setPhase("ready");
|
||||
return;
|
||||
}
|
||||
if (kind === "pdf") {
|
||||
setMedia("pdf");
|
||||
try {
|
||||
const bytes = await blob.arrayBuffer();
|
||||
const pdfjs = await import("pdfjs-dist");
|
||||
pdfjs.GlobalWorkerOptions.workerSrc = workerSrc;
|
||||
const doc = await pdfjs.getDocument({ data: bytes }).promise;
|
||||
if (!alive) {
|
||||
doc.destroy();
|
||||
return;
|
||||
}
|
||||
setPdf(doc);
|
||||
setPages(doc.numPages);
|
||||
setPhase("ready");
|
||||
} catch (err) {
|
||||
if (!alive) return;
|
||||
setMedia("pdf-frame");
|
||||
setPhase("ready");
|
||||
}
|
||||
return;
|
||||
}
|
||||
setMedia("other");
|
||||
setPhase("ready");
|
||||
}).catch((err) => {
|
||||
if (!alive) return;
|
||||
setPhase("ready");
|
||||
setError(err.message || "Die Anlage ist nicht verfügbar.");
|
||||
});
|
||||
return () => {
|
||||
alive = false;
|
||||
};
|
||||
}, [element.id, shownIndex, letter, context?.kind, context?.id]);
|
||||
|
||||
useEffect(() => () => {
|
||||
pdf?.destroy?.();
|
||||
if (objectUrl.current) URL.revokeObjectURL(objectUrl.current);
|
||||
}, [pdf]);
|
||||
|
||||
useEffect(() => {
|
||||
if (!pdf || !canvasRef.current) return undefined;
|
||||
let alive = true;
|
||||
pdf.getPage(page).then((pdfPage) => {
|
||||
if (!alive || !canvasRef.current) return;
|
||||
const canvas = canvasRef.current;
|
||||
const context2d = canvas.getContext("2d");
|
||||
const viewport = pdfPage.getViewport({ scale: 1 });
|
||||
canvas.width = viewport.width;
|
||||
canvas.height = viewport.height;
|
||||
return pdfPage.render({ canvasContext: context2d, viewport }).promise;
|
||||
}).catch(() => {});
|
||||
return () => {
|
||||
alive = false;
|
||||
};
|
||||
}, [pdf, page]);
|
||||
|
||||
async function openOriginal() {
|
||||
setError("");
|
||||
try {
|
||||
await downloadMailPart(element.id, context, "original", "nachricht.eml");
|
||||
} catch (err) {
|
||||
setError(err.message);
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<article className="mail-letter">
|
||||
<p className="mail-letter__way"><DirectionColumn direction={shownDirection} />{directionWord(shownDirection) ? <span>{directionWord(shownDirection)}</span> : null}</p>
|
||||
<p><span>Von</span> {letter?.message_from || "Ohne Absender"}</p>
|
||||
<p><span>An</span> {letter?.message_to || "Ohne Empfänger"}</p>
|
||||
{letter?.message_cc ? <p><span>Kopie</span> {letter.message_cc}</p> : null}
|
||||
{error ? <p className="error">{error}</p> : null}
|
||||
{letter ? (
|
||||
<>
|
||||
<MailAttachments files={letter.attachments} current={shownIndex} onOpen={(file) => {
|
||||
setError("");
|
||||
setShownFor((current) => (
|
||||
current?.elementId === element.id && current.index === file.index ? null : { elementId: element.id, index: file.index }
|
||||
));
|
||||
}} />
|
||||
{shownFile ? <p className="mail-attachment__caption">Anlage: {shownFile.filename}</p> : null}
|
||||
{shownFile && phase === "loading" ? <p className="muted">Die Anlage wird geladen …</p> : null}
|
||||
{media === "image" && blobUrl ? <img className="reader-image" alt={shownFile?.filename || element.title} src={blobUrl} /> : null}
|
||||
{media === "pdf" && pdf ? <canvas ref={canvasRef} className="reader-canvas" /> : null}
|
||||
{media === "pdf-frame" && blobUrl ? <iframe className="reader-frame" title={shownFile?.filename || element.title} src={blobUrl} /> : null}
|
||||
{media === "other" && blobUrl ? <a href={blobUrl} target="_blank" rel="noreferrer">Anlage öffnen</a> : null}
|
||||
{pages > 1 ? (
|
||||
<div className="reader-pages">
|
||||
<button type="button" disabled={page <= 1} onClick={() => setPage((current) => Math.max(1, current - 1))}>Vorherige Seite</button>
|
||||
<span>{page} / {pages}</span>
|
||||
<button type="button" disabled={page >= pages} onClick={() => setPage((current) => Math.min(pages, current + 1))}>Nächste Seite</button>
|
||||
</div>
|
||||
) : null}
|
||||
<MailBody html={letter.html} text={letter.text} truncated={letter.text_truncated} notices={letter.notices} />
|
||||
<button type="button" onClick={openOriginal}>Vollständige E-Mail</button>
|
||||
</>
|
||||
) : (
|
||||
<p className="muted">{error ? "Die vollständige Nachricht konnte nicht geladen werden." : "Die vollständige Nachricht wird geladen …"}</p>
|
||||
)}
|
||||
</article>
|
||||
);
|
||||
}
|
||||
|
||||
registerStage("note", NoteStage);
|
||||
registerStage("mail", MailStage);
|
||||
registerStage("text", TextStage);
|
||||
@@ -0,0 +1,23 @@
|
||||
import { editors, registerRepresentation, registerStage } from "./registry.jsx";
|
||||
|
||||
export function FixtureStage({ element }) {
|
||||
return (
|
||||
<article data-stage="fixture">
|
||||
<h2>{element.title}</h2>
|
||||
<p>{element.preview?.text}</p>
|
||||
</article>
|
||||
);
|
||||
}
|
||||
|
||||
export function installFixture() {
|
||||
registerRepresentation("fixture", "fixture");
|
||||
registerStage("fixture", FixtureStage);
|
||||
editors.fixture = {
|
||||
id: "fixture",
|
||||
available: true,
|
||||
async save() {
|
||||
return { notice: "gespeichert" };
|
||||
},
|
||||
};
|
||||
return FixtureStage;
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
import { useEffect, useState } from "react";
|
||||
import { useEffect, useRef, useState } from "react";
|
||||
import { api } from "../api.js";
|
||||
import { TargetLine } from "../pages/content.jsx";
|
||||
import { ErrorNote } from "../pages/widgets.jsx";
|
||||
@@ -26,6 +26,17 @@ const representationReaders = new Map([
|
||||
["markdown", "note"],
|
||||
]);
|
||||
|
||||
const stages = new Map();
|
||||
|
||||
export function registerStage(id, component) {
|
||||
stages.set(id, component);
|
||||
return component;
|
||||
}
|
||||
|
||||
export function stageFor(id) {
|
||||
return stages.get(id) || null;
|
||||
}
|
||||
|
||||
export function registerRepresentation(media, reader) {
|
||||
representationReaders.set(media, reader);
|
||||
}
|
||||
@@ -59,6 +70,7 @@ export function StandardSourcePicker({ sourceKind, context, placement, chapterId
|
||||
const [items, setItems] = useState([]);
|
||||
const [error, setError] = useState("");
|
||||
const [pending, setPending] = useState(false);
|
||||
const searchRef = useRef(0);
|
||||
const hint = module?.searchHint || "Suche im heute unterstützten Umfang dieser Quelle.";
|
||||
|
||||
useEffect(() => {
|
||||
@@ -78,13 +90,18 @@ export function StandardSourcePicker({ sourceKind, context, placement, chapterId
|
||||
setError("Wähle zuerst den Zugang.");
|
||||
return;
|
||||
}
|
||||
const token = searchRef.current + 1;
|
||||
searchRef.current = token;
|
||||
const asked = connectorId;
|
||||
const params = new URLSearchParams({ q: query });
|
||||
if (connectorId) params.set("connector_id", connectorId);
|
||||
try {
|
||||
const data = await api(`/api/v1/sources/${sourceKind}/search?${params}`);
|
||||
if (token !== searchRef.current) return;
|
||||
setItems(data.items || []);
|
||||
if (data.connector_id) setConnectorId(data.connector_id);
|
||||
if (!asked && data.connector_id) setConnectorId(data.connector_id);
|
||||
} catch (err) {
|
||||
if (token !== searchRef.current) return;
|
||||
setError(err.message);
|
||||
}
|
||||
}
|
||||
@@ -120,7 +137,7 @@ export function StandardSourcePicker({ sourceKind, context, placement, chapterId
|
||||
{connectors.length > 1 ? (
|
||||
<label>
|
||||
Zugang
|
||||
<select value={connectorId} onChange={(event) => setConnectorId(event.target.value)}>
|
||||
<select value={connectorId} onChange={(event) => { searchRef.current += 1; setConnectorId(event.target.value); setItems([]); }}>
|
||||
<option value="">Zugang wählen</option>
|
||||
{connectors.map((item) => <option key={item.id} value={item.id}>{item.name}</option>)}
|
||||
</select>
|
||||
|
||||
@@ -1,5 +1,33 @@
|
||||
import { createElement, useState } from "react";
|
||||
import { api } from "../api.js";
|
||||
import { registerSourceModule, unregisterSourceModule } from "./registry-core.js";
|
||||
|
||||
function SampleForm({ onSaved, onError, connectorId = "", initialName = "Beispielquelle", settings = null }) {
|
||||
const [name, setName] = useState(initialName);
|
||||
const [catalog, setCatalog] = useState(settings?.catalog || "alpha");
|
||||
|
||||
async function submit(event) {
|
||||
event.preventDefault();
|
||||
onError("");
|
||||
try {
|
||||
const body = { kind: "sample", name, config: { catalog } };
|
||||
if (connectorId) await api(`/api/v1/connectors/${connectorId}`, { method: "PATCH", body });
|
||||
else await api("/api/v1/connectors", { method: "POST", body });
|
||||
await onSaved();
|
||||
} catch (err) {
|
||||
onError(err.message);
|
||||
}
|
||||
}
|
||||
|
||||
return createElement(
|
||||
"form",
|
||||
{ onSubmit: submit, className: "stack" },
|
||||
createElement("label", null, "Name ", createElement("input", { value: name, onChange: (event) => setName(event.target.value), required: true })),
|
||||
createElement("label", null, "Katalog ", createElement("input", { value: catalog, onChange: (event) => setCatalog(event.target.value), required: true })),
|
||||
createElement("button", { type: "submit" }, connectorId ? "Zugang erneuern" : "Beispielquelle verbinden"),
|
||||
);
|
||||
}
|
||||
|
||||
export function installSampleSource() {
|
||||
return registerSourceModule({
|
||||
kind: "sample",
|
||||
@@ -7,6 +35,7 @@ export function installSampleSource() {
|
||||
addLabel: "Beispielquelle",
|
||||
representation: "text",
|
||||
manual: true,
|
||||
Form: SampleForm,
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -1050,6 +1050,23 @@ button.hierarchy__row { width: 100%; min-height: 34px; padding: 6px 8px; border:
|
||||
font: inherit;
|
||||
color: var(--text1);
|
||||
}
|
||||
.mail-letter__html {
|
||||
overflow-wrap: anywhere;
|
||||
max-width: 100%;
|
||||
}
|
||||
.mail-letter__html img,
|
||||
.mail-letter__html table {
|
||||
max-width: 100%;
|
||||
}
|
||||
.mail-letter__html table {
|
||||
border-collapse: collapse;
|
||||
}
|
||||
.mail-letter__html td,
|
||||
.mail-letter__html th {
|
||||
border: 1px solid var(--line);
|
||||
padding: 4px 6px;
|
||||
vertical-align: top;
|
||||
}
|
||||
|
||||
@media (min-width: 900px) {
|
||||
.record-layout { grid-template-columns: minmax(220px, 280px) minmax(0, 1fr); }
|
||||
|
||||
Reference in new issue
Block a user