refactor: extract KpaVerwandteDataMapper

src/main/java/dev/pcvolkmer/onco/datamapper/mapper/KpaVerwandteDataMapper.java

@@ -0,0 +1,74 @@
+package dev.pcvolkmer.onco.datamapper.mapper;
+
+import dev.pcvolkmer.mv64e.mtb.FamilyMemberHistory;
+import dev.pcvolkmer.mv64e.mtb.FamilyMemberHistoryRelationshipTypeCoding;
+import dev.pcvolkmer.mv64e.mtb.FamilyMemberHistoryRelationshipTypeCodingCode;
+import dev.pcvolkmer.onco.datamapper.ResultSet;
+import dev.pcvolkmer.onco.datamapper.datacatalogues.VerwandteCatalogue;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+import static dev.pcvolkmer.onco.datamapper.mapper.MapperUtils.getPatientReference;
+
+/**
+ * Mapper class to load and map prozedur data from database table 'dk_dnpm_uf_verwandte'
+ *
+ * @author Paul-Christian Volkmer
+ * @since 0.1
+ */
+public class KpaVerwandteDataMapper extends AbstractSubformDataMapper<FamilyMemberHistory> {
+
+    public KpaVerwandteDataMapper(final VerwandteCatalogue catalogue) {
+        super(catalogue);
+    }
+
+    /**
+     * Loads and maps Prozedur related by database id
+     *
+     * @param id The database id of the procedure data set
+     * @return The loaded data set
+     */
+    @Override
+    public FamilyMemberHistory getById(final int id) {
+        var data = catalogue.getById(id);
+        return this.map(data);
+    }
+
+    @Override
+    protected FamilyMemberHistory map(final ResultSet resultSet) {
+        var builder = FamilyMemberHistory.builder();
+        builder
+                .id(resultSet.getId().toString())
+                .patient(getPatientReference(resultSet.getString("patient_id")))
+                .relationship(
+                        getFamilyMemberHistoryRelationshipTypeCoding(resultSet.getString("verwandtschaftsgrad"))
+                )
+        ;
+
+        return builder.build();
+    }
+
+    private FamilyMemberHistoryRelationshipTypeCoding getFamilyMemberHistoryRelationshipTypeCoding(final String value) {
+        if (value == null || !Arrays.stream(FamilyMemberHistoryRelationshipTypeCodingCode.values()).map(FamilyMemberHistoryRelationshipTypeCodingCode::toValue).collect(Collectors.toSet()).contains(value)) {
+            return null;
+        }
+
+        var resultBuilder = FamilyMemberHistoryRelationshipTypeCoding.builder()
+                .system("dnpm-dip/mtb/family-meber-history/relationship-type");
+
+        switch (value) {
+            case "FAMMEMB":
+                resultBuilder.code(FamilyMemberHistoryRelationshipTypeCodingCode.FAMMEMB).display("Verwandter ersten Grades");
+                break;
+            case "EXT":
+                resultBuilder.code(FamilyMemberHistoryRelationshipTypeCodingCode.EXT).display("Verwandter weiteren Grades");
+                break;
+            default:
+                throw new IllegalArgumentException("Unknown family member history relationship type: " + value);
+        }
+
+        return resultBuilder.build();
+    }
+
+}

src/main/java/dev/pcvolkmer/onco/datamapper/mapper/MtbDataMapper.java

@@ -1,8 +1,5 @@
 package dev.pcvolkmer.onco.datamapper.mapper;
 
-import dev.pcvolkmer.mv64e.mtb.FamilyMemberHistory;
-import dev.pcvolkmer.mv64e.mtb.FamilyMemberHistoryRelationshipTypeCoding;
-import dev.pcvolkmer.mv64e.mtb.FamilyMemberHistoryRelationshipTypeCodingCode;
 import dev.pcvolkmer.mv64e.mtb.Mtb;
 import dev.pcvolkmer.onco.datamapper.PropertyCatalogue;
 import dev.pcvolkmer.onco.datamapper.datacatalogues.*;
@@ -15,8 +12,6 @@ import javax.sql.DataSource;
 import java.util.List;
 import java.util.stream.Collectors;
 
-import static dev.pcvolkmer.onco.datamapper.mapper.MapperUtils.getPatientReference;
-
 /**
  * Mapper class to load and map Mtb files from database
  *
@@ -91,6 +86,8 @@ public class MtbDataMapper implements DataMapper<Mtb> {
                 propertyCatalogue
         );
 
+        var verwandteDataMapper = new KpaVerwandteDataMapper(catalogueFactory.catalogue(VerwandteCatalogue.class));
+
         var resultBuilder = Mtb.builder();
 
         try {
@@ -105,20 +102,7 @@ public class MtbDataMapper implements DataMapper<Mtb> {
                     .guidelineProcedures(prozedurMapper.getByParentId(kpaId))
                     .guidelineTherapies(therapielinieMapper.getByParentId(kpaId))
                     .performanceStatus(ecogMapper.getByParentId(kpaId))
-                    // TODO Refactoring of inlined mapping
+                    .familyMemberHistories(verwandteDataMapper.getByParentId(kpaId))
-                    .familyMemberHistories(
-                            catalogueFactory.catalogue(VerwandteCatalogue.class).getAllByParentId(kpaId).stream()
-                                    .map(it -> FamilyMemberHistory.builder()
-                                            .id(it.getId().toString())
-                                            .patient(getPatientReference(patient.getId()))
-                                            .relationship(FamilyMemberHistoryRelationshipTypeCoding.builder().code(
-                                                    it.getString("verwandschaftsgrad").equals("FAMMEMB")
-                                                            ? FamilyMemberHistoryRelationshipTypeCodingCode.FAMMEMB
-                                                            : FamilyMemberHistoryRelationshipTypeCodingCode.EXT
-                                            ).build())
-                                            .build()
-                                    ).collect(Collectors.toList())
-                    )
                     // DNPM Therapieplan
                     .carePlans(
                             therapieplanCatalogue

src/test/java/dev/pcvolkmer/onco/datamapper/mapper/KpaVerwandteDataMapperTest.java

@@ -0,0 +1,78 @@
+package dev.pcvolkmer.onco.datamapper.mapper;
+
+import dev.pcvolkmer.mv64e.mtb.FamilyMemberHistory;
+import dev.pcvolkmer.mv64e.mtb.FamilyMemberHistoryRelationshipTypeCoding;
+import dev.pcvolkmer.mv64e.mtb.FamilyMemberHistoryRelationshipTypeCodingCode;
+import dev.pcvolkmer.mv64e.mtb.Reference;
+import dev.pcvolkmer.onco.datamapper.ResultSet;
+import dev.pcvolkmer.onco.datamapper.datacatalogues.VerwandteCatalogue;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class KpaVerwandteDataMapperTest {
+
+    VerwandteCatalogue catalogue;
+
+    KpaVerwandteDataMapper dataMapper;
+
+    @BeforeEach
+    void setUp(@Mock VerwandteCatalogue catalogue) {
+        this.catalogue = catalogue;
+        this.dataMapper = new KpaVerwandteDataMapper(catalogue);
+    }
+
+    @Test
+    void shouldMapResultSet(@Mock ResultSet resultSet) {
+        var testData = Map.of(
+                "id", "1",
+                "patient_id", "42",
+                "verwandtschaftsgrad", "EXT"
+        );
+
+        doAnswer(invocationOnMock -> {
+            var columnName = invocationOnMock.getArgument(0, String.class);
+            return testData.get(columnName);
+        }).when(resultSet).getString(anyString());
+
+        when(resultSet.getId()).thenReturn(1);
+
+        doAnswer(invocationOnMock -> List.of(resultSet))
+                .when(catalogue)
+                .getAllByParentId(anyInt());
+
+        var actualList = this.dataMapper.getByParentId(1);
+        assertThat(actualList).hasSize(1);
+
+        var actual = actualList.get(0);
+        assertThat(actual).isInstanceOf(FamilyMemberHistory.class);
+        assertThat(actual.getId()).isEqualTo("1");
+        assertThat(actual.getPatient())
+                .isEqualTo(Reference.builder()
+                        .id("42")
+                        .type("Patient")
+                        .build()
+                );
+        assertThat(actual.getRelationship())
+                .isEqualTo(
+                        FamilyMemberHistoryRelationshipTypeCoding.builder()
+                                .code(FamilyMemberHistoryRelationshipTypeCodingCode.EXT)
+                                .display("Verwandter weiteren Grades")
+                                .system("dnpm-dip/mtb/family-meber-history/relationship-type")
+                                .build()
+                );
+    }
+
+}