JMPI-742-update-notification-component

JeMPI_Apps/JeMPI_Bootstrapper/src/main/resources/data/postgres/initialSchema.sql

@@ -2,33 +2,33 @@ CREATE TABLE IF NOT EXISTS Notification_Type
 (
     Id uuid DEFAULT gen_random_uuid() PRIMARY KEY,
     Type VARCHAR(50)
-    );
+);
 
 CREATE TABLE IF NOT EXISTS Action_Type
 (
     Id UUID DEFAULT gen_random_uuid() PRIMARY KEY UNIQUE,
     Type VARCHAR(50)
-    );
+);
 
 CREATE TABLE IF NOT EXISTS Notification_State
 (
     Id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
     State VARCHAR(50)
-    );
+);
 
 CREATE TABLE IF NOT EXISTS Notification
 (
     Id uuid DEFAULT gen_random_uuid() PRIMARY KEY,
     Type VARCHAR(50),
-    Created date,
+    Created timestamp without time zone,
     Reviewd_By uuid,
     Reviewed_At timestamp without time zone,
     State VARCHAR(50),
     Patient_Id VARCHAR(50),
     Names VARCHAR(100),
     Golden_Id VARCHAR(50),
     Score Numeric
-    );
+);
 
 CREATE TABLE IF NOT EXISTS Action
 (
@@ -37,32 +37,32 @@ CREATE TABLE IF NOT EXISTS Action
     Action_Type_Id UUID,
     Date date,
     CONSTRAINT FK_Notification
-    FOREIGN KEY(Notification_Id)
-    REFERENCES Notification(Id),
+      FOREIGN KEY(Notification_Id)
+	    REFERENCES Notification(Id),
     CONSTRAINT FK_Action_Type
-    FOREIGN KEY(Action_Type_Id)
-    REFERENCES Action_Type(Id)
-    );
+      FOREIGN KEY(Action_Type_Id)
+	    REFERENCES Action_Type(Id)
+);
 
 CREATE TABLE IF NOT EXISTS Match
 (
     Notification_Id UUID,
     Score Numeric,
     Golden_Id VARCHAR(50),
     CONSTRAINT FK_Notification
-    FOREIGN KEY(Notification_Id)
-    REFERENCES Notification(Id)
-    );
+      FOREIGN KEY(Notification_Id)
+	    REFERENCES Notification(Id)
+);
 
 CREATE TABLE IF NOT EXISTS candidates
 (
     Notification_Id UUID,
     Score Numeric,
     Golden_Id VARCHAR(50),
     CONSTRAINT FK_Notification
-    FOREIGN KEY(Notification_Id)
-    REFERENCES Notification(Id)
-    );
+      FOREIGN KEY(Notification_Id)
+	    REFERENCES Notification(Id)
+);
 
 CREATE TABLE IF NOT EXISTS users
 (
@@ -71,10 +71,10 @@ CREATE TABLE IF NOT EXISTS users
     family_name VARCHAR(255),
     email VARCHAR(255) UNIQUE,
     username VARCHAR(255) UNIQUE
-    );
+);
 
 INSERT INTO Notification_State(State)
-VALUES ('New'), ('Seen'), ('Actioned'), ('Accepted'), ('Pending');
+VALUES ('OPEN'), ('CLOSED');
 
 INSERT INTO Notification_Type(Type)
 VALUES ('THRESHOLD'), ('MARGIN'), ('UPDATE');

JeMPI_Apps/JeMPI_Controller/src/main/java/org/jembi/jempi/controller/PsqlNotifications.java

@@ -3,9 +3,10 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
+import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.sql.Statement;
-import java.util.Date;
+import java.sql.Timestamp;
 import java.util.UUID;
 
 final class PsqlNotifications {
@@ -21,24 +22,28 @@ void insert(
          final String type,
          final String patientNames,
          final Float score,
-         final Long created,
+         final Timestamp created,
          final String gID,
          final String dID) throws SQLException {
 
       psqlClient.connect();
-      try (Statement stmt = psqlClient.createStatement()) {
-
-         // Set auto-commit to false
+      String sql = "INSERT INTO notification (id, type, state, names, created, patient_id, golden_id, score) "
+            + "VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
+      try (PreparedStatement pstmt = psqlClient.prepareStatement(sql)) {
          psqlClient.setAutoCommit(false);
-         Date res = new Date(created);
-         String state = "New";
-
-         String sql = "INSERT INTO notification (id, type, state, names, created, patient_id, golden_id, score) "
-                      + "VALUES ('" + id + "','" + type + "','" + state + "','" + patientNames + "', '" + res + "', '" + dID
-                      + "', '" + gID + "', '" + score + "')";
-         stmt.addBatch(sql);
-         stmt.executeBatch();
-         psqlClient.commit();
+         pstmt.setObject(1, id);
+         pstmt.setString(2, type);
+         pstmt.setString(3, "OPEN");
+         pstmt.setString(4, patientNames);
+         pstmt.setTimestamp(5, created);
+         pstmt.setString(6, dID);
+         pstmt.setString(7, gID);
+         pstmt.setFloat(8, score);
+         pstmt.executeUpdate();
+      } catch (SQLException e) {
+         LOGGER.error("Error executing INSERT statement: {}", e.getMessage(), e);
+      } finally {
+         psqlClient.setAutoCommit(true);
       }
    }
 

JeMPI_Apps/JeMPI_Controller/src/main/java/org/jembi/jempi/controller/SPNotification.java

@@ -18,6 +18,7 @@
 import org.jembi.jempi.shared.serdes.JsonPojoSerializer;
 
 import java.sql.SQLException;
+import java.sql.Timestamp;
 import java.util.Properties;
 import java.util.UUID;
 
@@ -46,20 +47,20 @@ void open() {
                try {
                   UUID id = UUID.randomUUID();
                   psqlNotifications.insert(id,
-                                           value.notificationType().toString(),
-                                           value.patientNames(),
-                                           value.linkedTo().score(),
-                                           value.timeStamp(),
-                                           value.linkedTo().gID(),
-                                           value.dID());
+                        value.notificationType().toString(),
+                        value.patientNames(),
+                        value.linkedTo().score(),
+                        new Timestamp(value.timeStamp()),
+                        value.linkedTo().gID(),
+                        value.dID());
 
                   for (int i = 0; i < value.candidates().size(); i++) {
                      psqlNotifications.insertCandidates(id,
-                                                        value.candidates().get(i).score(),
-                                                        value.candidates().get(i).gID());
+                           value.candidates().get(i).score(),
+                           value.candidates().get(i).gID());
                   }
                } catch (SQLException e) {
-                  LOGGER.debug(e.toString());
+                  LOGGER.debug("Error inserting notification", e.toString());
                }
             });
 

JeMPI_Apps/JeMPI_LibAPI/src/main/java/org/jembi/jempi/libapi/Ask.java

@@ -9,7 +9,7 @@
 import org.jembi.jempi.shared.models.*;
 
 import java.io.File;
-import java.time.LocalDate;
+import java.sql.Timestamp;
 import java.util.List;
 import java.util.concurrent.CompletionStage;
 
@@ -70,11 +70,12 @@ static CompletionStage<BackEnd.GetNotificationsResponse> getNotifications(
          final ActorRef<BackEnd.Event> backEnd,
          final int limit,
          final int offset,
-         final LocalDate date,
-         final String state) {
+         final Timestamp startDate,
+         final Timestamp endDate,
+         final List<String> states) {
       CompletionStage<BackEnd.GetNotificationsResponse> stage = AskPattern
             .ask(backEnd,
-                 replyTo -> new BackEnd.GetNotificationsRequest(replyTo, limit, offset, date, state),
+                 replyTo -> new BackEnd.GetNotificationsRequest(replyTo, limit, offset, startDate, endDate, states),
                  java.time.Duration.ofSeconds(30),
                  actorSystem.scheduler());
       return stage.thenApply(response -> response);
@@ -309,8 +310,7 @@ static CompletionStage<BackEnd.PostUpdateNotificationResponse> postUpdateNotific
       CompletionStage<BackEnd.PostUpdateNotificationResponse> stage = AskPattern
             .ask(backEnd,
                  replyTo -> new BackEnd.PostUpdateNotificationRequest(replyTo,
-                                                                      notificationRequest.notificationId(),
-                                                                      notificationRequest.state()),
+                                                                      notificationRequest.notificationId()),
                  java.time.Duration.ofSeconds(11),
                  actorSystem.scheduler());
       return stage.thenApply(response -> response);

JeMPI_Apps/JeMPI_LibAPI/src/main/java/org/jembi/jempi/libapi/BackEnd.java

@@ -21,7 +21,7 @@
 import java.nio.file.NoSuchFileException;
 import java.nio.file.Paths;
 import java.sql.SQLException;
-import java.time.LocalDate;
+import java.sql.Timestamp;
 import java.time.LocalDateTime;
 import java.util.*;
 
@@ -234,8 +234,8 @@ private Behavior<Event> postFilterGidsWithInteractionCountHandler(final PostFilt
    }
 
    private Behavior<Event> getNotificationsHandler(final GetNotificationsRequest request) {
-      MatchesForReviewResult result =
-            psqlNotifications.getMatchesForReview(request.limit(), request.offset(), request.date(), request.state);
+      MatchesForReviewResult result = psqlNotifications.getMatchesForReview(request.limit(), request.offset(),
+            request.startDate(), request.endDate(), request.states());
       request.replyTo.tell(new GetNotificationsResponse(result.getCount(),
                                                         result.getSkippedRecords(),
                                                         result.getNotifications()));
@@ -428,7 +428,7 @@ private Behavior<Event> getGidsPagedHandler(final GetGidsPagedRequest request) {
 
    private Behavior<Event> postUpdateNotificationHandler(final PostUpdateNotificationRequest request) {
       try {
-         psqlNotifications.updateNotificationState(request.notificationId, request.state);
+         psqlNotifications.updateNotificationState(request.notificationId);
       } catch (SQLException exception) {
          LOGGER.error(exception.getMessage());
       }
@@ -548,8 +548,9 @@ public record GetNotificationsRequest(
          ActorRef<GetNotificationsResponse> replyTo,
          int limit,
          int offset,
-         LocalDate date,
-         String state) implements Event {
+         Timestamp startDate,
+         Timestamp endDate,
+         List<String> states) implements Event {
    }
 
    public record GetNotificationsResponse(
@@ -592,8 +593,7 @@ public record PatchIidNewGidLinkResponse(Either<MpiGeneralError, LinkInfo> linkI
 
    public record PostUpdateNotificationRequest(
          ActorRef<PostUpdateNotificationResponse> replyTo,
-         String notificationId,
-         String state) implements Event {
+         String notificationId) implements Event {
    }
 
    public record PostUpdateNotificationResponse() implements EventResponse {

JeMPI_Apps/JeMPI_LibAPI/src/main/java/org/jembi/jempi/libapi/PsqlNotifications.java

@@ -5,17 +5,16 @@
 import org.jembi.jempi.shared.models.MatchesForReviewResult;
 
 import java.sql.*;
-import java.time.LocalDate;
 import java.util.*;
 
 final class PsqlNotifications {
    private static final String QUERY = """
-                                       SELECT patient_id, id, names, created, state,type, score, golden_id
-                                       FROM notification
-                                       WHERE created <= ? AND state = ?
-                                       ORDER BY created
-                                       LIMIT ? OFFSET ?
-                                       """;
+         SELECT patient_id, id, names, created, state,type, score, golden_id
+         FROM notification
+         WHERE created BETWEEN ? AND ? AND state IN (?, ?)
+         ORDER BY created
+         LIMIT ? OFFSET ?
+         """;
    private static final Logger LOGGER = LogManager.getLogger(PsqlNotifications.class);
    private final PsqlClient psqlClient;
 
@@ -34,29 +33,34 @@ final class PsqlNotifications {
     * @param limit  The maximum number of matches to retrieve.
     * @param offset The number of matches to skip from the beginning.
     * @param date   The date threshold for match creation.
-    * @param state   The state of notification.
+    * @param states   The state of notification.
     * @return A {@link MatchesForReviewResult} object containing the matches and related information.
     */
    MatchesForReviewResult getMatchesForReview(
          final int limit,
          final int offset,
-         final LocalDate date,
-         final String state) {
+         final Timestamp startDate,
+         final Timestamp endDate,
+         final List<String> states) {
       final var list = new ArrayList<HashMap<String, Object>>();
       MatchesForReviewResult result = new MatchesForReviewResult();
       int skippedRows = 0;
       psqlClient.connect();
       try (PreparedStatement preparedStatement = psqlClient.prepareStatement(QUERY);
-           PreparedStatement countStatement = psqlClient.prepareStatement("SELECT COUNT(*) FROM notification")) {
+           PreparedStatement countStatement = psqlClient.prepareStatement("SELECT COUNT(*) FROM notification WHERE created BETWEEN ? AND ? AND state IN (?, ?)")) {
+         countStatement.setTimestamp(1, startDate);
+         countStatement.setTimestamp(2, endDate);
+         countStatement.setString(3, extractState(0, states));
+         countStatement.setString(4, extractState(1, states));
          ResultSet countRs = countStatement.executeQuery();
          countRs.next();
          int totalCount = countRs.getInt(1);
-
-         preparedStatement.setDate(1, java.sql.Date.valueOf(date));
-         preparedStatement.setString(2, state);
-         preparedStatement.setInt(3, limit);
-         preparedStatement.setInt(4, offset);
-         LOGGER.debug("{}", preparedStatement);
+         preparedStatement.setTimestamp(1, startDate);
+         preparedStatement.setTimestamp(2, endDate);
+         preparedStatement.setString(3, extractState(0, states));
+         preparedStatement.setString(4, extractState(1, states));
+         preparedStatement.setInt(5, limit);
+         preparedStatement.setInt(6, offset);
          ResultSet rs = preparedStatement.executeQuery();
          ResultSetMetaData md = rs.getMetaData();
          int columns = md.getColumnCount();
@@ -82,6 +86,15 @@ MatchesForReviewResult getMatchesForReview(
       return result;
    }
 
+   String extractState(
+         final int index,
+         final List<String> states) {
+      if (index + 1 > states.size()) {
+         return null;
+      }
+      return states.get(index);
+   };
+
    List<HashMap<String, Object>> getCandidates(final UUID nID) {
       final var list = new ArrayList<HashMap<String, Object>>();
       String candidates = "select notification_id, score, golden_id from candidates where notification_id IN ('" + nID + "')";
@@ -128,12 +141,11 @@ void insertCandidates(
    }
 
    void updateNotificationState(
-         final String id,
-         final String state) throws SQLException {
+         final String id) throws SQLException {
       psqlClient.connect();
       try (Statement stmt = psqlClient.createStatement()) {
          ResultSet rs = stmt.executeQuery(String.format(Locale.ROOT,
-                                                        "update notification set state = \'%s\' where id = \'%s\'", state, id));
+                                                        "update notification set state = \'%s\' where id = \'%s\'", "CLOSED", id));
          psqlClient.commit();
       }
    }