Merge branch 'main' into dependabot/gradle/mock-mhs-adaptor/org.apache.qpid-qpid-jms-client-2.9.0

Author: ORybak5

CHANGELOG.md

@@ -6,12 +6,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+* Prevent duplicate processing: after a medication request is processed, the system no longer pulls a subsequent non‑consultation item based on the same request.
+
 ### Added
 * The GP2GP Adaptor now validates references inside condition objects to test whether they actually exist. Otherwise, the bundle is rejected.
 * The GP2GP Adaptor now adds the EhrComposition / confidentialityCode field when Encounter.meta.security contains NOPAT security entry
 * The GP2GP Adaptor now populates the ObservationStatement / confidentialityCode field when the .meta.security field of an Uncategorized Data Observation contains NOPAT
 * When List.meta.security field contains NOPAT, the GP2GP Adaptor will now populate the CompoundStatement.confidentialityCode
 
+### Fixed
+* When DiagnosticReport doesn't contain a Specimen reference, instead of "DUMMY" "NOT-PRESENT" value is used
+
 ### Update
 
 * [GP Connect 1.6.1] The GP2GP Adaptor is now able to identify e-referrals by using either `https://fhir.nhs.uk/Id/ubr-number` or `https://fhir.nhs.uk/Id/UBRN` when provided as an identifier system URL.

service/src/main/java/uk/nhs/adaptors/gp2gp/ehr/mapper/NonConsultationResourceMapper.java

@@ -12,6 +12,7 @@
 import org.hl7.fhir.dstu3.model.DiagnosticReport;
 import org.hl7.fhir.dstu3.model.IdType;
 import org.hl7.fhir.dstu3.model.ListResource;
+import org.hl7.fhir.dstu3.model.MedicationRequest;
 import org.hl7.fhir.dstu3.model.Observation;
 import org.hl7.fhir.dstu3.model.Reference;
 import org.hl7.fhir.dstu3.model.Resource;
@@ -25,6 +26,7 @@
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import uk.nhs.adaptors.gp2gp.common.service.RandomIdGeneratorService;
+import uk.nhs.adaptors.gp2gp.ehr.exception.EhrMapperException;
 import uk.nhs.adaptors.gp2gp.ehr.mapper.parameters.EncounterTemplateParameters;
 import uk.nhs.adaptors.gp2gp.ehr.mapper.parameters.EncounterTemplateParameters.EncounterTemplateParametersBuilder;
 import uk.nhs.adaptors.gp2gp.ehr.utils.BloodPressureValidator;
@@ -72,12 +74,12 @@ public class NonConsultationResourceMapper {
         );
 
     public List<String> mapRemainingResourcesToEhrCompositions(Bundle bundle) {
-        var mappedResources = bundle.getEntry()
-            .stream()
+
+        var mappedResources = bundle.getEntry().stream()
             .map(Bundle.BundleEntryComponent::getResource)
             .filter(this::isMappableNonConsultationResource)
             .sorted(this::compareProcessingOrder)
-            .filter(resource -> !hasIdBeenMapped(resource) && !isIgnoredResource(resource))
+            .filter(this::shouldMapResource)
             .map(this::mapResourceToEhrComposition)
             .flatMap(Optional::stream)
             .collect(Collectors.toList());
@@ -101,6 +103,32 @@ public List<String> mapRemainingResourcesToEhrCompositions(Bundle bundle) {
         return mappedResources;
     }
 
+    boolean shouldMapResource(Resource resource) {
+        if (hasIdBeenMapped(resource) || isIgnoredResource(resource)) {
+            return false;
+        }
+        if (resource instanceof MedicationRequest medicationRequest) {
+            return shouldMapMedicationRequest(medicationRequest);
+        }
+        return true;
+    }
+
+    boolean shouldMapMedicationRequest(MedicationRequest medicationRequest) {
+        if (!medicationRequest.hasBasedOn()) {
+            return true;
+        }
+
+        String referenceId = medicationRequest.getBasedOn().getFirst().getReference();
+
+        try {
+            Optional<Resource> referencedResource = messageContext.getInputBundleHolder().getResource(new IdType(referenceId));
+            return referencedResource.isEmpty() || !hasIdBeenMapped(referencedResource.get());
+        } catch (EhrMapperException e) {
+            LOGGER.info("MedicationRequest {} cannot be mapped", referenceId);
+            return true;
+        }
+    }
+
     private Resource replaceId(Resource resource) {
         resource.setIdElement(new IdType(resource.getResourceType().name(), randomIdGeneratorService.createNewId()));
         return resource;

service/src/main/java/uk/nhs/adaptors/gp2gp/ehr/mapper/diagnosticreport/DiagnosticReportMapper.java

@@ -52,7 +52,7 @@
 @Slf4j
 public class DiagnosticReportMapper {
 
-    public static final String DUMMY_SPECIMEN_ID_PREFIX = "DUMMY-SPECIMEN-";
+    public static final String NOT_PRESENT_SPECIMEN_ID_PREFIX = "NOT-PRESENT-SPECIMEN-";
     public static final String DUMMY_OBSERVATION_ID_PREFIX = "DUMMY-OBSERVATION-";
 
     private static final Mustache DIAGNOSTIC_REPORT_COMPOUND_STATEMENT_TEMPLATE =
@@ -142,7 +142,7 @@ private List<Specimen> fetchSpecimens(DiagnosticReport diagnosticReport, List<Ob
 
         // At least one specimen is required to exist for any DiagnosticReport, according to the mim
         if (!diagnosticReport.hasSpecimen() || hasObservationsWithoutSpecimen(observations)) {
-            specimens.add(generateDummySpecimen(diagnosticReport));
+            specimens.add(generateNotPresentSpecimen(diagnosticReport));
         }
 
         var inputBundleHolder = messageContext.getInputBundleHolder();
@@ -168,41 +168,38 @@ private boolean hasObservationsWithoutSpecimen(List<Observation> observations) {
     /**
      * For correct display in EMIS, any observation without a specimen must be assigned a dummy specimen.
      */
-    private List<Observation> assignDummySpecimensToObservationsWithNoSpecimen(
-            List<Observation> observations, List<Specimen> specimens) {
+    List<Observation> assignDummySpecimensToObservationsWithNoSpecimen(List<Observation> observations, List<Specimen> specimens) {
 
         List<Observation> filingComments = getFilingComments(observations);
-        observations = new ArrayList<>(stripFilingComments(observations));
+        List<Observation> nonFilingObservations = new ArrayList<>(stripFilingComments(observations));
 
-        if (!hasObservationsWithoutSpecimen(observations)) {
-            observations.addAll(filingComments);
-            return observations;
+        if (!hasObservationsWithoutSpecimen(nonFilingObservations)) {
+            nonFilingObservations.addAll(filingComments);
+            return nonFilingObservations;
         }
 
         // The assumption was made that all test results without a specimen will have the same dummy specimen referenced
-        Specimen dummySpecimen = specimens.stream()
-                .filter(specimen -> specimen.getId().contains(DUMMY_SPECIMEN_ID_PREFIX))
-                .toList().getFirst();
+        Specimen notPresentSpecimen = specimens.stream()
+            .filter(specimen -> specimen.getId().contains(NOT_PRESENT_SPECIMEN_ID_PREFIX))
+            .toList().getFirst();
 
-        Reference dummySpecimenReference = new Reference(dummySpecimen.getId());
+        Reference notPresentSpecimenReference = new Reference(notPresentSpecimen.getId());
 
-        for (Observation observation : observations) {
-            if (!observation.hasSpecimen() && !isFilingComment(observation)) {
-                observation.setSpecimen(dummySpecimenReference);
-            }
-        }
+        nonFilingObservations.stream()
+            .filter(obs -> !obs.hasSpecimen() && !isFilingComment(obs))
+            .forEach(obs -> obs.setSpecimen(notPresentSpecimenReference));
 
-        observations.addAll(filingComments);
-        return observations;
+        nonFilingObservations.addAll(filingComments);
+        return nonFilingObservations;
     }
 
-    private Specimen generateDummySpecimen(DiagnosticReport diagnosticReport) {
+    private Specimen generateNotPresentSpecimen(DiagnosticReport diagnosticReport) {
         Specimen specimen = new Specimen();
 
-        specimen.setId(DUMMY_SPECIMEN_ID_PREFIX + randomIdGeneratorService.createNewId());
+        specimen.setId(NOT_PRESENT_SPECIMEN_ID_PREFIX + randomIdGeneratorService.createNewId());
 
         return specimen
-            .setAccessionIdentifier(new Identifier().setValue("DUMMY"))
+            .setAccessionIdentifier(new Identifier().setValue("NOT PRESENT"))
             .setCollection(new Specimen.SpecimenCollectionComponent().setCollected(new DateTimeType(diagnosticReport.getIssued())))
             .setType(new CodeableConcept().setText("UNKNOWN"));
     }
@@ -247,7 +244,7 @@ private List<String> getSpecimenIdsWithoutObservation(List<Specimen> specimens,
         List<String> nonOrphanSpecimenIDList = new ArrayList<>();
         for (Specimen specimen : specimens) {
             // Dummy Specimens should not have a dummy observation attached.
-            if (!specimen.getId().contains(DUMMY_SPECIMEN_ID_PREFIX)) {
+            if (!specimen.getId().contains(NOT_PRESENT_SPECIMEN_ID_PREFIX)) {
                 specimenIDList.add(specimen.getId());
             }
         }

service/src/test/java/uk/nhs/adaptors/gp2gp/ehr/mapper/EhrExtractMapperComponentTest.java

@@ -41,17 +41,23 @@
 
 @ExtendWith(MockitoExtension.class)
 @MockitoSettings(strictness = Strictness.LENIENT)
-public class EhrExtractMapperComponentTest {
+class EhrExtractMapperComponentTest {
+
     private static final String TEST_FILE_DIRECTORY = "/ehr/request/fhir/";
     private static final String INPUT_DIRECTORY = "input/";
     private static final String OUTPUT_DIRECTORY = "output/";
     private static final String INPUT_PATH = TEST_FILE_DIRECTORY + INPUT_DIRECTORY;
     private static final String OUTPUT_PATH = TEST_FILE_DIRECTORY + OUTPUT_DIRECTORY;
-
     private static final String JSON_INPUT_FILE = "gpc-access-structured.json";
     private static final String JSON_INPUT_FILE_WITH_NOPAT = "gpc-access-structured-with-nopat.json";
     private static final String DUPLICATE_RESOURCE_BUNDLE = INPUT_PATH + "duplicated-resource-bundle.json";
     private static final String ONE_CONSULTATION_RESOURCE_BUNDLE = INPUT_PATH + "1-consultation-resource.json";
+    private static final String FHIR_BUNDLE_WITH_DUPLICATED_MEDICATION_REQUESTS = "fhir_bundle_with_duplicated_medication_requests.json";
+    private static final String EXPECTED_XML_FOR_ONE_CONSULTATION_RESOURCE = "ExpectedResponseFrom1ConsultationResponse.xml";
+
+    private static final String EXPECTED_XML_TO_JSON_FILE = "expected-ehr-extract-response-from-json.xml";
+    private static final String EXPECTED_XML_TO_JSON_FILE_WITH_NOPAT = "expected-ehr-extract-response-from-json-with-nopat.xml";
+
     private static final String FHIR_BUNDLE_WITHOUT_EFFECTIVE_TIME = "fhir-bundle-without-effective-time.json";
     private static final String FHIR_BUNDLE_WITHOUT_HIGH_EFFECTIVE_TIME = "fhir-bundle-without-high-effective-time.json";
     private static final String FHIR_BUNDLE_WITH_EFFECTIVE_TIME = "fhir-bundle-with-effective-time.json";
@@ -63,12 +69,7 @@ public class EhrExtractMapperComponentTest {
     private static final String FHIR_BUNDLE_WITH_OBSERVATIONS_UNRELATED_TO_DIAGNOSTIC_REPORT =
         "fhir-bundle-observations-unrelated-to-diagnostic-report.json";
     private static final String FHIR_BUNDLE_WITH_OBSERVATIONS_WITH_RELATED_OBSERVATIONS =
-            "fhir-bundle-observations-with-related-observations.json";
-
-    private static final String EXPECTED_XML_FOR_ONE_CONSULTATION_RESOURCE = "ExpectedResponseFrom1ConsultationResponse.xml";
-
-    private static final String EXPECTED_XML_TO_JSON_FILE = "expected-ehr-extract-response-from-json.xml";
-    private static final String EXPECTED_XML_TO_JSON_FILE_WITH_NOPAT = "expected-ehr-extract-response-from-json-with-nopat.xml";
+        "fhir-bundle-observations-with-related-observations.json";
     private static final String EXPECTED_XML_WITHOUT_EFFECTIVE_TIME = "expected-xml-without-effective-time.xml";
     private static final String EXPECTED_XML_WITHOUT_HIGH_EFFECTIVE_TIME = "expected-xml-without-high-effective-time.xml";
     private static final String EXPECTED_XML_WITH_EFFECTIVE_TIME = "expected-xml-with-effective-time.xml";
@@ -231,7 +232,7 @@ public void tearDown() {
     }
 
     @Test
-    public void When_MappingUncategorizedObservationWithNOPAT_Expect_ObservationStatementWithConfidentialityCode() {
+    void When_MappingUncategorizedObservationWithNOPAT_Expect_ObservationStatementWithConfidentialityCode() {
 
         String expectedJsonToXmlContent = ResourceTestFileUtils.getFileContent(OUTPUT_PATH + EXPECTED_XML_TO_JSON_FILE_WITH_NOPAT);
         String inputJsonFileContent = ResourceTestFileUtils.getFileContent(INPUT_PATH + JSON_INPUT_FILE_WITH_NOPAT);
@@ -259,7 +260,7 @@ public void When_MappingUncategorizedObservationWithNOPAT_Expect_ObservationStat
 
     @ParameterizedTest
     @MethodSource("testData")
-    public void When_MappingProperJsonRequestBody_Expect_ProperXmlOutput(String input, String expected) {
+    void When_MappingProperJsonRequestBody_Expect_ProperXmlOutput(String input, String expected) {
         String expectedJsonToXmlContent = ResourceTestFileUtils.getFileContent(OUTPUT_PATH + expected);
         String inputJsonFileContent = ResourceTestFileUtils.getFileContent(INPUT_PATH + input);
         Bundle bundle = new FhirParseService().parseResource(inputJsonFileContent, Bundle.class);
@@ -274,6 +275,20 @@ public void When_MappingProperJsonRequestBody_Expect_ProperXmlOutput(String inpu
         assertThat(output).isEqualToIgnoringWhitespace(expectedJsonToXmlContent);
     }
 
+    @Test
+    void When_MappingProperJsonRequestBody_Expect_NonDuplicatedMedicationRequestRemainingResources() {
+        String inputJsonFileContent =
+            ResourceTestFileUtils.getFileContent(INPUT_PATH + FHIR_BUNDLE_WITH_DUPLICATED_MEDICATION_REQUESTS);
+        Bundle bundle = new FhirParseService().parseResource(inputJsonFileContent, Bundle.class);
+        messageContext.initialize(bundle);
+
+        EhrExtractTemplateParameters ehrExtractTemplateParameters = ehrExtractMapper.mapBundleToEhrFhirExtractParams(
+            getGpcStructuredTaskDefinition,
+            bundle);
+
+        assertThat(ehrExtractTemplateParameters.getComponents()).hasSize(2);
+    }
+
     private static Stream<Arguments> testData() {
         return Stream.of(
             Arguments.of(JSON_INPUT_FILE, EXPECTED_XML_TO_JSON_FILE),
@@ -288,7 +303,7 @@ private static Stream<Arguments> testData() {
     }
 
     @Test
-    public void When_MappingJsonBody_Expect_OnlyOneConsultationResource() {
+    void When_MappingJsonBody_Expect_OnlyOneConsultationResource() {
         String expectedJsonToXmlContent = ResourceTestFileUtils.getFileContent(OUTPUT_PATH + EXPECTED_XML_FOR_ONE_CONSULTATION_RESOURCE);
         String inputJsonFileContent = ResourceTestFileUtils.getFileContent(ONE_CONSULTATION_RESOURCE_BUNDLE);
         Bundle bundle = new FhirParseService().parseResource(inputJsonFileContent, Bundle.class);
@@ -302,7 +317,7 @@ public void When_MappingJsonBody_Expect_OnlyOneConsultationResource() {
     }
 
     @Test
-    public void When_TransformingResourceToEhrComp_Expect_NoDuplicateMappings() {
+    void When_TransformingResourceToEhrComp_Expect_NoDuplicateMappings() {
         String bundle = ResourceTestFileUtils.getFileContent(DUPLICATE_RESOURCE_BUNDLE);
         Bundle parsedBundle = new FhirParseService().parseResource(bundle, Bundle.class);
         messageContext.initialize(parsedBundle);

service/src/test/java/uk/nhs/adaptors/gp2gp/ehr/mapper/EhrExtractResourceMapperTest.java

@@ -0,0 +1,122 @@
+package uk.nhs.adaptors.gp2gp.ehr.mapper;
+
+import org.hl7.fhir.dstu3.model.IdType;
+import org.hl7.fhir.dstu3.model.MedicationRequest;
+import org.hl7.fhir.dstu3.model.QuestionnaireResponse;
+import org.hl7.fhir.dstu3.model.Reference;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+import uk.nhs.adaptors.gp2gp.ehr.utils.IgnoredResourcesUtils;
+import org.hl7.fhir.dstu3.model.ResourceType;
+import java.util.Optional;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+class EhrExtractResourceMapperTest {
+
+    @Mock
+    private MessageContext messageContext;
+
+    @Mock
+    private InputBundle inputBundleHolder;
+
+    @Mock
+    private IdMapper idMapper;
+
+    @InjectMocks
+    private NonConsultationResourceMapper resourceMapper;
+
+    @BeforeEach
+    public void setUp() {
+        when(messageContext.getInputBundleHolder()).thenReturn(inputBundleHolder);
+        when(messageContext.getIdMapper()).thenReturn(idMapper);
+        when(idMapper.hasIdBeenMapped(any(), any())).thenReturn(false);
+    }
+
+    @AfterEach
+    public void tearDown() {
+        messageContext.resetMessageContext();
+    }
+
+    @Test
+    void When_ReferencedResourceIsEmpty_Expect_MapMedicationRequest() {
+
+        MedicationRequest medRequest = new MedicationRequest();
+        medRequest.setId("MedicationRequest/1");
+        medRequest.addBasedOn(new Reference("ServiceRequest/123"));
+        when(inputBundleHolder.getResource(new IdType("ServiceRequest/123"))).thenReturn(Optional.empty());
+
+        boolean result = resourceMapper.shouldMapResource(medRequest);
+
+        assertTrue(result);
+    }
+
+    @Test
+    void When_ReferencedResourceHasNotBeenMapped_Expect_MapMedicationRequest() {
+
+        MedicationRequest medRequest = new MedicationRequest();
+        medRequest.setId("MedicationRequest/1");
+        medRequest.addBasedOn(new Reference("ServiceRequest/123"));
+        when(inputBundleHolder.getResource(new IdType("ServiceRequest/123"))).thenReturn(
+            Optional.ofNullable(new MedicationRequest().setId("111")));
+
+        boolean result = resourceMapper.shouldMapResource(medRequest);
+
+        assertTrue(result);
+    }
+
+    @Test
+    void When_ReferencedResourceHasBeenMapped_Expect_MedicationRequestIsNotMapped() {
+
+        MedicationRequest medRequest = new MedicationRequest();
+        medRequest.setId("MedicationRequest/1");
+        medRequest.addBasedOn(new Reference("ServiceRequest/123"));
+        when(inputBundleHolder.getResource(new IdType("ServiceRequest/123"))).thenReturn(Optional.empty());
+        when(idMapper.hasIdBeenMapped(any(), any())).thenReturn(true);
+
+        boolean result = resourceMapper.shouldMapResource(medRequest);
+
+        assertFalse(result);
+    }
+
+    @Test
+    void When_ReferencedResourceHasNoBasedOn_Expect_MedicationRequestShouldBeMapped() {
+
+        MedicationRequest medRequest = new MedicationRequest();
+        medRequest.setId("MedicationRequest/1");
+
+        boolean result = resourceMapper.shouldMapResource(medRequest);
+
+        assertTrue(result);
+    }
+
+    @Test
+    void When_ReferencedResourceHasBeenIgnored_Expect_MedicationRequestShouldNotBeMapped() {
+        QuestionnaireResponse questionnaireResp = new QuestionnaireResponse();
+        questionnaireResp.setId("MedicationRequest/1");
+
+        try (MockedStatic<IgnoredResourcesUtils> ignoredMock = Mockito.mockStatic(IgnoredResourcesUtils.class)) {
+
+            ignoredMock.when(() -> IgnoredResourcesUtils.isIgnoredResourceType(ResourceType.QuestionnaireResponse)).thenReturn(true);
+
+            boolean result = resourceMapper.shouldMapResource(questionnaireResp);
+
+            assertFalse(result);
+        }
+    }
+
+}