fix: implement program message filtering based on orgUnit[DHIS2-17837]

dhis-2/dhis-api/src/main/java/org/hisp/dhis/program/message/ProgramMessageOperationParams.java

@@ -28,6 +28,7 @@
 package org.hisp.dhis.program.message;
 
 import java.util.Date;
+import java.util.HashSet;
 import java.util.Set;
 import lombok.Builder;
 import lombok.Getter;
@@ -37,9 +38,9 @@
  * @author Zubair Asghar
  */
 @Getter
-@Builder
+@Builder(toBuilder = true)
 public class ProgramMessageOperationParams {
-  private Set<String> ou;
+  @Builder.Default private Set<UID> organisationUnits = new HashSet<>();
 
   private UID enrollment;
 

dhis-2/dhis-api/src/main/java/org/hisp/dhis/program/message/ProgramMessageQueryParams.java

@@ -28,9 +28,11 @@
 package org.hisp.dhis.program.message;
 
 import java.util.Date;
+import java.util.HashSet;
 import java.util.Set;
 import lombok.Builder;
 import lombok.Data;
+import org.hisp.dhis.organisationunit.OrganisationUnit;
 import org.hisp.dhis.program.Enrollment;
 import org.hisp.dhis.program.Event;
 
@@ -40,7 +42,7 @@
 @Data
 @Builder
 public class ProgramMessageQueryParams {
-  private Set<String> organisationUnit;
+  @Builder.Default private Set<OrganisationUnit> organisationUnits = new HashSet<>();
 
   private ProgramMessageStatus messageStatus;
 
@@ -61,7 +63,7 @@ public class ProgramMessageQueryParams {
   // -------------------------------------------------------------------------
 
   public boolean hasOrganisationUnit() {
-    return organisationUnit != null;
+    return organisationUnits != null && !organisationUnits.isEmpty();
   }
 
   public boolean hasEnrollment() {

dhis-2/dhis-api/src/main/java/org/hisp/dhis/program/message/ProgramMessageService.java

@@ -29,6 +29,8 @@
 
 import java.util.List;
 import org.hisp.dhis.common.DeliveryChannel;
+import org.hisp.dhis.common.UID;
+import org.hisp.dhis.feedback.BadRequestException;
 import org.hisp.dhis.feedback.NotFoundException;
 import org.hisp.dhis.outboundmessage.BatchResponseStatus;
 
@@ -67,7 +69,7 @@ public interface ProgramMessageService {
   List<ProgramMessage> getAllProgramMessages();
 
   List<ProgramMessage> getProgramMessages(ProgramMessageOperationParams params)
-      throws NotFoundException;
+      throws NotFoundException, BadRequestException;
 
   // -------------------------------------------------------------------------
   // Save OR Update
@@ -77,9 +79,13 @@ List<ProgramMessage> getProgramMessages(ProgramMessageOperationParams params)
 
   void updateProgramMessage(ProgramMessage programMessage);
 
+  void updateProgramMessage(UID uid, ProgramMessageStatus status) throws NotFoundException;
+
   // -------------------------------------------------------------------------
   // Delete
   // -------------------------------------------------------------------------
 
   void deleteProgramMessage(ProgramMessage programMessage);
+
+  void deleteProgramMessage(UID uid) throws NotFoundException;
 }

dhis-2/dhis-services/dhis-service-core/src/main/java/org/hisp/dhis/program/hibernate/HibernateProgramMessageStore.java

@@ -95,10 +95,13 @@ private Query<ProgramMessage> getHqlQuery(ProgramMessageQueryParams params) {
       hql.append(helper.whereAnd()).append("pm.messageStatus = :messageStatus");
     }
     if (params.getAfterDate() != null) {
-      hql.append(helper.whereAnd()).append("pm.processeddate > :afterDate");
+      hql.append(helper.whereAnd()).append("pm.processedDate > :afterDate");
     }
     if (params.getBeforeDate() != null) {
-      hql.append(helper.whereAnd()).append("pm.processeddate < :beforeDate");
+      hql.append(helper.whereAnd()).append("pm.processedDate < :beforeDate");
+    }
+    if (params.hasOrganisationUnit()) {
+      hql.append(helper.whereAnd()).append("pm.recipients.organisationUnit = :orgUnits");
     }
 
     Query<ProgramMessage> query = getQuery(hql.toString());
@@ -118,6 +121,9 @@ private Query<ProgramMessage> getHqlQuery(ProgramMessageQueryParams params) {
     if (params.getBeforeDate() != null) {
       query.setParameter("beforeDate", params.getBeforeDate());
     }
+    if (params.hasOrganisationUnit()) {
+      query.setParameter("orgUnits", params.getOrganisationUnits());
+    }
 
     return query;
   }

dhis-2/dhis-services/dhis-service-core/src/main/java/org/hisp/dhis/program/message/DefaultProgramMessageService.java

@@ -34,14 +34,15 @@
 import java.util.Date;
 import java.util.List;
 import java.util.Set;
-import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.hisp.dhis.common.BaseIdentifiableObject;
 import org.hisp.dhis.common.DeliveryChannel;
 import org.hisp.dhis.common.IdentifiableObject;
 import org.hisp.dhis.common.IdentifiableObjectManager;
 import org.hisp.dhis.common.IllegalQueryException;
+import org.hisp.dhis.common.UID;
+import org.hisp.dhis.feedback.BadRequestException;
 import org.hisp.dhis.feedback.NotFoundException;
 import org.hisp.dhis.organisationunit.OrganisationUnitService;
 import org.hisp.dhis.outboundmessage.BatchResponseStatus;
@@ -106,7 +107,7 @@ public List<ProgramMessage> getAllProgramMessages() {
   @Override
   @Transactional(readOnly = true)
   public List<ProgramMessage> getProgramMessages(ProgramMessageOperationParams params)
-      throws NotFoundException {
+      throws NotFoundException, BadRequestException {
     ProgramMessageQueryParams queryParams = operationParamMapper.map(params);
 
     return programMessageStore.getProgramMessages(queryParams);
@@ -119,6 +120,28 @@ public long saveProgramMessage(ProgramMessage programMessage) {
     return programMessage.getId();
   }
 
+  @Override
+  @Transactional
+  public void updateProgramMessage(UID uid, ProgramMessageStatus status) throws NotFoundException {
+    ProgramMessage persisted = programMessageStore.getByUid(uid.getValue());
+    if (persisted == null) {
+      throw new NotFoundException(ProgramMessage.class, uid.getValue());
+    }
+
+    persisted.setMessageStatus(status);
+    programMessageStore.update(persisted);
+  }
+
+  @Override
+  @Transactional
+  public void deleteProgramMessage(UID uid) throws NotFoundException {
+    ProgramMessage persisted = programMessageStore.getByUid(uid.getValue());
+    if (persisted == null) {
+      throw new NotFoundException(ProgramMessage.class, uid.getValue());
+    }
+    programMessageStore.delete(persisted);
+  }
+
   @Override
   @Transactional
   public void updateProgramMessage(ProgramMessage programMessage) {
@@ -137,7 +160,7 @@ public BatchResponseStatus sendMessages(List<ProgramMessage> programMessages) {
         programMessages.stream()
             .filter(this::hasDataWriteAccess)
             .map(this::setAttributesBasedOnStrategy)
-            .collect(Collectors.toList());
+            .toList();
 
     List<OutboundMessageBatch> batches = createBatches(populatedProgramMessages);
 

dhis-2/dhis-services/dhis-service-core/src/main/java/org/hisp/dhis/program/message/ProgramMessageOperationParamMapper.java

@@ -27,14 +27,19 @@
  */
 package org.hisp.dhis.program.message;
 
+import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 import lombok.RequiredArgsConstructor;
 import org.hisp.dhis.common.BaseIdentifiableObject;
 import org.hisp.dhis.common.IdentifiableObjectManager;
 import org.hisp.dhis.common.IllegalQueryException;
 import org.hisp.dhis.common.UID;
+import org.hisp.dhis.feedback.BadRequestException;
 import org.hisp.dhis.feedback.NotFoundException;
+import org.hisp.dhis.organisationunit.OrganisationUnit;
+import org.hisp.dhis.organisationunit.OrganisationUnitService;
 import org.hisp.dhis.program.Enrollment;
 import org.hisp.dhis.program.Event;
 import org.hisp.dhis.program.Program;
@@ -53,13 +58,23 @@ public class ProgramMessageOperationParamMapper {
   private final IdentifiableObjectManager manager;
 
   private final ProgramService programService;
+  private final OrganisationUnitService organisationUnitService;
 
   @Transactional(readOnly = true)
   public ProgramMessageQueryParams map(ProgramMessageOperationParams operationParams)
-      throws NotFoundException {
+      throws NotFoundException, BadRequestException {
     Enrollment enrollment = getEntity(operationParams.getEnrollment(), Enrollment.class);
     Event event = getEntity(operationParams.getEvent(), Event.class);
 
+    Set<OrganisationUnit> ous = new HashSet<>();
+    for (UID orgUnitUid : operationParams.getOrganisationUnits()) {
+      OrganisationUnit orgUnit = organisationUnitService.getOrganisationUnit(orgUnitUid.getValue());
+      if (orgUnit == null) {
+        throw new BadRequestException("Organisation unit does not exist: " + orgUnitUid);
+      }
+      ous.add(orgUnit);
+    }
+
     currentUserHasAccess(enrollment, event);
 
     return ProgramMessageQueryParams.builder()
@@ -70,7 +85,7 @@ public ProgramMessageQueryParams map(ProgramMessageOperationParams operationPara
         .beforeDate(operationParams.getBeforeDate())
         .page(operationParams.getPage())
         .pageSize(operationParams.getPageSize())
-        .organisationUnit(operationParams.getOu())
+        .organisationUnits(ous)
         .build();
   }
 
@@ -98,6 +113,7 @@ private void currentUserHasAccess(Enrollment enrollment, Event event) {
     }
 
     List<Program> programs = programService.getCurrentUserPrograms();
+
     String currentUser = CurrentUserUtil.getCurrentUsername();
 
     if (!programs.contains(entity.getProgram())) {

dhis-2/dhis-services/dhis-service-core/src/test/java/org/hisp/dhis/message/ProgramMessageOperationParamsMapperTest.java

@@ -33,13 +33,16 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
 import java.util.List;
 import org.hisp.dhis.common.CodeGenerator;
 import org.hisp.dhis.common.IdentifiableObjectManager;
 import org.hisp.dhis.common.IllegalQueryException;
 import org.hisp.dhis.common.UID;
+import org.hisp.dhis.feedback.BadRequestException;
 import org.hisp.dhis.feedback.NotFoundException;
 import org.hisp.dhis.program.Enrollment;
 import org.hisp.dhis.program.Event;
@@ -56,13 +59,10 @@
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.mockito.junit.jupiter.MockitoSettings;
-import org.mockito.quality.Strictness;
 
 /**
  * @author Zubair Asghar
  */
-@MockitoSettings(strictness = Strictness.LENIENT)
 @ExtendWith(MockitoExtension.class)
 class ProgramMessageOperationParamsMapperTest {
   private static UID ENROLLMENT = UID.of(CodeGenerator.generateUid());
@@ -95,26 +95,32 @@ void setUp() {
     event = new Event();
     event.setUid(EVENT.getValue());
     event.setEnrollment(enrollment);
-
-    when(manager.get(eq(Enrollment.class), anyString())).thenReturn(enrollment);
-    when(manager.get(eq(Event.class), anyString())).thenReturn(event);
-    when(programService.getCurrentUserPrograms()).thenReturn(List.of(program));
   }
 
   @Test
-  void shouldMapEnrollmentUIDToEnrollmentObject() throws NotFoundException {
+  void shouldMapEnrollmentUIDToEnrollmentObject() throws NotFoundException, BadRequestException {
+    when(programService.getCurrentUserPrograms()).thenReturn(List.of(program));
+    when(manager.get(eq(Enrollment.class), anyString())).thenReturn(enrollment);
+
     ProgramMessageQueryParams queryParams =
         subject.map(ProgramMessageOperationParams.builder().enrollment(ENROLLMENT).build());
 
     assertEquals(enrollment, queryParams.getEnrollment());
+    verify(manager).get(Enrollment.class, ENROLLMENT.getValue());
+    verifyNoMoreInteractions(manager);
   }
 
   @Test
-  void shouldMapEventUIDToEnrollmentObject() throws NotFoundException {
+  void shouldMapEventUIDToEnrollmentObject() throws NotFoundException, BadRequestException {
+    when(programService.getCurrentUserPrograms()).thenReturn(List.of(program));
+    when(manager.get(eq(Event.class), anyString())).thenReturn(event);
+
     ProgramMessageQueryParams queryParams =
         subject.map(ProgramMessageOperationParams.builder().event(EVENT).build());
 
     assertEquals(event, queryParams.getEvent());
+    verify(manager).get(Event.class, EVENT.getValue());
+    verifyNoMoreInteractions(manager);
   }
 
   @Test
@@ -133,6 +139,8 @@ void shouldFailWhenEnrollmentNotFound() {
         String.format(
             "%s: %s does not exist.", Enrollment.class.getSimpleName(), invalidEnrollment),
         exception.getMessage());
+    verify(manager).get(Enrollment.class, invalidEnrollment.getValue());
+    verifyNoMoreInteractions(manager);
   }
 
   @Test
@@ -148,10 +156,13 @@ void shouldFailWhenEventNotFound() {
     assertStartsWith(
         String.format("%s: %s does not exist.", Event.class.getSimpleName(), invalidEvent),
         exception.getMessage());
+    verify(manager).get(Event.class, invalidEvent.getValue());
+    verifyNoMoreInteractions(manager);
   }
 
   @Test
   void shouldFailWhenUserHasNoAccessToProgram() {
+    when(manager.get(eq(Enrollment.class), anyString())).thenReturn(enrollment);
     when(programService.getCurrentUserPrograms()).thenReturn(List.of());
 
     IllegalQueryException exception =
@@ -166,5 +177,8 @@ void shouldFailWhenUserHasNoAccessToProgram() {
             "User:%s does not have access to the required program:%s",
             user.getUsername(), program.getName()),
         exception.getMessage());
+
+    verify(programService).getCurrentUserPrograms();
+    verifyNoMoreInteractions(programService);
   }
 }