Fix Nullpointer Exception in ReferenceResolve

Author: Lucas0T

src/main/java/de/medizininformatikinitiative/torch/config/AppConfig.java

@@ -33,6 +33,7 @@
 import de.medizininformatikinitiative.torch.util.Redaction;
 import de.medizininformatikinitiative.torch.util.ReferenceExtractor;
 import de.medizininformatikinitiative.torch.util.ReferenceHandler;
+import de.medizininformatikinitiative.torch.util.ResourceGroupValidator;
 import de.medizininformatikinitiative.torch.util.ResourceReader;
 import de.medizininformatikinitiative.torch.util.ResultFileManager;
 import de.numcodex.sq2cql.Translator;
@@ -126,8 +127,13 @@ public ProcessedGroupFactory attributeGroupProcessor(CompartmentManager manager)
 
 
     @Bean
-    ReferenceHandler referenceHandler(DataStore dataStore, ProfileMustHaveChecker mustHaveChecker, CompartmentManager compartmentManager, ConsentValidator consentValidator) {
-        return new ReferenceHandler(mustHaveChecker);
+    ReferenceHandler referenceHandler(ResourceGroupValidator resourceGroupValidator) {
+        return new ReferenceHandler(resourceGroupValidator);
+    }
+
+    @Bean
+    ResourceGroupValidator resourceGroupValidator(ProfileMustHaveChecker profileMustHaveChecker) {
+        return new ResourceGroupValidator(profileMustHaveChecker);
     }
 
     @Bean

src/main/java/de/medizininformatikinitiative/torch/exceptions/ResourceTypeMissmatchException.java

@@ -67,9 +67,7 @@ public Mono<ResourceBundle> resolveCoreBundle(ResourceBundle coreBundle, Map<Str
                         .collect(Collectors.toSet()))
                 .expand(currentGroupSet ->
                         processResourceGroups(currentGroupSet, null, coreBundle, false, groupMap)
-                                .onErrorResume(e -> {
-                                    return Mono.empty(); // Skip this resource group on error
-                                }))
+                                .onErrorResume(e -> Mono.empty()))
                 .then(Mono.just(coreBundle));
     }
 
@@ -144,26 +142,20 @@ public Mono<Set<ResourceGroup>> processResourceGroups(
         return bundleLoader.fetchUnknownResources(referencesGroupedByResourceGroup, patientBundle, coreBundle, applyConsent)
                 .thenMany(
                         Flux.fromIterable(referencesGroupedByResourceGroup.entrySet())
+                                .filter(entry -> entry.getKey() != null && entry.getValue() != null && !entry.getValue().isEmpty())
                                 .concatMap(entry ->
-                                        {
-                                            try {
-                                                return referenceHandler.handleReferences(
-                                                        entry.getValue(),
-                                                        patientBundle,
-                                                        coreBundle,
-                                                        groupMap
-                                                );
-                                            } catch (MustHaveViolatedException e) {
-                                                return Flux.empty();
-                                            }
-                                        }
+                                        Flux.fromIterable(referenceHandler.handleReferences(
+                                                entry.getValue(),
+                                                patientBundle,
+                                                coreBundle,
+                                                groupMap
+                                        ))
                                 )
                 )
                 .collect(Collectors.toSet())
                 .flatMap(set -> set.isEmpty() ? Mono.empty() : Mono.just(set));
     }
 
-
     /**
      * Extracts for every ResourceGroup the ReferenceWrappers and collects them ordered by
      *
@@ -179,9 +171,9 @@ public Map<ResourceGroup, List<ReferenceWrapper>> loadReferencesByResourceGroup(
             ResourceBundle coreBundle,
             Map<String, AnnotatedAttributeGroup> groupMap) {
 
-        return resourceGroups.parallelStream()
+        return resourceGroups.stream()
                 .map(resourceGroup -> processResourceGroup(resourceGroup, patientBundle, coreBundle, groupMap))
-                .filter(entry -> !entry.getValue().isEmpty())
+                .filter(entry -> entry.getKey() != null && entry.getValue() != null && !entry.getValue().isEmpty())
                 .collect(Collectors.toMap(
                         Map.Entry::getKey,
                         Map.Entry::getValue,
@@ -219,11 +211,7 @@ private Map.Entry<ResourceGroup, List<ReferenceWrapper>> processResourceGroup(
                 ? patientBundle.bundle().get(resourceGroup.resourceId())
                 : coreBundle.get(resourceGroup.resourceId());
 
-        if (resource.isPresent()) {
-            return extractReferences(resourceGroup, resource.get(), groupMap, processingBundle);
-        } else {
-            return handleMissingResource(resourceGroup, processingBundle);
-        }
+        return resource.map(value -> extractReferences(resourceGroup, value, groupMap, processingBundle)).orElseGet(() -> handleMissingResource(resourceGroup, processingBundle));
     }
 
     /**
@@ -253,9 +241,7 @@ private Map.Entry<ResourceGroup, List<ReferenceWrapper>> extractReferences(
             List<ReferenceWrapper> extracted = referenceExtractor.extract(resource, groupMap, resourceGroup.groupId());
             return Map.entry(resourceGroup, extracted);
         } catch (MustHaveViolatedException e) {
-            synchronized (processingBundle) {
-                processingBundle.addResourceGroupValidity(resourceGroup, false);
-            }
+            processingBundle.addResourceGroupValidity(resourceGroup, false);
             return Map.entry(resourceGroup, Collections.emptyList());
         }
     }
@@ -270,11 +256,8 @@ private Map.Entry<ResourceGroup, List<ReferenceWrapper>> extractReferences(
     private Map.Entry<ResourceGroup, List<ReferenceWrapper>> handleMissingResource(
             ResourceGroup resourceGroup,
             ResourceBundle processingBundle) {
-
-        synchronized (processingBundle) {
-            logger.warn("Empty resource marked as valid for group {}", resourceGroup);
-            processingBundle.addResourceGroupValidity(resourceGroup, false);
-        }
+        logger.warn("Empty resource marked as valid for group {}", resourceGroup);
+        processingBundle.addResourceGroupValidity(resourceGroup, false);
         return Map.entry(resourceGroup, Collections.emptyList());
     }
 

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

@@ -7,13 +7,12 @@
 import de.medizininformatikinitiative.torch.model.management.ResourceAttribute;
 import de.medizininformatikinitiative.torch.model.management.ResourceBundle;
 import de.medizininformatikinitiative.torch.model.management.ResourceGroup;
-import org.hl7.fhir.r4.model.Resource;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import reactor.core.publisher.Flux;
 
 import javax.annotation.Nullable;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -22,24 +21,27 @@
 
 public class ReferenceHandler {
     private static final Logger logger = LoggerFactory.getLogger(ReferenceHandler.class);
-    private final ProfileMustHaveChecker profileMustHaveChecker;
+    private final ResourceGroupValidator resourceGroupValidator;
 
 
-    public ReferenceHandler(ProfileMustHaveChecker profileMustHaveChecker) {
-        this.profileMustHaveChecker = profileMustHaveChecker;
+    public ReferenceHandler(ResourceGroupValidator resourceGroupValidator) {
+        this.resourceGroupValidator = resourceGroupValidator;
 
     }
 
-    private static Flux<List<ResourceGroup>> checkReferenceViolatesMustHave(ReferenceWrapper referenceWrapper, List<ResourceGroup> list, ResourceBundle processingBundle) {
+    private static List<ResourceGroup> checkReferenceViolatesMustHave(ReferenceWrapper referenceWrapper, List<ResourceGroup> list, ResourceBundle processingBundle) throws MustHaveViolatedException {
         ResourceAttribute referenceAttribute = referenceWrapper.toResourceAttributeGroup();
         if (referenceWrapper.refAttribute().mustHave() && list.isEmpty()) {
             processingBundle.setResourceAttributeInValid(referenceAttribute);
-            return Flux.error(new MustHaveViolatedException(
+            throw new MustHaveViolatedException(
                     "MustHave condition violated: No valid references were resolved for " + referenceWrapper.references()
-            ));
+            );
+        }
+        if (referenceWrapper.references().isEmpty()) {
+            return List.of();
         }
         processingBundle.setResourceAttributeValid(referenceAttribute);
-        return Flux.just(list);
+        return list;
     }
 
     /**
@@ -49,47 +51,57 @@ private static Flux<List<ResourceGroup>> checkReferenceViolatesMustHave(Referenc
      * @param groupMap      cache containing all known attributeGroups
      * @return newly added ResourceGroups to be processed
      */
-    public Flux<ResourceGroup> handleReferences(List<ReferenceWrapper> references,
+    public List<ResourceGroup> handleReferences(List<ReferenceWrapper> references,
                                                 @Nullable PatientResourceBundle patientBundle,
                                                 ResourceBundle coreBundle,
-                                                Map<String, AnnotatedAttributeGroup> groupMap) throws MustHaveViolatedException {
+                                                Map<String, AnnotatedAttributeGroup> groupMap) {
         ResourceBundle processingBundle = (patientBundle != null) ? patientBundle.bundle() : coreBundle;
         ResourceGroup parentGroup = new ResourceGroup(references.getFirst().resourceId(), references.getFirst().groupId());
 
-        List<ReferenceWrapper> unprocessedReferences = filterUnprocessedReferences(references, processingBundle);
-        Set<ResourceGroup> knownGroups = processingBundle.getKnownResourceGroups();
-        return Flux.fromIterable(unprocessedReferences)
-                .concatMap(ref -> handleReference(ref, patientBundle, coreBundle, groupMap).doOnNext(
-                        resourceGroupList -> {
-                            ResourceAttribute referenceAttribute = ref.toResourceAttributeGroup();
-                            resourceGroupList.forEach(resourceGroup -> processingBundle.addAttributeToChild(referenceAttribute, resourceGroup));
+        try {
+            List<ReferenceWrapper> unprocessedReferences = filterUnprocessedReferences(references, processingBundle);
+            Set<ResourceGroup> knownGroups = processingBundle.getKnownResourceGroups();
+            return unprocessedReferences.stream()
+                    // map each reference to a list of ResourceGroups
+                    .map(ref -> {
+                        List<ResourceGroup> resourceGroupList;
+                        try {
+                            resourceGroupList = handleReference(ref, patientBundle, coreBundle, groupMap);
+                        } catch (MustHaveViolatedException e) {
+                            processingBundle.addResourceGroupValidity(parentGroup, false);
+                            return Collections.<ResourceGroup>emptyList();
                         }
-                ))
-                .collectList()
-                .flatMapMany(results -> Flux.fromIterable(results.stream()
-                        .flatMap(List::stream)
-                        .toList()))
-                .filter(group -> !knownGroups.contains(group))
-                .onErrorResume(MustHaveViolatedException.class, e -> {
-                    processingBundle.addResourceGroupValidity(parentGroup, false);
-                    logger.warn("MustHaveViolatedException occurred. Stopping resource processing: {}", e.getMessage());
-                    return Flux.empty();
-                });
+                        ResourceAttribute referenceAttribute = ref.toResourceAttributeGroup();
+                        // side effect: add attribute to each resource group
+                        resourceGroupList.forEach(rg -> processingBundle.addAttributeToChild(referenceAttribute, rg));
+                        return resourceGroupList;
+                    })
+                    .flatMap(List::stream)
+                    .filter(group -> !knownGroups.contains(group))
+                    .toList();
+        } catch (MustHaveViolatedException e) {
+            processingBundle.addResourceGroupValidity(parentGroup, false);
+            logger.warn("MustHaveViolatedException occurred. Stopping resource processing: {}", e.getMessage());
+            return List.of();
+        }
     }
 
     /**
      * Handles a ReferenceWrapper by resolving its references and updating the processing bundle.
      *
+     * <p>
+     * Checks if referenceAttribute
+     *
      * @param referenceWrapper The reference wrapper to handle.
      * @param patientBundle    The patient bundle being updated, if present.
      * @param coreBundle       to be updated and queried, that contains a centrally shared concurrent HashMap.
      * @param groupMap         Map of attribute groups for validation.
      * @return A Flux emitting a list of ResourceGroups corresponding to the resolved references.
      */
-    public Flux<List<ResourceGroup>> handleReference(ReferenceWrapper referenceWrapper,
-                                                     @Nullable PatientResourceBundle patientBundle,
-                                                     ResourceBundle coreBundle,
-                                                     Map<String, AnnotatedAttributeGroup> groupMap) {
+    public List<ResourceGroup> handleReference(ReferenceWrapper referenceWrapper,
+                                               @Nullable PatientResourceBundle patientBundle,
+                                               ResourceBundle coreBundle,
+                                               Map<String, AnnotatedAttributeGroup> groupMap) throws MustHaveViolatedException {
 
         ResourceBundle processingBundle = patientBundle != null ? patientBundle.bundle() : coreBundle;
 
@@ -104,45 +116,14 @@ public Flux<List<ResourceGroup>> handleReference(ReferenceWrapper referenceWrapp
                 })
                 .filter(Objects::nonNull)
                 .filter(Optional::isPresent)
-                .flatMap(resource -> collectValidGroups(referenceWrapper, groupMap, resource.get(), processingBundle).stream())
+                .flatMap(resource -> resourceGroupValidator.collectValidGroups(referenceWrapper, groupMap, resource.get(), processingBundle).stream())
                 .toList();
 
         // Now run your must-have validation and wrap in Flux
         return checkReferenceViolatesMustHave(referenceWrapper, allValidGroups, processingBundle);
     }
 
 
-    /**
-     * Collects all valid resourceGroups for the currently processed ResourceBundle.
-     * <p> For a given reference and resource checks if already a valid group in processingBundle.
-     * If resourceGroups not assigned yet, executes filter, musthave (Without References) and profile checks.
-     *
-     * @param groupMap         known attribute groups
-     * @param resource         Resource to be checked
-     * @param processingBundle bundle that is currently processed
-     * @return ResourceGroup if previously unknown and assignable to the group.
-     */
-    private List<ResourceGroup> collectValidGroups(ReferenceWrapper referenceWrapper, Map<String, AnnotatedAttributeGroup> groupMap, Resource resource, ResourceBundle processingBundle) {
-        return referenceWrapper.refAttribute().linkedGroups().stream()
-                .map(groupId -> {
-                    ResourceGroup resourceGroup = new ResourceGroup(ResourceUtils.getRelativeURL(resource), groupId);
-                    Boolean isValid = processingBundle.isValidResourceGroup(resourceGroup);
-                    if (isValid == null) {
-                        AnnotatedAttributeGroup group = groupMap.get(groupId);
-                        boolean fulfilled = profileMustHaveChecker.fulfilled(resource, group);
-                        if (group.compiledFilter() != null) {
-                            fulfilled = fulfilled && group.compiledFilter().test(resource);
-                        }
-                        logger.trace("Group {} for Reference: {}", groupId, fulfilled);
-                        isValid = fulfilled;
-                        processingBundle.addResourceGroupValidity(resourceGroup, isValid);
-                    }
-                    return isValid ? resourceGroup : null;
-                })
-                .filter(Objects::nonNull)
-                .toList();
-    }
-
     /**
      * Iterates over the references to find unprocessed reference wrappers.
      *
@@ -163,19 +144,15 @@ private List<ReferenceWrapper> filterUnprocessedReferences(List<ReferenceWrapper
 
             Boolean isValid = processingBundle.resourceAttributeValidity().get(resourceAttribute);
             processingBundle.addAttributeToParent(resourceAttribute, parentGroup);
-            if (Boolean.TRUE.equals(isValid)) {
-                // Already valid, skip
+            if (isValid == null) {
+                uncheckedReferences.add(reference);
             } else {
-                if (Boolean.FALSE.equals(isValid)) {
-                    if (reference.refAttribute().mustHave()) {
-                        processingBundle.addResourceGroupValidity(parentGroup, false);
-                        throw new MustHaveViolatedException(
-                                "Must-have attribute violated for reference: " + reference + " in group: " + parentGroup);
-                    }
-
-                } else {
-                    uncheckedReferences.add(reference);
+                if (!isValid && reference.refAttribute().mustHave()) {
+                    processingBundle.addResourceGroupValidity(parentGroup, false);
+                    throw new MustHaveViolatedException(
+                            "Must-have attribute violated for reference: " + reference + " in group: " + parentGroup);
                 }
+
             }
         }
         return uncheckedReferences;