Korrigiere IMAP-Ordner, MIME-Ansicht und die gemeinsamen Leser, damit große Postfächer, Notizen und verspätete Quellenantworten zuverlässig bleiben.
Deploy Development / deploy (push) Successful in 39s
Test Suite / pytest-backend (push) Successful in 2m29s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 20s

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
LarsandCursor committed 2026-10-20 08:47:24 +02:00
1 parent 34c4084a7c
commit c29bd29f34
29 files changed
+2562 -410

No files matched your search

+284
View File
@@ -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);