Merge pull request 'OZG-4693: Antragstellerdaten aus Fromcycle auslesen' (#99)...

Merge pull request 'OZG-4693: Antragstellerdaten aus Fromcycle auslesen' (#99) from OZG-4693-Antragstellerdaten-ueber-Formcycle-schicken into master

Reviewed-on: https://git.ozg-sh.de/ozgcloud-app/eingang-manager/pulls/99

common/src/test/java/de/ozgcloud/eingang/common/formdata/AntragstellerTestFactory.java

@@ -43,6 +43,10 @@ public class AntragstellerTestFactory {
 	public static final String GEBURTSDATUM = "30.8.1955";
 	public static final String GEBURTSORT = "Mülheim an der Ruhr";
 	public static final String EMAIL = "schneider@helgeschneider.local";
+	public static final String STRASSE = "Musterstraße";
+	public static final String HAUSNUMMER = "1";
+	public static final String PLZ = "12345";
+	public static final String ORT = "Musterstadt";
 	public static final String TELEFON = "+ 0176 888 666 222XX";
 	public static final String POSTFACH_ID = UUID.randomUUID().toString();
 
@@ -60,6 +64,10 @@ public class AntragstellerTestFactory {
 				.geburtsort(GEBURTSORT)
 				.email(EMAIL)
 				.telefon(TELEFON)
+				.strasse(STRASSE)
+				.hausnummer(HAUSNUMMER)
+				.plz(PLZ)
+				.ort(ORT)
 				.postfachId(POSTFACH_ID)
 				.data(Map.of(GEBIET_BEZEICHNUNG_KEY, GEBIET_BEZEICHNUNG_VALUE,
 						SUB_PERSOENLICHE_EIGNUNG,

semantik-adapter/src/main/java/de/ozgcloud/eingang/semantik/enginebased/formcycle/FormCycleEngineBasedAdapter.java

@@ -23,14 +23,25 @@
  */
 package de.ozgcloud.eingang.semantik.enginebased.formcycle;
 
+import java.util.List;
+
+import org.springframework.beans.factory.annotation.Autowired;
+
 import de.ozgcloud.eingang.common.formdata.FormData;
 import de.ozgcloud.eingang.semantik.enginebased.EngineBasedSemantikAdapter;
 
 public class FormCycleEngineBasedAdapter implements EngineBasedSemantikAdapter {
 
+	@Autowired
+	private List<FormcycleEngineBasedMapper> mappers;
+
 	@Override
 	public FormData parseFormData(FormData formData) {
-		return formData;
+		var processed = formData;
+		for (var mapper : mappers) {
+			processed = mapper.parseFormData(processed);
+		}
+		return processed;
 	}
 
 }

semantik-adapter/src/main/java/de/ozgcloud/eingang/semantik/enginebased/formcycle/FormcycleAntragstellerMapper.java

+package de.ozgcloud.eingang.semantik.enginebased.formcycle;
+
+import java.util.Map;
+import java.util.Optional;
+
+import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Component;
+
+import de.ozgcloud.eingang.common.formdata.Antragsteller;
+import de.ozgcloud.eingang.common.formdata.FormData;
+
+@Component
+public class FormcycleAntragstellerMapper implements FormcycleEngineBasedMapper {
+
+	static final String KEY_ANTRAGSTELLER = "fsBKAllDaten";
+	static final String KEY_ANREDE = "tfAntragstellerAnrede";
+	static final String KEY_VORNAME = "tfAntragstellerVorname";
+	static final String KEY_NACHNAME = "tfAntragstellerName";
+	static final String KEY_GEBURTSNAME = "tfAntragstellerGeburtsname";
+	static final String KEY_GEBURTSDATUM = "tfAntragstellerGeburtsdatum";
+	static final String KEY_GEBURTSORT = "tfAntragstellerGeburtsort";
+	static final String KEY_EMAIL = "tfAntragstellerEmail";
+	static final String KEY_TELEFON = "tfAntragstellerTelefon";
+	static final String KEY_ADDRESS = "tfAntragstellerAdresse";
+	static final String KEY_PLZ = "tfAntragstellerPLZ";
+	static final String KEY_ORT = "tfAntragstellerOrt";
+
+	@Override
+	public FormData parseFormData(final FormData formData) {
+		return getAntragstellerData(formData.getFormData())
+				.map(this::buildAntragsteller)
+				.map(antragsteller -> formData.toBuilder().antragsteller(antragsteller).build())
+				.orElse(formData);
+	}
+
+	@SuppressWarnings("unchecked")
+	Optional<Map<String, Object>> getAntragstellerData(Map<String, Object> formDataMap) {
+		var antragstellerData = (Map<String, Object>) MapUtils.getMap(formDataMap, KEY_ANTRAGSTELLER);
+		return Optional.ofNullable(antragstellerData).map(map -> (Map<String, Object>) map.get("value"));
+	}
+
+	Antragsteller buildAntragsteller(Map<String, Object> antragstellerData) {
+		return Antragsteller.builder()
+				.anrede(getValue(antragstellerData, KEY_ANREDE))
+				.vorname(getValue(antragstellerData, KEY_VORNAME))
+				.nachname(getValue(antragstellerData, KEY_NACHNAME))
+				.geburtsname(getValue(antragstellerData, KEY_GEBURTSNAME))
+				.geburtsdatum(getValue(antragstellerData, KEY_GEBURTSDATUM))
+				.geburtsort(getValue(antragstellerData, KEY_GEBURTSORT))
+				.email(getValue(antragstellerData, KEY_EMAIL))
+				.telefon(getValue(antragstellerData, KEY_TELEFON))
+				.strasse(getValue(antragstellerData, KEY_ADDRESS))
+				.plz(getValue(antragstellerData, KEY_PLZ))
+				.ort(getValue(antragstellerData, KEY_ORT))
+				.build();
+	}
+
+	String getValue(Map<String, Object> formDataMap, String key) {
+		return Optional.ofNullable(MapUtils.getMap(formDataMap, key)).map(map -> map.get("value")).map(String::valueOf).orElse(StringUtils.EMPTY);
+	}
+}

semantik-adapter/src/main/java/de/ozgcloud/eingang/semantik/enginebased/formcycle/FormcycleEngineBasedMapper.java

+package de.ozgcloud.eingang.semantik.enginebased.formcycle;
+
+import de.ozgcloud.eingang.semantik.enginebased.EngineBasedMapper;
+
+interface FormcycleEngineBasedMapper extends EngineBasedMapper {
+}

semantik-adapter/src/test/java/de/ozgcloud/eingang/semantik/enginebased/formcycle/FormCycleEngineBasedAdapterTest.java

@@ -24,25 +24,47 @@
 package de.ozgcloud.eingang.semantik.enginebased.formcycle;
 
 import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
 
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.springframework.test.util.ReflectionTestUtils;
 
+import de.ozgcloud.eingang.common.formdata.FormData;
 import de.ozgcloud.eingang.common.formdata.FormDataTestFactory;
-import de.ozgcloud.eingang.semantik.enginebased.formcycle.FormCycleEngineBasedAdapter;
 
 class FormCycleEngineBasedAdapterTest {
 
 	@InjectMocks
 	private FormCycleEngineBasedAdapter adapter;
 
+	@Mock
+	private FormcycleEngineBasedMapper mapper;
+	@Mock
+	private FormData formData;
+
+	@BeforeEach
+	void setup() {
+		ReflectionTestUtils.setField(adapter, "mappers", List.of(mapper));
+	}
+
 	@Test
-	void shouldUnprocessedData() {
-		var formData = FormDataTestFactory.create();
+	void shouldParseFormData() {
+		adapter.parseFormData(formData);
 
-		var result = adapter.parseFormData(formData);
+		verify(mapper).parseFormData(formData);
+	}
+
+	@Test
+	void shouldNotRemoveParsedFormData() {
+		when(mapper.parseFormData(any())).thenReturn(formData);
+
+		var result = adapter.parseFormData(FormDataTestFactory.create());
 
 		assertThat(result).isSameAs(formData);
 	}
-
 }

semantik-adapter/src/test/java/de/ozgcloud/eingang/semantik/enginebased/formcycle/FormcycleAntragstellerMapperTest.java

+package de.ozgcloud.eingang.semantik.enginebased.formcycle;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+
+import de.ozgcloud.eingang.common.formdata.Antragsteller;
+import de.ozgcloud.eingang.common.formdata.AntragstellerTestFactory;
+import de.ozgcloud.eingang.common.formdata.FormData;
+import de.ozgcloud.eingang.common.formdata.FormDataTestFactory;
+
+class FormcycleAntragstellerMapperTest {
+
+	@Spy
+	@InjectMocks
+	private FormcycleAntragstellerMapper mapper;
+
+	private static final String VALUE_KEY = "value";
+	private static final String LABEL_KEY = "label";
+	private static final Map<String, Object> ANTRAGSTELLER_DATA = new HashMap<>();
+	private static final Map<String, Object> ANTRAGSTELLER_MAP = Map.of("fsBKAllDaten", Map.of(VALUE_KEY, ANTRAGSTELLER_DATA));
+
+	@BeforeAll
+	static void fillAntragstellerData() {
+		ANTRAGSTELLER_DATA.put("tfAntragstellerAnrede", Map.of(VALUE_KEY, AntragstellerTestFactory.ANREDE, LABEL_KEY, "Anrede"));
+		ANTRAGSTELLER_DATA.put("tfAntragstellerVorname", Map.of(LABEL_KEY, "Vorname", VALUE_KEY, AntragstellerTestFactory.VORNAME));
+		ANTRAGSTELLER_DATA.put("tfAntragstellerName", Map.of(VALUE_KEY, AntragstellerTestFactory.NACHNAME, LABEL_KEY, "Nachname"));
+		ANTRAGSTELLER_DATA.put("tfAntragstellerGeburtsname", Map.of(VALUE_KEY, AntragstellerTestFactory.GEBURTSNAME, LABEL_KEY, "Geburtsname"));
+		ANTRAGSTELLER_DATA.put("tfAntragstellerGeburtsdatum", Map.of(VALUE_KEY, AntragstellerTestFactory.GEBURTSDATUM, LABEL_KEY, "Geburtsdatum"));
+		ANTRAGSTELLER_DATA.put("tfAntragstellerGeburtsort", Map.of(VALUE_KEY, AntragstellerTestFactory.GEBURTSORT, LABEL_KEY, "Geburtsort"));
+		ANTRAGSTELLER_DATA.put("tfAntragstellerEmail", Map.of(VALUE_KEY, AntragstellerTestFactory.EMAIL, LABEL_KEY, "E-Mail"));
+		ANTRAGSTELLER_DATA.put("tfAntragstellerTelefon", Map.of(VALUE_KEY, AntragstellerTestFactory.TELEFON, LABEL_KEY, "Telefon"));
+		ANTRAGSTELLER_DATA.put("tfAntragstellerAdresse", Map.of(LABEL_KEY, "Adresse", VALUE_KEY, AntragstellerTestFactory.STRASSE + " " + AntragstellerTestFactory.HAUSNUMMER));
+		ANTRAGSTELLER_DATA.put("tfAntragstellerPLZ", Map.of(LABEL_KEY, "PLZ", VALUE_KEY, AntragstellerTestFactory.PLZ));
+		ANTRAGSTELLER_DATA.put("tfAntragstellerOrt", Map.of(LABEL_KEY, "Ort", VALUE_KEY, AntragstellerTestFactory.ORT));
+	}
+
+	@Nested
+	class TestParseFormData {
+
+		@Mock
+		private Antragsteller antragsteller;
+
+		@Test
+		void shouldCallGetAntragsteller() {
+			mapper.parseFormData(buildFormData());
+
+			verify(mapper).getAntragstellerData(ANTRAGSTELLER_MAP);
+		}
+
+		@Test
+		void shouldCallBuildAntragsteller() {
+			doReturn(Optional.of(ANTRAGSTELLER_DATA)).when(mapper).getAntragstellerData(anyMap());
+
+			mapper.parseFormData(buildFormData());
+
+			verify(mapper).buildAntragsteller(ANTRAGSTELLER_DATA);
+		}
+
+		@Test
+		void shouldSetAntragsteller() {
+			doReturn(antragsteller).when(mapper).buildAntragsteller(anyMap());
+
+			var formData = mapper.parseFormData(buildFormData());
+
+			assertThat(formData.getAntragsteller()).isSameAs(antragsteller);
+		}
+
+		@Test
+		void shouldReturnSameFormData() {
+			var formData = FormDataTestFactory.create();
+
+			var result = mapper.parseFormData(formData);
+
+			assertThat(result).isSameAs(formData);
+		}
+
+		FormData buildFormData() {
+			return FormData.builder().formData(ANTRAGSTELLER_MAP).build();
+		}
+	}
+
+	@Nested
+	class TestGetAntragstellerData {
+
+		@Test
+		void shouldReturnEmpty() {
+			Map<String, Object> formDataMap = Map.of("key", "value");
+
+			var result = mapper.getAntragstellerData(formDataMap);
+
+			assertThat(result).isEmpty();
+		}
+
+		@Test
+		void shouldReturnAntragstellerData() {
+			var result = mapper.getAntragstellerData(ANTRAGSTELLER_MAP);
+
+			assertThat(result).contains(ANTRAGSTELLER_DATA);
+		}
+	}
+
+	@Nested
+	class TestBuildAntragsteller {
+
+		@Test
+		void shouldSetAnrede() {
+			var result = buildAntragsteller();
+
+			assertThat(result.getAnrede()).isEqualTo(AntragstellerTestFactory.ANREDE);
+		}
+
+		@Test
+		void shouldSetVorname() {
+			var result = buildAntragsteller();
+
+			assertThat(result.getVorname()).isEqualTo(AntragstellerTestFactory.VORNAME);
+		}
+
+		@Test
+		void shouldSetNachname() {
+			var result = buildAntragsteller();
+
+			assertThat(result.getNachname()).isEqualTo(AntragstellerTestFactory.NACHNAME);
+		}
+
+		@Test
+		void shouldSetGeburtsname() {
+			var result = buildAntragsteller();
+
+			assertThat(result.getGeburtsname()).isEqualTo(AntragstellerTestFactory.GEBURTSNAME);
+		}
+
+		@Test
+		void shouldSetGeburtsdatum() {
+			var result = buildAntragsteller();
+
+			assertThat(result.getGeburtsdatum()).isEqualTo(AntragstellerTestFactory.GEBURTSDATUM);
+		}
+
+		@Test
+		void shouldSetGeburtsort() {
+			var result = buildAntragsteller();
+
+			assertThat(result.getGeburtsort()).isEqualTo(AntragstellerTestFactory.GEBURTSORT);
+		}
+
+		@Test
+		void shouldSetEmail() {
+			var result = buildAntragsteller();
+
+			assertThat(result.getEmail()).isEqualTo(AntragstellerTestFactory.EMAIL);
+		}
+
+		@Test
+		void shouldSetTelefon() {
+			var result = buildAntragsteller();
+
+			assertThat(result.getTelefon()).isEqualTo(AntragstellerTestFactory.TELEFON);
+		}
+
+		@Test
+		void shouldSetAdresse() {
+			var result = buildAntragsteller();
+
+			assertThat(result.getStrasse()).isEqualTo(AntragstellerTestFactory.STRASSE + " " + AntragstellerTestFactory.HAUSNUMMER);
+		}
+
+		@Test
+		void shouldSetPlz() {
+			var result = buildAntragsteller();
+
+			assertThat(result.getPlz()).isEqualTo(AntragstellerTestFactory.PLZ);
+		}
+
+		@Test
+		void shouldSetOrt() {
+			var result = buildAntragsteller();
+
+			assertThat(result.getOrt()).isEqualTo(AntragstellerTestFactory.ORT);
+		}
+
+		Antragsteller buildAntragsteller() {
+			return mapper.buildAntragsteller(ANTRAGSTELLER_DATA);
+		}
+	}
+}
\ No newline at end of file