Files
tsumugu/frontend/src/sources/builtin-views.jsx
T
LarsandCursor cd239a3ab8
Deploy Development / deploy (push) Successful in 47s
Test Suite / pytest-backend (push) Successful in 6m16s
Test Suite / smoke-dev (push) Successful in 1s
Test Suite / frontend-build (push) Successful in 22s
Zeige PDF-Anlagen in der Mail-Ansicht, damit der Browser sie nicht unter einem zufälligen Namen speichert.
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-23 12:59:07 +02:00

345 lines
13 KiB
React

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 { deviceClass, readImageChoice } from "../mail-images.js";
import { MarkdownView } from "../markdown.jsx";
import { NoteEditor } from "../notes.jsx";
import { DirectionColumn, directionWord } from "../pages/content.jsx";
import workerSrc from "pdfjs-dist/legacy/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";
}
function isPdfBytes(buffer) {
const sample = new TextDecoder("iso-8859-1").decode(buffer.slice(0, 1024)).trim();
return sample.startsWith("%PDF");
}
function downloadName(file, pdf) {
const name = file?.filename || "anlage";
if (!pdf || name.toLowerCase().endsWith(".pdf")) return name;
const stem = name.toLowerCase().endsWith(".bin") ? name.slice(0, -4).trim() : name;
return `${stem || "anlage"}.pdf`;
}
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, binding, 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) {
setMedia("");
setPdf(null);
setPages(0);
setPhase("idle");
if (objectUrl.current) {
URL.revokeObjectURL(objectUrl.current);
objectUrl.current = "";
}
setBlobUrl("");
return undefined;
}
const file = (letter?.attachments || []).find((item) => item.index === shownIndex);
if (!file) return undefined;
let alive = true;
setPhase("loading");
setPdf(null);
setPages(0);
setPage(1);
setMedia("");
fetchMailPart(element.id, context, `attachments/${file.index}`).then(async (blob) => {
if (!alive) return;
const buffer = await blob.arrayBuffer();
if (!alive) return;
const declared = previewKind(blob.type || file.content_type, file.filename);
const kind = isPdfBytes(buffer) ? "pdf" : declared;
if (objectUrl.current) {
URL.revokeObjectURL(objectUrl.current);
objectUrl.current = "";
}
setBlobUrl("");
if (kind === "image") {
const url = URL.createObjectURL(new Blob([buffer], { type: blob.type || file.content_type || "application/octet-stream" }));
objectUrl.current = url;
setBlobUrl(url);
setMedia("image");
setPhase("ready");
return;
}
if (kind === "pdf") {
setMedia("pdf");
try {
const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
pdfjs.GlobalWorkerOptions.workerSrc = workerSrc;
const doc = await pdfjs.getDocument({ data: new Uint8Array(buffer) }).promise;
if (!alive) {
doc.destroy();
return;
}
setPdf(doc);
setPages(doc.numPages);
setPhase("ready");
} catch (err) {
if (!alive) return;
setPdf(null);
setPhase("ready");
}
return;
}
setMedia("file");
setPhase("ready");
}).catch((err) => {
if (!alive) return;
setPhase("ready");
setMedia("");
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", `${letter?.title || "nachricht"}.eml`);
} catch (err) {
setError(err.message);
}
}
async function saveAttachment() {
if (!shownFile) return;
setError("");
const namedPdf = media === "pdf" || (shownFile.content_type || "").toLowerCase().includes("pdf") || (shownFile.filename || "").toLowerCase().endsWith(".pdf");
try {
await downloadMailPart(element.id, context, `attachments/${shownFile.index}`, downloadName(shownFile, namedPdf));
} 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}
{shownFile && phase === "ready" && binding?.rights?.download && (media === "file" || (media === "pdf" && !pdf)) ? (
<p className="muted">
<button type="button" onClick={saveAttachment}>{downloadName(shownFile, media === "pdf")} herunterladen</button>
</p>
) : 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}
remote={{
key: element.id,
count: letter.remote_images || 0,
auto: readImageChoice(deviceClass()) === "auto",
load: () => api(`/api/v1/external-refs/${element.id}/mail/html-with-images${context?.kind && context?.id ? `?context_kind=${context.kind}&context_id=${context.id}` : ""}`),
}}
/>
{binding?.rights?.download ? <button type="button" onClick={openOriginal}>Vollständige E-Mail herunterladen</button> : null}
</>
) : (
<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);