Adds NotesMetadata entity and repository

core/pom.xml

@@ -207,6 +207,13 @@
             <target>${java.version}</target>
             <release>${java.version}</release>
             <forceJavacCompilerUse>true</forceJavacCompilerUse>
+            <annotationProcessorPaths>
+              <path>
+                <groupId>org.projectlombok</groupId>
+                <artifactId>lombok</artifactId>
+                <version>${lombok.version}</version>
+              </path>
+            </annotationProcessorPaths>
           </configuration>
         </plugin>
       </plugins>

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

@@ -14,13 +14,15 @@
 import uk.ac.ucl.rits.inform.datasinks.emapstar.dataprocessors.FlowsheetProcessor;
 import uk.ac.ucl.rits.inform.datasinks.emapstar.dataprocessors.FormProcessor;
 import uk.ac.ucl.rits.inform.datasinks.emapstar.dataprocessors.LabProcessor;
+import uk.ac.ucl.rits.inform.datasinks.emapstar.dataprocessors.NotesMetadataProcessor;
 import uk.ac.ucl.rits.inform.datasinks.emapstar.dataprocessors.PatientStateProcessor;
 import uk.ac.ucl.rits.inform.datasinks.emapstar.dataprocessors.WaveformProcessor;
 import uk.ac.ucl.rits.inform.interchange.AdvanceDecisionMessage;
 import uk.ac.ucl.rits.inform.interchange.ConsultMetadata;
 import uk.ac.ucl.rits.inform.interchange.ConsultRequest;
 import uk.ac.ucl.rits.inform.interchange.EmapOperationMessageProcessingException;
 import uk.ac.ucl.rits.inform.interchange.EmapOperationMessageProcessor;
+import uk.ac.ucl.rits.inform.interchange.NotesMetadataMessage;
 import uk.ac.ucl.rits.inform.interchange.PatientAllergy;
 import uk.ac.ucl.rits.inform.interchange.PatientInfection;
 import uk.ac.ucl.rits.inform.interchange.PatientProblem;
@@ -73,6 +75,8 @@ public class InformDbOperations implements EmapOperationMessageProcessor {
     private FormProcessor formProcessor;
     @Autowired
     private WaveformProcessor waveformProcessor;
+    @Autowired
+    private NotesMetadataProcessor notesMetadataProcessor;
 
     @Value("${features.sde:false}")
     private boolean sdeFeatureEnabled;
@@ -83,6 +87,18 @@ public void logFeatureFlags() {
     }
 
 
+    /**
+     * Process a notes metadata message.
+     * @param msg the message
+     * @throws EmapOperationMessageProcessingException if message could not be processed
+     */
+    @Override
+    @Transactional
+    public void processMessage(NotesMetadataMessage msg) throws EmapOperationMessageProcessingException {
+        Instant storedFrom = Instant.now();
+        notesMetadataProcessor.processMessage(msg, storedFrom);
+    }
+
     /**
      * Process a lab order message.
      * @param labOrderMsg the message

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

@@ -0,0 +1,117 @@
+package uk.ac.ucl.rits.inform.datasinks.emapstar.controllers;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import uk.ac.ucl.rits.inform.datasinks.emapstar.RowState;
+import uk.ac.ucl.rits.inform.datasinks.emapstar.exceptions.MessageIgnoredException;
+import uk.ac.ucl.rits.inform.datasinks.emapstar.repos.NotesMetadataAuditRepository;
+import uk.ac.ucl.rits.inform.datasinks.emapstar.repos.NotesMetadataRepository;
+
+
+import uk.ac.ucl.rits.inform.informdb.notes.NotesMetadata;
+import uk.ac.ucl.rits.inform.informdb.notes.NotesMetadataAudit;
+import uk.ac.ucl.rits.inform.informdb.identity.HospitalVisit;
+import uk.ac.ucl.rits.inform.interchange.NotesMetadataMessage;
+
+import java.time.Instant;
+
+/**
+ * Controller for NotesMetadata specific information.
+ * @author Sarah Keating
+ */
+@Component
+public class NotesMetadataController {
+    private final Logger logger = LoggerFactory.getLogger(getClass());
+
+    private final NotesMetadataRepository notesMetadataRepository;
+    private final NotesMetadataAuditRepository notesMetadataAuditRepository;
+
+    NotesMetadataController(
+            NotesMetadataRepository notesMetadataRepository,
+            NotesMetadataAuditRepository notesMetadataAuditRepository) {
+        this.notesMetadataRepository = notesMetadataRepository;
+        this.notesMetadataAuditRepository = notesMetadataAuditRepository;
+    }
+
+    /**
+     * Process notesMetadata data message.
+     * @param msg the interchange message
+     * @param visit the hospital visit
+     * @param storedFrom stored from timestamp
+     * @throws MessageIgnoredException if message not processed
+     */
+    @Transactional
+    public void processMessage(
+            NotesMetadataMessage msg,
+            HospitalVisit visit,
+            Instant storedFrom) throws MessageIgnoredException {
+
+        RowState<NotesMetadata, NotesMetadataAudit> notesMetadataState =      getOrCreateNotesMetadata(msg, visit, storedFrom);
+
+        if (messageShouldBeUpdated(msg.getLastEditDatetime(),     notesMetadataState)) {
+            updateNotesMetadata(msg, notesMetadataState);
+        }
+
+        notesMetadataState.saveEntityOrAuditLogIfRequired(notesMetadataRepository, notesMetadataAuditRepository);
+    }
+
+    /**
+     * Get existing or create new advance decision.
+     * @param msg                 Advance decision message.
+     * @param visit               Hospital visit of patient this advanced decision message refers to.
+     * @param storedFrom          Time that emap-core started processing this advanced decision message.
+     * @return AdvancedDecision entity wrapped in RowState
+     */
+    private RowState<NotesMetadata, NotesMetadataAudit> getOrCreateNotesMetadata(NotesMetadataMessage msg, HospitalVisit visit,
+        Instant storedFrom) {
+        return notesMetadataRepository
+            .findByInternalId(msg.getNotesMetadataId())
+            .map(obs -> new RowState<>(obs, msg.getLastEditDatetime(), storedFrom, false))
+            .orElseGet(() -> createMinimalNotesMetadata(msg, visit, storedFrom));
+    }
+
+    /**
+     * Create minimal advance decision wrapped in RowState.
+     * @param msg                 Advance decision message
+     * @param visit               Hospital visit of the patient advanced decision was recorded for.
+     * @param storedFrom          Time that emap-core started processing the advanced decision of that patient.
+     * @return minimal advanced decision wrapped in RowState
+     */
+    private RowState<NotesMetadata, NotesMetadataAudit>
+        createMinimalNotesMetadata(NotesMetadataMessage msg,
+            HospitalVisit visit, Instant storedFrom) {
+        NotesMetadata notesMetadata = new NotesMetadata(
+            msg.getNotesMetadataId(), visit);
+        logger.debug("Created new {}", notesMetadata);
+        return new RowState<>(notesMetadata, msg.getLastEditDatetime(), storedFrom, true);
+    }
+
+    /**
+     * Decides whether or not the data held for a specific advance decision needs to be updated or not.
+     * @param statusChangeDatetime  Datetime of NotesMetadataMessage that's currently processed.
+     * @param notesMetadataState State of advance decision created from message.
+     * @return true if message should be updated
+     */
+    private boolean messageShouldBeUpdated(Instant statusChangeDatetime, RowState<NotesMetadata,
+            NotesMetadataAudit> notesMetadataState) {
+        return (notesMetadataState.isEntityCreated() || !statusChangeDatetime.isBefore(
+                notesMetadataState.getEntity().getValidFrom()));
+    }
+
+    /**
+     * Update advance decision data with information from NotesMetadataMessage.
+     * @param msg                  Advance decision message.
+     * @param notesMetadataState Advance decision referred to in message
+     */
+    private void updateNotesMetadata(NotesMetadataMessage msg, RowState<NotesMetadata,
+            NotesMetadataAudit> notesMetadataState) {
+        NotesMetadata notesMetadata = notesMetadataState.getEntity();
+
+        notesMetadataState.assignIfDifferent(msg.getLastEditDatetime(), notesMetadata.getLastEditDatetime(),
+                notesMetadata::setLastEditDatetime);
+    }
+}
+

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

@@ -0,0 +1,67 @@
+package uk.ac.ucl.rits.inform.datasinks.emapstar.dataprocessors;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import uk.ac.ucl.rits.inform.datasinks.emapstar.controllers.NotesMetadataController;
+import uk.ac.ucl.rits.inform.datasinks.emapstar.controllers.PersonController;
+import uk.ac.ucl.rits.inform.datasinks.emapstar.controllers.VisitController;
+
+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.NotesMetadataMessage;
+
+
+import java.time.Instant;
+
+/**
+ * Handle processing of notes metadata messages.
+ * @author Sarah Keating
+ */
+@Component
+public class NotesMetadataProcessor {
+    private final Logger logger = LoggerFactory.getLogger(getClass());
+    private final PersonController personController;
+    private final VisitController visitController;
+    private final NotesMetadataController notesMetadataController;
+
+    /**
+     * Notes metadata controller to identify whether metadata needs to be updated; person controller to identify patient.
+     * @param notesMetadataController    notes metadata controller
+     * @param personController           person controller
+     * @param visitController            hospital visit controller
+     */
+    public NotesMetadataProcessor(NotesMetadataController notesMetadataController,
+            PersonController personController, VisitController visitController) {
+        this.personController = personController;
+        this.visitController = visitController;
+        this.notesMetadataController = notesMetadataController;
+    }
+
+    /**
+     * Process notes metadata message.
+     * @param msg        message
+     * @param storedFrom Time the message started to be processed by star
+     * @throws EmapOperationMessageProcessingException if message can't be processed.
+     */
+    @Transactional
+    public void processMessage(final NotesMetadataMessage msg, final Instant storedFrom)
+            throws EmapOperationMessageProcessingException {
+        Instant msgStatusChangeTime = msg.getLastEditDatetime();
+        if (msgStatusChangeTime == null) {
+            msgStatusChangeTime = storedFrom;
+        }
+
+        // retrieve patient to whom message refers to; if MRN not registered, create new patient
+        Mrn mrn = personController.getOrCreateOnMrnOnly(msg.getMrn(), null, msg.getSourceSystem(),
+                msgStatusChangeTime, storedFrom);
+        HospitalVisit visit = visitController.getOrCreateMinimalHospitalVisit(
+                msg.getVisitNumber(), mrn, msg.getSourceSystem(), msg.getLastEditDatetime(), storedFrom);
+        logger.trace("Processing {}", msg);
+        notesMetadataController.processMessage(msg, visit, storedFrom);
+    }
+}

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

@@ -0,0 +1,19 @@
+package uk.ac.ucl.rits.inform.datasinks.emapstar.repos;
+
+import org.springframework.data.repository.CrudRepository;
+import uk.ac.ucl.rits.inform.informdb.notes.NotesMetadataAudit;
+
+import java.util.List;
+
+/**
+ * Interaction with the NotesMetadataAudit table.
+ * @author Sarah Keating
+ */
+public interface NotesMetadataAuditRepository extends CrudRepository<NotesMetadataAudit, Long> {
+    /**
+     * For testing.
+     * @param hospitalVisitId id of the hospital visit
+     * @return all notes metadata audits
+     */
+    List<NotesMetadataAudit> findAllByHospitalVisitId(long hospitalVisitId);
+}

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

@@ -0,0 +1,24 @@
+package uk.ac.ucl.rits.inform.datasinks.emapstar.repos;
+
+import org.springframework.data.repository.CrudRepository;
+
+import uk.ac.ucl.rits.inform.informdb.identity.HospitalVisit;
+import uk.ac.ucl.rits.inform.informdb.notes.NotesMetadata;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Interaction with the NotesMetadata table.
+ * @author Sarah Keating
+ */
+public interface NotesMetadataRepository extends CrudRepository<NotesMetadata, Long> {
+    /**
+     * Find notes metadata by unique identifier.
+     * @param internalId internal ID for the notes metadata
+     * @return possible NotesMetadata
+     */
+    Optional<NotesMetadata> findByInternalId(Long internalId);
+
+    List<NotesMetadata> findAllByHospitalVisitId(HospitalVisit hospitalVisit);
+}

core/src/test/java/uk/ac/ucl/rits/inform/datasinks/emapstar/TestNotesMetadataProcessing.java

@@ -0,0 +1,76 @@
+package uk.ac.ucl.rits.inform.datasinks.emapstar;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import uk.ac.ucl.rits.inform.datasinks.emapstar.repos.HospitalVisitRepository;
+import uk.ac.ucl.rits.inform.datasinks.emapstar.repos.MrnRepository;
+import uk.ac.ucl.rits.inform.datasinks.emapstar.repos.NotesMetadataRepository;
+import uk.ac.ucl.rits.inform.informdb.notes.NotesMetadata;
+import uk.ac.ucl.rits.inform.informdb.identity.HospitalVisit;
+import uk.ac.ucl.rits.inform.informdb.identity.Mrn;
+import uk.ac.ucl.rits.inform.informdb.identity.MrnToLive;
+import uk.ac.ucl.rits.inform.interchange.NotesMetadataMessage;
+import uk.ac.ucl.rits.inform.interchange.EmapOperationMessageProcessingException;
+
+import java.io.IOException;
+import java.time.Instant;
+import java.util.List;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Test cases to assert correct processing of NotesMetadataMessages.
+ * @author Anika Cawthorn
+ */
+public class TestNotesMetadataProcessing extends MessageProcessingBase {
+    @Autowired
+    NotesMetadataRepository notesMetadataRepo;
+    @Autowired
+    HospitalVisitRepository hospitalVisitRepository;
+    @Autowired
+    MrnRepository mrnRepository;
+
+    private NotesMetadataMessage minimal;
+    // private NotesMetadataMessage minimalWithQuestions;
+    // private NotesMetadataMessage closedAtDischarge;
+    // private NotesMetadataMessage cancelled;
+
+    private static Instant NOTES_METADATA_START_TIME =  Instant.parse("2013-02-14T09:00:00Z");
+    private static Instant NOTES_METADATA_EDIT_TIME =  Instant.parse("2013-02-14T09:00:00Z");
+    private static Long NOTES_METADATA_INTERNAL_ID = 1234521112L;
+    private static String NOTES_METADATA_MRN = "40800000";
+
+    @BeforeEach
+    public void setUp() throws IOException {
+        minimal = messageFactory.getNotesMetadataMessage("minimal.yaml");
+    }
+
+    /**
+     *  Given that no MRNS or hospital visits exist in the database
+     *  When a new NotesMetadataMessage without questions arrives
+     *  Then a minimal HospitalVisit, Mrn and NotesMetadata should be created
+     */
+    @Test
+    void testMinimalNotesMetadataCreated() throws EmapOperationMessageProcessingException {
+        processSingleMessage(minimal);
+
+        List<Mrn> mrns = getAllMrns();
+        assertEquals(1, mrns.size());
+
+        assertEquals(NOTES_METADATA_MRN, mrns.get(0).getMrn());
+        MrnToLive mrnToLive = mrnToLiveRepo.getByMrnIdEquals(mrns.get(0));
+        assertNotNull(mrnToLive);
+
+        Optional<HospitalVisit> visit = hospitalVisitRepository.findByEncounter(defaultEncounter);
+        assertTrue(visit.isPresent());
+
+
+
+        NotesMetadata notesMetadata = notesMetadataRepo.findByInternalId(NOTES_METADATA_INTERNAL_ID).orElseThrow();
+        assertEquals(NOTES_METADATA_EDIT_TIME, notesMetadata.getValidFrom());
+        assertEquals(NOTES_METADATA_START_TIME, notesMetadata.getStartedDatetime());
+    }
+}

emap-checker.xml

@@ -107,7 +107,10 @@
     <!-- Checks for Size Violations. -->
     <!-- See http://checkstyle.sf.net/config_sizes.html -->
     <module name="MethodLength"/>
-    <module name="ParameterNumber"/>
+    <module name="ParameterNumber">
+      <property name="max" value="10"/>
+      <property name="tokens" value="METHOD_DEF"/>
+    </module>
 
     <!-- Checks for whitespace -->
     <!-- See http://checkstyle.sf.net/config_whitespace.html -->

emap-interchange/pom.xml

@@ -128,6 +128,13 @@
             <source>${java.version}</source>
             <target>${java.version}</target>
             <forceJavacCompilerUse>true</forceJavacCompilerUse>
+            <annotationProcessorPaths>
+              <path>
+                <groupId>org.projectlombok</groupId>
+                <artifactId>lombok</artifactId>
+                <version>${lombok.version}</version>
+              </path>
+            </annotationProcessorPaths>
           </configuration>
         </plugin>
       </plugins>