Ignore Non-Implemented Filters

Fixes: #293

Author: bastianschaffer

src/main/java/de/medizininformatikinitiative/torch/service/FilterService.java

@@ -20,6 +20,7 @@
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
@@ -37,6 +38,8 @@ public class FilterService {
     private final IFhirPath fhirPathEngine;
     private final String searchParametersFile;
 
+    public static final Predicate<Resource> ALWAYS_TRUE_FILTER = r -> true;
+
     /**
      * Maps filter code, filter type and resource type (in this exact order) to an expression.
      */
@@ -79,25 +82,42 @@ public Predicate<Resource> compileFilter(List<Filter> attributeGroupFilters, Str
         }
         var parsedFilters = attributeGroupFilters.stream()
                 .map(filter ->
-                        new ParsedFilter(
-                                filter,
-                                parseFhirPath(searchParameters.get(List.of(filter.name(), filter.type(), resourceType)))))
+                        Optional.ofNullable(searchParameters.get(List.of(filter.name(), filter.type(), resourceType)))
+                                .or(() -> {
+                                    logger.warn("Could not find search parameter for filter with name '{}' and type '{}' " +
+                                            "for resource type '{}'. Ignoring this filter.", filter.name(), filter.type(), resourceType);
+                                    return Optional.empty();
+                                })
+                                .map(this::parseFhirPath)
+                                .map(parsed -> new ParsedFilter(filter, parsed))
+                )
+                .filter(Optional::isPresent).map(Optional::get)
                 .toList();
 
+        if (parsedFilters.isEmpty()) {
+            return ALWAYS_TRUE_FILTER;
+        }
+
         return new CompiledFilter(parsedFilters, fhirPathEngine);
     }
 
+    /**
+     * Parses a FHIRPath String into a parsed FHIRPath expression.
+     *
+     * @param path  the FHIRPath to parse
+     * @return      the parsed FHIRPath expression
+     * @throws IllegalArgumentException if {@code path} is null, empty or if it could not be parsed
+     */
     private IFhirPath.IParsedExpression parseFhirPath(String path) {
         if (path == null || path.isEmpty()) {
-            throw new IllegalArgumentException("Could not find any matching search parameter for filter. This can later " +
-                    "result in unexpected false negative results of the 'test' method of 'CompiledFilter'.");
+            throw new IllegalArgumentException("Path must not be null or empty.");
         }
 
         try {
             return fhirPathEngine.parse(path);
         } catch (Exception e) {
             // FHIRPath expressions from FHIR search parameters should usually never fail parsing
-            throw new RuntimeException("Unexpected parsing error occurred", e);
+            throw new IllegalArgumentException("Unexpected parsing error occurred with path " + path, e);
         }
     }
 

src/test/java/de/medizininformatikinitiative/torch/service/FilterServiceTest.java

@@ -2,6 +2,9 @@
 
 import ca.uhn.fhir.context.FhirContext;
 import ca.uhn.fhir.fhirpath.IFhirPath;
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.read.ListAppender;
 import de.medizininformatikinitiative.torch.exceptions.ReferenceToPatientException;
 import de.medizininformatikinitiative.torch.model.crtdl.AttributeGroup;
 import de.medizininformatikinitiative.torch.model.crtdl.Code;
@@ -13,9 +16,12 @@
 import org.hl7.fhir.r4.model.Observation;
 import org.hl7.fhir.r4.model.Period;
 import org.hl7.fhir.r4.model.Questionnaire;
+import org.hl7.fhir.r4.model.Resource;
 import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
+import org.slf4j.LoggerFactory;
 
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
@@ -71,21 +77,32 @@ public void test_compile_MultipleResources() {
         assertFalse(result_3);
     }
 
+    @Test
+    @DisplayName("This tests for example the case of 'chained filters'.")
+    public void testInvalidSearchParam() {
+        Resource anyResource = new Observation();
+        Logger logger = (Logger) LoggerFactory.getLogger(FilterService.class);
+        ListAppender<ILoggingEvent> listAppender = new ListAppender<>();
+        listAppender.start();
+        logger.addAppender(listAppender);
+
+        var compiledFilter = filterService.compileFilter(List.of(new Filter("none-existing-type", "some-code",
+                List.of(new Code(SYS, CODE_1)))), OBSERVATION);
+
+        assertThat(compiledFilter.test(anyResource)).isTrue();
+        assertThat(listAppender.list.size()).isEqualTo(1);
+        assertThat((listAppender.list.getFirst()).getFormattedMessage())
+                .isEqualTo("Could not find search parameter for filter with name 'some-code' and type " +
+                        "'none-existing-type' for resource type 'Observation'. Ignoring this filter.");
+    }
+
     @Test
     public void testEmptyFilter() {
         assertThatThrownBy(() -> filterService.compileFilter(List.of(), OBSERVATION))
                 .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("An empty list of filters can't be compiled.");
     }
 
-    @Test
-    public void test_nonExistingSearchParam() {
-        assertThatThrownBy(() -> filterService.compileFilter(List.of(new Filter("foo", "bar", List.of())), OBSERVATION))
-                .isInstanceOf(RuntimeException.class)
-                .hasMessageContaining("Could not find any matching search parameter for filter. This can later " +
-                        "result in unexpected false negative results of the 'test' method of 'CompiledFilter'.");
-    }
-
     @Nested
     class TestCodeableConcept {