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

Extraktion des Mappings Prozedur zu Prozedurwerten und Auswahl des Mappers

Browse Source 
Aktuell sind nur die beiden Formulare

* OS.Systemische Therapie
* OS.Systemische Therapie.VarianteUKW

bekannt. Beide lassen sich über den extrahierten Mapper in eine Map mit
Prozedurwerten mappen.
This commit is contained in:
Paul-Christian Volkmer
2023-03-22 12:04:10 +01:00
parent 3f3a23ccd2
commit a80295c4c8
10 changed files with 413 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
src/main/java/DNPM/DNPMHelper.java
View File

@ -1,6 +1,6 @@
package DNPM;
import ATCCodes.AtcCode;
import DNPM.services.systemtherapie.SystemtherapieService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import de.itc.onkostar.api.Disease;
@ -18,7 +18,10 @@ import org.hibernate.type.StandardBasicTypes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class DNPMHelper implements IProcedureAnalyzer {
@ -26,8 +29,11 @@ public class DNPMHelper implements IProcedureAnalyzer {
private final IOnkostarApi onkostarApi;
public DNPMHelper(final IOnkostarApi onkostarApi) {
private final SystemtherapieService systemtherapieService;
public DNPMHelper(final IOnkostarApi onkostarApi, final SystemtherapieService systemtherapieService) {
this.onkostarApi = onkostarApi;
this.systemtherapieService = systemtherapieService;
}
@Override
@ -144,70 +150,7 @@ public class DNPMHelper implements IProcedureAnalyzer {
return null;
}
List<Map<String, String>> result = new ArrayList<>();
for (Procedure Prozedur : onkostarApi.getProceduresForDiseaseByForm(Integer.parseInt(diagnoseId.toString()), "OS.Systemische Therapie")) {
result.add(getProzedurwerte(Prozedur));
}
return result;
}
private static Map<String, String> getProzedurwerte(Procedure Prozedur) {
List<String> wirkstoffListe = new ArrayList<>();
// SubstanzenCodesListe enthält die Liste der SubstanzenCodes
List<Map<String, String>> substanzenCodesListe = new ArrayList<>();
// alle Werte der Prozedur auslesen
Map<String, Item> alleWerte = Prozedur.getAllValues();
// Prozedurwerte enthält nur die interessanten Werte
Map<String, String> prozedurwerte = new HashMap<>();
// alle Werte durchgehen und die interessanten übernehmen
if (alleWerte.containsKey("Beendigung")) {
prozedurwerte.put("Beendigung", alleWerte.get("Beendigung").getValue());
}
if (alleWerte.containsKey("Ergebnis")) {
prozedurwerte.put("Ergebnis", alleWerte.get("Ergebnis").getValue());
}
if (alleWerte.containsKey("Beginn")) {
prozedurwerte.put("Beginn", alleWerte.get("Beginn").getString());
}
if (alleWerte.containsKey("Ende")) {
prozedurwerte.put("Ende", alleWerte.get("Ende").getString());
}
if (alleWerte.containsKey("SubstanzenList")) {
List<Map<String, String>> substanzList = alleWerte.get("SubstanzenList").getValue();
for (var substanz : substanzList) {
var substanzCodes = getSubstanzCode(substanz);
substanzenCodesListe.add(substanzCodes);
wirkstoffListe.add(substanzCodes.get("substance"));
}
}
prozedurwerte.put("Wirkstoffe", String.join(", ", wirkstoffListe));
try {
ObjectMapper mapper = new ObjectMapper();
prozedurwerte.put("WirkstoffCodes", mapper.writeValueAsString(substanzenCodesListe));
} catch (JsonProcessingException e) {
logger.error("Kann 'WirkstoffCodes' nicht in JSON-String mappen", e);
}
return prozedurwerte;
}
private static Map<String, String> getSubstanzCode(Map<String, String> substanz) {
Map<String, String> substanzCode = new HashMap<>();
if (substanz.containsKey("Substanz")) {
if (AtcCode.isAtcCode(substanz.get("Substanz"))) {
substanzCode.put("system", "ATC");
} else {
substanzCode.put("system", "other");
}
substanzCode.put("code", substanz.get("Substanz"));
}
if (substanz.containsKey("Substanz_shortDescription")) {
substanzCode.put("substance", substanz.get("Substanz_shortDescription"));
}
return substanzCode;
return systemtherapieService.getSystemischeTherapienFromDiagnose(Integer.parseInt(diagnoseId.toString()));
}
public Object getProzedurenFromDiagnose(final Map<String, Object> input) {

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

@ -4,6 +4,8 @@ import DNPM.database.SettingsRepository;
import DNPM.services.*;
import DNPM.services.mtb.DefaultMtbService;
import DNPM.services.mtb.MtbService;
import DNPM.services.systemtherapie.DefaultSystemtherapieService;
import DNPM.services.systemtherapie.SystemtherapieService;
import de.itc.onkostar.api.IOnkostarApi;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
@ -42,6 +44,14 @@ public class PluginConfiguration {
return new DefaultMtbService(onkostarApi);
}
@Bean
public SystemtherapieService systemtherapieService(
final IOnkostarApi onkostarApi,
final SettingsService settingsService
) {
return new DefaultSystemtherapieService(onkostarApi, settingsService);
}
@Bean
public TherapieplanServiceFactory therapieplanServiceFactory(
final IOnkostarApi onkostarApi,

73
src/main/java/DNPM/services/systemtherapie/DefaultSystemtherapieService.java Normal file
View File

@ -0,0 +1,73 @@
package DNPM.services.systemtherapie;
import DNPM.services.SettingsService;
import de.itc.onkostar.api.IOnkostarApi;
import de.itc.onkostar.api.Procedure;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* Standardimplementierung des Systemtherapieservices
*
* @since 0.2.0
*/
public class DefaultSystemtherapieService implements SystemtherapieService {
private static final Logger logger = LoggerFactory.getLogger(DefaultSystemtherapieService.class);
private final IOnkostarApi onkostarApi;
private final SettingsService settingsService;
public DefaultSystemtherapieService(final IOnkostarApi onkostarApi, final SettingsService settingsService) {
this.onkostarApi = onkostarApi;
this.settingsService = settingsService;
}
/**
* Ermittelt eine Zusammenfassung der systemischen Therapien für eine Erkrankung
*
* @param diseaseId Die ID der Erkrankung
* @return Zusammenfassung der systemischen Therapien
*/
@Override
public List<Map<String, String>> getSystemischeTherapienFromDiagnose(int diseaseId) {
var sid = this.settingsService.getSID();
if (sid.isEmpty()) {
logger.error("Kann SID nicht ermitteln um Formularnamen zu erhalten. Gebe 'null' zurück.");
return null;
}
List<Map<String, String>> result = new ArrayList<>();
for (Procedure prozedur : onkostarApi.getProceduresForDiseaseByForm(diseaseId, selectFormNameBySID(sid.get()))) {
prozedurToProzedurwerteMapper(prozedur).apply(prozedur).ifPresent(result::add);
}
return result;
}
/**
* Übergibt aktuell immer den Mapper für das Formular "OS.Systemische Therapie",
* da beide bekannte Varianten damit gemappt werden können.
*
* @param procedure Die Prozedur für die ein Mapper erstellt werden soll
* @return Der Mapper für die Prozedur
*/
@Override
public ProzedurToProzedurwerteMapper prozedurToProzedurwerteMapper(Procedure procedure) {
return new OsSystemischeTherapieToProzedurwerteMapper();
}
@Override
public String selectFormNameBySID(String sid) {
switch (sid) {
case "2011":
case "20119":
return "OS.Systemische Therapie.VarianteUKW";
default:
return "OS.Systemische Therapie";
}
}
}

90
src/main/java/DNPM/services/systemtherapie/OsSystemischeTherapieToProzedurwerteMapper.java Normal file
View File

@ -0,0 +1,90 @@
package DNPM.services.systemtherapie;
import ATCCodes.AtcCode;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import de.itc.onkostar.api.Item;
import de.itc.onkostar.api.Procedure;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
/**
* Implementierung zum Mappen des Formulars "OS.Systemische Therapie" auf die Prozedurwerte
*
* @since 0.2.0
*/
public class OsSystemischeTherapieToProzedurwerteMapper implements ProzedurToProzedurwerteMapper {
private static final Logger logger = LoggerFactory.getLogger(OsSystemischeTherapieToProzedurwerteMapper.class);
@Override
public Optional<Map<String, String>> apply(Procedure procedure) {
try {
return Optional.of(getProzedurwerte(procedure));
} catch (Exception e) {
logger.error("Fehler beim Mappen der Prozedur auf Prozedurwerte", e);
return Optional.empty();
}
}
private static Map<String, String> getProzedurwerte(Procedure Prozedur) {
List<String> wirkstoffListe = new ArrayList<>();
// SubstanzenCodesListe enthält die Liste der SubstanzenCodes
List<Map<String, String>> substanzenCodesListe = new ArrayList<>();
// alle Werte der Prozedur auslesen
Map<String, Item> alleWerte = Prozedur.getAllValues();
// Prozedurwerte enthält nur die interessanten Werte
Map<String, String> prozedurwerte = new HashMap<>();
// alle Werte durchgehen und die interessanten übernehmen
if (alleWerte.containsKey("Beendigung")) {
prozedurwerte.put("Beendigung", alleWerte.get("Beendigung").getValue());
}
if (alleWerte.containsKey("Ergebnis")) {
prozedurwerte.put("Ergebnis", alleWerte.get("Ergebnis").getValue());
}
if (alleWerte.containsKey("Beginn")) {
prozedurwerte.put("Beginn", alleWerte.get("Beginn").getString());
}
if (alleWerte.containsKey("Ende")) {
prozedurwerte.put("Ende", alleWerte.get("Ende").getString());
}
if (alleWerte.containsKey("SubstanzenList")) {
List<Map<String, String>> substanzList = alleWerte.get("SubstanzenList").getValue();
for (var substanz : substanzList) {
var substanzCodes = getSubstanzCode(substanz);
substanzenCodesListe.add(substanzCodes);
wirkstoffListe.add(substanzCodes.get("substance"));
}
}
prozedurwerte.put("Wirkstoffe", String.join(", ", wirkstoffListe));
try {
ObjectMapper mapper = new ObjectMapper();
prozedurwerte.put("WirkstoffCodes", mapper.writeValueAsString(substanzenCodesListe));
} catch (JsonProcessingException e) {
logger.error("Kann 'WirkstoffCodes' nicht in JSON-String mappen", e);
}
return prozedurwerte;
}
private static Map<String, String> getSubstanzCode(Map<String, String> substanz) {
Map<String, String> substanzCode = new HashMap<>();
if (substanz.containsKey("Substanz")) {
if (AtcCode.isAtcCode(substanz.get("Substanz"))) {
substanzCode.put("system", "ATC");
} else {
substanzCode.put("system", "other");
}
substanzCode.put("code", substanz.get("Substanz"));
}
if (substanz.containsKey("Substanz_shortDescription")) {
substanzCode.put("substance", substanz.get("Substanz_shortDescription"));
}
return substanzCode;
}
}

14
src/main/java/DNPM/services/systemtherapie/ProzedurToProzedurwerteMapper.java Normal file
View File

@ -0,0 +1,14 @@
package DNPM.services.systemtherapie;
import de.itc.onkostar.api.Procedure;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
/**
* Mapper um ein Systemtherapieformular in eine Optional-Map mit Prozedurwerten umzuwandeln
*
* @since 0.2.0
*/
public interface ProzedurToProzedurwerteMapper extends Function<Procedure, Optional<Map<String, String>>> {}

34
src/main/java/DNPM/services/systemtherapie/SystemtherapieService.java Normal file
View File

@ -0,0 +1,34 @@
package DNPM.services.systemtherapie;
import de.itc.onkostar.api.Procedure;
import java.util.List;
import java.util.Map;
/**
* Service für Systemtherapieformulare
*
* @since 0.2.0
*/
public interface SystemtherapieService {
/**
* Ermittelt eine Zusammenfassung der systemischen Therapien für eine Erkrankung
* @param diseaseId Die ID der Erkrankung
* @return Die Zusammenfassung der systemischen Therapien
*/
List<Map<String, String>> getSystemischeTherapienFromDiagnose(int diseaseId);
/**
* Erstellt den Mapper for die Prozedur
* @param procedure Die Prozedur für die ein Mapper erstellt werden soll
* @return Der erstellte ProzedurToProzedurwerteMapper
*/
ProzedurToProzedurwerteMapper prozedurToProzedurwerteMapper(Procedure procedure);
/**
* Ermittelt den Formularnamen anhand der SID
* @param sid die SID
* @return Den ermittelten Formularnamen
*/
String selectFormNameBySID(String sid);
}