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

Aufteilung der Methode getSystemischeTherapienFromDiagnose() und Prüfung auf DiagnoseId

Browse Source
This commit is contained in:
Paul-Christian Volkmer
2023-03-22 10:18:32 +01:00
parent 0d536f7ed7
commit 3f3a23ccd2
2 changed files with 268 additions and 267 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -15,11 +15,15 @@ import org.hibernate.Session;
import org.hibernate.SessionFactory; import org.hibernate.SessionFactory;
import org.hibernate.transform.Transformers; import org.hibernate.transform.Transformers;
import org.hibernate.type.StandardBasicTypes; import org.hibernate.type.StandardBasicTypes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*; import java.util.*;
public class DNPMHelper implements IProcedureAnalyzer { public class DNPMHelper implements IProcedureAnalyzer {
private static final Logger logger = LoggerFactory.getLogger(DNPMHelper.class);
private final IOnkostarApi onkostarApi; private final IOnkostarApi onkostarApi;
public DNPMHelper(final IOnkostarApi onkostarApi) { public DNPMHelper(final IOnkostarApi onkostarApi) {
@ -132,86 +136,78 @@ public class DNPMHelper implements IProcedureAnalyzer{
return VerbundeneFormulare; return VerbundeneFormulare;
} }
public Object getSystemischeTherapienFromDiagnose(final Map<String, Object> input) { public List<Map<String, String>> getSystemischeTherapienFromDiagnose(final Map<String, Object> input) {
int DiagnoseId = (int) input.get("DiagnoseId"); var diagnoseId = input.get("DiagnoseId");
String jsonStr = ""; if (null == diagnoseId || Integer.parseInt(diagnoseId.toString()) == 0) {
List<Object> Rueckgabewerte = new ArrayList<Object>(); logger.error("Kein Parameter 'DiagnoseId' angegeben, gebe 'null' zurück");
List<Procedure> Prozeduren = onkostarApi.getProceduresForDiseaseByForm(DiagnoseId, "OS.Systemische Therapie"); return null;
// für jede Prozedur }
for (Procedure Prozedur : Prozeduren) {
String Beginn = new String();
String Ende = new String();
String Wirkstoffe = new String();
String Beendigung = new String();
String Ergebnis = new String();
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 // SubstanzenCodesListe enthält die Liste der SubstanzenCodes
List<Map<String, String>> SubstanzenCodesListe = new ArrayList<Map<String, String>>(); List<Map<String, String>> substanzenCodesListe = new ArrayList<>();
// alle Werte der Prozedur auslesen // alle Werte der Prozedur auslesen
Map<String, Item> alleWerte = Prozedur.getAllValues(); Map<String, Item> alleWerte = Prozedur.getAllValues();
// Prozedurwerte enthält nur die interessanten Werte // Prozedurwerte enthält nur die interessanten Werte
Map<String, Object> Prozedurwerte = new HashMap<>(); Map<String, String> prozedurwerte = new HashMap<>();
// alle Werte durchgehen und die interessanten übernehmen // alle Werte durchgehen und die interessanten übernehmen
for (Map.Entry<String, Item> WerteListe : alleWerte.entrySet()) { if (alleWerte.containsKey("Beendigung")) {
// Datum des Hauptformulars merken prozedurwerte.put("Beendigung", alleWerte.get("Beendigung").getValue());
if (WerteListe.getKey().equals("Beendigung")) {
Beendigung = WerteListe.getValue().getValue();
} }
if (WerteListe.getKey().equals("Ergebnis")) { if (alleWerte.containsKey("Ergebnis")) {
Ergebnis = WerteListe.getValue().getValue(); prozedurwerte.put("Ergebnis", alleWerte.get("Ergebnis").getValue());
} }
if (WerteListe.getKey().equals("Beginn")) { if (alleWerte.containsKey("Beginn")) {
Beginn = WerteListe.getValue().getString();// + "," + WerteListe.getValue().getDateAccuracy(); prozedurwerte.put("Beginn", alleWerte.get("Beginn").getString());
} }
if (WerteListe.getKey().equals("Ende")) { if (alleWerte.containsKey("Ende")) {
Ende = WerteListe.getValue().getString();// + "," + WerteListe.getValue().getDateAccuracy(); 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"));
} }
// im Subformular (SubstanzenList) Substanzen auslesen
if (WerteListe.getKey().equals("SubstanzenList")) {
int Index = -1;
// SubstanzenCodesListe enthält die Liste der SubstanzenCodes eines Subformulars
ArrayList<Map<String, Map<String, String>>> Subformular = new ArrayList<>();
Subformular = WerteListe.getValue().getValue();
// Werte aus Subformular verarbeiten
for (Map<String, Map<String, String>> SubformularWerte: Subformular) {
// SubstanzenCodes enthält den Code und den Namen einer Substanz
Map<String, String> SubstanzenCodes = new HashMap<String, String>();
// Index des Codes (Substanz)
Index = Arrays.asList((SubformularWerte.keySet().toArray())).indexOf("Substanz");
if (AtcCode.isAtcCode(SubformularWerte.values().toArray()[Index].toString())) {
SubstanzenCodes.put("system", "ATC");
} else {
SubstanzenCodes.put("system", "other");
} }
SubstanzenCodes.put("code", (String) SubformularWerte.values().toArray()[Index]); prozedurwerte.put("Wirkstoffe", String.join(", ", wirkstoffListe));
// Index der Substanz (Substanz_shortDescription)
Index = Arrays.asList((SubformularWerte.keySet().toArray())).indexOf("Substanz_shortDescription");
SubstanzenCodes.put("substance", (String) SubformularWerte.values().toArray()[Index]);
SubstanzenCodesListe.add(SubstanzenCodes);
Wirkstoffe = Wirkstoffe + (String) SubformularWerte.values().toArray()[Index] + ", ";
}
}
}
ObjectMapper Obj = new ObjectMapper();
try { try {
jsonStr = Obj.writeValueAsString(SubstanzenCodesListe); ObjectMapper mapper = new ObjectMapper();
prozedurwerte.put("WirkstoffCodes", mapper.writeValueAsString(substanzenCodesListe));
} catch (JsonProcessingException e) { } catch (JsonProcessingException e) {
// TODO Auto-generated catch block logger.error("Kann 'WirkstoffCodes' nicht in JSON-String mappen", e);
e.printStackTrace();
} }
Prozedurwerte.put("Beginn", Beginn);
Prozedurwerte.put("Ende", Ende); return prozedurwerte;
Prozedurwerte.put("Beendigung", Beendigung);
Prozedurwerte.put("Ergebnis", Ergebnis);
Prozedurwerte.put("Wirkstoffe", Wirkstoffe.substring(0, Wirkstoffe.length()-2));
Prozedurwerte.put("WirkstoffCodes", jsonStr);
Rueckgabewerte.add(Prozedurwerte);
} }
return Rueckgabewerte;
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;
} }
public Object getProzedurenFromDiagnose(final Map<String, Object> input) { public Object getProzedurenFromDiagnose(final Map<String, Object> input) {

25
src/test/java/DNPM/DNPMHelperTest.java
View File

@ -12,6 +12,7 @@ import org.mockito.junit.jupiter.MockitoExtension;
import java.sql.Date; import java.sql.Date;
import java.time.Instant; import java.time.Instant;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -64,22 +65,19 @@ public class DNPMHelperTest {
assertThat(actual).isNotNull(); assertThat(actual).isNotNull();
assertThat(actual).isExactlyInstanceOf(ArrayList.class); assertThat(actual).isExactlyInstanceOf(ArrayList.class);
assertThat(actual).hasSize(1);
@SuppressWarnings("unchecked") assertThat(actual.get(0).get("Beginn"))
var actualList = (ArrayList<Map<String, Object>>) actual;
assertThat(actualList).hasSize(1);
assertThat(actualList.get(0).get("Beginn"))
.isEqualTo(Date.from(Instant.parse("2023-01-01T00:00:00Z")).toString()); .isEqualTo(Date.from(Instant.parse("2023-01-01T00:00:00Z")).toString());
assertThat(actualList.get(0).get("Ende")) assertThat(actual.get(0).get("Ende"))
.isEqualTo(Date.from(Instant.parse("2023-01-31T00:00:00Z")).toString()); .isEqualTo(Date.from(Instant.parse("2023-01-31T00:00:00Z")).toString());
assertThat(actualList.get(0).get("Beendigung")) assertThat(actual.get(0).get("Beendigung"))
.isEqualTo("E"); .isEqualTo("E");
assertThat(actualList.get(0).get("Ergebnis")) assertThat(actual.get(0).get("Ergebnis"))
.isEqualTo("T"); .isEqualTo("T");
assertThat(actualList.get(0).get("Wirkstoffe")) assertThat(actual.get(0).get("Wirkstoffe"))
.isEqualTo("Testsubstanz, cyclophosphamide"); .isEqualTo("Testsubstanz, cyclophosphamide");
assertThat(actualList.get(0).get("WirkstoffCodes")) assertThat(actual.get(0).get("WirkstoffCodes"))
.isEqualTo( .isEqualTo(
"[" + "[" +
"{\"system\":\"other\",\"code\":\"Testsubstanz\",\"substance\":\"Testsubstanz\"}," + "{\"system\":\"other\",\"code\":\"Testsubstanz\",\"substance\":\"Testsubstanz\"}," +
@ -88,4 +86,11 @@ public class DNPMHelperTest {
); );
} }
@Test
void testShouldReturnNullIfNoDiagnoseId() {
var actual = dnpmHelper.getSystemischeTherapienFromDiagnose(new HashMap<>());
assertThat(actual).isNull();
}
} }