From 3afe109494e2b4a751874a027694c17f6cabc4cd Mon Sep 17 00:00:00 2001 From: Paul-Christian Volkmer Date: Mon, 8 May 2023 16:23:52 +0200 Subject: [PATCH 1/5] Issue #28: Initiale Implementierung zur Ermittlung der NGS-Befund-Varianten --- .../analyzer/EinzelempfehlungAnalyzer.java | 104 ++++++++++++++++++ .../java/DNPM/config/PluginConfiguration.java | 7 ++ src/main/java/DNPM/dto/Variant.java | 67 +++++++++++ .../MolekulargenetikFormService.java | 12 ++ .../OsMolekulargenetikFormService.java | 34 ++++++ 5 files changed, 224 insertions(+) create mode 100644 src/main/java/DNPM/analyzer/EinzelempfehlungAnalyzer.java create mode 100644 src/main/java/DNPM/dto/Variant.java create mode 100644 src/main/java/DNPM/services/molekulargenetik/MolekulargenetikFormService.java create mode 100644 src/main/java/DNPM/services/molekulargenetik/OsMolekulargenetikFormService.java diff --git a/src/main/java/DNPM/analyzer/EinzelempfehlungAnalyzer.java b/src/main/java/DNPM/analyzer/EinzelempfehlungAnalyzer.java new file mode 100644 index 0000000..101f28b --- /dev/null +++ b/src/main/java/DNPM/analyzer/EinzelempfehlungAnalyzer.java @@ -0,0 +1,104 @@ +package DNPM.analyzer; + +import DNPM.dto.Variant; +import DNPM.security.DelegatingDataBasedPermissionEvaluator; +import DNPM.services.molekulargenetik.MolekulargenetikFormService; +import de.itc.onkostar.api.Disease; +import de.itc.onkostar.api.IOnkostarApi; +import de.itc.onkostar.api.Procedure; +import de.itc.onkostar.api.analysis.AnalyzerRequirement; +import de.itc.onkostar.api.analysis.IProcedureAnalyzer; +import de.itc.onkostar.api.analysis.OnkostarPluginType; +import org.springframework.stereotype.Component; + +import java.util.List; +import java.util.Map; + +/** + * Diese Klasse implementiert ein Plugin, welches Funktionen für DNPM UF Einzelempfehlung bereit stellt. + * + * @since 0.2.0 + */ +@Component +public class EinzelempfehlungAnalyzer implements IProcedureAnalyzer { + + private final IOnkostarApi onkostarApi; + + private final MolekulargenetikFormService molekulargenetikFormService; + + private final DelegatingDataBasedPermissionEvaluator permissionEvaluator; + + public EinzelempfehlungAnalyzer( + final IOnkostarApi onkostarApi, + final MolekulargenetikFormService molekulargenetikFormService, + final DelegatingDataBasedPermissionEvaluator permissionEvaluator + ) { + this.onkostarApi = onkostarApi; + this.molekulargenetikFormService = molekulargenetikFormService; + this.permissionEvaluator = permissionEvaluator; + } + + @Override + public OnkostarPluginType getType() { + return OnkostarPluginType.BACKEND_SERVICE; + } + + @Override + public String getVersion() { + return "0.1.0"; + } + + @Override + public String getName() { + return "DNPM Einzelempfehlung Backend Service"; + } + + @Override + public String getDescription() { + return "Stellt Funktionen zur Nutzung im Therapieplan-Unterformular für Einzelempfehlungen bereit"; + } + + /** + * @deprecated + */ + @Override + public boolean isRelevantForDeletedProcedure() { + return false; + } + + @Override + public boolean isRelevantForAnalyzer(Procedure procedure, Disease disease) { + return false; + } + + @Override + public boolean isSynchronous() { + return false; + } + + @Override + public AnalyzerRequirement getRequirement() { + return AnalyzerRequirement.PROCEDURE; + } + + @Override + public void analyze(Procedure procedure, Disease disease) { + // No op + } + + public List getVariants(Map input) { + var procedureId = AnalyzerUtils.getRequiredId(input, "id"); + + if (procedureId.isEmpty()) { + return List.of(); + } + + var procedure = onkostarApi.getProcedure(procedureId.get()); + if (null == procedure) { + return List.of(); + } + + return molekulargenetikFormService.getVariants(procedure); + } + +} diff --git a/src/main/java/DNPM/config/PluginConfiguration.java b/src/main/java/DNPM/config/PluginConfiguration.java index 28abbda..e520a45 100644 --- a/src/main/java/DNPM/config/PluginConfiguration.java +++ b/src/main/java/DNPM/config/PluginConfiguration.java @@ -3,6 +3,8 @@ package DNPM.config; import DNPM.database.SettingsRepository; import DNPM.services.*; import DNPM.services.consent.ConsentManagerServiceFactory; +import DNPM.services.molekulargenetik.MolekulargenetikFormService; +import DNPM.services.molekulargenetik.OsMolekulargenetikFormService; import DNPM.services.mtb.DefaultMtbService; import DNPM.services.mtb.MtbService; import DNPM.services.systemtherapie.DefaultSystemtherapieService; @@ -68,4 +70,9 @@ public class PluginConfiguration { return new TherapieplanServiceFactory(onkostarApi, settingsService, formService); } + @Bean + public MolekulargenetikFormService molekulargenetikFormService() { + return new OsMolekulargenetikFormService(); + } + } diff --git a/src/main/java/DNPM/dto/Variant.java b/src/main/java/DNPM/dto/Variant.java new file mode 100644 index 0000000..36788f2 --- /dev/null +++ b/src/main/java/DNPM/dto/Variant.java @@ -0,0 +1,67 @@ +package DNPM.dto; + +import de.itc.onkostar.api.Procedure; + +import java.util.Optional; + +public class Variant { + private final Integer id; + + private final String shortDescription; + + private Variant( + final int id, + final String shortDescription + ) { + this.id = id; + this.shortDescription = shortDescription.trim(); + } + + public Integer getId() { + return id; + } + + public String getShortDescription() { + return shortDescription; + } + + public static Optional fromProcedure(Procedure procedure) { + if (! "OS.Molekulargenetische Untersuchung".equals(procedure.getFormName())) { + return Optional.empty(); + } + + var ergebnis = procedure.getValue("Ergebnis"); + var gene = procedure.getValue("Untersucht"); + var exon = procedure.getValue("ExonInt"); + var pathogenitaetsklasse = procedure.getValue("Pathogenitaetsklasse"); + + if (null == gene) { + return Optional.empty(); + } + + if (ergebnis.getString().equals("P")) { + return Optional.of( + new Variant( + procedure.getId(), + String.format("Einfache Variante: %s, %s, %s", gene.getString(), exon.getString(), pathogenitaetsklasse.getString()) + ) + ); + } else if (ergebnis.getString().equals("CNV")) { + return Optional.of( + new Variant( + procedure.getId(), + String.format("Copy Number Variation: %s, %s, %s", gene.getString(), exon.getString(), pathogenitaetsklasse.getString()) + ) + ); + } else if (ergebnis.getString().equals("F")) { + return Optional.of( + new Variant( + procedure.getId(), + String.format("Fusion: %s, %s, %s", gene.getString(), exon.getString(), pathogenitaetsklasse.getString()) + ) + ); + } else { + return Optional.empty(); + } + } +} diff --git a/src/main/java/DNPM/services/molekulargenetik/MolekulargenetikFormService.java b/src/main/java/DNPM/services/molekulargenetik/MolekulargenetikFormService.java new file mode 100644 index 0000000..5af03b2 --- /dev/null +++ b/src/main/java/DNPM/services/molekulargenetik/MolekulargenetikFormService.java @@ -0,0 +1,12 @@ +package DNPM.services.molekulargenetik; + +import DNPM.dto.Variant; +import de.itc.onkostar.api.Procedure; + +import java.util.List; + +public interface MolekulargenetikFormService { + + List getVariants(Procedure procedure); + +} diff --git a/src/main/java/DNPM/services/molekulargenetik/OsMolekulargenetikFormService.java b/src/main/java/DNPM/services/molekulargenetik/OsMolekulargenetikFormService.java new file mode 100644 index 0000000..03017ad --- /dev/null +++ b/src/main/java/DNPM/services/molekulargenetik/OsMolekulargenetikFormService.java @@ -0,0 +1,34 @@ +package DNPM.services.molekulargenetik; + +import DNPM.dto.Variant; +import DNPM.security.FormSecured; +import DNPM.security.PersonPoolSecured; +import de.itc.onkostar.api.Procedure; + +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; + +public class OsMolekulargenetikFormService implements MolekulargenetikFormService { + + @Override + @FormSecured + @PersonPoolSecured + public List getVariants(Procedure procedure) { + if (! "OS.Molekulargenetik".equals(procedure.getFormName())) { + return List.of(); + } + + var subforms = procedure.getSubProceduresMap().get("MolekulargenetischeUntersuchung"); + if (null == subforms) { + return List.of(); + } + + return subforms.stream() + .map(Variant::fromProcedure) + .filter(Optional::isPresent) + .map(Optional::get) + .collect(Collectors.toList()); + + } +} From c45dc8f5df1c9ce5c2ed200ec4a4a368db9861ef Mon Sep 17 00:00:00 2001 From: Paul-Christian Volkmer Date: Tue, 9 May 2023 08:50:47 +0200 Subject: [PATCH 2/5] Issue #28: Verwende erforderliche Informationen ohne Zusammenfassung --- src/main/java/DNPM/dto/Variant.java | 49 +++++++++-- src/test/java/DNPM/dto/VariantTest.java | 103 ++++++++++++++++++++++++ 2 files changed, 144 insertions(+), 8 deletions(-) create mode 100644 src/test/java/DNPM/dto/VariantTest.java diff --git a/src/main/java/DNPM/dto/Variant.java b/src/main/java/DNPM/dto/Variant.java index 36788f2..8ebe740 100644 --- a/src/main/java/DNPM/dto/Variant.java +++ b/src/main/java/DNPM/dto/Variant.java @@ -7,22 +7,46 @@ import java.util.Optional; public class Variant { private final Integer id; - private final String shortDescription; + private final String ergebnis; + + private final String gen; + + private final String exon; + + private final String pathogenitaetsklasse; private Variant( final int id, - final String shortDescription + final String ergebnis, + final String gen, + final String exon, + final String pathogenitaetsklasse ) { this.id = id; - this.shortDescription = shortDescription.trim(); + this.ergebnis = ergebnis; + this.gen = gen; + this.exon = exon; + this.pathogenitaetsklasse = pathogenitaetsklasse; } public Integer getId() { return id; } - public String getShortDescription() { - return shortDescription; + public String getErgebnis() { + return ergebnis; + } + + public String getGen() { + return gen; + } + + public String getExon() { + return exon; + } + + public String getPathogenitaetsklasse() { + return pathogenitaetsklasse; } public static Optional fromProcedure(Procedure procedure) { @@ -43,21 +67,30 @@ public class Variant { return Optional.of( new Variant( procedure.getId(), - String.format("Einfache Variante: %s, %s, %s", gene.getString(), exon.getString(), pathogenitaetsklasse.getString()) + "Einfache Variante", + gene.getString(), + exon.getString(), + pathogenitaetsklasse.getString() ) ); } else if (ergebnis.getString().equals("CNV")) { return Optional.of( new Variant( procedure.getId(), - String.format("Copy Number Variation: %s, %s, %s", gene.getString(), exon.getString(), pathogenitaetsklasse.getString()) + "Copy Number Variation", + gene.getString(), + exon.getString(), + pathogenitaetsklasse.getString() ) ); } else if (ergebnis.getString().equals("F")) { return Optional.of( new Variant( procedure.getId(), - String.format("Fusion: %s, %s, %s", gene.getString(), exon.getString(), pathogenitaetsklasse.getString()) + "Fusion", + gene.getString(), + exon.getString(), + pathogenitaetsklasse.getString() ) ); } else { diff --git a/src/test/java/DNPM/dto/VariantTest.java b/src/test/java/DNPM/dto/VariantTest.java new file mode 100644 index 0000000..4a29ba1 --- /dev/null +++ b/src/test/java/DNPM/dto/VariantTest.java @@ -0,0 +1,103 @@ +package DNPM.dto; + +import de.itc.onkostar.api.Item; +import de.itc.onkostar.api.Procedure; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class VariantTest { + + @Test + void testShouldMapVariantFromProcedureForSimpleVariant() { + var procedure = new Procedure(null); + procedure.setId(12345); + procedure.setFormName("OS.Molekulargenetische Untersuchung"); + + procedure.setValue("Ergebnis", new Item("Ergebnis", "P")); + procedure.setValue("Untersucht", new Item("Untersucht", "BRAF")); + procedure.setValue("ExonInt", new Item("ExonInt", 123)); + procedure.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); + + var actual = Variant.fromProcedure(procedure); + + assertThat(actual).isPresent(); + assertThat(actual.get().getId()).isEqualTo(12345); + assertThat(actual.get().getErgebnis()).isEqualTo("Einfache Variante"); + assertThat(actual.get().getGen()).isEqualTo("BRAF"); + assertThat(actual.get().getExon()).isEqualTo("123"); + assertThat(actual.get().getPathogenitaetsklasse()).isEqualTo("2"); + } + + @Test + void testShouldMapVariantFromProcedureForCopyNumberVariation() { + var procedure = new Procedure(null); + procedure.setId(12345); + procedure.setFormName("OS.Molekulargenetische Untersuchung"); + + procedure.setValue("Ergebnis", new Item("Ergebnis", "CNV")); + procedure.setValue("Untersucht", new Item("Untersucht", "BRAF")); + procedure.setValue("ExonInt", new Item("ExonInt", 123)); + procedure.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); + + var actual = Variant.fromProcedure(procedure); + + assertThat(actual).isPresent(); + assertThat(actual.get().getId()).isEqualTo(12345); + assertThat(actual.get().getErgebnis()).isEqualTo("Copy Number Variation"); + assertThat(actual.get().getGen()).isEqualTo("BRAF"); + assertThat(actual.get().getExon()).isEqualTo("123"); + assertThat(actual.get().getPathogenitaetsklasse()).isEqualTo("2"); + } + + @Test + void testShouldMapVariantFromProcedureForFusion() { + var procedure = new Procedure(null); + procedure.setId(12345); + procedure.setFormName("OS.Molekulargenetische Untersuchung"); + + procedure.setValue("Ergebnis", new Item("Ergebnis", "F")); + procedure.setValue("Untersucht", new Item("Untersucht", "BRAF")); + procedure.setValue("ExonInt", new Item("ExonInt", 123)); + procedure.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); + + var actual = Variant.fromProcedure(procedure); + + assertThat(actual).isPresent(); + assertThat(actual.get().getId()).isEqualTo(12345); + assertThat(actual.get().getErgebnis()).isEqualTo("Fusion"); + assertThat(actual.get().getGen()).isEqualTo("BRAF"); + assertThat(actual.get().getExon()).isEqualTo("123"); + assertThat(actual.get().getPathogenitaetsklasse()).isEqualTo("2"); + } + + @Test + void testShouldNotMapVariantFromProcedureForUnknownVariant() { + var procedure = new Procedure(null); + procedure.setId(12345); + procedure.setFormName("OS.Molekulargenetische Untersuchung"); + + procedure.setValue("Ergebnis", new Item("Ergebnis", "X")); + procedure.setValue("Untersucht", new Item("Untersucht", "BRAF")); + procedure.setValue("ExonInt", new Item("ExonInt", 123)); + procedure.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); + + var actual = Variant.fromProcedure(procedure); + + assertThat(actual).isEmpty(); + } + + @Test + void testShouldNotMapVariantFromUnknownProcedureForm() { + var procedure = new Procedure(null); + procedure.setId(12345); + procedure.setFormName("ABC.Irgendwas"); + + procedure.setValue("Testfeld", new Item("Testfeld", "T")); + + var actual = Variant.fromProcedure(procedure); + + assertThat(actual).isEmpty(); + } + +} From de50c50eb44042e85d68270526756f50711b9974 Mon Sep 17 00:00:00 2001 From: Paul-Christian Volkmer Date: Tue, 9 May 2023 09:20:27 +0200 Subject: [PATCH 3/5] =?UTF-8?q?Issue=20#28:=20Tests=20zur=20Ermittlung=20v?= =?UTF-8?q?on=20Varianten=20aus=20"OS.Molekulargenetik"=20hinzugef=C3=BCgt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../EinzelempfehlungAnalyzerTest.java | 46 +++++++++++++++++ .../OsMolekluargenetikFormServiceTest.java | 49 +++++++++++++++++++ 2 files changed, 95 insertions(+) create mode 100644 src/test/java/DNPM/analyzer/EinzelempfehlungAnalyzerTest.java create mode 100644 src/test/java/DNPM/services/molekulargenetik/OsMolekluargenetikFormServiceTest.java diff --git a/src/test/java/DNPM/analyzer/EinzelempfehlungAnalyzerTest.java b/src/test/java/DNPM/analyzer/EinzelempfehlungAnalyzerTest.java new file mode 100644 index 0000000..337ffdb --- /dev/null +++ b/src/test/java/DNPM/analyzer/EinzelempfehlungAnalyzerTest.java @@ -0,0 +1,46 @@ +package DNPM.analyzer; + +import DNPM.security.DelegatingDataBasedPermissionEvaluator; +import DNPM.services.molekulargenetik.MolekulargenetikFormService; +import de.itc.onkostar.api.IOnkostarApi; +import de.itc.onkostar.api.Procedure; +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.Map; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +class EinzelempfehlungAnalyzerTest { + + private IOnkostarApi onkostarApi; + + private MolekulargenetikFormService molekulargenetikFormService; + + private EinzelempfehlungAnalyzer analyzer; + + @BeforeEach + void setup( + @Mock IOnkostarApi onkostarApi, + @Mock MolekulargenetikFormService molekulargenetikFormService, + @Mock DelegatingDataBasedPermissionEvaluator permissionEvaluator + ) { + this.onkostarApi = onkostarApi; + this.molekulargenetikFormService = molekulargenetikFormService; + this.analyzer = new EinzelempfehlungAnalyzer(onkostarApi, molekulargenetikFormService, permissionEvaluator); + } + + @Test + void testShouldRequestVariantsFromMolekulargenetikFormService() { + doAnswer(invocationOnMock -> new Procedure(this.onkostarApi)).when(onkostarApi).getProcedure(anyInt()); + + analyzer.getVariants(Map.of("id", 123)); + verify(molekulargenetikFormService, times(1)).getVariants(any(Procedure.class)); + } + +} diff --git a/src/test/java/DNPM/services/molekulargenetik/OsMolekluargenetikFormServiceTest.java b/src/test/java/DNPM/services/molekulargenetik/OsMolekluargenetikFormServiceTest.java new file mode 100644 index 0000000..4e11341 --- /dev/null +++ b/src/test/java/DNPM/services/molekulargenetik/OsMolekluargenetikFormServiceTest.java @@ -0,0 +1,49 @@ +package DNPM.services.molekulargenetik; + +import de.itc.onkostar.api.Item; +import de.itc.onkostar.api.Procedure; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class OsMolekluargenetikFormServiceTest { + + private OsMolekulargenetikFormService service; + + @BeforeEach + void setup() { + this.service = new OsMolekulargenetikFormService(); + } + + @Test + void testShouldReturnVariants() { + + var procedure = new Procedure(null); + procedure.setId(123); + procedure.setFormName("OS.Molekulargenetik"); + + var subProcedure1 = new Procedure(null); + subProcedure1.setId(1123); + subProcedure1.setFormName("OS.Molekulargenetische Untersuchung"); + subProcedure1.setValue("Ergebnis", new Item("Ergebnis", "P")); + subProcedure1.setValue("Untersucht", new Item("Untersucht", "BRAF")); + subProcedure1.setValue("ExonInt", new Item("ExonInt", 123)); + subProcedure1.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); + procedure.addSubProcedure("MolekulargenetischeUntersuchung", subProcedure1); + + var subProcedure2 = new Procedure(null); + subProcedure2.setId(2123); + subProcedure2.setFormName("OS.Molekulargenetische Untersuchung"); + subProcedure2.setValue("Ergebnis", new Item("Ergebnis", "CNV")); + subProcedure2.setValue("Untersucht", new Item("Untersucht", "BRAF")); + subProcedure2.setValue("ExonInt", new Item("ExonInt", 123)); + subProcedure2.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); + procedure.addSubProcedure("MolekulargenetischeUntersuchung", subProcedure2); + + var actual = service.getVariants(procedure); + + assertThat(actual).hasSize(2); + } + +} From b4c836f7ed87c84a5194900139717db2502d4f7f Mon Sep 17 00:00:00 2001 From: Paul-Christian Volkmer Date: Tue, 9 May 2023 14:06:57 +0200 Subject: [PATCH 4/5] Issue #28: Fange Zugriffsfehler bei fehlender Berechtigung --- .../java/DNPM/analyzer/EinzelempfehlungAnalyzer.java | 12 +++++++++++- .../OsMolekulargenetikFormService.java | 2 -- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/src/main/java/DNPM/analyzer/EinzelempfehlungAnalyzer.java b/src/main/java/DNPM/analyzer/EinzelempfehlungAnalyzer.java index 101f28b..efcc0a7 100644 --- a/src/main/java/DNPM/analyzer/EinzelempfehlungAnalyzer.java +++ b/src/main/java/DNPM/analyzer/EinzelempfehlungAnalyzer.java @@ -2,6 +2,7 @@ package DNPM.analyzer; import DNPM.dto.Variant; import DNPM.security.DelegatingDataBasedPermissionEvaluator; +import DNPM.security.IllegalSecuredObjectAccessException; import DNPM.services.molekulargenetik.MolekulargenetikFormService; import de.itc.onkostar.api.Disease; import de.itc.onkostar.api.IOnkostarApi; @@ -9,6 +10,8 @@ import de.itc.onkostar.api.Procedure; import de.itc.onkostar.api.analysis.AnalyzerRequirement; import de.itc.onkostar.api.analysis.IProcedureAnalyzer; import de.itc.onkostar.api.analysis.OnkostarPluginType; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import org.springframework.stereotype.Component; import java.util.List; @@ -22,6 +25,8 @@ import java.util.Map; @Component public class EinzelempfehlungAnalyzer implements IProcedureAnalyzer { + private final static Logger logger = LoggerFactory.getLogger(EinzelempfehlungAnalyzer.class); + private final IOnkostarApi onkostarApi; private final MolekulargenetikFormService molekulargenetikFormService; @@ -98,7 +103,12 @@ public class EinzelempfehlungAnalyzer implements IProcedureAnalyzer { return List.of(); } - return molekulargenetikFormService.getVariants(procedure); + try { + return molekulargenetikFormService.getVariants(procedure); + } catch (IllegalSecuredObjectAccessException e) { + logger.error("Security", e); + return List.of(); + } } } diff --git a/src/main/java/DNPM/services/molekulargenetik/OsMolekulargenetikFormService.java b/src/main/java/DNPM/services/molekulargenetik/OsMolekulargenetikFormService.java index 03017ad..8e673d7 100644 --- a/src/main/java/DNPM/services/molekulargenetik/OsMolekulargenetikFormService.java +++ b/src/main/java/DNPM/services/molekulargenetik/OsMolekulargenetikFormService.java @@ -1,7 +1,6 @@ package DNPM.services.molekulargenetik; import DNPM.dto.Variant; -import DNPM.security.FormSecured; import DNPM.security.PersonPoolSecured; import de.itc.onkostar.api.Procedure; @@ -12,7 +11,6 @@ import java.util.stream.Collectors; public class OsMolekulargenetikFormService implements MolekulargenetikFormService { @Override - @FormSecured @PersonPoolSecured public List getVariants(Procedure procedure) { if (! "OS.Molekulargenetik".equals(procedure.getFormName())) { From 2da02d1cf3cbb5d18597e18c2914fc2abe618121 Mon Sep 17 00:00:00 2001 From: Paul-Christian Volkmer Date: Tue, 9 May 2023 14:08:33 +0200 Subject: [PATCH 5/5] =?UTF-8?q?Issue=20#28:=20Erweitere=20Text=20f=C3=BCr?= =?UTF-8?q?=20Ergebnis,=20Exon=20und=20Pathogenit=C3=A4tsklasse?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit closes #28 --- src/main/java/DNPM/dto/Variant.java | 26 ++++++++++++------------- src/test/java/DNPM/dto/VariantTest.java | 6 +++--- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/src/main/java/DNPM/dto/Variant.java b/src/main/java/DNPM/dto/Variant.java index 8ebe740..f8d25c1 100644 --- a/src/main/java/DNPM/dto/Variant.java +++ b/src/main/java/DNPM/dto/Variant.java @@ -50,7 +50,7 @@ public class Variant { } public static Optional fromProcedure(Procedure procedure) { - if (! "OS.Molekulargenetische Untersuchung".equals(procedure.getFormName())) { + if (!"OS.Molekulargenetische Untersuchung".equals(procedure.getFormName())) { return Optional.empty(); } @@ -67,30 +67,30 @@ public class Variant { return Optional.of( new Variant( procedure.getId(), - "Einfache Variante", - gene.getString(), - exon.getString(), - pathogenitaetsklasse.getString() + "Einfache Variante (Mutation)", + gene.getString().isBlank() ? "-" : gene.getString(), + null == exon || exon.getString().isBlank() ? "-" : exon.getString(), + null == pathogenitaetsklasse || pathogenitaetsklasse.getString().isBlank() ? "-" : pathogenitaetsklasse.getString() ) ); } else if (ergebnis.getString().equals("CNV")) { return Optional.of( new Variant( procedure.getId(), - "Copy Number Variation", - gene.getString(), - exon.getString(), - pathogenitaetsklasse.getString() + "Copy Number Variation (CNV)", + gene.getString().isBlank() ? "-" : gene.getString(), + null == exon || exon.getString().isBlank() ? "-" : exon.getString(), + null == pathogenitaetsklasse || pathogenitaetsklasse.getString().isBlank() ? "-" : pathogenitaetsklasse.getString() ) ); } else if (ergebnis.getString().equals("F")) { return Optional.of( new Variant( procedure.getId(), - "Fusion", - gene.getString(), - exon.getString(), - pathogenitaetsklasse.getString() + "Fusion (Translokation Inversion Insertion)", + gene.getString().isBlank() ? "-" : gene.getString(), + null == exon || exon.getString().isBlank() ? "-" : exon.getString(), + null == pathogenitaetsklasse || pathogenitaetsklasse.getString().isBlank() ? "-" : pathogenitaetsklasse.getString() ) ); } else { diff --git a/src/test/java/DNPM/dto/VariantTest.java b/src/test/java/DNPM/dto/VariantTest.java index 4a29ba1..3242852 100644 --- a/src/test/java/DNPM/dto/VariantTest.java +++ b/src/test/java/DNPM/dto/VariantTest.java @@ -23,7 +23,7 @@ public class VariantTest { assertThat(actual).isPresent(); assertThat(actual.get().getId()).isEqualTo(12345); - assertThat(actual.get().getErgebnis()).isEqualTo("Einfache Variante"); + assertThat(actual.get().getErgebnis()).isEqualTo("Einfache Variante (Mutation)"); assertThat(actual.get().getGen()).isEqualTo("BRAF"); assertThat(actual.get().getExon()).isEqualTo("123"); assertThat(actual.get().getPathogenitaetsklasse()).isEqualTo("2"); @@ -44,7 +44,7 @@ public class VariantTest { assertThat(actual).isPresent(); assertThat(actual.get().getId()).isEqualTo(12345); - assertThat(actual.get().getErgebnis()).isEqualTo("Copy Number Variation"); + assertThat(actual.get().getErgebnis()).isEqualTo("Copy Number Variation (CNV)"); assertThat(actual.get().getGen()).isEqualTo("BRAF"); assertThat(actual.get().getExon()).isEqualTo("123"); assertThat(actual.get().getPathogenitaetsklasse()).isEqualTo("2"); @@ -65,7 +65,7 @@ public class VariantTest { assertThat(actual).isPresent(); assertThat(actual.get().getId()).isEqualTo(12345); - assertThat(actual.get().getErgebnis()).isEqualTo("Fusion"); + assertThat(actual.get().getErgebnis()).isEqualTo("Fusion (Translokation Inversion Insertion)"); assertThat(actual.get().getGen()).isEqualTo("BRAF"); assertThat(actual.get().getExon()).isEqualTo("123"); assertThat(actual.get().getPathogenitaetsklasse()).isEqualTo("2");