pcvolkmer/onkostar-plugin-dnpm
1
0
Fork 0
mirror of https://github.com/pcvolkmer/onkostar-plugin-dnpm.git synced 2025-07-01 17:02:53 +00:00
Code Issues Activity

Alternative Implementierung des Mappings Prozedur zu Protokollauszug

Browse Source 
Diese Implementierung basiert auf der Zuordnung zum Formularnamen.
Unbekannte Formulare werden zum leeren String gemappt.
This commit is contained in:
Paul-Christian Volkmer
2023-03-21 14:57:46 +01:00
parent 7052becabf
commit 47c7730c0c
9 changed files with 190 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
pom.xml
View File

@ -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>

4
src/main/java/DNPM/config/PluginConfiguration.java
View File

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

44
src/main/java/DNPM/services/mtb/DefaultMtbService.java
View File

@ -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;
var sid = settingsService.getSID();
return procedures.stream()
.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("");
}
}

12
src/main/java/DNPM/services/mtb/MtbService.java
View File

@ -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();
}
}
}

13
src/main/java/DNPM/services/mtb/OsTumorkonferenzToProtocolMapper.java
View File

@ -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) {
assert(procedures.size() == 1);
var procedure = procedures.get(0);
public Optional<String> apply(Procedure procedure) {
assert(procedure.getFormName().equals("OS.Tumorkonferenz"));
var fragestellung = procedure.getValue("Fragestellung");

46
src/main/java/DNPM/services/mtb/OsTumorkonferenzVarianteUkwToProtocolMapper.java
View File

@ -2,41 +2,31 @@ 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) {
procedures.forEach(procedure -> {
assert (procedure.getFormName().equals("OS.Tumorkonferenz.VarianteUKW"));
});
public Optional<String> apply(Procedure procedure) {
assert (procedure.getFormName().equals("OS.Tumorkonferenz.VarianteUKW"));
procedures.sort(Comparator.comparing(Procedure::getStartDate));
var fragestellung = procedure.getValue("Fragestellung");
var empfehlung = procedure.getValue("Empfehlung");
var result = procedures.stream().map(procedure -> {
var fragestellung = procedure.getValue("Fragestellung");
var empfehlung = procedure.getValue("Empfehlung");
if (
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());
} else if (null != fragestellung && !fragestellung.getString().isBlank()) {
return fragestellung.getString().trim();
} else if (null != empfehlung && !empfehlung.getString().isBlank()) {
return empfehlung.getString().trim();
}
return "";
}).collect(Collectors.joining("\n\n"));
if (!result.isBlank()) {
return Optional.of(result);
if (
null != fragestellung && !fragestellung.getString().isBlank()
&& null != empfehlung && !empfehlung.getString().isBlank()
) {
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 Optional.of(fragestellung.getString().trim());
} else if (null != empfehlung && !empfehlung.getString().isBlank()) {
return Optional.of(empfehlung.getString().trim());
}
return Optional.empty();
}
}

3
src/main/java/DNPM/services/mtb/ProcedureToProtocolMapper.java
View File

@ -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>> {}

104
src/test/java/DNPM/services/mtb/DefaultMtbServiceTest.java
View File

@ -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 SettingsService settingsService
@Mock IOnkostarApi onkostarApi
) {
this.onkostarApi = onkostarApi;
this.settingsService = settingsService;
this.service = new DefaultMtbService(settingsService);
this.service = new DefaultMtbService();
}
@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() {
when(settingsService.getSID()).thenReturn(Optional.of("12345"));
when(settingsService.multipleMtbsInMtbEpisode()).thenReturn(true);
void testShouldReturnMtbProtocolForMultipleTK() {
var procedure1 = new Procedure(onkostarApi);
procedure1.setFormName("OS.Tumorkonferenz");
procedure1.setStartDate(Date.from(Instant.parse("2023-01-01T00:00:00Z")));
procedure1.setValue("Fragestellung", new Item("Fragestellung", "Test ok?"));
procedure1.setValue("Empfehlung", new Item("Empfehlung", "Rerun Test if not ok!"));
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");
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() {
when(settingsService.getSID()).thenReturn(Optional.of("20119"));
when(settingsService.multipleMtbsInMtbEpisode()).thenReturn(true);
void testShouldReturnMtbProtocolForMultipleTKVarianteUKW() {
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();
}
}

47
src/test/java/DNPM/services/mtb/MtbServiceTest.java Normal file
View File

@ -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());
}
}