Deploy Development / deploy (push) Successful in 44s
Prüfstufen hier, darin, Umfeld stehen als Kontoeinstellung bereit. Der Server antwortet bei einem sicheren Treffer mit 409 und bindet auf Wunsch das vorhandene Element zusätzlich ein. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
1280 lines
52 KiB
React
1280 lines
52 KiB
React
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 (
|
||
<main className="page">
|
||
<header className="page-head">
|
||
<div>
|
||
<h1>Quellen</h1>
|
||
<p className="muted">Paperless und E-Mail-Konten bleiben bei dir. Eine Verknüpfung zeigt in der Akte nur Titel und Herkunft.</p>
|
||
</div>
|
||
{modules.length ? <button type="button" onClick={() => setAdding(true)} disabled={adding}>Quelle hinzufügen</button> : null}
|
||
</header>
|
||
<ErrorNote error={error || moduleError} />
|
||
{adding ? (
|
||
<NewConnector
|
||
modules={modules}
|
||
onCancel={() => setAdding(false)}
|
||
onSaved={(saved) => navigate(`/sources/${saved.id}`)}
|
||
/>
|
||
) : null}
|
||
{!items.length && !adding ? <p className="muted">Noch keine Quelle verbunden.</p> : null}
|
||
<div className="tiles">
|
||
{items.map((item) => (
|
||
<Link key={item.id} to={`/sources/${item.id}`} className="tile">
|
||
<span className="tile__kind">{labels.get(item.kind) || item.kind}</span>
|
||
<strong>{item.name}</strong>
|
||
<span>{item.settings.base_url || item.settings.username || item.settings.catalog || ""}</span>
|
||
<span>{item.probe ? (item.probe.ok ? "Zuletzt erreichbar" : "Letzte Prüfung fehlgeschlagen") : "Noch nicht geprüft"}</span>
|
||
</Link>
|
||
))}
|
||
</div>
|
||
</main>
|
||
);
|
||
}
|
||
|
||
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 (
|
||
<fieldset className="paperless-custom">
|
||
<legend>Zusatzfelder, alle Bedingungen zugleich</legend>
|
||
{rows.map((row) => {
|
||
const field = byId.get(row.field);
|
||
const kind = customKind(field);
|
||
const value = (name, label) => {
|
||
if (kind === "boolean") {
|
||
return (
|
||
<select aria-label={label} value={row.value} onChange={(event) => update(row.key, { [name]: event.target.value })}>
|
||
<option value="true">Ja</option>
|
||
<option value="false">Nein</option>
|
||
</select>
|
||
);
|
||
}
|
||
if (kind === "select") {
|
||
return (
|
||
<select aria-label={label} value={row.value} onChange={(event) => update(row.key, { [name]: event.target.value })}>
|
||
<option value="">Wert wählen</option>
|
||
{(field.options || []).map((option) => <option key={option.id} value={option.id}>{option.name}</option>)}
|
||
</select>
|
||
);
|
||
}
|
||
return (
|
||
<input
|
||
aria-label={label}
|
||
type={kind === "date" ? "date" : "text"}
|
||
inputMode={kind === "number" ? "decimal" : undefined}
|
||
value={name === "value" ? row.value : row.value2}
|
||
onChange={(event) => update(row.key, { [name]: event.target.value })}
|
||
/>
|
||
);
|
||
};
|
||
const presence = row.op === "set" || row.op === "unset";
|
||
return (
|
||
<div key={row.key} className="paperless-custom__row">
|
||
<select aria-label="Zusatzfeld" value={row.field} onChange={(event) => choose(row.key, event.target.value)}>
|
||
<option value="">Feld wählen</option>
|
||
{fields.map((item) => <option key={item.id} value={item.id}>{item.name}</option>)}
|
||
</select>
|
||
{field ? (
|
||
<select aria-label="Bedingung" value={row.op} onChange={(event) => update(row.key, { op: event.target.value })}>
|
||
{CUSTOM_OPERATORS[kind].map(([op, label]) => <option key={op} value={op}>{label}</option>)}
|
||
{CUSTOM_PRESENCE.map(([op, label]) => <option key={op} value={op}>{label}</option>)}
|
||
</select>
|
||
) : null}
|
||
{field && !presence ? value("value", row.op === "range" ? "Von" : "Wert") : null}
|
||
{field && row.op === "range" ? value("value2", "Bis") : null}
|
||
<button type="button" className="quiet" onClick={() => onChange(rows.filter((item) => item.key !== row.key))}>Entfernen</button>
|
||
</div>
|
||
);
|
||
})}
|
||
{rows.length < CUSTOM_LIMIT ? <button type="button" className="quiet" onClick={add}>Zusatzfeld-Bedingung hinzufügen</button> : null}
|
||
</fieldset>
|
||
);
|
||
}
|
||
|
||
// 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 <img src={url} alt="" className="paperless-thumb__image" />;
|
||
return <span className="paperless-thumb__empty" title={failed || undefined}>{failed ? "Kein Bild" : ""}</span>;
|
||
}
|
||
|
||
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 (
|
||
<select value={value} onChange={(event) => setFilter(name, event.target.value)}>
|
||
<option value="">Alle</option>
|
||
<option value="none">{empty}</option>
|
||
{entries.map((item) => <option key={item.id} value={item.id}>{item.name}</option>)}
|
||
</select>
|
||
);
|
||
}
|
||
|
||
return (
|
||
<SourceFrame targetLabel={targetLabel} chapterId={chapterId} chapterTitle={chapterTitle}>
|
||
<div className="paperless-layout">
|
||
<aside className="paperless-layout__filters" aria-label="Suche und Filter">
|
||
{connectors.length > 1 ? (
|
||
<label>
|
||
Paperless-Zugang
|
||
<select value={connectorId} onChange={(event) => {
|
||
invalidate();
|
||
closePreview();
|
||
setConnectorId(event.target.value);
|
||
setFilters(EMPTY_FILTERS);
|
||
setItems([]);
|
||
setNextPage(null);
|
||
setPreviousPage(null);
|
||
setTotal(null);
|
||
setSearched(false);
|
||
setPage(1);
|
||
setFacets(NO_FACETS);
|
||
}}>
|
||
<option value="">Zugang wählen</option>
|
||
{connectors.map((item) => (
|
||
<option key={item.id} value={item.id}>{item.name}</option>
|
||
))}
|
||
</select>
|
||
</label>
|
||
) : null}
|
||
<form onSubmit={(event) => runSearch(event)} className="stack source-filters">
|
||
<div className="paperless-search">
|
||
<label>
|
||
Suche in
|
||
<select value={filters.mode} onChange={(event) => setMode(event.target.value)}>
|
||
{PAPERLESS_MODES.map(([value, label]) => <option key={value} value={value}>{label}</option>)}
|
||
</select>
|
||
</label>
|
||
<label className="paperless-search__text">
|
||
Suchtext
|
||
<input value={filters.query} onChange={(event) => setFilter("query", event.target.value)} />
|
||
</label>
|
||
<button type="submit">Suchen</button>
|
||
</div>
|
||
<p className="muted">{PAPERLESS_MODE_HINTS[filters.mode]}</p>
|
||
<details className="paperless-more" open={moreOpen} onToggle={(event) => setMoreOpen(event.currentTarget.open)}>
|
||
<summary>{active ? `Weitere Filter (${active} aktiv)` : "Weitere Filter"}</summary>
|
||
<div className="source-filters">
|
||
<label>
|
||
Titel enthält
|
||
<input value={filters.title} onChange={(event) => setFilter("title", event.target.value)} />
|
||
</label>
|
||
<label>
|
||
Korrespondent
|
||
{choiceSelect("correspondent", filters.correspondent, facets.correspondents, "Ohne Korrespondent")}
|
||
</label>
|
||
<label>
|
||
Dokumenttyp
|
||
{choiceSelect("documentType", filters.documentType, facets.document_types, "Ohne Dokumenttyp")}
|
||
</label>
|
||
<label>
|
||
Speicherpfad
|
||
{choiceSelect("storagePath", filters.storagePath, facets.storage_paths, "Ohne Speicherpfad")}
|
||
</label>
|
||
<fieldset>
|
||
<legend>Tags</legend>
|
||
<label>
|
||
Verknüpfung
|
||
<select value={filters.tagMode} onChange={(event) => setFilter("tagMode", event.target.value)}>
|
||
<option value="all">Alle gewählten Tags</option>
|
||
<option value="any">Mindestens eines der gewählten Tags</option>
|
||
<option value="none">Keines der gewählten Tags</option>
|
||
</select>
|
||
</label>
|
||
{filters.tags.length ? (
|
||
<ul className="paperless-chips" aria-label="Gewählte Tags">
|
||
{filters.tags.map((id) => (
|
||
<li key={id}>
|
||
<button type="button" className="paperless-chip" onClick={() => toggleTag(id)} aria-label={`Tag ${tagName(id)} entfernen`}>
|
||
{tagName(id)} <span aria-hidden="true">×</span>
|
||
</button>
|
||
</li>
|
||
))}
|
||
</ul>
|
||
) : null}
|
||
{facets.tags.length ? (
|
||
<>
|
||
<input type="search" value={tagSearch} onChange={(event) => setTagSearch(event.target.value)} placeholder="Tags suchen" aria-label="Tags suchen" />
|
||
<div className="paperless-tags__actions">
|
||
<button type="button" className="quiet" onClick={() => selectTags(visibleTags.map((item) => item.id))} disabled={!visibleTags.length}>
|
||
{tagSearch.trim() ? "Treffer wählen" : "Alle wählen"}
|
||
</button>
|
||
<button type="button" className="quiet" onClick={() => setFilter("tags", [])} disabled={!filters.tags.length}>
|
||
Alle abwählen
|
||
</button>
|
||
</div>
|
||
</>
|
||
) : null}
|
||
<div className="paperless-tags">
|
||
{visibleTags.map((item) => (
|
||
<label key={item.id} className="paperless-pick">
|
||
<input type="checkbox" checked={filters.tags.includes(item.id)} onChange={() => toggleTag(item.id)} />
|
||
<span>{item.name}</span>
|
||
</label>
|
||
))}
|
||
{!facets.tags.length ? <p className="muted">Keine Tags an diesem Zugang.</p> : null}
|
||
{facets.tags.length && !visibleTags.length ? <p className="muted">Kein Tag passt zur Suche.</p> : null}
|
||
</div>
|
||
</fieldset>
|
||
<label>
|
||
Dokumentdatum von
|
||
<input type="date" value={filters.documentFrom} onChange={(event) => setFilter("documentFrom", event.target.value)} />
|
||
</label>
|
||
<label>
|
||
Dokumentdatum bis
|
||
<input type="date" value={filters.documentTo} onChange={(event) => setFilter("documentTo", event.target.value)} />
|
||
</label>
|
||
<label>
|
||
Hinzugefügt von
|
||
<input type="date" value={filters.addedFrom} onChange={(event) => setFilter("addedFrom", event.target.value)} />
|
||
</label>
|
||
<label>
|
||
Hinzugefügt bis
|
||
<input type="date" value={filters.addedTo} onChange={(event) => setFilter("addedTo", event.target.value)} />
|
||
</label>
|
||
<label>
|
||
Archivnummer (ASN)
|
||
<input inputMode="numeric" value={filters.asn} onChange={(event) => setFilter("asn", event.target.value)} />
|
||
</label>
|
||
<CustomFieldFilters fields={facets.custom_fields || []} rows={filters.custom} onChange={(rows) => setFilter("custom", rows)} />
|
||
</div>
|
||
</details>
|
||
<label>
|
||
Sortierung
|
||
<select value={filters.sort} onChange={(event) => setFilter("sort", event.target.value)}>
|
||
<option value="-created">Dokumentdatum, neueste zuerst</option>
|
||
<option value="created">Dokumentdatum, älteste zuerst</option>
|
||
<option value="-added">Hinzugefügt, neueste zuerst</option>
|
||
<option value="added">Hinzugefügt, älteste zuerst</option>
|
||
<option value="title">Titel aufsteigend</option>
|
||
<option value="-title">Titel absteigend</option>
|
||
<option value="-score" disabled={!relevance}>Relevanz (nur Volltextindex mit Suchtext)</option>
|
||
</select>
|
||
</label>
|
||
<div className="row">
|
||
<button type="button" className="quiet" onClick={resetFilters}>Filter zurücksetzen</button>
|
||
</div>
|
||
</form>
|
||
</aside>
|
||
<section className="paperless-layout__results" aria-label="Treffer">
|
||
<ErrorNote error={error} />
|
||
<p className="muted">{SEARCH_LIMITS.paperless}</p>
|
||
<p className="muted">Die Verbindung richtest du unter <Link to="/sources">Quellen</Link> ein. Ausgewählte Belege bleiben erhalten, wenn du weiterblätterst oder neu suchst.</p>
|
||
{review ? (
|
||
<div className="card stack duplicate-panel" role="alert">
|
||
<strong>Diese Belege sind schon vorhanden. Was soll geschehen?</strong>
|
||
<ul className="duplicate-list">
|
||
{[...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 (
|
||
<li key={key}>
|
||
<span>{item.title}: {matches.length ? describeMatch(matches[0]) : "schon vorhanden"}</span>
|
||
<select
|
||
value={review.get(key)}
|
||
aria-label={`Entscheidung für ${item.title}`}
|
||
onChange={(event) => setReview((current) => new Map(current).set(key, event.target.value))}
|
||
>
|
||
<option value="skip">Nicht einfügen</option>
|
||
<option value="insert">Trotzdem erneut einfügen</option>
|
||
{bindable(matches) ? <option value="bind">Vorhandenes zusätzlich einbinden</option> : null}
|
||
</select>
|
||
</li>
|
||
);
|
||
})}
|
||
</ul>
|
||
<div className="row">
|
||
<button type="button" className="quiet" disabled={pending} onClick={() => setReview(null)}>Zurück zur Auswahl</button>
|
||
<button type="button" disabled={pending} onClick={() => linkMany(review)}>Entscheidung ausführen</button>
|
||
</div>
|
||
</div>
|
||
) : null}
|
||
{items.length || picked.size ? (
|
||
<button type="button" disabled={pending || picked.size === 0 || Boolean(review)} onClick={() => linkMany()}>
|
||
{picked.size ? `${picked.size} Belege einfügen` : "Belege auswählen"}
|
||
</button>
|
||
) : null}
|
||
{searched ? (
|
||
<p className="muted" role="status">
|
||
{items.length
|
||
? `${total !== null ? `${total} Treffer` : "Treffer"}, Seite ${page}`
|
||
: "Dazu gibt es in Paperless keinen Treffer."}
|
||
</p>
|
||
) : null}
|
||
<div className="stack">
|
||
{held.map((item) => (
|
||
<div key={`held-${item.connector_id}:${item.id}`} className="paperless-pick">
|
||
<label>
|
||
<input type="checkbox" checked disabled={pending} onChange={() => toggle(item)} />
|
||
<span>{paperlessLabel(item)}</span>
|
||
</label>
|
||
</div>
|
||
))}
|
||
{items.map((item) => {
|
||
const key = `${connectorId}:${item.id}`;
|
||
const open = previewKey === key;
|
||
const facts = paperlessFacts(item);
|
||
return (
|
||
<article key={key} className={open ? "paperless-card is-open" : "paperless-card"}>
|
||
<input
|
||
type="checkbox"
|
||
checked={picked.has(key)}
|
||
disabled={pending}
|
||
onChange={() => toggle(item)}
|
||
aria-label={`${item.title} auswählen`}
|
||
/>
|
||
<button type="button" className="paperless-thumb" onClick={() => preview(item)} aria-label={`${item.title} ansehen`}>
|
||
<PaperlessThumb connectorId={connectorId} id={item.id} />
|
||
</button>
|
||
<div className="paperless-card__body">
|
||
<strong>{item.title}</strong>
|
||
<PresentNote matches={matchesOf(item)} />
|
||
{facts.length ? <span className="paperless-card__facts">{facts.join(" · ")}</span> : null}
|
||
{item.tags?.length ? (
|
||
<ul className="paperless-card__tags" aria-label="Tags">
|
||
{item.tags.map((tag) => <li key={tag}>{tag}</li>)}
|
||
</ul>
|
||
) : null}
|
||
{item.custom_fields?.length ? (
|
||
<dl className="paperless-card__fields" aria-label="Zusatzfelder">
|
||
{item.custom_fields.map((field) => (
|
||
<div key={field.name}>
|
||
<dt>{field.name}</dt>
|
||
<dd>{field.type === "date" && formatDate(field.value) !== "Ohne Datum" ? formatDate(field.value) : field.value}</dd>
|
||
</div>
|
||
))}
|
||
</dl>
|
||
) : null}
|
||
{item.snippet ? <p className="paperless-card__snippet">{item.snippet}</p> : null}
|
||
<div className="row">
|
||
<button type="button" className="quiet" onClick={() => preview(item)} aria-expanded={open}>
|
||
{open ? "Ansicht schließen" : "Ansehen"}
|
||
</button>
|
||
</div>
|
||
</div>
|
||
{open ? (
|
||
<div className="paperless-card__view">
|
||
{previewUrl ? <DocumentView title={`Paperless-Vorschau: ${item.title}`} url={previewUrl} /> : <p className="muted">Vorschau wird geladen …</p>}
|
||
</div>
|
||
) : null}
|
||
</article>
|
||
);
|
||
})}
|
||
</div>
|
||
{previousPage || nextPage ? (
|
||
<div className="row">
|
||
{previousPage ? <button type="button" className="quiet" onClick={(event) => runSearch(event, previousPage)}>Vorherige Treffer</button> : null}
|
||
{nextPage ? <button type="button" onClick={(event) => runSearch(event, nextPage)}>Weitere Treffer</button> : null}
|
||
</div>
|
||
) : null}
|
||
</section>
|
||
</div>
|
||
</SourceFrame>
|
||
);
|
||
}
|
||
|
||
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 (
|
||
<li>
|
||
<div className={rowClass}>
|
||
{node.children.length ? (
|
||
<button type="button" className="folder-twist" aria-expanded={open} aria-label={open ? `${node.label} zuklappen` : `${node.label} aufklappen`} onClick={() => onToggle(node.name)}>
|
||
{open ? "▾" : "▸"}
|
||
</button>
|
||
) : <span className="folder-twist" aria-hidden="true" />}
|
||
{node.selectable ? (
|
||
<button type="button" className="folder-name" aria-current={current ? "true" : undefined} onClick={() => onSelect(node.name)}>
|
||
<NavIcon name="folder" />
|
||
<span>{node.label}</span>
|
||
</button>
|
||
) : (
|
||
<span className="folder-name"><NavIcon name="folder" /><span>{node.label}</span></span>
|
||
)}
|
||
</div>
|
||
{node.children.length && open ? (
|
||
<ul>
|
||
{node.children.map((child) => (
|
||
<FolderBranch key={child.name} node={child} mailbox={mailbox} path={path} expanded={expanded} onToggle={onToggle} onSelect={onSelect} />
|
||
))}
|
||
</ul>
|
||
) : null}
|
||
</li>
|
||
);
|
||
}
|
||
|
||
function MailFiles({ files }) {
|
||
if (!files?.length) return <p className="muted">Keine Anhänge.</p>;
|
||
return (
|
||
<ul className="mail-files">
|
||
{files.map((file) => <li key={file.filename}>{file.filename}</li>)}
|
||
</ul>
|
||
);
|
||
}
|
||
|
||
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 <p className="muted">Keine Fächer.</p>;
|
||
return (
|
||
<nav className="mailbox__folders" aria-label="Fächer">
|
||
<ul className="folder-tree">
|
||
{roots.map((node) => (
|
||
<FolderBranch key={node.name} node={node} mailbox={mailbox} path={path} expanded={expanded} onToggle={toggle} onSelect={onSelect} />
|
||
))}
|
||
</ul>
|
||
</nav>
|
||
);
|
||
}
|
||
|
||
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 (
|
||
<SourceFrame targetLabel={targetLabel} chapterId={chapterId} chapterTitle={chapterTitle}>
|
||
<label>
|
||
Konto
|
||
<select value={accountId} onChange={(event) => setAccountId(event.target.value)}>
|
||
{accounts.length ? null : <option value="">Kein Konto</option>}
|
||
{accounts.map((item) => (
|
||
<option key={item.id} value={item.id}>{item.name}</option>
|
||
))}
|
||
</select>
|
||
</label>
|
||
{!accounts.length ? <p className="muted">Lege zuerst ein E-Mail-Konto unter <Link to="/sources">Quellen</Link> an.</p> : null}
|
||
<div className="mailbox mailbox--read">
|
||
<FolderTree folders={folders} mailbox={mailbox} onSelect={setMailbox} />
|
||
<div className="mailbox__messages">
|
||
<form onSubmit={search} className="inline">
|
||
<input value={draft} onChange={(event) => setDraft(event.target.value)} placeholder="Im gewählten Fach suchen" aria-label="Im gewählten Fach suchen" />
|
||
<button type="submit" className="quiet" disabled={!mailbox || !!loading}>Suchen</button>
|
||
</form>
|
||
<p className="muted">{SEARCH_LIMITS.imap}</p>
|
||
<ErrorNote error={error} />
|
||
{notice ? <p className="notice">{notice}</p> : null}
|
||
{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={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">
|
||
{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 (
|
||
<button key={key} type="button" className={key === selectedKey ? "mail-row is-current" : "mail-row"} aria-current={key === selectedKey ? "true" : undefined} onClick={() => choose(item)}>
|
||
<span className="mail-row__date">{formatDate(item.document_on)}</span>
|
||
<span className="mail-row__main">
|
||
<strong>{item.title}</strong>
|
||
<span>{[way, who].filter(Boolean).join(" · ")}</span>
|
||
</span>
|
||
{files ? <span className="mail-row__files" aria-label={`${files} ${files === 1 ? "Anhang" : "Anhänge"}`}>{files}</span> : null}
|
||
</button>
|
||
);
|
||
})}
|
||
</div>
|
||
{nextBefore ? <button type="button" className="quiet" onClick={older} disabled={!!loading}>Ältere laden</button> : null}
|
||
</div>
|
||
<aside className="mail-preview" aria-label="E-Mail-Vorschau">
|
||
{!selected ? <p className="muted">Wähle eine Nachricht, um Absender, Empfänger und Inhalt zu prüfen.</p> : (
|
||
<>
|
||
<h3>{preview?.title || selected.title}</h3>
|
||
<p className="mail-preview__party">{(preview?.direction || selected.direction) === "out" ? "Ausgang" : (preview?.direction || selected.direction) === "in" ? "Eingang" : "Richtung nicht bekannt"}</p>
|
||
<p><span>Von</span> {preview?.message_from || selected.message_from || "Ohne Absender"}</p>
|
||
<p><span>An</span> {preview?.message_to || selected.message_to || "Ohne Empfänger"}</p>
|
||
{(preview?.message_cc || selected.message_cc) ? <p><span>Kopie</span> {preview?.message_cc || selected.message_cc}</p> : null}
|
||
<p><span>Datum</span> {formatDate(preview?.document_on || selected.document_on)}</p>
|
||
<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 ? <MailBody html={preview.html} text={preview.text} truncated={preview.text_truncated} notices={preview.notices} /> : null}
|
||
<ErrorNote error={error} />
|
||
{panel}
|
||
<button type="button" onClick={() => link(selected)} disabled={!selected.uid || adopting}>{adopting ? "Wird übernommen …" : "Übernehmen"}</button>
|
||
</>
|
||
)}
|
||
</aside>
|
||
</div>
|
||
</SourceFrame>
|
||
);
|
||
}
|
||
|
||
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 });
|