import { DocumentView } from "./DocumentView.jsx";
import { useEffect, useRef, useState } from "react";
import { Link, useNavigate } from "react-router-dom";
import { api, fetchBlob } from "../api.js";
import { MailBody } from "../mail-view.jsx";
import { NewConnector, useSourceModules } from "../sources/connector-config.jsx";
import { SourceFrame, registerSourceModule } from "../sources/registry.jsx";
import { PresentNote, bindable, describeMatch, lookupPresent, presentKey, useExternalPlacement } from "../sources/duplicates.jsx";
const SEARCH_LIMITS = {
paperless: "Die Suche läuft in Paperless selbst, über Titel und Inhalt, den Titel allein, den Inhalt allein oder den Volltextindex. Filter nach Korrespondent, Dokumenttyp, Speicherpfad, Tags, Dokumentdatum, Hinzugefügt-Datum und Archivnummer grenzen sie ein.",
imap: "Die Suche gilt für das ganze gewählte Fach, auch über die erste Seite hinaus. Betreff, Absender und Nachrichtentext werden auf dem Server geprüft.",
};
import { formatDate } from "./content.jsx";
import { NavIcon } from "./icons.jsx";
import { ErrorNote } from "./widgets.jsx";
export function Sources() {
const [items, setItems] = useState([]);
const [error, setError] = useState("");
const [adding, setAdding] = useState(false);
const { modules, error: moduleError } = useSourceModules();
const navigate = useNavigate();
async function load() {
const data = await api("/api/v1/connectors");
setItems(data.items);
}
useEffect(() => {
load().catch((err) => setError(err.message));
}, []);
const labels = new Map(modules.map((item) => [item.kind, item.label]));
return (
{adding ? (
setAdding(false)}
onSaved={(saved) => navigate(`/sources/${saved.id}`)}
/>
) : null}
{!items.length && !adding ? Noch keine Quelle verbunden.
: null}
{items.map((item) => (
{labels.get(item.kind) || item.kind}
{item.name}
{item.settings.base_url || item.settings.username || item.settings.catalog || ""}
{item.probe ? (item.probe.ok ? "Zuletzt erreichbar" : "Letzte Prüfung fehlgeschlagen") : "Noch nicht geprüft"}
))}
);
}
function paperlessLabel(item) {
const dated = formatDate(item.document_on);
return dated !== "Ohne Datum" ? `${dated} · ${item.title}` : item.title;
}
function paperlessFacts(item) {
return [
formatDate(item.document_on) !== "Ohne Datum" ? formatDate(item.document_on) : "",
item.correspondent,
item.document_type,
item.pages ? `${item.pages} ${item.pages === 1 ? "Seite" : "Seiten"}` : "",
item.asn ? `ASN ${item.asn}` : "",
].filter(Boolean);
}
const PAPERLESS_MODES = [
["title_content", "Titel und Inhalt"],
["title", "Nur Titel"],
["content", "Nur Inhalt"],
["index", "Volltextindex"],
];
const PAPERLESS_MODE_HINTS = {
title_content: "Sucht den Text im Titel und im erkannten Inhalt, wie „Titel & Inhalt“ in Paperless.",
title: "Sucht den Text nur im Titel.",
content: "Sucht den Text nur im erkannten Inhalt der Dokumente.",
index: "Der Volltextindex von Paperless findet ganze Wörter, auch mit AND, OR und Anführungszeichen, und ordnet nach Relevanz. Ein neues Dokument erscheint erst, wenn Paperless es indexiert hat.",
};
const NO_FACETS = { correspondents: [], document_types: [], storage_paths: [], tags: [], custom_fields: [] };
const EMPTY_FILTERS = {
query: "",
mode: "title_content",
title: "",
correspondent: "",
documentType: "",
storagePath: "",
tags: [],
tagMode: "all",
documentFrom: "",
documentTo: "",
addedFrom: "",
addedTo: "",
asn: "",
custom: [],
sort: "-created",
};
function activeFilterCount(filters) {
return [
filters.title.trim(),
filters.correspondent,
filters.documentType,
filters.storagePath,
filters.tags.length ? "tags" : "",
filters.documentFrom,
filters.documentTo,
filters.addedFrom,
filters.addedTo,
filters.asn.trim(),
].filter(Boolean).length + customPayload(filters.custom).length;
}
const CUSTOM_KINDS = {
string: "text",
url: "text",
longtext: "text",
integer: "number",
float: "number",
monetary: "number",
date: "date",
boolean: "boolean",
select: "select",
};
const CUSTOM_OPERATORS = {
text: [["icontains", "enthält"], ["exact", "ist gleich"], ["istartswith", "beginnt mit"], ["iendswith", "endet mit"]],
number: [["exact", "gleich"], ["gte", "mindestens"], ["lte", "höchstens"], ["gt", "größer als"], ["lt", "kleiner als"], ["range", "zwischen"]],
date: [["exact", "am"], ["gte", "ab"], ["lte", "bis"], ["gt", "nach"], ["lt", "vor"], ["range", "zwischen"]],
boolean: [["exact", "ist"]],
select: [["exact", "ist"]],
};
const CUSTOM_PRESENCE = [["set", "hat einen Wert"], ["unset", "ist leer"]];
const CUSTOM_LIMIT = 5;
function customKind(field) {
return CUSTOM_KINDS[field?.type] || "text";
}
// A row that is not complete is reported, not left out of the search.
function customProblem(rows) {
for (const row of rows) {
const name = row.field ? "Eine Zusatzfeld-Bedingung" : "Eine Zusatzfeld-Bedingung ohne Feld";
if (!row.field) return `${name} ist unvollständig. Wähle ein Feld oder entferne die Zeile.`;
const presence = row.op === "set" || row.op === "unset";
if (presence || row.kind === "boolean") continue;
if (row.op === "range" ? !(row.value && row.value2) : !String(row.value).trim()) {
return `${name} ist unvollständig. Gib den Wert an oder entferne die Zeile.`;
}
}
return "";
}
function customPayload(rows) {
const payload = [];
for (const row of rows) {
if (!row.field) continue;
if (row.op === "set" || row.op === "unset") {
payload.push({ field: row.field, op: "exists", value: row.op === "set" });
} else if (row.op === "range") {
if (row.value && row.value2) payload.push({ field: row.field, op: "range", value: [row.value, row.value2] });
} else if (row.kind === "boolean") {
payload.push({ field: row.field, op: "exact", value: row.value !== "false" });
} else if (String(row.value).trim()) {
payload.push({ field: row.field, op: row.op, value: String(row.value).trim() });
}
}
return payload;
}
function CustomFieldFilters({ fields, rows, onChange }) {
if (!fields.length) return null;
const byId = new Map(fields.map((item) => [item.id, item]));
function update(key, patch) {
onChange(rows.map((row) => (row.key === key ? { ...row, ...patch } : row)));
}
function choose(key, id) {
const field = byId.get(id);
const kind = customKind(field);
const first = field ? CUSTOM_OPERATORS[kind][0][0] : "";
update(key, { field: id, kind, op: first, value: kind === "boolean" ? "true" : "", value2: "" });
}
function add() {
onChange([...rows, { key: `${Date.now()}-${rows.length}`, field: "", kind: "text", op: "", value: "", value2: "" }]);
}
return (
Zusatzfelder, alle Bedingungen zugleich
{rows.map((row) => {
const field = byId.get(row.field);
const kind = customKind(field);
const value = (name, label) => {
if (kind === "boolean") {
return (
update(row.key, { [name]: event.target.value })}>
Ja
Nein
);
}
if (kind === "select") {
return (
update(row.key, { [name]: event.target.value })}>
Wert wählen
{(field.options || []).map((option) => {option.name} )}
);
}
return (
update(row.key, { [name]: event.target.value })}
/>
);
};
const presence = row.op === "set" || row.op === "unset";
return (
choose(row.key, event.target.value)}>
Feld wählen
{fields.map((item) => {item.name} )}
{field ? (
update(row.key, { op: event.target.value })}>
{CUSTOM_OPERATORS[kind].map(([op, label]) => {label} )}
{CUSTOM_PRESENCE.map(([op, label]) => {label} )}
) : null}
{field && !presence ? value("value", row.op === "range" ? "Von" : "Wert") : null}
{field && row.op === "range" ? value("value2", "Bis") : null}
onChange(rows.filter((item) => item.key !== row.key))}>Entfernen
);
})}
{rows.length < CUSTOM_LIMIT ? Zusatzfeld-Bedingung hinzufügen : null}
);
}
// The thumbnail comes through the server like every other Paperless call, so the key stays there.
function PaperlessThumb({ connectorId, id }) {
const [url, setUrl] = useState("");
const [failed, setFailed] = useState("");
useEffect(() => {
let alive = true;
let made = "";
setUrl("");
setFailed("");
fetchBlob(`/api/v1/sources/paperless/thumbnail?connector_id=${connectorId}&item=${id}`)
.then((blob) => {
if (!alive) return;
made = URL.createObjectURL(blob);
setUrl(made);
})
.catch((err) => {
if (alive) setFailed(err.message || "Das Vorschaubild ist nicht verfügbar.");
});
return () => {
alive = false;
if (made) URL.revokeObjectURL(made);
};
}, [connectorId, id]);
if (url) return ;
return {failed ? "Kein Bild" : ""} ;
}
export function PaperlessPicker({ context, placement, chapterId = "", chapterTitle = "", targetLabel = "", onDone, onInserted }) {
const [filters, setFilters] = useState(EMPTY_FILTERS);
const [items, setItems] = useState([]);
const [connectors, setConnectors] = useState([]);
const [connectorId, setConnectorId] = useState("");
const [facets, setFacets] = useState(NO_FACETS);
const [page, setPage] = useState(1);
const [nextPage, setNextPage] = useState(null);
const [previousPage, setPreviousPage] = useState(null);
const [total, setTotal] = useState(null);
const [searched, setSearched] = useState(false);
const [picked, setPicked] = useState(() => new Map());
// Documents that are already present around the target, by presentKey. `review` holds the choices while the user decides.
const [present, setPresent] = useState(() => new Map());
const [review, setReview] = useState(null);
const [previewKey, setPreviewKey] = useState("");
const [previewUrl, setPreviewUrl] = useState("");
const [pending, setPending] = useState(false);
const [error, setError] = useState("");
// The filters sit beside the hits on a wide screen. On a phone they start folded away.
const [tagSearch, setTagSearch] = useState("");
const [moreOpen, setMoreOpen] = useState(() => typeof window === "undefined" || !window.matchMedia || window.matchMedia("(min-width: 900px)").matches);
const searchRef = useRef(0);
const previewRef = useRef(0);
const facetRef = useRef(0);
useEffect(() => {
api("/api/v1/connectors")
.then((data) => {
const paper = (data.items || []).filter((item) => item.kind === "paperless");
setConnectors(paper);
if (paper.length === 1) setConnectorId(paper[0].id);
})
.catch((err) => setError(err.message));
}, []);
useEffect(() => {
if (!connectorId) {
setFacets(NO_FACETS);
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 && token === facetRef.current) setFacets({ ...NO_FACETS, ...data });
})
.catch((err) => {
if (alive && token === facetRef.current) setError(err.message);
});
return () => {
alive = false;
};
}, [connectorId]);
useEffect(() => () => {
if (previewUrl) URL.revokeObjectURL(previewUrl);
}, [previewUrl]);
function paramsFor(pageNumber) {
const params = new URLSearchParams();
const text = filters.query.trim();
if (connectorId) params.set("connector_id", connectorId);
if (text) params.set("q", text);
if (text && filters.mode !== "title_content") params.set("mode", filters.mode);
if (filters.title.trim()) params.set("title", filters.title.trim());
if (filters.correspondent) params.set("correspondent", filters.correspondent);
if (filters.documentType) params.set("document_type", filters.documentType);
if (filters.storagePath) params.set("storage_path", filters.storagePath);
if (filters.tags.length) {
params.set("tag", filters.tags.join(","));
if (filters.tagMode !== "all") params.set("tag_mode", filters.tagMode);
}
if (filters.documentFrom) params.set("document_from", filters.documentFrom);
if (filters.documentTo) params.set("document_to", filters.documentTo);
if (filters.addedFrom) params.set("added_from", filters.addedFrom);
if (filters.addedTo) params.set("added_to", filters.addedTo);
if (filters.asn.trim()) params.set("asn", filters.asn.trim());
const custom = customPayload(filters.custom);
if (custom.length) params.set("custom", JSON.stringify(custom));
if (filters.sort === "-score") {
if (text && filters.mode === "index") params.set("sort", "-score");
} else if (filters.sort) {
params.set("sort", filters.sort);
}
if (pageNumber) params.set("cursor", String(pageNumber));
return params;
}
function closePreview() {
previewRef.current += 1;
if (previewUrl) URL.revokeObjectURL(previewUrl);
setPreviewUrl("");
setPreviewKey("");
}
function invalidate() {
searchRef.current += 1;
previewRef.current += 1;
facetRef.current += 1;
}
async function runSearch(event, wanted = "") {
event?.preventDefault();
setError("");
if (connectors.length > 1 && !connectorId) {
setError("Wähle zuerst den Paperless-Zugang.");
return;
}
const problem = customProblem(filters.custom);
if (problem) {
setError(problem);
return;
}
const token = searchRef.current + 1;
searchRef.current = token;
const asked = connectorId;
try {
const data = await api(`/api/v1/sources/paperless/documents?${paramsFor(wanted)}`);
if (token !== searchRef.current) return;
closePreview();
setItems(data.items || []);
setPage(Number(wanted) || 1);
setNextPage(data.next_page || data.continuation || null);
setPreviousPage(data.previous_page || null);
setTotal(typeof data.total === "number" ? data.total : null);
setSearched(true);
if (!asked && data.connector_id) setConnectorId(data.connector_id);
refreshPresent(data.items || [], asked || data.connector_id || "");
} catch (err) {
if (token !== searchRef.current) return;
setError(err.message);
}
}
function presentEntry(item, bound = connectorId) {
return { source: "paperless", external_id: String(item.id), connector_id: item.connector_id || bound };
}
function matchesOf(item) {
const entry = presentEntry(item);
return present.get(presentKey(entry.source, entry.connector_id, entry.external_id)) || [];
}
async function refreshPresent(list, bound) {
const entries = list.map((item) => presentEntry(item, bound));
const found = await lookupPresent(context, placement, entries);
setPresent((current) => {
const next = new Map(current);
entries.forEach((entry) => next.delete(presentKey(entry.source, entry.connector_id, entry.external_id)));
found.forEach((value, key) => next.set(key, value));
return next;
});
}
function resetFilters() {
invalidate();
closePreview();
setFilters(EMPTY_FILTERS);
setItems([]);
setNextPage(null);
setPreviousPage(null);
setTotal(null);
setSearched(false);
setPage(1);
}
function toggle(item) {
const bound = item.connector_id || connectorId;
const key = `${bound}:${item.id}`;
setPicked((current) => {
const next = new Map(current);
if (next.has(key)) next.delete(key);
else next.set(key, { ...item, connector_id: bound });
return next;
});
}
async function preview(item) {
setError("");
const bound = item.connector_id || connectorId;
const key = `${bound}:${item.id}`;
if (key === previewKey) {
closePreview();
return;
}
closePreview();
const token = previewRef.current + 1;
previewRef.current = token;
setPreviewKey(key);
try {
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;
setPreviewKey("");
setError(err.message);
}
}
async function linkMany(choices = null) {
const chosen = [...picked.values()];
if (!chosen.length) return;
setError("");
const keyOf = (item) => `${item.connector_id || connectorId}:${item.id}`;
if (!choices) {
const known = chosen.filter((item) => matchesOf(item).length);
if (known.length) {
setReview(new Map(known.map((item) => [keyOf(item), "skip"])));
return;
}
}
setReview(null);
setPending(true);
const inserted = [];
const skipped = [];
const conflicts = [];
try {
for (const item of chosen) {
const key = keyOf(item);
const choice = choices?.get(key);
if (choice === "skip") {
skipped.push(key);
continue;
}
const existing = choice === "bind" ? bindable(matchesOf(item)) : null;
try {
await api("/api/v1/external-refs", {
method: "POST",
body: {
title: item.title,
source: "paperless",
external_id: String(item.id),
context,
...(placement ? { placement } : {}),
...(chapterId ? { chapter_id: chapterId } : {}),
...(choice === "insert" ? { duplicate: "insert" } : {}),
...(existing ? { bind_element_id: existing.element_id } : {}),
...(item.document_on || item.correspondent || item.open_url || connectorId
? {
dates: { document_on: item.document_on || null, sent_on: null, received_on: null },
detail: {
...(item.connector_id || connectorId ? { connector_id: item.connector_id || connectorId } : {}),
...(item.correspondent ? { correspondent: item.correspondent } : {}),
...(item.open_url ? { open_url: item.open_url } : {}),
},
}
: {}),
},
});
inserted.push(key);
} catch (err) {
// Inserted by someone else in the meantime: ask again instead of failing.
if (err.code !== "already_present") throw err;
conflicts.push(item);
}
}
} catch (err) {
setError(err.message);
} finally {
setPending(false);
}
if (conflicts.length) {
await refreshPresent(conflicts, connectorId);
setReview(new Map(conflicts.map((item) => [keyOf(item), "skip"])));
}
if (inserted.length) {
setItems((current) => current.filter((item) => !inserted.includes(`${connectorId}:${item.id}`)));
onInserted?.();
}
setPicked((current) => {
const next = new Map(current);
[...inserted, ...skipped].forEach((id) => next.delete(id));
return next;
});
if (inserted.length && inserted.length + skipped.length === chosen.length) onDone();
}
function setFilter(name, value) {
setFilters((current) => ({ ...current, [name]: value }));
}
function setMode(mode) {
setFilters((current) => ({ ...current, mode, sort: current.sort === "-score" && mode !== "index" ? "-created" : current.sort }));
}
const visibleTags = facets.tags.filter((item) => item.name.toLocaleLowerCase().includes(tagSearch.trim().toLocaleLowerCase()));
function tagName(id) {
return facets.tags.find((item) => item.id === id)?.name || id;
}
function selectTags(ids) {
setFilters((current) => ({ ...current, tags: [...new Set([...current.tags, ...ids])] }));
}
function toggleTag(id) {
setFilters((current) => {
const tags = current.tags.includes(id) ? current.tags.filter((item) => item !== id) : [...current.tags, id];
return { ...current, tags };
});
}
const held = [...picked.values()].filter((item) => !items.some((entry) => `${connectorId}:${entry.id}` === `${item.connector_id}:${item.id}`));
const active = activeFilterCount(filters);
const relevance = filters.mode === "index" && filters.query.trim() !== "";
function choiceSelect(name, value, entries, empty) {
return (
setFilter(name, event.target.value)}>
Alle
{empty}
{entries.map((item) => {item.name} )}
);
}
return (
{connectors.length > 1 ? (
Paperless-Zugang
{
invalidate();
closePreview();
setConnectorId(event.target.value);
setFilters(EMPTY_FILTERS);
setItems([]);
setNextPage(null);
setPreviousPage(null);
setTotal(null);
setSearched(false);
setPage(1);
setFacets(NO_FACETS);
}}>
Zugang wählen
{connectors.map((item) => (
{item.name}
))}
) : null}
{SEARCH_LIMITS.paperless}
Die Verbindung richtest du unter Quellen ein. Ausgewählte Belege bleiben erhalten, wenn du weiterblätterst oder neu suchst.
{review ? (
Diese Belege sind schon vorhanden. Was soll geschehen?
{[...picked.values()].filter((item) => review.has(`${item.connector_id || connectorId}:${item.id}`)).map((item) => {
const key = `${item.connector_id || connectorId}:${item.id}`;
const matches = matchesOf(item);
return (
{item.title}: {matches.length ? describeMatch(matches[0]) : "schon vorhanden"}
setReview((current) => new Map(current).set(key, event.target.value))}
>
Nicht einfügen
Trotzdem erneut einfügen
{bindable(matches) ? Vorhandenes zusätzlich einbinden : null}
);
})}
setReview(null)}>Zurück zur Auswahl
linkMany(review)}>Entscheidung ausführen
) : null}
{items.length || picked.size ? (
linkMany()}>
{picked.size ? `${picked.size} Belege einfügen` : "Belege auswählen"}
) : null}
{searched ? (
{items.length
? `${total !== null ? `${total} Treffer` : "Treffer"}, Seite ${page}`
: "Dazu gibt es in Paperless keinen Treffer."}
) : null}
{held.map((item) => (
toggle(item)} />
{paperlessLabel(item)}
))}
{items.map((item) => {
const key = `${connectorId}:${item.id}`;
const open = previewKey === key;
const facts = paperlessFacts(item);
return (
toggle(item)}
aria-label={`${item.title} auswählen`}
/>
preview(item)} aria-label={`${item.title} ansehen`}>
{item.title}
{facts.length ?
{facts.join(" · ")} : null}
{item.tags?.length ? (
{item.tags.map((tag) => {tag} )}
) : null}
{item.custom_fields?.length ? (
{item.custom_fields.map((field) => (
{field.name}
{field.type === "date" && formatDate(field.value) !== "Ohne Datum" ? formatDate(field.value) : field.value}
))}
) : null}
{item.snippet ?
{item.snippet}
: null}
preview(item)} aria-expanded={open}>
{open ? "Ansicht schließen" : "Ansehen"}
{open ? (
{previewUrl ?
:
Vorschau wird geladen …
}
) : null}
);
})}
{previousPage || nextPage ? (
{previousPage ? runSearch(event, previousPage)}>Vorherige Treffer : null}
{nextPage ? runSearch(event, nextPage)}>Weitere Treffer : null}
) : null}
);
}
function folderTree(folders) {
const roots = [];
const stack = [];
for (const folder of folders) {
const node = { ...folder, children: [] };
while (stack.length && stack[stack.length - 1].depth >= folder.depth) stack.pop();
if (stack.length) stack[stack.length - 1].node.children.push(node);
else roots.push(node);
stack.push({ depth: folder.depth, node });
}
return roots;
}
function ancestorNames(folders, name) {
const folder = folders.find((item) => item.name === name);
if (!folder?.delimiter || !name.includes(folder.delimiter)) return [];
const parts = name.split(folder.delimiter);
const names = [];
for (let index = 1; index < parts.length; index += 1) names.push(parts.slice(0, index).join(folder.delimiter));
return names;
}
function FolderBranch({ node, mailbox, path, expanded, onToggle, onSelect }) {
const open = expanded.has(node.name);
const current = node.name === mailbox;
const onPath = path.has(node.name);
const rowClass = current ? "folder-row is-current" : onPath ? "folder-row is-ancestor" : "folder-row";
return (
{node.children.length ? (
onToggle(node.name)}>
{open ? "▾" : "▸"}
) : }
{node.selectable ? (
onSelect(node.name)}>
{node.label}
) : (
{node.label}
)}
{node.children.length && open ? (
{node.children.map((child) => (
))}
) : null}
);
}
function MailFiles({ files }) {
if (!files?.length) return Keine Anhänge.
;
return (
{files.map((file) => {file.filename} )}
);
}
function FolderTree({ folders, mailbox, onSelect }) {
const [expanded, setExpanded] = useState(() => new Set());
useEffect(() => {
setExpanded((current) => {
const next = new Set(current);
for (const name of ancestorNames(folders, mailbox)) next.add(name);
return next;
});
}, [folders, mailbox]);
const roots = folderTree(folders);
const path = new Set([mailbox, ...ancestorNames(folders, mailbox)]);
function toggle(name) {
setExpanded((current) => {
const next = new Set(current);
if (next.has(name)) next.delete(name);
else next.add(name);
return next;
});
}
if (!roots.length) return Keine Fächer.
;
return (
{roots.map((node) => (
))}
);
}
export function MailPicker({ context, placement, chapterId = "", chapterTitle = "", targetLabel = "", onDone }) {
const [accounts, setAccounts] = useState([]);
const [accountId, setAccountId] = useState("");
const [folders, setFolders] = useState([]);
const [mailbox, setMailbox] = useState("");
const [draft, setDraft] = useState("");
const [query, setQuery] = useState("");
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("");
const [preview, setPreview] = useState(null);
const [previewError, setPreviewError] = useState("");
const [adopting, setAdopting] = useState(false);
const { place, panel } = useExternalPlacement({ context, placement, onPlaced: () => onDone() });
const [loading, setLoading] = useState("");
const [error, setError] = useState("");
const requestRef = useRef(0);
const previewRef = useRef(0);
function beginRequest() {
requestRef.current += 1;
return requestRef.current;
}
function applyMessages(data, append, token) {
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 || []);
setNotice("Das Fach wurde auf dem Server neu aufgebaut. Die Liste beginnt vorn.");
} else {
setNotice("");
setItems((current) => append ? [...current, ...(data.items || [])] : (data.items || []));
}
setLoading("");
}
useEffect(() => {
api("/api/v1/connectors")
.then((data) => {
const mail = data.items.filter((item) => item.kind === "imap");
setAccounts(mail);
if (mail[0]) setAccountId(mail[0].id);
})
.catch((err) => setError(err.message));
}, []);
useEffect(() => {
if (!accountId) return undefined;
let alive = true;
setFolders([]);
setMailbox("");
setItems([]);
setError("");
setLoading("Fächer werden gelesen …");
api(`/api/v1/sources/imap/mailboxes?connector_id=${accountId}`)
.then((data) => {
if (!alive) return;
const list = data.items || [];
setFolders(list);
const standard = accounts.find((item) => item.id === accountId)?.settings?.mailbox;
const preferred = (standard && list.find((item) => item.selectable && item.name === standard))
|| list.find((item) => item.selectable && item.name.toUpperCase() === "INBOX")
|| list.find((item) => item.selectable);
setMailbox(preferred ? preferred.name : "");
if (!preferred) setLoading("");
})
.catch((err) => {
if (!alive) return;
setLoading("");
setError(err.message);
});
return () => {
alive = false;
};
}, [accountId]);
useEffect(() => {
if (!accountId || !mailbox) return undefined;
const token = beginRequest();
setQuery("");
setDraft("");
setItems([]);
setNextBefore(null);
setIncomplete(false);
setContradictory(false);
setNotice("");
setSelectedKey("");
setPreview(null);
setPreviewError("");
setError("");
setLoading("Nachrichten werden gelesen …");
const params = new URLSearchParams({ connector_id: accountId, mailbox });
api(`/api/v1/sources/imap/messages?${params}`)
.then((data) => applyMessages(data, false, token))
.catch((err) => {
if (token !== requestRef.current) return;
setLoading("");
setError(err.message);
});
return undefined;
}, [accountId, mailbox]);
async function search(event) {
event.preventDefault();
if (!accountId || !mailbox) return;
const token = beginRequest();
setError("");
setLoading("Nachrichten werden gelesen …");
const params = new URLSearchParams({ connector_id: accountId, mailbox });
if (draft.trim()) params.set("q", draft.trim());
if (uidValidity) params.set("uidvalidity", String(uidValidity));
try {
const data = await api(`/api/v1/sources/imap/messages?${params}`);
if (token !== requestRef.current) return;
setQuery(draft.trim());
setSelectedKey("");
setPreview(null);
setPreviewError("");
applyMessages(data, false, token);
} catch (err) {
if (token !== requestRef.current) return;
setLoading("");
setError(err.message);
}
}
async function older() {
if (!nextBefore) return;
const token = beginRequest();
setError("");
setLoading("Ältere Nachrichten werden gelesen …");
const params = new URLSearchParams({ connector_id: accountId, mailbox, before: String(nextBefore) });
if (query) params.set("q", query);
if (uidValidity) params.set("uidvalidity", String(uidValidity));
try {
const data = await api(`/api/v1/sources/imap/messages?${params}`);
applyMessages(data, !data.restarted, token);
} catch (err) {
if (token !== requestRef.current) return;
setLoading("");
setError(err.message);
}
}
function choose(item) {
const key = `${mailbox}:${item.uid || item.id}`;
const token = previewRef.current + 1;
previewRef.current = token;
setSelectedKey(key);
setPreview(null);
setPreviewError("");
if (!item.uid) {
setPreviewError("Diese Nachricht lässt sich nicht öffnen.");
return;
}
const params = new URLSearchParams({ connector_id: accountId, mailbox, uid: String(item.uid) });
api(`/api/v1/sources/imap/message?${params}`)
.then((data) => {
if (token === previewRef.current) setPreview(data);
})
.catch((err) => {
if (token === previewRef.current) setPreviewError(err.message);
});
}
async function link(item) {
if (adopting) return;
setError("");
setAdopting(true);
const letter = preview && preview.uid === item.uid ? preview : null;
const known = letter?.direction || item.direction;
const direction = known === "out" || known === "in" ? known : null;
const attachments = (letter?.attachments || item.attachments || [])
.filter((file) => file?.filename)
.map((file) => ({
filename: file.filename,
...(file.content_type ? { content_type: file.content_type } : {}),
}));
const detail = {
direction,
mailbox,
connector_id: accountId,
uid: item.uid,
};
const from = letter?.message_from || item.message_from;
const to = letter?.message_to || item.message_to;
const cc = letter?.message_cc || item.message_cc;
if (from) detail.message_from = from;
if (to) detail.message_to = to;
if (cc) detail.message_cc = cc;
if (attachments.length) detail.attachments = attachments;
try {
await place({
title: item.title,
source: "imap",
external_id: item.id,
context,
...(placement ? { placement } : {}),
...(chapterId ? { chapter_id: chapterId } : {}),
...(item.document_on ? {
dates: {
document_on: item.document_on,
sent_on: direction === "out" ? item.document_on : null,
received_on: direction === "in" ? item.document_on : null,
},
} : {}),
detail,
});
} catch (err) {
setError(err.message);
} finally {
setAdopting(false);
}
}
const selected = items.find((item) => `${mailbox}:${item.uid || item.id}` === selectedKey) || null;
return (
Konto
setAccountId(event.target.value)}>
{accounts.length ? null : Kein Konto }
{accounts.map((item) => (
{item.name}
))}
{!accounts.length ? Lege zuerst ein E-Mail-Konto unter Quellen an.
: null}
{SEARCH_LIMITS.imap}
{notice ?
{notice}
: null}
{accountId && !loading && !mailbox && !error ?
Dieses Konto hat keine lesbaren Fächer.
: null}
{loading ?
{loading}
: null}
{!loading && mailbox && !items.length && !error ? (
{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."}
) : null}
{items.map((item) => {
const key = `${mailbox}:${item.uid || item.id}`;
const outgoing = item.direction === "out";
const incoming = item.direction === "in";
const who = outgoing ? (item.message_to ? `an ${item.message_to}` : "") : (item.message_from || "");
const way = outgoing ? "Ausgang" : incoming ? "Eingang" : "";
const files = item.attachments?.length || 0;
return (
choose(item)}>
{formatDate(item.document_on)}
{item.title}
{[way, who].filter(Boolean).join(" · ")}
{files ? {files} : null}
);
})}
{nextBefore ?
Ältere laden : null}
{!selected ? Wähle eine Nachricht, um Absender, Empfänger und Inhalt zu prüfen.
: (
<>
{preview?.title || selected.title}
{(preview?.direction || selected.direction) === "out" ? "Ausgang" : (preview?.direction || selected.direction) === "in" ? "Eingang" : "Richtung nicht bekannt"}
Von {preview?.message_from || selected.message_from || "Ohne Absender"}
An {preview?.message_to || selected.message_to || "Ohne Empfänger"}
{(preview?.message_cc || selected.message_cc) ? Kopie {preview?.message_cc || selected.message_cc}
: null}
Datum {formatDate(preview?.document_on || selected.document_on)}
{previewError ? {previewError}
: null}
{selected && !preview && !previewError ? Vorschau wird geladen …
: null}
{preview ? : null}
{panel}
link(selected)} disabled={!selected.uid || adopting}>{adopting ? "Wird übernommen …" : "Übernehmen"}
>
)}
);
}
registerSourceModule({ kind: "paperless", title: "Paperless", addLabel: "Paperless", manual: true, large: true, searchHint: SEARCH_LIMITS.paperless, Picker: PaperlessPicker });
registerSourceModule({ kind: "imap", title: "E-Mail-Konto", addLabel: "E-Mail", wide: true, searchHint: SEARCH_LIMITS.imap, Picker: MailPicker });