Test branch zella

.github/workflows/emap-tests.yaml

@@ -3,7 +3,7 @@ on:
   push:
     branches: [ main, develop ]
   pull_request:
-    branches: [ main, develop, sk/waveform-dev ]
+    branches: [ main, develop, sk/waveform-dev, test_branch_zella  ]
   repository_dispatch:
 permissions:
   contents: read

core/src/main/java/uk/ac/ucl/rits/inform/datasinks/emapstar/InformDbOperations.java

@@ -35,6 +35,7 @@
 import uk.ac.ucl.rits.inform.interchange.adt.PendingDischarge;
 import uk.ac.ucl.rits.inform.interchange.adt.PendingTransfer;
 import uk.ac.ucl.rits.inform.interchange.adt.SwapLocations;
+import uk.ac.ucl.rits.inform.interchange.adt.UpdateSubSpeciality;
 import uk.ac.ucl.rits.inform.interchange.form.FormMetadataMsg;
 import uk.ac.ucl.rits.inform.interchange.form.FormMsg;
 import uk.ac.ucl.rits.inform.interchange.form.FormQuestionMetadataMsg;
@@ -361,5 +362,16 @@ public void processMessage(FormQuestionMetadataMsg msg) {
         formProcessor.processQuestionMetadataMessage(msg, storedFrom);
     }
 
+    /**
+     * Process an Update Sub Speciality message.
+     * @param  updateSubSpeciality the message
+     * @throws EmapOperationMessageProcessingException if message could not be processed
+     */
+    @Override
+    @Transactional
+    public void processMessage(UpdateSubSpeciality updateSubSpeciality) throws EmapOperationMessageProcessingException {
+        Instant storedFrom = Instant.now();
+        adtProcessor.processUpdateSubSpeciality(updateSubSpeciality, storedFrom);
+    }
 
 }

core/src/main/java/uk/ac/ucl/rits/inform/datasinks/emapstar/controllers/LocationController.java

@@ -199,7 +199,7 @@ class DepartmentController {
     }
 
     /**
-     * Get or create minomal department entity.
+     * Get or create minimal department entity.
      * @param msg minimal department message
      * @return saved department entity
      */
@@ -257,7 +257,10 @@ private static boolean updateFieldIfNull(String currentData, String newdata, Con
     void processDepartmentStates(DepartmentMetadata msg, Department department, Instant storedFrom) throws IncompatibleDatabaseStateException {
         Instant validFrom = msg.getSpecialityUpdate() == null ? msg.getDepartmentContactDate() : msg.getSpecialityUpdate();
         DepartmentState currentState = new DepartmentState(
-                department, msg.getDepartmentRecordStatus().toString(), msg.getDepartmentSpeciality(), validFrom, storedFrom);
+            department, msg.getDepartmentRecordStatus().toString(),
+            msg.getDepartmentSpeciality(), msg.getDepartmentType(),
+            msg.getIsWardOrFlowArea(), msg.getIsCoreInpatientArea(),
+            msg.getSiteLocation(), validFrom, storedFrom);
 
         if (departmentStateRepo.existsByDepartmentIdAndSpecialityAndValidFrom(department, msg.getDepartmentSpeciality(), validFrom)) {
             logger.debug("Department State already exists in the database, no need to process further");
@@ -274,9 +277,11 @@ void processDepartmentStates(DepartmentMetadata msg, Department department, Inst
             invalidatePreviousStateIfChanged(msg.getPreviousDepartmentSpeciality(), currentState, possiblePreviousState.get());
         } else if (msg.getPreviousDepartmentSpeciality() != null) {
             // if the previous department speciality is not in the database
-            DepartmentState previousState = new DepartmentState(
-                    department, msg.getDepartmentRecordStatus().toString(), msg.getPreviousDepartmentSpeciality(),
-                    msg.getDepartmentContactDate(), storedFrom);
+            DepartmentState previousState = new DepartmentState(department,
+                msg.getDepartmentRecordStatus().toString(),
+                msg.getPreviousDepartmentSpeciality(), msg.getDepartmentType(),
+                msg.getIsWardOrFlowArea(), msg.getIsCoreInpatientArea(),
+                msg.getSiteLocation(), msg.getDepartmentContactDate(), storedFrom);
             previousState.setStoredUntil(currentState.getStoredFrom());
             previousState.setValidUntil(currentState.getValidFrom());
             departmentStateRepo.saveAll(List.of(previousState, currentState));

core/src/main/java/uk/ac/ucl/rits/inform/datasinks/emapstar/controllers/PendingAdtController.java

@@ -10,13 +10,18 @@
 import uk.ac.ucl.rits.inform.informdb.movement.Location;
 import uk.ac.ucl.rits.inform.informdb.movement.PlannedMovement;
 import uk.ac.ucl.rits.inform.informdb.movement.PlannedMovementAudit;
+import uk.ac.ucl.rits.inform.interchange.adt.AdmitPatient;
+import uk.ac.ucl.rits.inform.interchange.adt.AdtCancellation;
+import uk.ac.ucl.rits.inform.interchange.adt.AdtMessage;
 import uk.ac.ucl.rits.inform.interchange.adt.CancelPendingTransfer;
+import uk.ac.ucl.rits.inform.interchange.adt.HospitalService;
 import uk.ac.ucl.rits.inform.interchange.adt.PendingTransfer;
 import uk.ac.ucl.rits.inform.interchange.adt.CancelPendingDischarge;
 import uk.ac.ucl.rits.inform.interchange.adt.PendingDischarge;
 
 import java.time.Instant;
 import java.util.List;
+import java.util.Objects;
 import java.util.Optional;
 
 
@@ -174,6 +179,96 @@ public void processMsg(HospitalVisit visit, CancelPendingTransfer msg, Instant v
         plannedState.saveEntityOrAuditLogIfRequired(plannedMovementRepo, plannedMovementAuditRepo);
     }
 
+     /**
+     * Process a real ADT-triggered change of hospital service/subspeciality, as a fallback for when
+     * a matching pending transfer request was never sent (e.g. Z99 edits, or a real admission/update
+     * that carries a hospital service different to the one currently recorded).
+     * <p>
+     * The Hl7 feed will eventually be changed so that we have an identifier per pending transfer, until then we guarantee the order of cancellations.
+     * If we get messages out of order and have several cancellation messages before we receive any requests,
+     * then the first request message for the location and encounter will add the eventDatetime to the earliest cancellation.
+     * Subsequent requests will add the eventDatetime to the earliest cancellation with no eventDatetime, or create a new request if none exist
+     * after the pending request eventDatetime.
+     * @param visit      associated visit
+     * @param msg        the ADT message, for the fields shared by all ADT messages
+     * @param serviceMsg the same message, as its HospitalService view
+     * @param validFrom  time in the hospital when the message was created
+     * @param storedFrom time that emap core started processing the message
+     */
+    public void processHospitalServiceFallback(HospitalVisit visit, AdtMessage msg, HospitalService serviceMsg,
+                                                 Instant validFrom, Instant storedFrom) {
+        if (serviceMsg.getHospitalService().isUnknown()) {
+            return;
+        }
+
+        Location fullLocation = null;
+        if (msg.getFullLocationString().isSave()) {
+            fullLocation = locationController.getOrCreateLocation(msg.getFullLocationString().get());
+        }
+
+        Instant eventDateTime = msg.getEventOccurredDateTime();
+
+        List<PlannedMovement> movements = plannedMovementRepo.findMatchingMovementsForHospitalServiceFallback(visit, fullLocation, eventDateTime);
+        if (!movements.isEmpty()) {
+
+            int mostRecentMoveIndex = movements.size() - 1;
+            String currentService = movements.get(mostRecentMoveIndex).getHospitalService();
+            String editedService = serviceMsg.getHospitalService().get();
+
+            if (!Objects.equals(currentService, editedService)) {
+                Long matchedMovementId = movements.get(mostRecentMoveIndex).getPlannedMovementId();
+                RowState<PlannedMovement, PlannedMovementAudit> plannedState = getOrCreate(
+                        allFromRequest, visit, fullLocation, "EDIT/HOSPITAL_SERVICE_CHANGE", eventDateTime, validFrom, storedFrom
+                );
+                PlannedMovement movement = plannedState.getEntity();
+                // not sure why but event date time isn't being set. Add it here.
+                plannedState.assignIfDifferent(eventDateTime, movement.getEventDatetime(), movement::setEventDatetime);
+                plannedState.assignInterchangeValue(serviceMsg.getHospitalService(), movement.getHospitalService(), movement::setHospitalService);
+                plannedState.assignIfDifferent(matchedMovementId, movement.getMatchedMovementId(), movement::setMatchedMovementId);
+                plannedState.saveEntityOrAuditLogIfRequired(plannedMovementRepo, plannedMovementAuditRepo);
+            }
+        }
+    }
+
+    /**
+     * Record a real admission as its own planned movement.
+     * <p>
+     * Unlike {@link #processHospitalServiceFallback}, this always inserts (or idempotently reuses) an
+     * ADMISSION row, regardless of whether a matching planned movement already exists or has the same
+     * hospital service. Any matched prior movement (e.g. a TRANSFER row from a pending transfer request)
+     * is only referenced via matchedMovementId - it is never itself modified.
+     * @param visit      associated visit
+     * @param msg        the admission message
+     * @param validFrom  time in the hospital when the message was created
+     * @param storedFrom time that emap core started processing the message
+     */
+    public void processAdmission(HospitalVisit visit, AdmitPatient msg, Instant validFrom, Instant storedFrom) {
+        if (msg.getHospitalService().isUnknown()) {
+            return;
+        }
+
+        Location fullLocation = null;
+        if (msg.getFullLocationString().isSave()) {
+            fullLocation = locationController.getOrCreateLocation(msg.getFullLocationString().get());
+        }
+        Instant eventDateTime = msg.getEventOccurredDateTime();
+
+        List<PlannedMovement> priorMovements = plannedMovementRepo.findMatchingMovementsForHospitalServiceFallback(
+                visit, fullLocation, eventDateTime);
+        Long matchedMovementId = priorMovements.isEmpty() ? null : priorMovements.get(priorMovements.size() - 1).getPlannedMovementId();
+
+        RowState<PlannedMovement, PlannedMovementAudit> plannedState = getOrCreate(
+                allFromRequest, visit, fullLocation, "ADMISSION", eventDateTime, validFrom, storedFrom
+        );
+        PlannedMovement movement = plannedState.getEntity();
+        plannedState.assignIfDifferent(eventDateTime, movement.getEventDatetime(), movement::setEventDatetime);
+        plannedState.assignInterchangeValue(msg.getHospitalService(), movement.getHospitalService(), movement::setHospitalService);
+        if (matchedMovementId != null) {
+            plannedState.assignIfDifferent(matchedMovementId, movement.getMatchedMovementId(), movement::setMatchedMovementId);
+        }
+        plannedState.saveEntityOrAuditLogIfRequired(plannedMovementRepo, plannedMovementAuditRepo);
+    }
+
     /**
      * Process pending ADT cancellation.
      * <p>
@@ -203,6 +298,42 @@ public void processMsg(HospitalVisit visit, CancelPendingDischarge msg, Instant
     }
 
 
+    /**
+     * Cancel the matching ADMISSION row for a cancelled admission.
+     * <p>
+     * Only rows created by {@link #processAdmission} (event type ADMISSION) are ever cancelled here.
+     * A row originating from a real pending transfer/discharge request is left alone, since it
+     * represents a separately-tracked plan that may still be valid regardless of this one ADT message.
+     * @param visit        associated visit
+     * @param msg          the ADT message, for the fields shared by all ADT messages
+     * @param cancellation the same message, as its AdtCancellation view
+     * @param validFrom    time in the hospital when the message was created
+     * @param storedFrom   time that emap core started processing the message
+     */
+    public void processAdmissionCancellation(HospitalVisit visit, AdtMessage msg, AdtCancellation cancellation,
+                                              Instant validFrom, Instant storedFrom) {
+        Location fullLocation = null;
+        if (msg.getFullLocationString().isSave()) {
+            fullLocation = locationController.getOrCreateLocation(msg.getFullLocationString().get());
+        }
+
+        List<PlannedMovement> movements = plannedMovementRepo.findMatchingMovementsForHospitalServiceFallback(
+                visit, fullLocation, cancellation.getCancelledDateTime());
+        if (movements.isEmpty()) {
+            return;
+        }
+
+        PlannedMovement movement = movements.get(movements.size() - 1);
+        if (!"ADMISSION".equals(movement.getEventType()) || movement.getCancelledDatetime() != null) {
+            return;
+        }
+
+        RowState<PlannedMovement, PlannedMovementAudit> plannedState = new RowState<>(movement, validFrom, storedFrom, false);
+        plannedState.assignIfDifferent(cancellation.getCancelledDateTime(), movement.getCancelledDatetime(), movement::setCancelledDatetime);
+        plannedState.assignIfDifferent(true, movement.getCancelled(), movement::setCancelled);
+        plannedState.saveEntityOrAuditLogIfRequired(plannedMovementRepo, plannedMovementAuditRepo);
+    }
+
     /**
      * Delete planned movements from a delete patient information message.
      * @param visit            Hospital visit that should have their planned movements deleted

core/src/main/java/uk/ac/ucl/rits/inform/datasinks/emapstar/controllers/VisitController.java

@@ -69,6 +69,18 @@ public HospitalVisit getOrCreateMinimalHospitalVisit(
         return visit.getEntity();
     }
 
+    /**
+     * Look up an existing hospital visit without creating one.
+     * @param encounter encounter number
+     * @return the existing visit, or null if none exists for this encounter
+     */
+    public HospitalVisit getHospitalVisitIfExists(final String encounter) {
+        if (encounter == null || encounter.isEmpty()) {
+            return null;
+        }
+        return hospitalVisitRepo.findByEncounter(encounter).orElse(null);
+    }
+
     /**
      * Get or create minimal hospital visit, and update whether it was created.
      * @param encounter       encounter number
@@ -138,7 +150,7 @@ public HospitalVisit updateOrCreateHospitalVisit(
         Instant validFrom = msg.bestGuessAtValidFrom();
         RowState<HospitalVisit, HospitalVisitAudit> visitState = getOrCreateHospitalVisit(
                 msg.getVisitNumber(), mrn, msg.getSourceSystem(), validFrom, storedFrom);
-
+        addAdmissionType(msg, visitState);
         if (visitShouldBeUpdated(validFrom, msg.getSourceSystem(), visitState)) {
             updateGenericData(msg, visitState);
 
@@ -219,6 +231,17 @@ private void addAdmissionDateTime(final AdmissionDateTime msg, RowState<Hospital
         visitState.assignInterchangeValue(msg.getAdmissionDateTime(), visit.getAdmissionDatetime(), visit::setAdmissionDatetime);
     }
 
+    /**
+     * Add admission type.
+     * @param msg        AdmissionDateTime
+     * @param visitState visit wrapped in state class
+     */
+    private void addAdmissionType(final AdtMessage msg, RowState<HospitalVisit, HospitalVisitAudit> visitState) {
+        HospitalVisit visit = visitState.getEntity();
+        visitState.assignInterchangeValue(msg.getAdmissionType(), visit.getAdmissionType(), visit::setAdmissionType);
+    }
+
+
     /**
      * Delete admission specific information.
      * @param msg        cancellation message

core/src/main/java/uk/ac/ucl/rits/inform/datasinks/emapstar/dataprocessors/AdtProcessor.java

@@ -13,16 +13,20 @@
 import uk.ac.ucl.rits.inform.informdb.identity.HospitalVisit;
 import uk.ac.ucl.rits.inform.informdb.identity.Mrn;
 import uk.ac.ucl.rits.inform.interchange.EmapOperationMessageProcessingException;
+import uk.ac.ucl.rits.inform.interchange.adt.AdmitPatient;
 import uk.ac.ucl.rits.inform.interchange.adt.AdtMessage;
+import uk.ac.ucl.rits.inform.interchange.adt.CancelAdmitPatient;
 import uk.ac.ucl.rits.inform.interchange.adt.CancelPendingDischarge;
 import uk.ac.ucl.rits.inform.interchange.adt.CancelPendingTransfer;
 import uk.ac.ucl.rits.inform.interchange.adt.ChangePatientIdentifiers;
 import uk.ac.ucl.rits.inform.interchange.adt.DeletePersonInformation;
+import uk.ac.ucl.rits.inform.interchange.adt.HospitalService;
 import uk.ac.ucl.rits.inform.interchange.adt.MergePatient;
 import uk.ac.ucl.rits.inform.interchange.adt.MoveVisitInformation;
 import uk.ac.ucl.rits.inform.interchange.adt.PendingDischarge;
 import uk.ac.ucl.rits.inform.interchange.adt.PendingTransfer;
 import uk.ac.ucl.rits.inform.interchange.adt.SwapLocations;
+import uk.ac.ucl.rits.inform.interchange.adt.UpdateSubSpeciality;
 
 import java.time.Instant;
 import java.util.List;
@@ -42,11 +46,11 @@ public class AdtProcessor {
 
     /**
      * Implicitly wired spring beans.
-     * @param personController          person interactions.
-     * @param visitController           encounter interactions.
-     * @param patientLocationController location interactions.
-     * @param pendingAdtController      pending ADT interactions.
-     * @param deletionController        cascading deletes for hospital visits.
+     * @param personController              person interactions.
+     * @param visitController               encounter interactions.
+     * @param patientLocationController     location interactions.
+     * @param pendingAdtController          pending ADT interactions.
+     * @param deletionController            cascading deletes for hospital visits.
      */
     public AdtProcessor(PersonController personController, VisitController visitController,
                         PatientLocationController patientLocationController, PendingAdtController pendingAdtController,
@@ -70,6 +74,18 @@ public void processMessage(final AdtMessage msg, final Instant storedFrom) throw
         Instant messageDateTime = msg.bestGuessAtValidFrom();
         HospitalVisit visit = processPersonAndVisit(msg, storedFrom, messageDateTime);
         patientLocationController.processVisitLocation(visit, msg, storedFrom);
+        if (msg instanceof AdmitPatient) {
+            pendingAdtController.processAdmission(visit, (AdmitPatient) msg, messageDateTime, storedFrom);
+        } else if (msg instanceof HospitalService) {
+            // UpdatePatientInfo doesn't create a visit of its own, so look up an existing one for the fallback.
+            HospitalVisit visitForFallback = (visit != null) ? visit : visitController.getHospitalVisitIfExists(msg.getVisitNumber());
+            if (visitForFallback != null) {
+                pendingAdtController.processHospitalServiceFallback(visitForFallback, msg, (HospitalService) msg, messageDateTime, storedFrom);
+            }
+        }
+        if (msg instanceof CancelAdmitPatient) {
+            pendingAdtController.processAdmissionCancellation(visit, msg, (CancelAdmitPatient) msg, messageDateTime, storedFrom);
+        }
     }
 
     private HospitalVisit processPersonAndVisit(AdtMessage msg, Instant storedFrom, Instant validFrom) throws RequiredDataMissingException {
@@ -244,4 +260,21 @@ public void processPendingAdt(CancelPendingDischarge msg, Instant storedFrom) th
         pendingAdtController.processMsg(visit, msg, validFrom, storedFrom);
     }
 
+
+    /**
+     * Process an update subspeciality message.
+     * <p>
+     * Updates the sub speciality in the hospital visit table
+     * @param msg        change sub speciality adt message
+     * @param storedFrom time that emap core started processing the message
+     * @throws RequiredDataMissingException if the visit number is missing
+     */
+    @Transactional
+    public void processUpdateSubSpeciality(UpdateSubSpeciality msg, Instant storedFrom) throws RequiredDataMissingException {
+        Instant validFrom = msg.bestGuessAtValidFrom();
+        HospitalVisit visit = processPersonAndVisit(msg, storedFrom, validFrom);
+        // patientLocationController.processVisitLocation(visit, msg, storedFrom);
+        pendingAdtController.processHospitalServiceFallback(visit, msg, msg, validFrom, storedFrom);
+    }
+
 }