Alternative Implementierung des Mappings Prozedur zu Protokollauszug

Diese Implementierung basiert auf der Zuordnung zum Formularnamen.
Unbekannte Formulare werden zum leeren String gemappt.

pom.xml

@@ -92,6 +92,12 @@
             <version>5.9.2</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-params</artifactId>
+            <version>5.9.2</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.assertj</groupId>
             <artifactId>assertj-core</artifactId>

src/main/java/DNPM/config/PluginConfiguration.java

@@ -38,8 +38,8 @@ public class PluginConfiguration {
     }
 
     @Bean
-    public MtbService mtbService(final SettingsService settingsService) {
+    public MtbService mtbService() {
-        return new DefaultMtbService(settingsService);
+        return new DefaultMtbService();
     }
 
     @Bean

src/main/java/DNPM/services/mtb/DefaultMtbService.java

@@ -1,40 +1,32 @@
 package DNPM.services.mtb;
 
-import DNPM.services.SettingsService;
 import de.itc.onkostar.api.Procedure;
 
+import java.util.Comparator;
 import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
 
+/**
+ * Standardimplementierung des MtbService
+ *
+ * @since 0.0.2
+ */
 public class DefaultMtbService implements MtbService {
 
-    private final SettingsService settingsService;
-
-    public DefaultMtbService(final SettingsService settingsService) {
-        this.settingsService = settingsService;
-    }
-
     @Override
     public String getProtocol(List<Procedure> procedures) {
-        ProcedureToProtocolMapper mapper = null;
+        return procedures.stream()
-        var sid = settingsService.getSID();
+                .sorted(Comparator.comparing(Procedure::getStartDate))
+                .map(procedure -> {
+                    var mapper = MtbService.procedureToProtocolMapper(procedure);
+                    return mapper.apply(procedure);
+                })
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .distinct()
+                .collect(Collectors.joining("\n\n"));
 
-        if (sid.isPresent()) {
-            switch (sid.get()) {
-                case "2011":
-                case "20119":
-                    mapper = new OsTumorkonferenzVarianteUkwToProtocolMapper();
-                default:
-                    if (!settingsService.multipleMtbsInMtbEpisode()) {
-                        mapper = new OsTumorkonferenzToProtocolMapper();
-                    }
-            }
-        }
-
-        if (null == mapper) {
-            return "";
-        }
-
-        return mapper.apply(procedures).orElse("");
     }
 
 }

src/main/java/DNPM/services/mtb/MtbService.java

@@ -3,7 +3,19 @@ package DNPM.services.mtb;
 import de.itc.onkostar.api.Procedure;
 
 import java.util.List;
+import java.util.Optional;
 
 public interface MtbService {
     String getProtocol(List<Procedure> procedures);
+
+    static ProcedureToProtocolMapper procedureToProtocolMapper(Procedure procedure) {
+        switch (procedure.getFormName()) {
+            case "OS.Tumorkonferenz":
+                return new OsTumorkonferenzToProtocolMapper();
+            case "OS.Tumorkonferenz.VarianteUKW":
+                return new OsTumorkonferenzVarianteUkwToProtocolMapper();
+            default:
+                return p -> Optional.empty();
+        }
+    }
 }

src/main/java/DNPM/services/mtb/OsTumorkonferenzToProtocolMapper.java

@@ -2,16 +2,17 @@ package DNPM.services.mtb;
 
 import de.itc.onkostar.api.Procedure;
 
-import java.util.List;
 import java.util.Optional;
 
+
+/**
+ * Mapper zum Ermitteln des Protokollauszugs für Formular "OS.Tumorkonferenz"
+ *
+ * @since 0.0.2
+ */
 public class OsTumorkonferenzToProtocolMapper implements ProcedureToProtocolMapper {
     @Override
-    public Optional<String> apply(List<Procedure> procedures) {
+    public Optional<String> apply(Procedure procedure) {
-        assert(procedures.size() == 1);
-
-        var procedure = procedures.get(0);
-
         assert(procedure.getFormName().equals("OS.Tumorkonferenz"));
 
         var fragestellung = procedure.getValue("Fragestellung");

src/main/java/DNPM/services/mtb/OsTumorkonferenzVarianteUkwToProtocolMapper.java

@@ -2,21 +2,18 @@ package DNPM.services.mtb;
 
 import de.itc.onkostar.api.Procedure;
 
-import java.util.Comparator;
-import java.util.List;
 import java.util.Optional;
-import java.util.stream.Collectors;
 
+/**
+ * Mapper zum Ermitteln des Protokollauszugs für Formular "OS.Tumorkonferenz.VarianteUKW"
+ *
+ * @since 0.0.2
+ */
 public class OsTumorkonferenzVarianteUkwToProtocolMapper implements ProcedureToProtocolMapper {
     @Override
-    public Optional<String> apply(List<Procedure> procedures) {
+    public Optional<String> apply(Procedure procedure) {
-        procedures.forEach(procedure -> {
         assert (procedure.getFormName().equals("OS.Tumorkonferenz.VarianteUKW"));
-        });
 
-        procedures.sort(Comparator.comparing(Procedure::getStartDate));
-
-        var result = procedures.stream().map(procedure -> {
         var fragestellung = procedure.getValue("Fragestellung");
         var empfehlung = procedure.getValue("Empfehlung");
 
@@ -24,19 +21,12 @@ public class OsTumorkonferenzVarianteUkwToProtocolMapper implements ProcedureToP
                 null != fragestellung && !fragestellung.getString().isBlank()
                         && null != empfehlung && !empfehlung.getString().isBlank()
         ) {
-                return String.format("Fragestellung:\n%s\n\nEmpfehlung:\n%s", fragestellung.getString().trim(), empfehlung.getString().trim());
+            return Optional.of(String.format("Fragestellung:\n%s\n\nEmpfehlung:\n%s", fragestellung.getString().trim(), empfehlung.getString().trim()));
         } else if (null != fragestellung && !fragestellung.getString().isBlank()) {
-                return fragestellung.getString().trim();
+            return Optional.of(fragestellung.getString().trim());
         } else if (null != empfehlung && !empfehlung.getString().isBlank()) {
-                return empfehlung.getString().trim();
+            return Optional.of(empfehlung.getString().trim());
         }
-            return "";
-        }).collect(Collectors.joining("\n\n"));
-
-        if (!result.isBlank()) {
-            return Optional.of(result);
-        }
-
         return Optional.empty();
     }
 }

src/main/java/DNPM/services/mtb/ProcedureToProtocolMapper.java

@@ -2,9 +2,8 @@ package DNPM.services.mtb;
 
 import de.itc.onkostar.api.Procedure;
 
-import java.util.List;
 import java.util.Optional;
 import java.util.function.Function;
 
 @FunctionalInterface
-public interface ProcedureToProtocolMapper extends Function<List<Procedure>, Optional<String>> {}
+public interface ProcedureToProtocolMapper extends Function<Procedure, Optional<String>> {}

src/test/java/DNPM/services/mtb/DefaultMtbServiceTest.java

@@ -1,6 +1,5 @@
 package DNPM.services.mtb;
 
-import DNPM.services.SettingsService;
 import de.itc.onkostar.api.IOnkostarApi;
 import de.itc.onkostar.api.Item;
 import de.itc.onkostar.api.Procedure;
@@ -14,35 +13,26 @@ import java.time.Instant;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
-import java.util.Optional;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.when;
 
 @ExtendWith(MockitoExtension.class)
 public class DefaultMtbServiceTest {
 
     private IOnkostarApi onkostarApi;
 
-    private SettingsService settingsService;
-
     private DefaultMtbService service;
 
     @BeforeEach
     void setup(
-            @Mock IOnkostarApi onkostarApi,
+            @Mock IOnkostarApi onkostarApi
-            @Mock SettingsService settingsService
     ) {
         this.onkostarApi = onkostarApi;
-        this.settingsService = settingsService;
+        this.service = new DefaultMtbService();
-        this.service = new DefaultMtbService(settingsService);
     }
 
     @Test
     void testShouldReturnMtbProtocolForDefaultImplementation() {
-        when(settingsService.getSID()).thenReturn(Optional.of("12345"));
-        when(settingsService.multipleMtbsInMtbEpisode()).thenReturn(false);
-
         var procedure1 = new Procedure(onkostarApi);
         procedure1.setFormName("OS.Tumorkonferenz");
         procedure1.setStartDate(Date.from(Instant.parse("2023-01-01T00:00:00Z")));
@@ -59,30 +49,34 @@ public class DefaultMtbServiceTest {
     }
 
     @Test
-    void testShouldReturnEmptyMtbProtocolForMultipleMtb() {
+    void testShouldReturnMtbProtocolForMultipleTK() {
-        when(settingsService.getSID()).thenReturn(Optional.of("12345"));
-        when(settingsService.multipleMtbsInMtbEpisode()).thenReturn(true);
-
         var procedure1 = new Procedure(onkostarApi);
         procedure1.setFormName("OS.Tumorkonferenz");
-        procedure1.setStartDate(Date.from(Instant.parse("2023-01-01T00:00:00Z")));
+        procedure1.setStartDate(Date.from(Instant.parse("2023-02-01T00:00:00Z")));
-        procedure1.setValue("Fragestellung", new Item("Fragestellung", "Test ok?"));
+        procedure1.setValue("Fragestellung", new Item("Fragestellung", "Test immer noch ok?"));
-        procedure1.setValue("Empfehlung", new Item("Empfehlung", "Rerun Test if not ok!"));
+        procedure1.setValue("Empfehlung", new Item("Empfehlung", "Do not rerun Test if ok!"));
+
+        var procedure2 = new Procedure(onkostarApi);
+        procedure2.setFormName("OS.Tumorkonferenz");
+        procedure2.setStartDate(Date.from(Instant.parse("2023-01-01T00:00:00Z")));
+        procedure2.setValue("Fragestellung", new Item("Fragestellung", "Test ok?"));
+        procedure2.setValue("Empfehlung", new Item("Empfehlung", "Rerun Test if not ok!"));
 
         var procedures = List.of(
-                procedure1
+                procedure1,
+                procedure2
         );
 
         var actual = service.getProtocol(procedures);
 
-        assertThat(actual).isEmpty();
+        assertThat(actual).isEqualTo(
+                "Fragestellung:\nTest ok?\n\nEmpfehlung:\nRerun Test if not ok!\n\n" +
+                        "Fragestellung:\nTest immer noch ok?\n\nEmpfehlung:\nDo not rerun Test if ok!"
+        );
     }
 
     @Test
-    void testShouldReturnMtbProtocolForSID20119() {
+    void testShouldReturnMtbProtocolForMultipleTKVarianteUKW() {
-        when(settingsService.getSID()).thenReturn(Optional.of("20119"));
-        when(settingsService.multipleMtbsInMtbEpisode()).thenReturn(true);
-
         var procedure1 = new Procedure(onkostarApi);
         procedure1.setFormName("OS.Tumorkonferenz.VarianteUKW");
         procedure1.setStartDate(Date.from(Instant.parse("2023-02-01T00:00:00Z")));
@@ -109,4 +103,64 @@ public class DefaultMtbServiceTest {
         );
     }
 
+    @Test
+    void testShouldReturnDistinctProtocolEntries() {
+        var procedure1 = new Procedure(onkostarApi);
+        procedure1.setFormName("OS.Tumorkonferenz.VarianteUKW");
+        procedure1.setStartDate(Date.from(Instant.parse("2023-02-01T00:00:00Z")));
+        procedure1.setValue("Fragestellung", new Item("Fragestellung", "Test immer noch ok?"));
+        procedure1.setValue("Empfehlung", new Item("Empfehlung", "Do not rerun Test if ok!"));
+
+        var procedure2 = new Procedure(onkostarApi);
+        procedure2.setFormName("OS.Tumorkonferenz.VarianteUKW");
+        procedure2.setStartDate(Date.from(Instant.parse("2023-02-01T00:00:00Z")));
+        procedure2.setValue("Fragestellung", new Item("Fragestellung", "Test immer noch ok?"));
+        procedure2.setValue("Empfehlung", new Item("Empfehlung", "Do not rerun Test if ok!"));
+
+        var procedure3 = new Procedure(onkostarApi);
+        procedure3.setFormName("OS.Tumorkonferenz.VarianteUKW");
+        procedure3.setStartDate(Date.from(Instant.parse("2023-01-01T00:00:00Z")));
+        procedure3.setValue("Fragestellung", new Item("Fragestellung", "Test ok?"));
+        procedure3.setValue("Empfehlung", new Item("Empfehlung", "Rerun Test if not ok!"));
+
+
+        var procedures = Arrays.asList(
+                procedure1,
+                procedure2,
+                procedure3
+        );
+
+        var actual = service.getProtocol(procedures);
+
+        assertThat(actual).isEqualTo(
+                "Fragestellung:\nTest ok?\n\nEmpfehlung:\nRerun Test if not ok!\n\n" +
+                        "Fragestellung:\nTest immer noch ok?\n\nEmpfehlung:\nDo not rerun Test if ok!"
+        );
+    }
+
+    @Test
+    void testShouldReturnEmptyMtbProtocolForUnknownForm() {
+        var procedure1 = new Procedure(onkostarApi);
+        procedure1.setFormName("OS.Tumorkonferenz.Unbekannt");
+        procedure1.setStartDate(Date.from(Instant.parse("2023-02-01T00:00:00Z")));
+        procedure1.setValue("Fragestellung", new Item("Fragestellung", "Test immer noch ok?"));
+        procedure1.setValue("Empfehlung", new Item("Empfehlung", "Do not rerun Test if ok!"));
+
+        var procedure2 = new Procedure(onkostarApi);
+        procedure2.setFormName("OS.Tumorkonferenz.Unbekannt");
+        procedure2.setStartDate(Date.from(Instant.parse("2023-01-01T00:00:00Z")));
+        procedure2.setValue("Fragestellung", new Item("Fragestellung", "Test ok?"));
+        procedure2.setValue("Empfehlung", new Item("Empfehlung", "Rerun Test if not ok!"));
+
+
+        var procedures = Arrays.asList(
+                procedure1,
+                procedure2
+        );
+
+        var actual = service.getProtocol(procedures);
+
+        assertThat(actual).isEmpty();
+    }
+
 }

src/test/java/DNPM/services/mtb/MtbServiceTest.java

@@ -0,0 +1,47 @@
+package DNPM.services.mtb;
+
+import de.itc.onkostar.api.IOnkostarApi;
+import de.itc.onkostar.api.Procedure;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Map;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@ExtendWith(MockitoExtension.class)
+public class MtbServiceTest {
+
+    private IOnkostarApi onkostarApi;
+
+    @BeforeEach
+    void setup(
+            @Mock IOnkostarApi onkostarApi
+    ) {
+        this.onkostarApi = onkostarApi;
+    }
+
+    private static Set<Map.Entry<String, Class<? extends ProcedureToProtocolMapper>>> expectedMappings() {
+        return Map.ofEntries(
+                Map.entry("OS.Tumorkonferenz", OsTumorkonferenzToProtocolMapper.class),
+                Map.entry("OS.Tumorkonferenz.VarianteUKW", OsTumorkonferenzVarianteUkwToProtocolMapper.class)
+        ).entrySet();
+    }
+
+    @ParameterizedTest
+    @MethodSource("expectedMappings")
+    void testShouldMapFormNameToMapper(Map.Entry<String, Class<?>> expectedMapping) {
+        var procedure = new Procedure(onkostarApi);
+        procedure.setFormName(expectedMapping.getKey());
+
+        var actual = MtbService.procedureToProtocolMapper(procedure);
+
+        assertThat(actual).isExactlyInstanceOf(expectedMapping.getValue());
+    }
+
+}