Assecutor/workflow-editor
4
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Undo (max. 10 Schritte), Pflichtfelder je Listeneintrag und Statusauswahl als Zeilen-Editor

Browse Source 
- Canvas-Undo über Schnappschuss-Historie (Strg+Z + Header-Button); Server
  gleicht BlockInstances nach Undo ab und stellt Einstellungen gelöschter
  Blöcke aus einem Papierkorb wieder her
- Element-Einstellungsdialog um 33% vergrößert (440px -> 585px)
- Listen von Texten/Zahlen/Checkboxen: Pflicht-Checkbox je Eintrag statt
  übergreifender "Optionale Aufgabe"; required wird im JSON (fields/entries)
  exportiert und beim Deep-Link-Import wiederhergestellt
- Statusauswahl erfasst Optionen als einzelne Zeilen (CHOICE_LIST) statt
  Textarea; Altdaten (Text bzw. entries) werden weiter unterstützt
- Titeländerungen werden im Graph-HTML nachgezogen (überleben Export/Laden)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Sven Carstensen
2026-07-06 08:03:39 +02:00
parent 72508a60bf
commit d0b2373cc1
10 changed files with 353 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
src/main/frontend/node-editor/node-editor.js
View File

@@ -181,6 +181,70 @@ if (Drawflow && Drawflow.prototype) {
const editors = new WeakMap();
// --- Undo-Historie ---------------------------------------------------------
// Nach jeder Canvas-Änderung wird ein Schnappschuss (Drawflow-Export)
// abgelegt; Strg+Z bzw. der Rückgängig-Button stellt den vorherigen
// Schnappschuss wieder her. Es sind maximal UNDO_LIMIT Schritte rücknehmbar.
const UNDO_LIMIT = 10;
function currentSnapshot(state) {
return JSON.stringify(state.editor.export());
}
// Legt (um einen Tick verzögert) einen Schnappschuss ab. Mehrere Drawflow-
// Events derselben Benutzeraktion (z. B. Knoten löschen inkl. seiner
// Verbindungen) werden so zu einem einzigen Undo-Schritt zusammengefasst.
function recordHistory(state) {
if (state.undoSuppressed || state.undoScheduled) return;
state.undoScheduled = true;
setTimeout(() => {
state.undoScheduled = false;
if (state.undoSuppressed) return;
const snap = currentSnapshot(state);
const stack = state.history;
if (stack.length && stack[stack.length - 1] === snap) return;
stack.push(snap);
// Basiszustand + UNDO_LIMIT rücknehmbare Schritte behalten.
if (stack.length > UNDO_LIMIT + 1) stack.shift();
}, 0);
}
// Setzt die Historie auf den aktuellen Zustand als neuen Basiszustand zurück
// (z. B. nach dem Laden eines gespeicherten Canvas).
function resetHistory(state) {
state.history = [currentSnapshot(state)];
}
// Stellt den vorherigen Schnappschuss wieder her; liefert false, wenn es
// nichts zurückzunehmen gibt.
function undoLast(state) {
const stack = state.history;
if (!stack || stack.length < 2) return false;
stack.pop(); // aktueller Zustand
const previous = stack[stack.length - 1];
state.undoSuppressed = true;
try {
state.editor.import(JSON.parse(previous));
} finally {
state.undoSuppressed = false;
}
notifyCanvasRestored(state);
return true;
}
// Meldet dem Server die nach einem Undo vorhandenen Knoten, damit dieser
// seine BlockInstances (inkl. der Einstellungen wiederhergestellter Blöcke)
// abgleichen kann.
function notifyCanvasRestored(state) {
if (!state.host || !state.host.$server) return;
const data = state.editor.drawflow.drawflow[state.editor.module].data;
const nodes = Object.keys(data).map(id => ({
id: parseInt(id, 10),
typeId: data[id].data ? data[id].data.typeId : null
}));
state.host.$server.onCanvasRestored(JSON.stringify(nodes));
}
if (!window.__taskListEditorDragInit) {
window.__taskListEditorDragInit = true;
document.addEventListener('dragstart', e => {
@@ -261,9 +325,14 @@ function attach(host) {
const state = {
editor,
container,
registry: new Map()
host,
registry: new Map(),
history: [],
undoSuppressed: false,
undoScheduled: false
};
editors.set(host, state);
resetHistory(state);
// Hindernis-bewusste Linienführung. Reroute-Teilsegmente
// (type != 'openclose') nutzen die einfache vertikale Kurve.
@@ -360,6 +429,14 @@ function attach(host) {
editor.on('nodeRemoved', refresh);
editor.on('import', refresh);
// Undo-Historie: jede strukturelle Änderung erzeugt einen Schnappschuss.
const record = () => recordHistory(state);
editor.on('nodeCreated', record);
editor.on('nodeRemoved', record);
editor.on('nodeMoved', record);
editor.on('connectionCreated', record);
editor.on('connectionRemoved', record);
// Klick in die Nähe einer Verbindung (auf leerem Canvas-Hintergrund) wählt
// diese aus – robuster als das exakte Treffen der dünnen Linie. Läuft in der
// Capture-Phase vor Drawflow, um das Verschieben/Deselektieren zu verhindern.
@@ -412,13 +489,20 @@ function attach(host) {
const newTop = rightDrag.nodeEl.offsetTop + (e.clientY - rightDrag.lastY) / zoom;
rightDrag.lastX = e.clientX;
rightDrag.lastY = e.clientY;
rightDrag.moved = true;
rightDrag.nodeEl.style.left = newLeft + 'px';
rightDrag.nodeEl.style.top = newTop + 'px';
const data = editor.drawflow.drawflow[editor.module].data[rightDrag.id];
if (data) { data.pos_x = newLeft; data.pos_y = newTop; }
editor.updateConnectionNodes('node-' + rightDrag.id);
};
const onRightUp = () => { rightDrag = null; rightPan = null; };
const onRightUp = () => {
// Ein per Rechts-Drag verschobener Knoten löst Drawflows nodeMoved
// nicht aus -> Undo-Schnappschuss hier ablegen.
if (rightDrag && rightDrag.moved) recordHistory(state);
rightDrag = null;
rightPan = null;
};
document.addEventListener('mousemove', onRightMove);
document.addEventListener('mouseup', onRightUp);
@@ -465,8 +549,25 @@ function attach(host) {
editor.removeConnection();
};
document.addEventListener('keydown', deleteSelectedConnection);
// Strg+Z / Cmd+Z: letzte Canvas-Änderung zurücknehmen. Eingaben in
// Textfeldern und geöffneten Dialogen bleiben unangetastet.
const undoKeyHandler = e => {
if (!(e.ctrlKey || e.metaKey) || e.shiftKey || (e.key !== 'z' && e.key !== 'Z')) return;
const active = document.activeElement;
if (active && (active.tagName === 'INPUT' || active.tagName === 'TEXTAREA'
|| active.isContentEditable
|| (active.closest && active.closest('vaadin-dialog-overlay')))) {
return;
}
e.preventDefault();
undoLast(state);
};
document.addEventListener('keydown', undoKeyHandler);
state.cleanup = () => {
document.removeEventListener('keydown', deleteSelectedConnection);
document.removeEventListener('keydown', undoKeyHandler);
document.removeEventListener('mousemove', onRightMove);
document.removeEventListener('mouseup', onRightUp);
container.removeEventListener('wheel', onWheelZoom, { capture: true });
@@ -592,6 +693,7 @@ window.taskListEditor = {
editor.removeNodeOutput(nodeId, `output_${current}`);
current--;
}
recordHistory(state);
requestAnimationFrame(() => refreshValidity(state));
},
updateNodeLabel(host, nodeId, label) {
@@ -601,12 +703,23 @@ window.taskListEditor = {
if (!node) return;
const html = buildNodeHtml(label, state.registry.get(node.data.typeId)?.color || '#444');
state.editor.updateNodeDataFromId(nodeId, { ...node.data, label });
// Auch das im Graphen hinterlegte HTML aktualisieren, damit Export,
// Laden und Undo den neuen Titel anzeigen.
const nodeData = state.editor.drawflow.drawflow[state.editor.module].data[nodeId];
if (nodeData) nodeData.html = html;
const el = state.container.querySelector(`#node-${nodeId} .drawflow_content_node`);
if (el) el.innerHTML = html;
recordHistory(state);
},
undo(host) {
const state = editors.get(host);
return state ? undoLast(state) : false;
},
clear(host) {
const state = editors.get(host);
if (state) state.editor.clear();
if (!state) return;
state.editor.clear();
recordHistory(state);
},
exportGraph(host) {
const state = editors.get(host);
@@ -646,6 +759,8 @@ window.taskListEditor = {
state.editor.addConnection(ids[i], ids[i + 1], 'output_1', 'input_1');
}
// Frisch geladener Stand ist der neue Basiszustand der Undo-Historie.
resetHistory(state);
return JSON.stringify(ids);
},
importGraph(host, graphJson) {
@@ -653,6 +768,8 @@ window.taskListEditor = {
if (!graphJson) return;
try {
state.editor.import(JSON.parse(graphJson));
// Frisch geladener Stand ist der neue Basiszustand der Undo-Historie.
resetHistory(state);
} catch (e) {
console.error('importGraph failed', e);
}

35
src/main/java/de/assecutor/tasklisteditor/component/NodeEditor.java
View File

@@ -62,6 +62,16 @@ public class NodeEditor extends Div {
getElement().executeJs("window.taskListEditor.clear(this)");
}
/**
* Nimmt die letzte Canvas-Änderung zurück (maximal 10 Schritte). Der
* Callback erhält {@code true}, wenn ein Schritt zurückgenommen wurde,
* sonst {@code false}.
*/
public void undo(SerializableConsumer<Boolean> callback) {
getElement().executeJs("return window.taskListEditor.undo(this)")
.then(Boolean.class, callback::accept);
}
/**
* Liest den aktuellen Drawflow-Graphen (Knoten + Verbindungen) als
* JSON-String aus dem Client und übergibt ihn an den Callback.
@@ -115,6 +125,10 @@ public class NodeEditor extends Div {
return addListener(NodeRemovedEvent.class, listener);
}
public Registration addCanvasRestoredListener(ComponentEventListener<CanvasRestoredEvent> listener) {
return addListener(CanvasRestoredEvent.class, listener);
}
@ClientCallable
private void onNodeAdded(int nodeId, String typeId) {
fireEvent(new NodeAddedEvent(this, nodeId, typeId));
@@ -140,6 +154,11 @@ public class NodeEditor extends Div {
fireEvent(new NodeRemovedEvent(this, nodeId));
}
@ClientCallable
private void onCanvasRestored(String nodesJson) {
fireEvent(new CanvasRestoredEvent(this, nodesJson));
}
public static class NodeAddedEvent extends ComponentEvent<NodeEditor> {
private final int nodeId;
private final String typeId;
@@ -192,4 +211,20 @@ public class NodeEditor extends Div {
public int nodeId() { return nodeId; }
}
/**
* Wird nach einem Undo gefeuert und enthält die danach auf dem Canvas
* vorhandenen Knoten als JSON-Array aus Objekten mit {@code id} und
* {@code typeId}, damit der Server seinen Zustand abgleichen kann.
*/
public static class CanvasRestoredEvent extends ComponentEvent<NodeEditor> {
private final String nodesJson;
public CanvasRestoredEvent(NodeEditor source, String nodesJson) {
super(source, true);
this.nodesJson = nodesJson;
}
public String nodesJson() { return nodesJson; }
}
}

5
src/main/java/de/assecutor/tasklisteditor/model/BlockTypeRegistry.java
View File

@@ -188,7 +188,7 @@ public class BlockTypeRegistry {
11,
1, 1,
List.of(
PropertyDefinition.textArea("choices", "Statusoptionen (eine pro Zeile)"),
PropertyDefinition.choiceList("choices", "Statusoptionen"),
PropertyDefinition.bool("opt", "Optionale Aufgabe", false),
PropertyDefinition.bool("reenter", "Erneut bearbeitbar", false)
)
@@ -208,7 +208,6 @@ public class BlockTypeRegistry {
1, 1,
List.of(
PropertyDefinition.fieldList("fields", "Textfelder (Titel + Platzhalter)"),
PropertyDefinition.bool("opt", "Optionale Aufgabe", false),
PropertyDefinition.bool("reenter", "Erneut bearbeitbar", false)
)
));
@@ -223,7 +222,6 @@ public class BlockTypeRegistry {
1, 1,
List.of(
PropertyDefinition.fieldList("fields", "Zahlenfelder (Titel + Platzhalter)"),
PropertyDefinition.bool("opt", "Optionale Aufgabe", false),
PropertyDefinition.bool("reenter", "Erneut bearbeitbar", false)
)
));
@@ -238,7 +236,6 @@ public class BlockTypeRegistry {
1, 1,
List.of(
PropertyDefinition.nameList("entries", "Name der Checkboxen"),
PropertyDefinition.bool("opt", "Optionale Aufgabe", false),
PropertyDefinition.bool("reenter", "Erneut bearbeitbar", false)
)
));

15
src/main/java/de/assecutor/tasklisteditor/model/FieldDto.java
View File

@@ -5,17 +5,18 @@ import com.fasterxml.jackson.annotation.JsonPropertyOrder;
/**
* Ein einzelnes Eingabefeld eines Listen-Text-Tasks (Typ 12).
* Definiert Titel und Platzhalter eines vom Bearbeiter auszufüllenden
* Textfeldes.
* Definiert Titel, Platzhalter und Pflichtfeld-Kennzeichen eines vom
* Bearbeiter auszufüllenden Textfeldes.
*
* <p>{@code null}-Felder werden ausgelassen.
*/
@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({"title", "placeholder"})
@JsonPropertyOrder({"title", "placeholder", "required"})
public class FieldDto {
private String title;
private String placeholder;
private Boolean required;
public FieldDto() {
}
@@ -25,6 +26,14 @@ public class FieldDto {
this.placeholder = placeholder;
}
public Boolean getRequired() {
return required;
}
public void setRequired(Boolean required) {
this.required = required;
}
public String getTitle() {
return title;
}

4
src/main/java/de/assecutor/tasklisteditor/model/PropertyDefinition.java
View File

@@ -26,4 +26,8 @@ public record PropertyDefinition(String id, String label, PropertyType type, Obj
public static PropertyDefinition nameList(String id, String label) {
return new PropertyDefinition(id, label, PropertyType.NAME_LIST, List.of());
}
public static PropertyDefinition choiceList(String id, String label) {
return new PropertyDefinition(id, label, PropertyType.CHOICE_LIST, List.of());
}
}

7
src/main/java/de/assecutor/tasklisteditor/model/PropertyType.java
View File

@@ -8,5 +8,10 @@ public enum PropertyType {
/** Wiederholbare Liste aus Eingabefeldern mit Titel und Platzhalter. */
FIELD_LIST,
/** Wiederholbare Liste aus reinen Namens-Einträgen (ein Textfeld je Zeile). */
NAME_LIST
NAME_LIST,
/**
* Wiederholbare Liste aus Auswahloptionen (ein Textfeld je Zeile,
* ohne Pflichtfeld-Kennzeichen).
*/
CHOICE_LIST
}

13
src/main/java/de/assecutor/tasklisteditor/model/TaskEntryDto.java
View File

@@ -1,5 +1,6 @@
package de.assecutor.tasklisteditor.model;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
@@ -14,6 +15,10 @@ public class TaskEntryDto {
@JsonProperty("query_remark")
private boolean queryRemark;
/** Pflichtfeld-Kennzeichen (nur bei Listen-Tasks gesetzt, sonst ausgelassen). */
@JsonInclude(JsonInclude.Include.NON_NULL)
private Boolean required;
public TaskEntryDto() {
}
@@ -46,4 +51,12 @@ public class TaskEntryDto {
public void setQueryRemark(boolean queryRemark) {
this.queryRemark = queryRemark;
}
public Boolean getRequired() {
return required;
}
public void setRequired(Boolean required) {
this.required = required;
}
}

28
src/main/java/de/assecutor/tasklisteditor/service/TaskListExporter.java
View File

@@ -230,7 +230,10 @@ public class TaskListExporter {
}
if (v.containsKey("choices")) {
task.setChoices(parseChoices(asText(v.get("choices"))));
Object raw = v.get("choices");
task.setChoices(raw instanceof List<?> list
? parseChoices(list)
: parseChoices(asText(raw)));
}
if (v.containsKey("fields")) {
@@ -273,13 +276,30 @@ public class TaskListExporter {
if (o instanceof Map<?, ?> m) {
String text = m.get("title") == null ? "" : m.get("title").toString().trim();
if (!text.isEmpty()) {
entries.add(new TaskEntryDto(code++, text, queryRemark));
TaskEntryDto entry = new TaskEntryDto(code++, text, queryRemark);
entry.setRequired(asBool(m.get("required")));
entries.add(entry);
}
}
}
return entries.isEmpty() ? null : entries;
}
/** Variante für den Zeilen-Editor: Liste aus {@code {title}}-Einträgen. */
private List<ChoiceDto> parseChoices(List<?> raw) {
List<ChoiceDto> choices = new ArrayList<>();
int ret = 1;
for (Object o : raw) {
if (o instanceof Map<?, ?> m) {
String text = m.get("title") == null ? "" : m.get("title").toString().trim();
if (!text.isEmpty()) {
choices.add(new ChoiceDto(text, ret++));
}
}
}
return choices.isEmpty() ? null : choices;
}
private List<ChoiceDto> parseChoices(String raw) {
if (raw == null || raw.isBlank()) {
return null;
@@ -305,7 +325,9 @@ public class TaskListExporter {
String title = m.get("title") == null ? "" : m.get("title").toString().trim();
String placeholder = m.get("placeholder") == null ? "" : m.get("placeholder").toString().trim();
if (!title.isEmpty() || !placeholder.isEmpty()) {
fields.add(new FieldDto(title, placeholder));
FieldDto field = new FieldDto(title, placeholder);
field.setRequired(asBool(m.get("required")));
fields.add(field);
}
}
}

20
src/main/java/de/assecutor/tasklisteditor/service/TaskListImporter.java
View File

@@ -2,6 +2,7 @@ package de.assecutor.tasklisteditor.service;
import de.assecutor.tasklisteditor.model.BlockType;
import de.assecutor.tasklisteditor.model.BlockTypeRegistry;
import de.assecutor.tasklisteditor.model.ChoiceDto;
import de.assecutor.tasklisteditor.model.FieldDto;
import de.assecutor.tasklisteditor.model.PropertyDefinition;
import de.assecutor.tasklisteditor.model.TaskDto;
@@ -69,6 +70,7 @@ public class TaskListImporter {
Object value = switch (def.type()) {
case FIELD_LIST -> fieldRows(task);
case NAME_LIST -> entryRows(task);
case CHOICE_LIST -> choiceRows(task);
default -> scalarValue(def, task);
};
values.put(def.id(), value);
@@ -103,6 +105,7 @@ public class TaskListImporter {
Map<String, Object> row = new LinkedHashMap<>();
row.put("title", field.getTitle() == null ? "" : field.getTitle());
row.put("placeholder", field.getPlaceholder() == null ? "" : field.getPlaceholder());
row.put("required", Boolean.TRUE.equals(field.getRequired()));
rows.add(row);
}
return rows;
@@ -117,11 +120,28 @@ public class TaskListImporter {
for (TaskEntryDto entry : task.getEntries()) {
Map<String, Object> row = new LinkedHashMap<>();
row.put("title", entry.getText() == null ? "" : entry.getText());
row.put("required", Boolean.TRUE.equals(entry.getRequired()));
rows.add(row);
}
return rows;
}
/** {@code choices}-Array (Typ 11) zurück in Zeilen mit Namen ({@code title}). */
private List<Map<String, Object>> choiceRows(TaskDto task) {
List<Map<String, Object>> rows = new ArrayList<>();
if (task.getChoices() != null && !task.getChoices().isEmpty()) {
for (ChoiceDto choice : task.getChoices()) {
Map<String, Object> row = new LinkedHashMap<>();
row.put("title", choice.getTxt() == null ? "" : choice.getTxt());
rows.add(row);
}
return rows;
}
// Altdaten des früheren Typ 11 (Abhol-/Lieferstatus) liefern die
// Optionen als entries; diese als Zeilen übernehmen.
return entryRows(task);
}
private Object orDefault(Object value, Object fallback) {
return value != null ? value : fallback;
}

124
src/main/java/de/assecutor/tasklisteditor/view/MainView.java
View File

@@ -78,6 +78,18 @@ public class MainView extends VerticalLayout implements BeforeEnterObserver {
private final ObjectMapper objectMapper;
private final NodeEditor nodeEditor;
private final Map<Integer, BlockInstance> instances = new HashMap<>();
/**
* Zuletzt vom Canvas entfernte Blöcke. Stellt ein Undo einen Knoten wieder
* her, werden seine Einstellungen von hier zurückgeholt (begrenzt, damit
* die Session nicht unbegrenzt wächst).
*/
private final Map<Integer, BlockInstance> removedInstances = new LinkedHashMap<>() {
@Override
protected boolean removeEldestEntry(Map.Entry<Integer, BlockInstance> eldest) {
return size() > 100;
}
};
private Div palettePanel;
private String currentListName;
private final String appVersion;
@@ -135,7 +147,52 @@ public class MainView extends VerticalLayout implements BeforeEnterObserver {
openSettingsDialog(instance);
}
});
nodeEditor.addNodeRemovedListener(e -> instances.remove(e.nodeId()));
nodeEditor.addNodeRemovedListener(e -> {
BlockInstance removed = instances.remove(e.nodeId());
if (removed != null) {
removedInstances.put(e.nodeId(), removed);
}
});
nodeEditor.addCanvasRestoredListener(e -> reconcileAfterUndo(e.nodesJson()));
}
/**
* Gleicht die serverseitigen BlockInstances nach einem Undo mit den auf dem
* Canvas vorhandenen Knoten ab: Verschwundene Knoten wandern in den
* Papierkorb, wieder aufgetauchte werden von dort (inkl. ihrer
* Einstellungen) wiederhergestellt.
*/
private void reconcileAfterUndo(String nodesJson) {
Map<Integer, String> present = new LinkedHashMap<>();
try {
JsonNode nodes = objectMapper.readTree(nodesJson);
for (JsonNode node : nodes) {
present.put(node.path("id").asInt(), node.path("typeId").asText());
}
} catch (Exception ex) {
return;
}
instances.entrySet().removeIf(entry -> {
if (present.containsKey(entry.getKey())) {
return false;
}
removedInstances.put(entry.getKey(), entry.getValue());
return true;
});
present.forEach((id, typeId) -> {
if (instances.containsKey(id)) {
return;
}
BlockInstance restored = removedInstances.remove(id);
if (restored == null) {
BlockType type = registry.find(typeId).orElse(null);
if (type == null) {
return;
}
restored = new BlockInstance(id, type);
}
instances.put(id, restored);
});
}
private Component buildHeader() {
@@ -159,10 +216,21 @@ public class MainView extends VerticalLayout implements BeforeEnterObserver {
title.add(version);
}
Button undo = new Button("Rückgängig", new Icon(VaadinIcon.ARROW_BACKWARD));
undo.addThemeVariants(ButtonVariant.LUMO_TERTIARY);
undo.setTooltipText("Letzte Canvas-Änderung zurücknehmen (Strg+Z, max. 10 Schritte)");
undo.addClickListener(e -> nodeEditor.undo(undone -> {
if (!Boolean.TRUE.equals(undone)) {
Notification.show("Nichts zum Rückgängigmachen.");
}
}));
Button clear = new Button("Workflow löschen", new Icon(VaadinIcon.TRASH));
clear.addThemeVariants(ButtonVariant.LUMO_TERTIARY);
clear.addClickListener(e -> {
nodeEditor.clear();
// In den Papierkorb statt verwerfen: Undo kann das Leeren zurücknehmen.
removedInstances.putAll(instances);
instances.clear();
Notification.show("Canvas geleert");
});
@@ -186,7 +254,7 @@ public class MainView extends VerticalLayout implements BeforeEnterObserver {
Span spacer = new Span();
spacer.getStyle().set("flex", "1");
header.add(title, spacer, clear, saveCanvas, loadCanvas, appJson, export);
header.add(title, spacer, undo, clear, saveCanvas, loadCanvas, appJson, export);
return header;
}
@@ -461,7 +529,7 @@ public class MainView extends VerticalLayout implements BeforeEnterObserver {
private void openBlockDialog(BlockInstance instance) {
Dialog dialog = new Dialog();
dialog.setHeaderTitle(instance.type().label());
dialog.setWidth("440px");
dialog.setWidth("585px");
Paragraph desc = new Paragraph(instance.type().description());
desc.addClassName("properties-desc");
@@ -732,23 +800,48 @@ public class MainView extends VerticalLayout implements BeforeEnterObserver {
return box;
}
case FIELD_LIST -> {
return buildRowList(instance, def, current, true);
return buildRowList(instance, def, current, true, true);
}
case NAME_LIST -> {
return buildRowList(instance, def, current, false);
return buildRowList(instance, def, current, false, true);
}
case CHOICE_LIST -> {
return buildRowList(instance, def, legacyLinesToRows(current), false, false);
}
}
return new Span();
}
/**
* Wandelt den früheren Textarea-Wert der Statusauswahl (eine Option pro
* Zeile) in die vom Zeilen-Editor erwartete Struktur um. Listen werden
* unverändert durchgereicht.
*/
private Object legacyLinesToRows(Object current) {
if (!(current instanceof String s)) {
return current;
}
List<Map<String, Object>> rows = new ArrayList<>();
for (String line : s.split("\\r?\\n")) {
String text = line.trim();
if (!text.isEmpty()) {
Map<String, Object> row = new LinkedHashMap<>();
row.put("title", text);
rows.add(row);
}
}
return rows;
}
/**
* Editor für eine wiederholbare Liste von Eingabefeldern. Jede Zeile besteht
* aus einem Titel und – falls {@code withPlaceholder} – zusätzlich einem
* Platzhalter. Der Wert wird als {@code List<Map<String,Object>>} unter der
* Platzhalter sowie – falls {@code withRequired} – einer Pflichtfeld-
* Checkbox. Der Wert wird als {@code List<Map<String,Object>>} unter der
* Property-ID abgelegt (rundläuft über Mongo und Export).
*/
private Component buildRowList(BlockInstance instance, PropertyDefinition def, Object current,
boolean withPlaceholder) {
boolean withPlaceholder, boolean withRequired) {
List<Map<String, Object>> rows = new ArrayList<>();
if (current instanceof List<?> list) {
for (Object o : list) {
@@ -758,6 +851,11 @@ public class MainView extends VerticalLayout implements BeforeEnterObserver {
if (withPlaceholder) {
row.put("placeholder", m.get("placeholder") == null ? "" : m.get("placeholder").toString());
}
if (withRequired) {
row.put("required", m.get("required") instanceof Boolean b
? b
: Boolean.parseBoolean(String.valueOf(m.get("required"))));
}
rows.add(row);
}
}
@@ -811,6 +909,15 @@ public class MainView extends VerticalLayout implements BeforeEnterObserver {
line.add(placeholder);
line.setFlexGrow(1, placeholder);
}
if (withRequired) {
Checkbox required = new Checkbox("Pflicht");
required.setValue(Boolean.TRUE.equals(row.get("required")));
required.addValueChangeListener(e -> {
row.put("required", e.getValue());
commit.run();
});
line.add(required);
}
line.add(remove);
line.setAlignItems(FlexComponent.Alignment.BASELINE);
rowsBox.add(line);
@@ -825,6 +932,9 @@ public class MainView extends VerticalLayout implements BeforeEnterObserver {
if (withPlaceholder) {
row.put("placeholder", "");
}
if (withRequired) {
row.put("required", false);
}
rows.add(row);
commit.run();
render[0].run();