diff --git a/pluto-utils/pom.xml b/pluto-utils/pom.xml
index 0c5d7a2588c59d795f8797c973b3034e20514c90..613685990f4bb953c202e1033da7e2fc3d8c2dc8 100644
--- a/pluto-utils/pom.xml
+++ b/pluto-utils/pom.xml
@@ -40,7 +40,7 @@
<version>1.9.0-SNAPSHOT</version>
<properties>
- <pluto.version>1.8.0-SNAPSHOT</pluto.version>
+ <pluto.version>1.9.0-SNAPSHOT</pluto.version>
<maven-compiler-plugin.version>3.10.1</maven-compiler-plugin.version>
<maven-jar-plugin.version>3.2.2</maven-jar-plugin.version>
@@ -100,6 +100,12 @@
<artifactId>assertj-core</artifactId>
<scope>test</scope>
</dependency>
+
+ <!-- commons -->
+ <dependency>
+ <groupId>commons-beanutils</groupId>
+ <artifactId>commons-beanutils</artifactId>
+ </dependency>
</dependencies>
<build>
diff --git a/pluto-utils/src/main/java/de/itvsh/kop/pluto/common/grpc/GrpcFormDataMapper.java b/pluto-utils/src/main/java/de/itvsh/kop/pluto/common/grpc/GrpcFormDataMapper.java
index a91550795befdc3662de8fee871a0fd133575544..b4ae99a05170947abf68a4767437a366dfde9cd6 100644
--- a/pluto-utils/src/main/java/de/itvsh/kop/pluto/common/grpc/GrpcFormDataMapper.java
+++ b/pluto-utils/src/main/java/de/itvsh/kop/pluto/common/grpc/GrpcFormDataMapper.java
@@ -30,7 +30,9 @@ import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
+import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.mapstruct.CollectionMappingStrategy;
@@ -53,6 +55,9 @@ public interface GrpcFormDataMapper {
String VALUE_KEY = "value";
String LABEL_KEY = "label";
+ String CONTROL_DATA_KEY = "_kopControlData";
+ String LABELS_KEY = "labels";
+
default GrpcFormData mapToFormData(Map<String, Object> formData) {
return GrpcFormData.newBuilder()
.addAllField(mapToAllFields(formData))
@@ -63,10 +68,18 @@ public interface GrpcFormDataMapper {
default List<GrpcFormField> mapToAllFields(Map<String, Object> formData) {
return formData.entrySet().stream().filter(entry -> entry.getValue() instanceof String)//
- .map(entry -> mapToField(entry.getKey(), entry.getValue().toString()))//
+ .map(entry -> mapToField(entry.getKey(), entry.getValue().toString(), getFieldLabel(formData, entry.getKey())))//
.toList();
}
+ default Optional<String> getFieldLabel(Map<String, Object> formData, String key) {
+ return getControlData(formData)
+ .map(controlData -> controlData.get(LABELS_KEY))
+ .map(Map.class::cast)
+ .map(labelsmap -> labelsmap.get(key))
+ .map(String.class::cast);
+ }
+
default List<GrpcFormField> mapStringListsToFields(Map<String, Object> formData) {
return formData.entrySet().stream()
.filter(entry -> entry.getValue() instanceof List)
@@ -80,7 +93,7 @@ public interface GrpcFormDataMapper {
return ((List<Object>) entry.getValue()).stream()
.filter(String.class::isInstance)
.map(String.class::cast)
- .map(e -> mapToField(entry.getKey(), e))
+ .map(e -> mapToField(entry.getKey(), e, Optional.empty()))
.toList();
}
@@ -109,16 +122,32 @@ public interface GrpcFormDataMapper {
.toList();
}
+ default Optional<String> getSubFormLabel(Map<String, Object> map) {
+ return getControlData(map).map(controlData -> controlData.get(LABEL_KEY)).map(Object::toString);
+ }
+
default GrpcSubForm buildSubForm(String name, Map<String, Object> map) {
- return GrpcSubForm.newBuilder().setTitle(name)
+ var subFormBuilder = GrpcSubForm.newBuilder();
+ getLabel(map).ifPresent(subFormBuilder::setLabel);
+ return subFormBuilder.setTitle(name)
.addAllField(mapToAllFields(map))
.addAllSubForm(mapToSubForms(map))
.addAllField(mapStringListsToFields(map))
.addAllSubForm(mapObjectListsToFields(map)).build();
}
- default GrpcFormField mapToField(String name, String value) {
- return GrpcFormField.newBuilder().setName(name).setValue(value).build();
+ default Optional<String> getLabel(Map<String, Object> map) {
+ return getControlData(map).map(controlData -> controlData.get(LABEL_KEY)).map(Object::toString);
+ }
+
+ default Optional<Map<String, Object>> getControlData(Map<String, Object> formData) {
+ return Optional.ofNullable(MapUtils.getMap(formData, CONTROL_DATA_KEY)).map(Map.class::cast);
+ }
+
+ default GrpcFormField mapToField(String name, String value, Optional<String> label) {
+ var formFieldBuilder = GrpcFormField.newBuilder().setName(name).setValue(value);
+ label.ifPresent(formFieldBuilder::setLabel);
+ return formFieldBuilder.build();
}
default Map<String, Object> mapFromFormData(GrpcFormData formData) {
diff --git a/pluto-utils/src/test/java/de/itvsh/kop/pluto/common/grpc/GrpcFormDataMapperTest.java b/pluto-utils/src/test/java/de/itvsh/kop/pluto/common/grpc/GrpcFormDataMapperTest.java
index 20a049e20f7a0d64c4cb293b48a465a0873bfb90..cac2415723102b3ac15e16cab51e922a9d883c0a 100644
--- a/pluto-utils/src/test/java/de/itvsh/kop/pluto/common/grpc/GrpcFormDataMapperTest.java
+++ b/pluto-utils/src/test/java/de/itvsh/kop/pluto/common/grpc/GrpcFormDataMapperTest.java
@@ -30,6 +30,7 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import org.apache.commons.collections.MapUtils;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
@@ -103,108 +104,200 @@ class GrpcFormDataMapperTest {
}
}
- @DisplayName("Mapped SubFormField")
+ @DisplayName("buildSubForm")
@Nested
- class TestSubFormFieldMapping {
+ class TestBuildSubFormWithLabel {
- private final GrpcSubForm subForm = GrpcSubFormTestFactory.create();
+ @DisplayName("with label")
+ @Nested
+ class TestWithLabel {
- @Test
- void shouldContainField() {
- var mapped = mapper.mapSubFormFields(subForm.getFieldList());
+ public static final String NODE_ATTRIBUTES = "nodeAttributes";
+ public static final String NODE_ATTRIBUTES_LABEL = "nodeAttributesLabel";
- assertThat(mapped).containsKey(GrpcSubFormTestFactory.FIELD_NAME);
- }
+ public static final String SUB_KEY = "subKey";
+ public static final String SUB_VALUE = "subValue";
- @Test
- void shouldContainValue() {
- var mapped = mapper.mapSubFormFields(subForm.getFieldList());
+ private final Map<String, Object> map = Map.of(
+ SUB_KEY, SUB_VALUE,
+ GrpcFormDataMapper.CONTROL_DATA_KEY, Map.of(
+ GrpcFormDataMapper.LABEL_KEY, NODE_ATTRIBUTES_LABEL));
- assertThat(mapped).containsEntry(GrpcSubFormTestFactory.FIELD_NAME, GrpcSubFormTestFactory.FIELD_VALUE);
+ @Test
+ void shouldContainField() {
+ var mapped = mapper.buildSubForm(NODE_ATTRIBUTES, map);
+
+ assertThat(mapped.getLabel()).isEqualTo(NODE_ATTRIBUTES_LABEL);
+ }
}
+ }
+ @DisplayName("Map to all fields")
+ @Nested
+ class TestMapToField {
+
+ @DisplayName("with label")
@Nested
- class TestCombiner {
- @Test
- void missingInMap2ShouldContainValue() {
- Map<String, Object> map1 = Map.of("TEST", "VALUE1");
- Map<String, Object> map2 = Map.of();
+ class TestWithLabel {
- var combined = mapper.combiner(map1, map2);
+ public static final String KEY = "subKey";
+ public static final String VALUE = "subValue";
+ public static final String LABEL = "NewSubKeyLabel";
- assertThat(combined).containsEntry("TEST", "VALUE1");
- }
+ private final Map<String, Object> map = Map.of(KEY, VALUE,
+ GrpcFormDataMapper.CONTROL_DATA_KEY, Map.of(
+ GrpcFormDataMapper.LABELS_KEY, Map.of(KEY, LABEL)));
@Test
- void missingInMap1ShouldContainValue() {
- Map<String, Object> map1 = new HashMap<>();
- Map<String, Object> map2 = Map.of("TEST", "VALUE1");
-
- var combined = mapper.combiner(map1, map2);
+ void shouldHaveSetLabel() {
+ var mapped = mapper.mapToAllFields(map);
- assertThat(combined).containsEntry("TEST", "VALUE1");
+ assertThat(mapped.get(0).getLabel()).isEqualTo(LABEL);
}
+ }
+ }
- @Test
- void inBothMapShouldCombineToList() {
- Map<String, Object> map1 = new HashMap<>(Map.of("TEST", "VALUE1"));
- Map<String, Object> map2 = Map.of("TEST", "VALUE2");
+ @DisplayName("Mapped SubForm")
+ @Nested
+ class TestSubFormFieldMapping {
- var combined = mapper.combiner(map1, map2);
+ @DisplayName("field")
+ @Nested
+ class TestField {
- assertThat(combined).containsEntry("TEST", List.of("VALUE1", "VALUE2"));
- }
+ private final GrpcSubForm subForm = GrpcSubFormTestFactory.create();
@Test
- void listInMap2ShouldStayAList() {
- Map<String, Object> map1 = Map.of("TEST", List.of("VALUE1", "VALUE2"));
- Map<String, Object> map2 = Map.of();
+ void shouldContainField() {
+ var mapped = mapper.mapSubFormFields(subForm.getFieldList());
- var combined = mapper.combiner(map1, map2);
-
- assertThat(combined).containsEntry("TEST", List.of("VALUE1", "VALUE2"));
+ assertThat(mapped).containsKey(GrpcSubFormTestFactory.FIELD_NAME);
}
@Test
- void valueInMap1ShouldBeAddedToList() {
- Map<String, Object> map1 = new HashMap<>(Map.of("TEST", "VALUE1"));
- Map<String, Object> map2 = Map.of("TEST", List.of("VALUE2", "VALUE3"));
-
- var combined = mapper.combiner(map1, map2);
+ void shouldContainValue() {
+ var mapped = mapper.mapSubFormFields(subForm.getFieldList());
- assertThat(combined).containsEntry("TEST", List.of("VALUE1", "VALUE2", "VALUE3"));
+ assertThat(mapped).containsEntry(GrpcSubFormTestFactory.FIELD_NAME, GrpcSubFormTestFactory.FIELD_VALUE);
}
+ }
- @Test
- void valueInMap2ShouldBeAddedToList() {
- Map<String, Object> map1 = new HashMap<>(Map.of("TEST", List.of("VALUE1", "VALUE2")));
- Map<String, Object> map2 = Map.of("TEST", "VALUE3");
+ @DisplayName("field with label")
+ @Nested
+ class TestFieldWithLabel {
+
+ private final GrpcSubForm subForm = GrpcSubFormTestFactory.createWithLabels();
- var combined = mapper.combiner(map1, map2);
+ @Test
+ void shouldContainField() {
+ var mapped = mapper.mapSubFormFields(subForm.getFieldList());
- assertThat(combined).containsEntry("TEST", List.of("VALUE1", "VALUE2", "VALUE3"));
+ assertThat(mapped).containsKey(GrpcSubFormTestFactory.FIELD_NAME);
}
@Test
- void listInMap1ShouldStayAList() {
- Map<String, Object> map1 = new HashMap<>();
- Map<String, Object> map2 = Map.of("TEST", List.of("VALUE1", "VALUE2"));
+ void shouldContainValue() {
+ var mapped = mapper.mapSubFormFields(subForm.getFieldList());
- var combined = mapper.combiner(map1, map2);
-
- assertThat(combined).containsEntry("TEST", List.of("VALUE1", "VALUE2"));
+ assertThat(getMapFromMap(mapped, GrpcSubFormTestFactory.FIELD_NAME)).containsEntry("value", GrpcSubFormTestFactory.FIELD_VALUE);
}
@Test
- void listInBothMapsShouldByCombined() {
- Map<String, Object> map1 = new HashMap<>(Map.of("TEST", List.of("VALUE1", "VALUE2")));
- Map<String, Object> map2 = Map.of("TEST", List.of("VALUE3", "VALUE4"));
-
- var combined = mapper.combiner(map1, map2);
+ void shouldHaveLabel() {
+ var mapped = mapper.mapSubFormFields(subForm.getFieldList());
- assertThat(combined).containsEntry("TEST", List.of("VALUE1", "VALUE2", "VALUE3", "VALUE4"));
+ assertThat(getMapFromMap(mapped, GrpcSubFormTestFactory.FIELD_NAME)).containsEntry("label",
+ GrpcSubFormTestFactory.FIELD_LABEL);
}
}
+
+ @SuppressWarnings("unchecked")
+ private Map<String, Object> getMapFromMap(Map<String, Object> map, String key) {
+ return MapUtils.getMap(map, key);
+ }
+ }
+
+ @Nested
+ class TestCombiner {
+ @Test
+ void missingInMap2ShouldContainValue() {
+ Map<String, Object> map1 = Map.of("TEST", "VALUE1");
+ Map<String, Object> map2 = Map.of();
+
+ var combined = mapper.combiner(map1, map2);
+
+ assertThat(combined).containsEntry("TEST", "VALUE1");
+ }
+
+ @Test
+ void missingInMap1ShouldContainValue() {
+ Map<String, Object> map1 = new HashMap<>();
+ Map<String, Object> map2 = Map.of("TEST", "VALUE1");
+
+ var combined = mapper.combiner(map1, map2);
+
+ assertThat(combined).containsEntry("TEST", "VALUE1");
+ }
+
+ @Test
+ void inBothMapShouldCombineToList() {
+ Map<String, Object> map1 = new HashMap<>(Map.of("TEST", "VALUE1"));
+ Map<String, Object> map2 = Map.of("TEST", "VALUE2");
+
+ var combined = mapper.combiner(map1, map2);
+
+ assertThat(combined).containsEntry("TEST", List.of("VALUE1", "VALUE2"));
+ }
+
+ @Test
+ void listInMap2ShouldStayAList() {
+ Map<String, Object> map1 = Map.of("TEST", List.of("VALUE1", "VALUE2"));
+ Map<String, Object> map2 = Map.of();
+
+ var combined = mapper.combiner(map1, map2);
+
+ assertThat(combined).containsEntry("TEST", List.of("VALUE1", "VALUE2"));
+ }
+
+ @Test
+ void valueInMap1ShouldBeAddedToList() {
+ Map<String, Object> map1 = new HashMap<>(Map.of("TEST", "VALUE1"));
+ Map<String, Object> map2 = Map.of("TEST", List.of("VALUE2", "VALUE3"));
+
+ var combined = mapper.combiner(map1, map2);
+
+ assertThat(combined).containsEntry("TEST", List.of("VALUE1", "VALUE2", "VALUE3"));
+ }
+
+ @Test
+ void valueInMap2ShouldBeAddedToList() {
+ Map<String, Object> map1 = new HashMap<>(Map.of("TEST", List.of("VALUE1", "VALUE2")));
+ Map<String, Object> map2 = Map.of("TEST", "VALUE3");
+
+ var combined = mapper.combiner(map1, map2);
+
+ assertThat(combined).containsEntry("TEST", List.of("VALUE1", "VALUE2", "VALUE3"));
+ }
+
+ @Test
+ void listInMap1ShouldStayAList() {
+ Map<String, Object> map1 = new HashMap<>();
+ Map<String, Object> map2 = Map.of("TEST", List.of("VALUE1", "VALUE2"));
+
+ var combined = mapper.combiner(map1, map2);
+
+ assertThat(combined).containsEntry("TEST", List.of("VALUE1", "VALUE2"));
+ }
+
+ @Test
+ void listInBothMapsShouldByCombined() {
+ Map<String, Object> map1 = new HashMap<>(Map.of("TEST", List.of("VALUE1", "VALUE2")));
+ Map<String, Object> map2 = Map.of("TEST", List.of("VALUE3", "VALUE4"));
+
+ var combined = mapper.combiner(map1, map2);
+
+ assertThat(combined).containsEntry("TEST", List.of("VALUE1", "VALUE2", "VALUE3", "VALUE4"));
+ }
}
@Nested
@@ -320,178 +413,37 @@ class GrpcFormDataMapperTest {
}
}
- @DisplayName("Map with existing labels")
+ @DisplayName("Map formData")
@Nested
- class TestMapWithExistingLabels {
-
- private static final String FIELD_LABEL = "Alternative field label";
+ class TestMapFormData {
- private final GrpcFormData formData = GrpcFormDataTestFactory.createBuilder()
- .clearField().addField(GrpcFormFieldTestFactory.createBuilder().setLabel(FIELD_LABEL))
- .addForm(GrpcSubFormTestFactory.createWithLabelsBuilder())
- .build();
-
- @DisplayName("field")
+ @DisplayName("with subForm")
@Nested
- class TestField {
-
- @Test
- void shouldHaveSize() {
- var mappedFormData = mapFromFormData();
-
- var fieldMap = getValueAsMap(mappedFormData, GrpcFormFieldTestFactory.NAME);
- assertThat(fieldMap).hasSize(2);
- }
-
- @Test
- void shouldContainsValue() {
- var mappedFormData = mapFromFormData();
-
- var fieldMap = getValueAsMap(mappedFormData, GrpcFormFieldTestFactory.NAME);
- assertThat(fieldMap).containsEntry(GrpcFormDataMapper.VALUE_KEY, GrpcFormFieldTestFactory.VALUE);
- }
-
- @Test
- void shouldContainsLabel() {
- var mappedFormData = mapFromFormData();
-
- var fieldMap = getValueAsMap(mappedFormData, GrpcFormFieldTestFactory.NAME);
- assertThat(fieldMap).containsEntry(GrpcFormDataMapper.LABEL_KEY, FIELD_LABEL);
- }
- }
-
- @DisplayName("form")
- @Nested
- class TestForm {
-
- @Test
- void shouldMapAsValueLabelMap() {
- var mappedFormData = mapFromFormData();
-
- var subFormMap = getValueAsMap(mappedFormData, GrpcSubFormTestFactory.TITLE);
- assertThat(subFormMap).hasSize(2)
- .containsKey(GrpcFormDataMapper.VALUE_KEY)
- .containsEntry(GrpcFormDataMapper.LABEL_KEY, GrpcSubFormTestFactory.LABEL);
- }
-
- @Test
- void shouldContainsMapOfFieldsAndSubForms() {
- var mappedFormData = mapFromFormData();
-
- assertThat(getFormValueMap(mappedFormData)).hasSize(2).containsKeys(GrpcSubFormTestFactory.FIELD_NAME,
- GrpcSubFormTestFactory.SUBFORM_TITLE);
- }
-
- private Map<String, Object> getFormValueMap(Map<String, Object> formData) {
- var formMap = getValueAsMap(formData, GrpcSubFormTestFactory.TITLE);
- return getValueAsMap(formMap, GrpcFormDataMapper.VALUE_KEY);
- }
+ class TestSubForm {
- @DisplayName("field")
+ @DisplayName("contains label")
@Nested
- class TestField {
+ class TestContainsLabel {
@Test
- void shouldHaveSize() {
- var mappedFormData = mapFromFormData();
+ void shouldHaveSetValue() {
+ var mappedData = mapper.mapFormData(GrpcSubFormTestFactory.createWithLabels().getSubFormList());
- assertThat(getFormValueFieldMap(mappedFormData)).hasSize(2);
+ assertThat(getSubForm(mappedData)).containsKeys(GrpcFormDataMapper.VALUE_KEY, GrpcFormDataMapper.VALUE_KEY);
}
@Test
- void shouldContainsValue() {
- var mappedFormData = mapFromFormData();
+ void shouldHaveSetLabel() {
+ var mappedData = mapper.mapFormData(GrpcSubFormTestFactory.createWithLabels().getSubFormList());
- assertThat(getFormValueFieldMap(mappedFormData)).containsEntry(GrpcFormDataMapper.VALUE_KEY,
- GrpcSubFormTestFactory.FIELD_VALUE);
+ assertThat(getSubForm(mappedData)).containsEntry(GrpcFormDataMapper.LABEL_KEY, GrpcSubFormTestFactory.SUBFORM_LABEL);
}
- @Test
- void shouldContainsLabel() {
- var mappedFormData = mapFromFormData();
-
- assertThat(getFormValueFieldMap(mappedFormData)).containsEntry(GrpcFormDataMapper.LABEL_KEY,
- GrpcSubFormTestFactory.FIELD_LABEL);
- }
-
- private Map<String, Object> getFormValueFieldMap(Map<String, Object> formData) {
- return getValueAsMap(getFormValueMap(formData), GrpcSubFormTestFactory.FIELD_NAME);
+ @SuppressWarnings("unchecked")
+ private Map<String, Object> getSubForm(Map<String, Object> map) {
+ return MapUtils.getMap(map, GrpcSubFormTestFactory.SUBFORM_TITLE);
}
}
-
- @DisplayName("subForm")
- @Nested
- class TestSubForm {
-
- @Test
- void shouldHaveSize() {
- var mappedFormData = mapFromFormData();
-
- assertThat(getFormValueSubFormMap(mappedFormData)).hasSize(2);
- }
-
- @Test
- void shouldContainsValue() {
- var mappedFormData = mapFromFormData();
-
- assertThat(getFormValueSubFormMap(mappedFormData)).containsKey(GrpcFormDataMapper.VALUE_KEY);
- }
-
- @Test
- void shouldContainsLabel() {
- var mappedFormData = mapFromFormData();
-
- assertThat(getFormValueSubFormMap(mappedFormData)).containsEntry(GrpcFormDataMapper.LABEL_KEY,
- GrpcSubFormTestFactory.SUBFORM_LABEL);
- }
-
- private Map<String, Object> getFormValueSubFormMap(Map<String, Object> formData) {
- return getValueAsMap(getFormValueMap(formData), GrpcSubFormTestFactory.SUBFORM_TITLE);
- }
-
- @DisplayName("field")
- @Nested
- class TestSubFormField {
-
- @Test
- void shouldHaveSize() {
- var mappedFormData = mapFromFormData();
-
- assertThat(getFormFieldSubFormMap(mappedFormData)).hasSize(2);
- }
-
- @Test
- void shouldContainsValue() {
- var mappedFormData = mapFromFormData();
-
- assertThat(getFormFieldSubFormMap(mappedFormData))
- .containsEntry(GrpcFormDataMapper.VALUE_KEY, GrpcSubFormTestFactory.SUBFORM_FIELD_VALUE);
- }
-
- @Test
- void shouldContainsLabel() {
- var mappedFormData = mapFromFormData();
-
- assertThat(getFormFieldSubFormMap(mappedFormData))
- .containsEntry(GrpcFormDataMapper.LABEL_KEY, GrpcSubFormTestFactory.SUBFORM_FIELD_LABEL);
- }
-
- private Map<String, Object> getFormFieldSubFormMap(Map<String, Object> formData) {
- var subFormFieldMap = getValueAsMap(getFormValueMap(formData), GrpcSubFormTestFactory.SUBFORM_TITLE);
- var subFormFieldValueMap = getValueAsMap(subFormFieldMap, GrpcFormDataMapper.VALUE_KEY);
- return getValueAsMap(subFormFieldValueMap, GrpcSubFormTestFactory.SUBFORM_FIELD_NAME);
- }
- }
- }
- }
-
- private Map<String, Object> mapFromFormData() {
- return mapper.mapFromFormData(formData);
- }
-
- @SuppressWarnings("unchecked")
- private Map<String, Object> getValueAsMap(Map<String, Object> map, String key) {
- return (Map<String, Object>) map.get(key);
}
}
-}
+}
\ No newline at end of file