Updated changes in ICT4H repo

openmrs-atomfeed-api/pom.xml

@@ -4,7 +4,7 @@
 	<parent>
 		<groupId>org.ict4h.openmrs</groupId>
 		<artifactId>openmrs-atomfeed</artifactId>
-		<version>2.5.1-SNAPSHOT</version>
+		<version>2.6.3</version>
 	</parent>
 
 	<artifactId>openmrs-atomfeed-api</artifactId>
@@ -17,14 +17,25 @@
         <dependency>
             <groupId>org.ict4h</groupId>
             <artifactId>atomfeed-server</artifactId>
+			<version>${atomfeed.version}</version>
         </dependency>
 
 		<dependency>
 			<groupId>org.openmrs.api</groupId>
 			<artifactId>openmrs-api</artifactId>
 			<type>jar</type>
 		</dependency>
-
+
+		<dependency>
+			<groupId>org.apache.logging.log4j</groupId>
+			<artifactId>log4j-api</artifactId>
+		</dependency>
+
+		<dependency>
+			<groupId>org.apache.logging.log4j</groupId>
+			<artifactId>log4j-core</artifactId>
+		</dependency>
+
 		<dependency>
 			<groupId>org.openmrs.web</groupId>
 			<artifactId>openmrs-web</artifactId>

openmrs-atomfeed-api/src/main/java/org/openmrs/module/atomfeed/EventPublishFilterHook.java

@@ -1,7 +1,8 @@
 package org.openmrs.module.atomfeed;
 
 import groovy.lang.GroovyClassLoader;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.openmrs.module.atomfeed.advice.EncounterSaveAdvice;
 import org.openmrs.module.atomfeed.filter.DefaultEventPublishFilter;
 import org.openmrs.module.atomfeed.filter.EventPublishFilter;
@@ -14,7 +15,7 @@
 
 public class EventPublishFilterHook {
 
-    private static final Logger log = Logger.getLogger(EncounterSaveAdvice.class);
+    private static final Logger log = LogManager.getLogger(EncounterSaveAdvice.class);
     private static GroovyClassLoader groovyClassLoader = new GroovyClassLoader();
     private static Map<String, EventPublishFilter> eventPublishFilterMap = new HashMap<String, EventPublishFilter>();
 

openmrs-atomfeed-api/src/main/java/org/openmrs/module/atomfeed/advice/EncounterSaveAdvice.java

@@ -7,7 +7,6 @@
 import org.ict4h.atomfeed.server.service.EventService;
 import org.ict4h.atomfeed.server.service.EventServiceImpl;
 import org.ict4h.atomfeed.transaction.AFTransactionWorkWithoutResult;
-import org.joda.time.DateTime;
 import org.openmrs.api.context.Context;
 import org.openmrs.module.atomfeed.EventPublishFilterHook;
 import org.openmrs.module.atomfeed.transaction.support.AtomFeedSpringTransactionManager;
@@ -17,6 +16,7 @@
 import java.lang.reflect.Method;
 import java.net.URI;
 import java.sql.SQLException;
+import java.time.LocalDateTime;
 import java.util.List;
 import java.util.UUID;
 
@@ -46,7 +46,7 @@ public void afterReturning(Object returnValue, Method method, Object[] args, Obj
         if (method.getName().equals(SAVE_METHOD)) {
             Object encounterUuid = PropertyUtils.getProperty(returnValue, "encounterUuid");
             String url = String.format(ENCOUNTER_REST_URL, encounterUuid);
-            final Event event = new Event(UUID.randomUUID().toString(), TITLE, DateTime.now(), (URI) null, url, CATEGORY);
+            final Event event = new Event(UUID.randomUUID().toString(), TITLE, LocalDateTime.now(), (URI) null, url, CATEGORY);
             if (EventPublishFilterHook.shouldPublish(returnValue, args, "EncounterPublishCondition.groovy")) {
                 atomFeedSpringTransactionManager.executeWithTransaction(
                         new AFTransactionWorkWithoutResult() {

openmrs-atomfeed-api/src/main/java/org/openmrs/module/atomfeed/advice/EncounterServiceSaveAdvice.java

@@ -0,0 +1,81 @@
+package org.openmrs.module.atomfeed.advice;
+
+
+import org.ict4h.atomfeed.server.repository.AllEventRecordsQueue;
+import org.ict4h.atomfeed.server.repository.jdbc.AllEventRecordsQueueJdbcImpl;
+import org.ict4h.atomfeed.server.service.Event;
+import org.ict4h.atomfeed.server.service.EventService;
+import org.ict4h.atomfeed.server.service.EventServiceImpl;
+import org.ict4h.atomfeed.transaction.AFTransactionWorkWithoutResult;
+import org.openmrs.Encounter;
+import org.openmrs.api.context.Context;
+import org.openmrs.module.atomfeed.EventPublishFilterHook;
+import org.openmrs.module.atomfeed.transaction.support.AtomFeedSpringTransactionManager;
+import org.springframework.aop.AfterReturningAdvice;
+import org.springframework.transaction.PlatformTransactionManager;
+
+import java.lang.reflect.Method;
+import java.net.URI;
+import java.sql.SQLException;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+
+public class EncounterServiceSaveAdvice implements AfterReturningAdvice {
+
+    public static final String ENCOUNTER_REST_URL = getEncounterFeedUrl();
+    public static final String TITLE = "Encounter";
+    public static final String CATEGORY = "Encounter";
+    private final AtomFeedSpringTransactionManager atomFeedSpringTransactionManager;
+
+    private static final String SAVE_METHOD = "saveEncounter";
+    private static final String ENCOUNTER_TYPE_INVESTIGATION = "INVESTIGATION";
+
+    private EventService eventService;
+
+    public EncounterServiceSaveAdvice() throws SQLException {
+        PlatformTransactionManager platformTransactionManager = getSpringPlatformTransactionManager();
+        atomFeedSpringTransactionManager = new AtomFeedSpringTransactionManager(platformTransactionManager);
+        AllEventRecordsQueue allEventRecordsQueue = new AllEventRecordsQueueJdbcImpl(atomFeedSpringTransactionManager);
+        this.eventService = new EventServiceImpl(allEventRecordsQueue);
+    }
+
+
+    @Override
+    public void afterReturning(Object returnValue, Method method, Object[] args, Object encounterService) throws Throwable {
+        if (method.getName().equals(SAVE_METHOD)) {
+            Encounter encounter = (Encounter) args[0]; // Assuming encounter is the first argument
+            String encounterType = encounter.getEncounterType().getName(); // Assuming encounterType is a string
+            if (ENCOUNTER_TYPE_INVESTIGATION.equals(encounterType)) {
+
+                String url = String.format(ENCOUNTER_REST_URL, encounter.getUuid());
+                final Event event = new Event(UUID.randomUUID().toString(), TITLE, LocalDateTime.now(), (URI) null, url, CATEGORY);
+                if (EventPublishFilterHook.shouldPublish(returnValue, args, "EncounterPublishCondition.groovy")) {
+                    atomFeedSpringTransactionManager.executeWithTransaction(
+                            new AFTransactionWorkWithoutResult() {
+                                @Override
+                                protected void doInTransaction() {
+                                    eventService.notify(event);
+                                }
+
+                                @Override
+                                public PropagationDefinition getTxPropagationDefinition() {
+                                    return PropagationDefinition.PROPAGATION_REQUIRED;
+                                }
+                            }
+                    );
+                }
+            }
+        }
+    }
+
+    private static String getEncounterFeedUrl() {
+        return Context.getAdministrationService().getGlobalProperty("encounter.feed.publish.url");
+    }
+
+    private PlatformTransactionManager getSpringPlatformTransactionManager() {
+        List<PlatformTransactionManager> platformTransactionManagers = Context.getRegisteredComponents(PlatformTransactionManager.class);
+        return platformTransactionManagers.get(0);
+    }
+}
+

openmrs-atomfeed-api/src/main/java/org/openmrs/module/atomfeed/advice/PatientAdvice.java

@@ -6,7 +6,6 @@
 import org.ict4h.atomfeed.server.service.EventService;
 import org.ict4h.atomfeed.server.service.EventServiceImpl;
 import org.ict4h.atomfeed.transaction.AFTransactionWorkWithoutResult;
-import org.joda.time.DateTime;
 import org.openmrs.Patient;
 import org.openmrs.api.context.Context;
 import org.openmrs.module.atomfeed.transaction.support.AtomFeedSpringTransactionManager;
@@ -16,6 +15,7 @@
 import java.lang.reflect.Method;
 import java.net.URI;
 import java.sql.SQLException;
+import java.time.LocalDateTime;
 import java.util.List;
 import java.util.UUID;
 
@@ -38,7 +38,7 @@ public PatientAdvice() throws SQLException {
     public void afterReturning(Object returnValue, Method method, Object[] arguments, Object target) throws Throwable {
         if (method.getName().equals(SAVE_PATIENT_METHOD)) {
             String contents = String.format(TEMPLATE, ((Patient) returnValue).getUuid());
-            final Event event = new Event(UUID.randomUUID().toString(), TITLE, DateTime.now(), (URI) null, contents, CATEGORY);
+            final Event event = new Event(UUID.randomUUID().toString(), TITLE, LocalDateTime.now(), (URI) null, contents, CATEGORY);
 
             atomFeedSpringTransactionManager.executeWithTransaction(
                     new AFTransactionWorkWithoutResult() {

openmrs-atomfeed-api/src/main/java/org/openmrs/module/atomfeed/advice/PatientProgramAdvice.java

@@ -0,0 +1,98 @@
+package org.openmrs.module.atomfeed.advice;
+
+import org.ict4h.atomfeed.server.repository.jdbc.AllEventRecordsQueueJdbcImpl;
+import org.ict4h.atomfeed.server.service.Event;
+import org.ict4h.atomfeed.server.service.EventService;
+import org.ict4h.atomfeed.server.service.EventServiceImpl;
+import org.ict4h.atomfeed.transaction.AFTransactionWorkWithoutResult;
+import org.openmrs.PatientProgram;
+import org.openmrs.api.context.Context;
+import org.openmrs.module.atomfeed.transaction.support.AtomFeedSpringTransactionManager;
+import org.springframework.aop.AfterReturningAdvice;
+import org.springframework.transaction.PlatformTransactionManager;
+
+import java.lang.reflect.Method;
+import java.net.URI;
+import java.sql.SQLException;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+
+public class PatientProgramAdvice implements AfterReturningAdvice {
+    private static final String CATEGORY = "programenrollment";
+    private static final String TITLE = "Progam Enrollment";
+    private static final String SAVE_PATIENT_PROGRAM_METHOD = "savePatientProgram";
+    private static final String RAISE_PATIENT_PROGRAM_EVENT_GLOBAL_PROPERTY = "atomfeed.publish.eventsForPatientProgramStateChange";
+    private static final String PATIENT_PROGRAM_EVENT_URL_PATTERN_GLOBAL_PROPERTY = "atomfeed.event.urlPatternForProgramStateChange";
+    private static final String DEFAULT_PATIENT_PROGRAM_URL_PATTERN = "/openmrs/ws/rest/v1/programenrollment/{uuid}?v=full";
+    private AtomFeedSpringTransactionManager atomFeedSpringTransactionManager;
+    private EventService eventService;
+    private final Object eventServiceMonitor = new Object();
+    private final Object txManagerMonitor = new Object();
+
+    public PatientProgramAdvice() throws SQLException {
+
+    }
+
+    @Override
+    public void afterReturning(Object returnValue, Method method, Object[] arguments, Object target) throws Throwable {
+        if (method.getName().equals(SAVE_PATIENT_PROGRAM_METHOD) && shouldRaiseRelationshipEvent()) {
+            String contents = getUrlPattern().replace("{uuid}",((PatientProgram) returnValue).getUuid());
+            final Event event = new Event(UUID.randomUUID().toString(), TITLE, LocalDateTime.now(), (URI) null, contents, CATEGORY);
+
+            getAFTxManager().executeWithTransaction(
+                    new AFTransactionWorkWithoutResult() {
+                        @Override
+                        protected void doInTransaction() {
+                            getEventService().notify(event);
+                        }
+
+                        @Override
+                        public PropagationDefinition getTxPropagationDefinition() {
+                            return PropagationDefinition.PROPAGATION_REQUIRED;
+                        }
+                    }
+            );
+        }
+    }
+
+    private EventService getEventService() {
+        if (eventService == null) {                // Single Checked
+            synchronized (eventServiceMonitor) {
+                if (eventService == null) {        // Double checked
+                    this.eventService = new EventServiceImpl(new AllEventRecordsQueueJdbcImpl(getAFTxManager()));
+                }
+            }
+        }
+        return this.eventService;
+    }
+
+    private AtomFeedSpringTransactionManager getAFTxManager() {
+        if (this.atomFeedSpringTransactionManager == null) {
+            synchronized (txManagerMonitor) {
+                if(this.atomFeedSpringTransactionManager == null) {
+                    this.atomFeedSpringTransactionManager = new AtomFeedSpringTransactionManager(getSpringPlatformTransactionManager());
+                }
+            }
+        }
+        return this.atomFeedSpringTransactionManager;
+    }
+
+    private boolean shouldRaiseRelationshipEvent() {
+        String raiseEvent = Context.getAdministrationService().getGlobalProperty(RAISE_PATIENT_PROGRAM_EVENT_GLOBAL_PROPERTY);
+        return Boolean.valueOf(raiseEvent);
+    }
+
+    private String getUrlPattern() {
+        String urlPattern = Context.getAdministrationService().getGlobalProperty(PATIENT_PROGRAM_EVENT_URL_PATTERN_GLOBAL_PROPERTY);
+        if (urlPattern == null || urlPattern.equals("")) {
+            return DEFAULT_PATIENT_PROGRAM_URL_PATTERN;
+        }
+        return urlPattern;
+    }
+
+    private PlatformTransactionManager getSpringPlatformTransactionManager() {
+        List<PlatformTransactionManager> platformTransactionManagers = Context.getRegisteredComponents(PlatformTransactionManager.class);
+        return platformTransactionManagers.get(0);
+    }
+}

openmrs-atomfeed-api/src/main/java/org/openmrs/module/atomfeed/advice/PersonRelationshipAdvice.java

@@ -0,0 +1,77 @@
+package org.openmrs.module.atomfeed.advice;
+
+import org.ict4h.atomfeed.server.repository.AllEventRecordsQueue;
+import org.ict4h.atomfeed.server.repository.jdbc.AllEventRecordsQueueJdbcImpl;
+import org.ict4h.atomfeed.server.service.Event;
+import org.ict4h.atomfeed.server.service.EventService;
+import org.ict4h.atomfeed.server.service.EventServiceImpl;
+import org.ict4h.atomfeed.transaction.AFTransactionWorkWithoutResult;
+import org.openmrs.Relationship;
+import org.openmrs.api.context.Context;
+import org.openmrs.module.atomfeed.transaction.support.AtomFeedSpringTransactionManager;
+import org.springframework.aop.AfterReturningAdvice;
+import org.springframework.transaction.PlatformTransactionManager;
+
+import java.lang.reflect.Method;
+import java.net.URI;
+import java.sql.SQLException;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+
+public class PersonRelationshipAdvice implements AfterReturningAdvice {
+    private static final String CATEGORY = "relationship";
+    private static final String TITLE = "Relationship";
+    private static final String SAVE_RELATIONSHIP_METHOD = "saveRelationship";
+    private static final String RAISE_RELATIONSHIP_EVENT_GLOBAL_PROPERTY = "atomfeed.publish.eventsForPatientRelationshipChange";
+    private static final String RELATIONSHIP_EVENT_URL_PATTERN_GLOBAL_PROPERTY = "atomfeed.event.urlPatternForPatientRelationshipChange";
+    private static final String DEFAULT_RELATIONSHIP_URL_PATTERN = "/openmrs/ws/rest/v1/relationship/%s";
+    private final AtomFeedSpringTransactionManager atomFeedSpringTransactionManager;
+    private final EventService eventService;
+
+    public PersonRelationshipAdvice() throws SQLException {
+        atomFeedSpringTransactionManager = new AtomFeedSpringTransactionManager(getSpringPlatformTransactionManager());
+        AllEventRecordsQueue allEventRecordsQueue = new AllEventRecordsQueueJdbcImpl(atomFeedSpringTransactionManager);
+        this.eventService = new EventServiceImpl(allEventRecordsQueue);
+    }
+
+    @Override
+    public void afterReturning(Object returnValue, Method method, Object[] arguments, Object target) throws Throwable {
+        if (method.getName().equals(SAVE_RELATIONSHIP_METHOD) && shouldRaiseRelationshipEvent()) {
+            String contents = String.format(getUrlPattern(), ((Relationship) returnValue).getUuid());
+            final Event event = new Event(UUID.randomUUID().toString(), TITLE, LocalDateTime.now(), (URI) null, contents, CATEGORY);
+
+            atomFeedSpringTransactionManager.executeWithTransaction(
+                    new AFTransactionWorkWithoutResult() {
+                        @Override
+                        protected void doInTransaction() {
+                            eventService.notify(event);
+                        }
+
+                        @Override
+                        public PropagationDefinition getTxPropagationDefinition() {
+                            return PropagationDefinition.PROPAGATION_REQUIRED;
+                        }
+                    }
+            );
+        }
+    }
+
+    private boolean shouldRaiseRelationshipEvent() {
+        String raiseEvent = Context.getAdministrationService().getGlobalProperty(RAISE_RELATIONSHIP_EVENT_GLOBAL_PROPERTY);
+        return Boolean.valueOf(raiseEvent);
+    }
+
+    private String getUrlPattern() {
+        String urlPattern = Context.getAdministrationService().getGlobalProperty(RELATIONSHIP_EVENT_URL_PATTERN_GLOBAL_PROPERTY);
+        if (urlPattern == null || urlPattern.equals("")) {
+            return DEFAULT_RELATIONSHIP_URL_PATTERN;
+        }
+        return urlPattern;
+    }
+
+    private PlatformTransactionManager getSpringPlatformTransactionManager() {
+        List<PlatformTransactionManager> platformTransactionManagers = Context.getRegisteredComponents(PlatformTransactionManager.class);
+        return platformTransactionManagers.get(0);
+    }
+}