972 lines
37 KiB
React
972 lines
37 KiB
React
import { useEffect, useMemo, useRef, useState } from "react";
|
|
import { Link } from "react-router-dom";
|
|
import { api } from "../api.js";
|
|
import { moduleFor } from "../sources/registry-core.js";
|
|
import { buildChapterSections, sectionCounts } from "./chapters.js";
|
|
|
|
function formatDate(value) {
|
|
if (!value) return "Ohne Datum";
|
|
const [year, month, day] = String(value).slice(0, 10).split("-");
|
|
if (!year || !month || !day) return String(value);
|
|
return `${day}.${month}.${year}`;
|
|
}
|
|
|
|
export function scopeBody(context, containerKind, containerId) {
|
|
const rights = context || { kind: containerKind, id: containerId };
|
|
const same = rights.kind === containerKind && rights.id === containerId;
|
|
return { context: rights, placement: same ? null : { kind: containerKind, id: containerId } };
|
|
}
|
|
|
|
export function channelWord(channel) {
|
|
if (channel === "email") return "per E-Mail";
|
|
if (channel === "post") return "per Post";
|
|
if (channel === "other") return "sonstiger Weg";
|
|
return "";
|
|
}
|
|
|
|
export function unitMarks(binding) {
|
|
const pack = binding?.correspondence;
|
|
if (!pack) return "";
|
|
const parts = [];
|
|
const attachments = pack.attachments || [];
|
|
if (attachments.length === 1) parts.push("1 Anlage");
|
|
else if (attachments.length > 1) parts.push(`${attachments.length} Anlagen`);
|
|
const dispatches = pack.dispatches || [];
|
|
if (dispatches.length === 1) parts.push(channelWord(dispatches[0].channel));
|
|
else if (dispatches.length > 1) parts.push(`${dispatches.length} Versände`);
|
|
const evidence = dispatches.reduce((sum, item) => sum + (item.evidence || []).length, 0);
|
|
if (evidence === 1) parts.push("1 Beleg");
|
|
else if (evidence > 1) parts.push(`${evidence} Belege`);
|
|
return parts.join(" · ");
|
|
}
|
|
|
|
export function hostMark(binding) {
|
|
const hosts = binding?.correspondence?.hosts || [];
|
|
if (!hosts.length) return "";
|
|
return `Dieselbe Unterlage · Anlage zu ${hosts.map((item) => item.title).join(", ")}`;
|
|
}
|
|
|
|
function fieldBody(scope, extra) {
|
|
const body = { ...extra, context: scope.context };
|
|
if (scope.placement) body.placement = scope.placement;
|
|
return body;
|
|
}
|
|
|
|
export const ASSIGN_MIME = "application/x-tsumugu-item";
|
|
|
|
export const RECEIPT_ROLES = [
|
|
["email", "E-Mail"],
|
|
["submission", "Einlieferungsbeleg"],
|
|
["delivery", "Zustellung oder Versandbestätigung"],
|
|
["other", "Sonstiger Beleg"],
|
|
];
|
|
|
|
export function receiptRoleLabel(role, fallback = "") {
|
|
return RECEIPT_ROLES.find((item) => item[0] === role)?.[1] || fallback || role;
|
|
}
|
|
|
|
function receiptCaption(proof) {
|
|
if (proof.role === "email" && moduleFor(proof.source)?.representation !== "email") return "Beleg";
|
|
return receiptRoleLabel(proof.role, proof.role_label);
|
|
}
|
|
|
|
function receiptWhen(item) {
|
|
if (item.sent_on) return formatDate(item.sent_on);
|
|
const dated = (item.evidence || []).find((proof) => proof.document_on);
|
|
return dated ? formatDate(dated.document_on) : "";
|
|
}
|
|
|
|
function isShipment(item) {
|
|
const proofs = item.evidence || [];
|
|
if (item.channel === "other") return false;
|
|
if (proofs.length > 0 && proofs.every((proof) => proof.kind === "file")) return false;
|
|
return (item.items || []).length > 0;
|
|
}
|
|
|
|
function receiptHeading(item) {
|
|
const who = item.counterpart ? ` · ${item.counterpart}` : "";
|
|
const when = receiptWhen(item);
|
|
if (!isShipment(item)) return `${when || "Beleg"}${who}`;
|
|
return `Versand ${when || "undatiert"} · ${item.channel_label}${who}`;
|
|
}
|
|
|
|
export function writeAssign(event, payload) {
|
|
event.dataTransfer.effectAllowed = "copyMove";
|
|
event.dataTransfer.setData(ASSIGN_MIME, JSON.stringify(payload));
|
|
event.dataTransfer.setData("text/plain", payload.title || "");
|
|
}
|
|
|
|
function ancestorIds(chapters, chapterId) {
|
|
const byId = new Map((chapters || []).map((chapter) => [chapter.id, chapter]));
|
|
const ids = [];
|
|
const seen = new Set();
|
|
let current = chapterId ? byId.get(chapterId) : null;
|
|
while (current && !seen.has(current.id)) {
|
|
seen.add(current.id);
|
|
ids.push(current.id);
|
|
current = current.parent_chapter_id ? byId.get(current.parent_chapter_id) : null;
|
|
}
|
|
return ids;
|
|
}
|
|
|
|
function branchItems(section) {
|
|
return [
|
|
...(section.items || []),
|
|
...(section.children || []).flatMap(branchItems),
|
|
];
|
|
}
|
|
|
|
function titleMatches(binding, needle) {
|
|
if (!needle) return true;
|
|
return (binding.element?.title || "").toLowerCase().includes(needle);
|
|
}
|
|
|
|
function branchVisible(section, needle) {
|
|
if (!needle) return true;
|
|
if ((section.items || []).some((item) => titleMatches(item, needle))) return true;
|
|
return (section.children || []).some((child) => branchVisible(child, needle));
|
|
}
|
|
|
|
function PickBox({ checked, mixed = false, disabled = false, label, onChange }) {
|
|
const ref = useRef(null);
|
|
useEffect(() => {
|
|
if (ref.current) ref.current.indeterminate = mixed;
|
|
}, [mixed]);
|
|
return (
|
|
<input
|
|
ref={ref}
|
|
type="checkbox"
|
|
checked={checked}
|
|
disabled={disabled}
|
|
aria-checked={mixed ? "mixed" : checked}
|
|
aria-label={label}
|
|
onChange={onChange}
|
|
/>
|
|
);
|
|
}
|
|
|
|
function selectionState(ids, selected) {
|
|
if (!ids.length) return "off";
|
|
const count = ids.filter((id) => selected.has(id)).length;
|
|
if (count === 0) return "off";
|
|
if (count === ids.length) return "on";
|
|
return "mixed";
|
|
}
|
|
|
|
export function StructureAssignDialog({ host, bindings, chapters, scope, pending, onClose, onDone }) {
|
|
const visibleBindings = useMemo(
|
|
() => (bindings || []).filter((item) => !item.correspondence?.fold),
|
|
[bindings],
|
|
);
|
|
const tree = useMemo(() => buildChapterSections(chapters, visibleBindings), [chapters, visibleBindings]);
|
|
const receiptIds = useMemo(() => new Set(
|
|
(host.correspondence?.dispatches || []).flatMap((item) => (item.evidence || []).map((proof) => proof.element_id)),
|
|
), [host]);
|
|
const [opened, setOpened] = useState(() => new Set(host.chapter_id ? ancestorIds(chapters, host.chapter_id) : ["loose"]));
|
|
const [query, setQuery] = useState("");
|
|
const [selected, setSelected] = useState(() => new Set());
|
|
const [step, setStep] = useState("pick");
|
|
const [role, setRole] = useState("other");
|
|
const [fold, setFold] = useState("evidence");
|
|
const [dispatchId, setDispatchId] = useState(host.correspondence?.dispatches?.[0]?.id || "");
|
|
const [channel, setChannel] = useState("other");
|
|
const [sentOn, setSentOn] = useState("");
|
|
const [counterpart, setCounterpart] = useState("");
|
|
const [error, setError] = useState("");
|
|
const [busy, setBusy] = useState(false);
|
|
const needle = query.trim().toLowerCase();
|
|
const taken = new Set((host.correspondence?.attachments || []).map((item) => item.element_id));
|
|
const dispatches = host.correspondence?.dispatches || [];
|
|
|
|
function toggle(id) {
|
|
setSelected((current) => {
|
|
const next = new Set(current);
|
|
if (next.has(id)) next.delete(id);
|
|
else next.add(id);
|
|
return next;
|
|
});
|
|
}
|
|
|
|
function toggleIds(ids) {
|
|
if (!ids.length) return;
|
|
setSelected((current) => {
|
|
const next = new Set(current);
|
|
const allOn = ids.every((id) => next.has(id));
|
|
ids.forEach((id) => {
|
|
if (allOn) next.delete(id);
|
|
else next.add(id);
|
|
});
|
|
return next;
|
|
});
|
|
}
|
|
|
|
function selectable(id) {
|
|
return id !== host.element.id && !taken.has(id) && !receiptIds.has(id);
|
|
}
|
|
|
|
function toggleChapter(section) {
|
|
toggleIds(branchItems(section).map((item) => item.element.id).filter(selectable));
|
|
}
|
|
|
|
function visibleIds() {
|
|
const ids = [];
|
|
function walk(section) {
|
|
if (!branchVisible(section, needle)) return;
|
|
for (const item of section.items || []) {
|
|
if (selectable(item.element.id) && titleMatches(item, needle)) ids.push(item.element.id);
|
|
}
|
|
for (const child of section.children || []) walk(child);
|
|
}
|
|
tree.roots.forEach(walk);
|
|
for (const item of tree.loose) {
|
|
if (selectable(item.element.id) && titleMatches(item, needle)) ids.push(item.element.id);
|
|
}
|
|
return ids;
|
|
}
|
|
|
|
async function saveAttachments() {
|
|
const ids = [...selected].filter((id) => selectable(id));
|
|
if (!ids.length) {
|
|
setError("In der Auswahl ist keine neue Anlage.");
|
|
return;
|
|
}
|
|
setBusy(true);
|
|
setError("");
|
|
try {
|
|
await api(`/api/v1/elements/${host.element.id}/attachments`, {
|
|
method: "POST",
|
|
body: fieldBody(scope, {
|
|
expected_version: host.element.version,
|
|
attachment_element_ids: ids,
|
|
fold: "attachment",
|
|
}),
|
|
});
|
|
onDone();
|
|
onClose();
|
|
} catch (err) {
|
|
setError(err.message);
|
|
onDone();
|
|
} finally {
|
|
setBusy(false);
|
|
}
|
|
}
|
|
|
|
async function saveReceipts(event) {
|
|
event.preventDefault();
|
|
const ids = [...selected].filter((id) => selectable(id));
|
|
if (!ids.length) return;
|
|
setBusy(true);
|
|
setError("");
|
|
try {
|
|
if (!dispatchId) {
|
|
await api(`/api/v1/elements/${host.element.id}/dispatches`, {
|
|
method: "POST",
|
|
body: fieldBody(scope, {
|
|
expected_version: host.element.version,
|
|
channel,
|
|
sent_on: sentOn || null,
|
|
counterpart: counterpart.trim() || null,
|
|
attachment_element_ids: [],
|
|
evidence: ids.map((id) => ({ element_id: id, role, fold })),
|
|
historical_gap: false,
|
|
capture_editions: false,
|
|
}),
|
|
});
|
|
} else {
|
|
const dispatch = dispatches.find((item) => item.id === dispatchId);
|
|
const already = new Set((dispatch?.evidence || []).map((item) => item.element_id));
|
|
const fresh = ids.filter((id) => !already.has(id));
|
|
if (!fresh.length) {
|
|
setError("Diese Belege liegen an dem Versand bereits.");
|
|
return;
|
|
}
|
|
let version = dispatch?.version || 1;
|
|
for (const id of fresh) {
|
|
await api(`/api/v1/dispatches/${dispatchId}/evidence`, {
|
|
method: "POST",
|
|
body: fieldBody(scope, {
|
|
expected_version: version,
|
|
element_id: id,
|
|
role,
|
|
fold,
|
|
}),
|
|
});
|
|
version += 1;
|
|
}
|
|
}
|
|
onDone();
|
|
onClose();
|
|
} catch (err) {
|
|
setError(err.message);
|
|
onDone();
|
|
} finally {
|
|
setBusy(false);
|
|
}
|
|
}
|
|
|
|
function renderRow(item) {
|
|
const id = item.element.id;
|
|
const isHost = id === host.element.id;
|
|
const notes = [
|
|
formatDate(item.element.dates?.document_on),
|
|
isHost ? "dieses Schriftstück" : "",
|
|
taken.has(id) ? "bereits Anlage" : "",
|
|
receiptIds.has(id) ? "bereits Beleg" : "",
|
|
].filter(Boolean).join(" · ");
|
|
const blocked = isHost || taken.has(id) || receiptIds.has(id);
|
|
return (
|
|
<li key={item.id}>
|
|
<label className="pick-tree__row">
|
|
<PickBox checked={selected.has(id)} disabled={blocked} label={item.element.title} onChange={() => toggle(id)} />
|
|
<span className="pick-tree__title">{item.element.title}</span>
|
|
<span className="pick-tree__kind">{notes}</span>
|
|
</label>
|
|
</li>
|
|
);
|
|
}
|
|
|
|
function renderSection(section) {
|
|
if (!branchVisible(section, needle)) return null;
|
|
const expanded = Boolean(needle) || opened.has(section.id);
|
|
const counts = sectionCounts(section);
|
|
const total = counts.direct + counts.nested;
|
|
const ids = branchItems(section).map((item) => item.element.id).filter(selectable);
|
|
const state = selectionState(ids, selected);
|
|
return (
|
|
<li key={section.id}>
|
|
<div className="pick-tree__row">
|
|
<button
|
|
type="button"
|
|
className="pick-tree__twist"
|
|
aria-expanded={expanded}
|
|
aria-label={`${section.title} ${expanded ? "zuklappen" : "aufklappen"}`}
|
|
onClick={() => setOpened((current) => {
|
|
const next = new Set(current);
|
|
if (next.has(section.id)) next.delete(section.id);
|
|
else next.add(section.id);
|
|
return next;
|
|
})}
|
|
>
|
|
{expanded ? "▾" : "▸"}
|
|
</button>
|
|
<label>
|
|
<PickBox
|
|
checked={state === "on"}
|
|
mixed={state === "mixed"}
|
|
disabled={!ids.length}
|
|
label={`Alle in ${section.title}`}
|
|
onChange={() => toggleChapter(section)}
|
|
/>
|
|
<span className="pick-tree__title">{section.title}</span>
|
|
<span className="pick-tree__kind">{total}</span>
|
|
</label>
|
|
</div>
|
|
{expanded ? (
|
|
<ul>
|
|
{(section.items || []).filter((item) => titleMatches(item, needle)).map((item) => renderRow(item))}
|
|
{(section.children || []).map((child) => renderSection(child))}
|
|
</ul>
|
|
) : null}
|
|
</li>
|
|
);
|
|
}
|
|
|
|
const loose = tree.loose.filter((item) => titleMatches(item, needle));
|
|
const roots = tree.roots.map((section) => renderSection(section, 0)).filter(Boolean);
|
|
|
|
const looseIds = loose.map((item) => item.element.id).filter(selectable);
|
|
const looseState = selectionState(looseIds, selected);
|
|
const looseOpen = Boolean(needle) || opened.has("loose");
|
|
|
|
return (
|
|
<div className="stack pick-tree-dialog">
|
|
<p className="pick-tree__lead">Zuordnen an {host.element.title}</p>
|
|
<label className="pick-tree__find">
|
|
Suchen
|
|
<input value={query} onChange={(event) => setQuery(event.target.value)} placeholder="Titel" />
|
|
</label>
|
|
{step === "pick" ? (
|
|
<>
|
|
<ul className="pick-tree">
|
|
{roots}
|
|
{loose.length ? (
|
|
<li>
|
|
<div className="pick-tree__row">
|
|
<button
|
|
type="button"
|
|
className="pick-tree__twist"
|
|
aria-expanded={looseOpen}
|
|
aria-label={`Ohne Kapitel ${looseOpen ? "zuklappen" : "aufklappen"}`}
|
|
onClick={() => setOpened((current) => {
|
|
const next = new Set(current);
|
|
if (next.has("loose")) next.delete("loose");
|
|
else next.add("loose");
|
|
return next;
|
|
})}
|
|
>
|
|
{looseOpen ? "▾" : "▸"}
|
|
</button>
|
|
<label>
|
|
<PickBox
|
|
checked={looseState === "on"}
|
|
mixed={looseState === "mixed"}
|
|
disabled={!looseIds.length}
|
|
label="Alle ohne Kapitel"
|
|
onChange={() => toggleIds(looseIds)}
|
|
/>
|
|
<span className="pick-tree__title">Ohne Kapitel</span>
|
|
<span className="pick-tree__kind">{loose.length}</span>
|
|
</label>
|
|
</div>
|
|
{looseOpen ? (
|
|
<ul>
|
|
{loose.map((item) => renderRow(item))}
|
|
</ul>
|
|
) : null}
|
|
</li>
|
|
) : null}
|
|
{!roots.length && !loose.length ? <li className="pick-tree__empty">Nichts mit diesem Titel.</li> : null}
|
|
</ul>
|
|
<div className="pick-tree__bar">
|
|
<span>{selected.size} ausgewählt</span>
|
|
{needle ? <button type="button" className="quiet" onClick={() => toggleIds(visibleIds())}>Sichtbare</button> : null}
|
|
<button type="button" disabled={pending || busy || !selected.size} onClick={saveAttachments}>Als Anlagen</button>
|
|
<button type="button" disabled={pending || busy || !selected.size} onClick={() => { setError(""); setStep("receipt"); }}>Als Belege</button>
|
|
<button type="button" className="quiet" onClick={onClose}>Schließen</button>
|
|
</div>
|
|
</>
|
|
) : (
|
|
<form className="stack" onSubmit={saveReceipts}>
|
|
<p>{selected.size} Belege. Dieselbe Rolle gilt für die Auswahl.</p>
|
|
<label>
|
|
Versand
|
|
<select value={dispatchId} onChange={(event) => setDispatchId(event.target.value)}>
|
|
<option value="">Neuen Versand anlegen</option>
|
|
{dispatches.map((item) => (
|
|
<option key={item.id} value={item.id}>
|
|
{item.sent_on ? formatDate(item.sent_on) : "undatiert"} · {item.channel_label}
|
|
</option>
|
|
))}
|
|
</select>
|
|
</label>
|
|
{!dispatchId ? (
|
|
<>
|
|
<label>
|
|
Weg
|
|
<select value={channel} onChange={(event) => setChannel(event.target.value)}>
|
|
<option value="email">E-Mail</option>
|
|
<option value="post">Post</option>
|
|
<option value="other">Sonstiger Weg</option>
|
|
</select>
|
|
</label>
|
|
<label>Versanddatum<input type="date" value={sentOn} onChange={(event) => setSentOn(event.target.value)} /></label>
|
|
<label>Gegenüber<input value={counterpart} onChange={(event) => setCounterpart(event.target.value)} maxLength={200} /></label>
|
|
</>
|
|
) : null}
|
|
<label>
|
|
Rolle
|
|
<select value={role} onChange={(event) => setRole(event.target.value)}>
|
|
{RECEIPT_ROLES.map(([value, label]) => <option key={value} value={value}>{label}</option>)}
|
|
</select>
|
|
</label>
|
|
<fieldset>
|
|
<legend>Darstellung in der Liste</legend>
|
|
<label><input type="radio" name="assign-fold" checked={fold === "evidence"} onChange={() => setFold("evidence")} /> Nur am Versand zeigen</label>
|
|
<label><input type="radio" name="assign-fold" checked={fold === "keep"} onChange={() => setFold("keep")} /> Zusätzlich als eigenen Eintrag behalten</label>
|
|
</fieldset>
|
|
<button type="submit" disabled={pending || busy}>Belege zuordnen</button>
|
|
<button type="button" className="quiet" onClick={() => setStep("pick")}>Zurück zur Struktur</button>
|
|
</form>
|
|
)}
|
|
{error ? <p className="error">{error}</p> : null}
|
|
</div>
|
|
);
|
|
}
|
|
|
|
export function DispatchDialog({ host, scope, pending, onClose, onDone }) {
|
|
const proposal = host.correspondence?.attachments || [];
|
|
const [order, setOrder] = useState(proposal.map((item) => item.element_id));
|
|
const [chosen, setChosen] = useState(() => new Set(proposal.map((item) => item.element_id)));
|
|
const [channel, setChannel] = useState("email");
|
|
const [sentOn, setSentOn] = useState("");
|
|
const [counterpart, setCounterpart] = useState("");
|
|
const [historical, setHistorical] = useState(false);
|
|
const [error, setError] = useState("");
|
|
|
|
function move(id, delta) {
|
|
setOrder((current) => {
|
|
const index = current.indexOf(id);
|
|
const target = index + delta;
|
|
if (index < 0 || target < 0 || target >= current.length) return current;
|
|
const next = [...current];
|
|
const [item] = next.splice(index, 1);
|
|
next.splice(target, 0, item);
|
|
return next;
|
|
});
|
|
}
|
|
|
|
async function save(event) {
|
|
event.preventDefault();
|
|
setError("");
|
|
try {
|
|
await api(`/api/v1/elements/${host.element.id}/dispatches`, {
|
|
method: "POST",
|
|
body: fieldBody(scope, {
|
|
expected_version: host.element.version,
|
|
channel,
|
|
sent_on: sentOn || null,
|
|
counterpart: counterpart.trim() || null,
|
|
attachment_element_ids: order.filter((id) => chosen.has(id)),
|
|
evidence: [],
|
|
historical_gap: historical,
|
|
}),
|
|
});
|
|
onDone();
|
|
} catch (err) {
|
|
setError(err.message);
|
|
}
|
|
}
|
|
|
|
return (
|
|
<form className="stack" onSubmit={save}>
|
|
<p>Versand von <strong>{host.element.title}</strong> dokumentieren. Dabei wird nichts verschickt. Die Anlagenliste ist ein Vorschlag für diesen Versand.</p>
|
|
<label>
|
|
Weg
|
|
<select value={channel} onChange={(event) => setChannel(event.target.value)}>
|
|
<option value="email">E-Mail</option>
|
|
<option value="post">Post</option>
|
|
<option value="other">Sonstiger Weg</option>
|
|
</select>
|
|
</label>
|
|
<label>
|
|
Versanddatum
|
|
<input type="date" value={sentOn} onChange={(event) => setSentOn(event.target.value)} />
|
|
</label>
|
|
<p className="muted">Leer lassen, wenn der Versandtag unbekannt ist. Der Erfassungszeitpunkt ersetzt ihn nicht.</p>
|
|
<label>
|
|
Gegenüber
|
|
<input value={counterpart} onChange={(event) => setCounterpart(event.target.value)} maxLength={200} />
|
|
</label>
|
|
<p className="muted">Leer lassen, wenn das Gegenüber unbekannt ist.</p>
|
|
<fieldset>
|
|
<legend>Tatsächlich mitversendet</legend>
|
|
<ol className="choice-list">
|
|
{order.map((id, index) => {
|
|
const item = proposal.find((entry) => entry.element_id === id);
|
|
if (!item) return null;
|
|
return (
|
|
<li key={id}>
|
|
<label>
|
|
<input type="checkbox" checked={chosen.has(id)} onChange={() => setChosen((current) => {
|
|
const next = new Set(current);
|
|
if (next.has(id)) next.delete(id);
|
|
else next.add(id);
|
|
return next;
|
|
})} />
|
|
<span>{item.title}</span>
|
|
<span className="muted">{formatDate(item.document_on)}</span>
|
|
</label>
|
|
<span className="choice-list__move">
|
|
<button type="button" disabled={index === 0} onClick={() => move(id, -1)} aria-label={`${item.title} nach oben`}>↑</button>
|
|
<button type="button" disabled={index === order.length - 1} onClick={() => move(id, 1)} aria-label={`${item.title} nach unten`}>↓</button>
|
|
</span>
|
|
</li>
|
|
);
|
|
})}
|
|
</ol>
|
|
{!proposal.length ? <p className="muted">Keine zugeordnete Anlage. Das Schreiben kann allein dokumentiert werden.</p> : null}
|
|
</fieldset>
|
|
<label>
|
|
<input type="checkbox" checked={historical} onChange={(event) => setHistorical(event.target.checked)} />
|
|
Historische Originalfassung liegt nicht mehr vor
|
|
</label>
|
|
{error ? <p className="error">{error}</p> : null}
|
|
<button type="submit" disabled={pending}>Versand dokumentieren</button>
|
|
<button type="button" className="quiet" onClick={onClose}>Abbrechen</button>
|
|
</form>
|
|
);
|
|
}
|
|
|
|
export function EvidenceDialog({ element, hosts, scope, pending, presetDispatchId, replace = null, onClose, onDone }) {
|
|
const [hostId, setHostId] = useState(hosts[0]?.element.id || "");
|
|
const host = hosts.find((item) => item.element.id === hostId) || null;
|
|
const [dispatchId, setDispatchId] = useState(
|
|
presetDispatchId !== undefined ? presetDispatchId : (host?.correspondence?.dispatches?.[0]?.id || ""),
|
|
);
|
|
const [role, setRole] = useState("other");
|
|
const [fold, setFold] = useState("evidence");
|
|
const [channel, setChannel] = useState("other");
|
|
const [sentOn, setSentOn] = useState("");
|
|
const [counterpart, setCounterpart] = useState("");
|
|
const [result, setResult] = useState(null);
|
|
const [error, setError] = useState("");
|
|
|
|
async function save(event) {
|
|
event.preventDefault();
|
|
if (!host) return;
|
|
setError("");
|
|
try {
|
|
if (replace?.dispatchId && replace.dispatchId !== dispatchId) {
|
|
await api(`/api/v1/dispatches/${replace.dispatchId}/evidence/${element.id}/detach`, {
|
|
method: "POST",
|
|
body: fieldBody(scope, { expected_version: replace.version }),
|
|
});
|
|
}
|
|
let target = dispatchId;
|
|
if (!target) {
|
|
const created = await api(`/api/v1/elements/${host.element.id}/dispatches`, {
|
|
method: "POST",
|
|
body: fieldBody(scope, {
|
|
expected_version: host.element.version,
|
|
channel,
|
|
sent_on: sentOn || null,
|
|
counterpart: counterpart.trim() || null,
|
|
attachment_element_ids: [],
|
|
evidence: [{ element_id: element.id, role, fold }],
|
|
historical_gap: false,
|
|
capture_editions: false,
|
|
}),
|
|
});
|
|
const proof = (created.evidence || []).find((item) => item.element_id === element.id);
|
|
setResult(proof || created);
|
|
onDone(false);
|
|
return;
|
|
}
|
|
const dispatch = (host.correspondence?.dispatches || []).find((item) => item.id === target);
|
|
const proof = await api(`/api/v1/dispatches/${target}/evidence`, {
|
|
method: "POST",
|
|
body: fieldBody(scope, {
|
|
expected_version: dispatch?.version || 1,
|
|
element_id: element.id,
|
|
role,
|
|
fold,
|
|
}),
|
|
});
|
|
setResult(proof);
|
|
onDone(false);
|
|
} catch (err) {
|
|
setError(err.message);
|
|
}
|
|
}
|
|
|
|
return (
|
|
<form className="stack" onSubmit={save}>
|
|
<p><strong>{element.title}</strong> als Beleg zu diesem Versand. E-Mail, Notiz, Foto und Paperless-Dokument bleiben das Original. An einem Versand können mehrere Belege liegen.</p>
|
|
<label>
|
|
Hauptschriftstück
|
|
<select value={hostId} onChange={(event) => {
|
|
const next = event.target.value;
|
|
setHostId(next);
|
|
const found = hosts.find((item) => item.element.id === next);
|
|
setDispatchId(found?.correspondence?.dispatches?.[0]?.id || "");
|
|
}}>
|
|
{hosts.map((item) => <option key={item.element.id} value={item.element.id}>{item.element.title}</option>)}
|
|
</select>
|
|
</label>
|
|
<label>
|
|
Versand
|
|
<select value={dispatchId} onChange={(event) => setDispatchId(event.target.value)}>
|
|
<option value="">Neuen Versand in diesem Ablauf anlegen</option>
|
|
{(host?.correspondence?.dispatches || []).map((item) => (
|
|
<option key={item.id} value={item.id}>
|
|
{item.sent_on ? formatDate(item.sent_on) : "undatiert"} · {item.channel_label}
|
|
</option>
|
|
))}
|
|
</select>
|
|
</label>
|
|
{!dispatchId ? (
|
|
<>
|
|
<label>
|
|
Weg
|
|
<select value={channel} onChange={(event) => setChannel(event.target.value)}>
|
|
<option value="email">E-Mail</option>
|
|
<option value="post">Post</option>
|
|
<option value="other">Sonstiger Weg</option>
|
|
</select>
|
|
</label>
|
|
<label>Versanddatum<input type="date" value={sentOn} onChange={(event) => setSentOn(event.target.value)} /></label>
|
|
<label>Gegenüber<input value={counterpart} onChange={(event) => setCounterpart(event.target.value)} maxLength={200} /></label>
|
|
</>
|
|
) : null}
|
|
<label>
|
|
Rolle
|
|
<select value={role} onChange={(event) => setRole(event.target.value)}>
|
|
{RECEIPT_ROLES.map(([value, label]) => <option key={value} value={value}>{label}</option>)}
|
|
</select>
|
|
</label>
|
|
<fieldset>
|
|
<legend>Darstellung in der Liste</legend>
|
|
<label><input type="radio" name="evidence-fold" checked={fold === "evidence"} onChange={() => setFold("evidence")} /> Nur am Versand zeigen</label>
|
|
<label><input type="radio" name="evidence-fold" checked={fold === "keep"} onChange={() => setFold("keep")} /> Zusätzlich als eigenen Eintrag behalten</label>
|
|
</fieldset>
|
|
{result ? <ComparisonList comparisons={result.comparisons || []} state={result.source_state} reason={result.gap_reason} /> : null}
|
|
{error ? <p className="error">{error}</p> : null}
|
|
<button type="submit" disabled={pending || !host}>Beleg zuordnen</button>
|
|
<button type="button" className="quiet" onClick={onClose}>Schließen</button>
|
|
</form>
|
|
);
|
|
}
|
|
|
|
export function ComparisonList({ comparisons = [], state, reason }) {
|
|
if (!comparisons.length && state !== "gap") return null;
|
|
return (
|
|
<div className="comparison">
|
|
{state === "gap" ? <p>Originalfassung nicht gesichert: {reason}</p> : null}
|
|
{state === "identified" ? <p>Nachweis manuell zugeordnet. Gleiche Dateinamen werden nicht automatisch zusammengeführt.</p> : null}
|
|
<ul>
|
|
{comparisons.map((item) => (
|
|
<li key={`${item.filename}-${item.sha256}`}>
|
|
<strong>{item.filename}</strong>
|
|
{item.disposition === "same_bytes" ? ` · gleicher Dateiinhalt wie ${item.matches.map((match) => match.title).join(", ")} · Vorschlag, nicht automatisch zugeordnet` : null}
|
|
{item.disposition === "same_name_different_bytes" ? ` · gleicher Name, anderer Inhalt als ${item.matches.map((match) => match.title).join(", ")}` : null}
|
|
{item.disposition === "distinct" ? " · eigener Inhalt" : null}
|
|
</li>
|
|
))}
|
|
</ul>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
function chipPointer(enabled, payload, onCarryStart) {
|
|
if (!enabled) return {};
|
|
return {
|
|
onPointerDown(event) {
|
|
onCarryStart?.(event, payload);
|
|
},
|
|
};
|
|
}
|
|
|
|
function openTitleProps(onOpen) {
|
|
return {
|
|
role: "link",
|
|
tabIndex: 0,
|
|
onClick(event) {
|
|
const row = event.currentTarget.closest(".use-chip");
|
|
if (row?.dataset.dragged === "1") {
|
|
delete row.dataset.dragged;
|
|
return;
|
|
}
|
|
onOpen();
|
|
},
|
|
onKeyDown(event) {
|
|
if (event.key !== "Enter" && event.key !== " ") return;
|
|
event.preventDefault();
|
|
onOpen();
|
|
},
|
|
};
|
|
}
|
|
|
|
export function UnitDetail({
|
|
binding,
|
|
canEdit,
|
|
pending,
|
|
onOpen,
|
|
onDetach,
|
|
onDetachEvidence,
|
|
onUnfold,
|
|
onCarryStart,
|
|
children,
|
|
}) {
|
|
const pack = binding.correspondence || {};
|
|
const attachments = pack.attachments || [];
|
|
const dispatches = pack.dispatches || [];
|
|
const [attachmentsOpen, setAttachmentsOpen] = useState(false);
|
|
const [receiptsOpen, setReceiptsOpen] = useState(false);
|
|
if (!attachments.length && !dispatches.length) {
|
|
return typeof children === "function" ? children(null, null) : null;
|
|
}
|
|
const evidenceCount = dispatches.reduce((sum, item) => sum + (item.evidence || []).length, 0);
|
|
const shipmentCount = dispatches.filter(isShipment).length;
|
|
const attachmentLabel = attachments.length === 1 ? "1 Anlage" : `${attachments.length} Anlagen`;
|
|
const receiptParts = [];
|
|
if (shipmentCount === 1) receiptParts.push("1 Versand");
|
|
else if (shipmentCount > 1) receiptParts.push(`${shipmentCount} Versände`);
|
|
if (evidenceCount === 1) receiptParts.push("1 Beleg");
|
|
else if (evidenceCount > 1) receiptParts.push(`${evidenceCount} Belege`);
|
|
const receiptLabel = receiptParts.join(" · ");
|
|
const switches = (
|
|
<span className="unit-switches">
|
|
{attachments.length ? (
|
|
<button type="button" className="unit-switch" aria-expanded={attachmentsOpen} onClick={() => setAttachmentsOpen((value) => !value)}>
|
|
{attachmentLabel}
|
|
</button>
|
|
) : null}
|
|
{dispatches.length ? (
|
|
<button type="button" className="unit-switch" aria-expanded={receiptsOpen} onClick={() => setReceiptsOpen((value) => !value)}>
|
|
{receiptLabel || "Belege"}
|
|
</button>
|
|
) : null}
|
|
</span>
|
|
);
|
|
const lists = attachmentsOpen || receiptsOpen ? (
|
|
<div className="unit-detail unit-detail--slim">
|
|
{attachmentsOpen && attachments.length ? (
|
|
<section>
|
|
<h4>Anlagen</h4>
|
|
<ol>
|
|
{attachments.map((item, index) => (
|
|
<li
|
|
key={item.id}
|
|
className="use-chip"
|
|
data-carry={`attachment:${item.element_id}`}
|
|
{...chipPointer(canEdit && !pending, {
|
|
source: "attachment",
|
|
elementId: item.element_id,
|
|
hostElementId: binding.element.id,
|
|
hostBindingId: binding.id,
|
|
bindingId: item.binding_id || "",
|
|
title: item.title,
|
|
}, onCarryStart)}
|
|
>
|
|
{canEdit ? <span className="use-chip__grip" aria-hidden="true" /> : null}
|
|
<span className="use-chip__title" {...openTitleProps(() => onOpen(item.element_id))}>
|
|
{index + 1}. {item.title}
|
|
</span>
|
|
<span className="muted">{formatDate(item.document_on)}</span>
|
|
{canEdit ? (
|
|
<button type="button" className="quiet" disabled={pending} onClick={() => onDetach(item.element_id)}>In die Liste</button>
|
|
) : null}
|
|
</li>
|
|
))}
|
|
</ol>
|
|
</section>
|
|
) : null}
|
|
{receiptsOpen ? dispatches.map((item) => (
|
|
<section key={item.id}>
|
|
<h4>{receiptHeading(item)}</h4>
|
|
{item.evidence?.length ? (
|
|
<ul>
|
|
{item.evidence.map((proof) => (
|
|
<li
|
|
key={proof.id}
|
|
className="use-chip"
|
|
data-carry={`evidence:${proof.element_id}`}
|
|
{...chipPointer(canEdit && !pending, {
|
|
source: "evidence",
|
|
elementId: proof.element_id,
|
|
dispatchId: item.id,
|
|
hostElementId: binding.element.id,
|
|
hostBindingId: binding.id,
|
|
version: item.version,
|
|
title: proof.title,
|
|
}, onCarryStart)}
|
|
>
|
|
{canEdit ? <span className="use-chip__grip" aria-hidden="true" /> : null}
|
|
<span className="use-chip__title" {...openTitleProps(() => onOpen(proof.element_id))}>
|
|
{receiptCaption(proof)}: {proof.title}
|
|
</span>
|
|
<span className="muted">{formatDate(proof.document_on)}</span>
|
|
{proof.source_state === "gap" ? <span>Lücke: {proof.gap_reason}</span> : null}
|
|
{canEdit ? (
|
|
<button type="button" className="quiet" disabled={pending} onClick={() => onDetachEvidence(proof, item)}>
|
|
In die Liste
|
|
</button>
|
|
) : null}
|
|
{canEdit && proof.listed_fold === "evidence" ? (
|
|
<button type="button" className="quiet" disabled={pending} onClick={() => onUnfold(proof.element_id)}>
|
|
Zusätzlich in der Liste zeigen
|
|
</button>
|
|
) : null}
|
|
</li>
|
|
))}
|
|
</ul>
|
|
) : <p className="muted">Ohne Beleg</p>}
|
|
</section>
|
|
)) : null}
|
|
</div>
|
|
) : null;
|
|
if (typeof children === "function") return children(switches, lists);
|
|
return (
|
|
<div className="unit-fold">
|
|
{switches}
|
|
{lists}
|
|
</div>
|
|
);
|
|
}
|
|
|
|
export function Chronology({ bindings, direction, itemHref, selectedId, onOpen }) {
|
|
const events = [];
|
|
for (const binding of bindings || []) {
|
|
if (binding.correspondence?.fold !== "evidence") {
|
|
events.push({
|
|
key: `doc-${binding.id}`,
|
|
date: binding.element?.dates?.document_on || "",
|
|
label: "Unterlage",
|
|
title: binding.element?.title || "",
|
|
detail: `Dokumentdatum ${formatDate(binding.element?.dates?.document_on)}`,
|
|
binding,
|
|
});
|
|
}
|
|
for (const dispatch of binding.correspondence?.dispatches || []) {
|
|
events.push({
|
|
key: `send-${dispatch.id}`,
|
|
date: dispatch.sent_on || "",
|
|
label: isShipment(dispatch) ? "Versand" : "Beleg",
|
|
title: binding.element?.title || "",
|
|
detail: [
|
|
dispatch.undated ? "Versand undatiert" : `Versanddatum ${formatDate(dispatch.sent_on)}`,
|
|
dispatch.channel_label,
|
|
(dispatch.evidence || []).length === 1
|
|
? "1 Beleg"
|
|
: (dispatch.evidence || []).length
|
|
? `${dispatch.evidence.length} Belege`
|
|
: "ohne Beleg",
|
|
].join(" · "),
|
|
binding,
|
|
dispatch,
|
|
});
|
|
}
|
|
}
|
|
events.sort((left, right) => {
|
|
if (!left.date && !right.date) return left.key.localeCompare(right.key);
|
|
if (!left.date) return 1;
|
|
if (!right.date) return -1;
|
|
const compared = left.date.localeCompare(right.date);
|
|
if (compared) return direction === "desc" ? -compared : compared;
|
|
return left.key.localeCompare(right.key);
|
|
});
|
|
const undated = events.filter((item) => !item.date);
|
|
const dated = events.filter((item) => item.date);
|
|
const ordered = direction === "desc" ? [...undated, ...dated] : [...dated, ...undated];
|
|
const groups = [];
|
|
for (const event of ordered) {
|
|
const name = event.date ? formatDate(event.date) : "Ohne Datum";
|
|
const last = groups[groups.length - 1];
|
|
if (!last || last.name !== name) groups.push({ name, events: [event] });
|
|
else last.events.push(event);
|
|
}
|
|
if (!groups.length) return <p className="muted">In dieser Ansicht ist noch nichts zu sehen.</p>;
|
|
return (
|
|
<div className="chrono">
|
|
{groups.map((group) => (
|
|
<section key={group.name}>
|
|
<h3>{group.name}</h3>
|
|
<ol className="preview-list">
|
|
{group.events.map((event) => (
|
|
<li key={event.key} className={selectedId === event.binding.id ? "preview-row is-selected" : "preview-row"}>
|
|
<div className="preview-row__body">
|
|
<Link to={itemHref(event.binding)} onClick={(click) => {
|
|
if (click.metaKey || click.ctrlKey || click.shiftKey || click.altKey || click.button !== 0) return;
|
|
click.preventDefault();
|
|
onOpen(event.binding);
|
|
}}>
|
|
<strong>{event.label}: {event.title}</strong>
|
|
</Link>
|
|
<span className="preview-row__facts">{event.detail}</span>
|
|
</div>
|
|
</li>
|
|
))}
|
|
</ol>
|
|
</section>
|
|
))}
|
|
</div>
|
|
);
|
|
}
|
|
|
|
export async function restoreFold(bindingId, version, scope) {
|
|
await api(`/api/v1/bindings/${bindingId}/fold`, {
|
|
method: "PATCH",
|
|
body: fieldBody(scope, { expected_version: version, fold: null }),
|
|
});
|
|
}
|