Merge pull request #30 from CCC-MF/issue_28

Ermitteln stützender molekularer Alterationen zu einem Formular "OS.Molekulargenetik"

src/main/java/DNPM/analyzer/EinzelempfehlungAnalyzer.java

@@ -0,0 +1,114 @@
+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;
+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;
+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 static Logger logger = LoggerFactory.getLogger(EinzelempfehlungAnalyzer.class);
+
+    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<Variant> getVariants(Map<String, Object> 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();
+        }
+
+        try {
+            return molekulargenetikFormService.getVariants(procedure);
+        } catch (IllegalSecuredObjectAccessException e) {
+            logger.error("Security", e);
+            return List.of();
+        }
+    }
+
+}

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

src/main/java/DNPM/dto/Variant.java

@@ -0,0 +1,100 @@
+package DNPM.dto;
+
+import de.itc.onkostar.api.Procedure;
+
+import java.util.Optional;
+
+public class Variant {
+    private final Integer id;
+
+    private final String ergebnis;
+
+    private final String gen;
+
+    private final String exon;
+
+    private final String pathogenitaetsklasse;
+
+    private Variant(
+            final int id,
+            final String ergebnis,
+            final String gen,
+            final String exon,
+            final String pathogenitaetsklasse
+    ) {
+        this.id = id;
+        this.ergebnis = ergebnis;
+        this.gen = gen;
+        this.exon = exon;
+        this.pathogenitaetsklasse = pathogenitaetsklasse;
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public String getErgebnis() {
+        return ergebnis;
+    }
+
+    public String getGen() {
+        return gen;
+    }
+
+    public String getExon() {
+        return exon;
+    }
+
+    public String getPathogenitaetsklasse() {
+        return pathogenitaetsklasse;
+    }
+
+    public static Optional<Variant> 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(),
+                            "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 (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 (Translokation Inversion Insertion)",
+                            gene.getString().isBlank() ? "-" : gene.getString(),
+                            null == exon || exon.getString().isBlank() ? "-" : exon.getString(),
+                            null == pathogenitaetsklasse || pathogenitaetsklasse.getString().isBlank() ? "-" : pathogenitaetsklasse.getString()
+                    )
+            );
+        } else {
+            return Optional.empty();
+        }
+    }
+}

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<Variant> getVariants(Procedure procedure);
+
+}

src/main/java/DNPM/services/molekulargenetik/OsMolekulargenetikFormService.java

@@ -0,0 +1,32 @@
+package DNPM.services.molekulargenetik;
+
+import DNPM.dto.Variant;
+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
+    @PersonPoolSecured
+    public List<Variant> 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());
+
+    }
+}

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));
+    }
+
+}

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 (Mutation)");
+        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 (CNV)");
+        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 (Translokation Inversion Insertion)");
+        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();
+    }
+
+}

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);
+    }
+
+}