candidate starters publish events (#4191)

activiti-core/activiti-api-impl/activiti-api-process-model-impl/src/main/java/org/activiti/api/runtime/event/impl/ProcessCandidateStarterGroupAddedEvents.java

+/*
+ * Copyright 2010-2020 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.activiti.api.runtime.event.impl;
+
+import org.activiti.api.process.runtime.events.ProcessCandidateStarterGroupAddedEvent;
+
+import java.util.List;
+
+public class ProcessCandidateStarterGroupAddedEvents {
+
+    private List<ProcessCandidateStarterGroupAddedEvent> events;
+
+    public ProcessCandidateStarterGroupAddedEvents(List<ProcessCandidateStarterGroupAddedEvent> events) {
+        this.events = events;
+    }
+
+    public List<ProcessCandidateStarterGroupAddedEvent> getEvents() {
+        return events;
+    }
+}

activiti-core/activiti-api-impl/activiti-api-process-model-impl/src/main/java/org/activiti/api/runtime/event/impl/ProcessCandidateStarterUserAddedEvents.java

+/*
+ * Copyright 2010-2020 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.activiti.api.runtime.event.impl;
+
+import org.activiti.api.process.runtime.events.ProcessCandidateStarterUserAddedEvent;
+
+import java.util.List;
+
+public class ProcessCandidateStarterUserAddedEvents {
+
+    private List<ProcessCandidateStarterUserAddedEvent> events;
+
+    public ProcessCandidateStarterUserAddedEvents(List<ProcessCandidateStarterUserAddedEvent> events) {
+        this.events = events;
+    }
+
+    public List<ProcessCandidateStarterUserAddedEvent> getEvents() {
+        return events;
+    }
+}

activiti-core/activiti-spring-boot-starter/src/main/java/org/activiti/spring/ProcessCandidateStartersEventProducer.java

@@ -19,14 +19,18 @@ import org.activiti.api.process.runtime.events.ProcessCandidateStarterGroupAdded
 import org.activiti.api.process.runtime.events.ProcessCandidateStarterUserAddedEvent;
 import org.activiti.api.process.runtime.events.listener.ProcessRuntimeEventListener;
 import org.activiti.api.runtime.event.impl.ProcessCandidateStarterGroupAddedEventImpl;
+import org.activiti.api.runtime.event.impl.ProcessCandidateStarterGroupAddedEvents;
 import org.activiti.api.runtime.event.impl.ProcessCandidateStarterUserAddedEventImpl;
+import org.activiti.api.runtime.event.impl.ProcessCandidateStarterUserAddedEvents;
 import org.activiti.api.runtime.model.impl.ProcessCandidateStarterGroupImpl;
 import org.activiti.api.runtime.model.impl.ProcessCandidateStarterUserImpl;
 import org.activiti.engine.RepositoryService;
 import org.activiti.engine.repository.ProcessDefinition;
 import org.activiti.engine.task.IdentityLink;
 import org.activiti.runtime.api.event.impl.ProcessCandidateStarterEventConverterHelper;
+import org.springframework.context.ApplicationEventPublisher;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
@@ -36,39 +40,50 @@ public class ProcessCandidateStartersEventProducer extends AbstractActivitiSmart
     private List<ProcessRuntimeEventListener<ProcessCandidateStarterUserAddedEvent>> candidateStarterUserListeners;
     private List<ProcessRuntimeEventListener<ProcessCandidateStarterGroupAddedEvent>> candidateStarterGroupListeners;
     private ProcessCandidateStarterEventConverterHelper processCandidateStarterEventConverterHelper = new ProcessCandidateStarterEventConverterHelper();
+    private ApplicationEventPublisher eventPublisher;
 
     public ProcessCandidateStartersEventProducer(RepositoryService repositoryService,
                                                  List<ProcessRuntimeEventListener<ProcessCandidateStarterUserAddedEvent>> candidateStarterUserListeners,
-                                                 List<ProcessRuntimeEventListener<ProcessCandidateStarterGroupAddedEvent>> candidateStarterGroupListeners) {
+                                                 List<ProcessRuntimeEventListener<ProcessCandidateStarterGroupAddedEvent>> candidateStarterGroupListeners,
+                                                 ApplicationEventPublisher eventPublisher) {
         this.repositoryService = repositoryService;
         this.candidateStarterUserListeners = Optional.ofNullable(candidateStarterUserListeners).orElseGet(() -> List.of());
         this.candidateStarterGroupListeners = Optional.ofNullable(candidateStarterGroupListeners).orElseGet(() -> List.of());
+        this.eventPublisher = eventPublisher;
     }
 
     @Override
     public void doStart() {
         List<ProcessDefinition> processDefinitions = repositoryService.createProcessDefinitionQuery().latestVersion().list();
+        List<ProcessCandidateStarterUserAddedEvent> candidateStarterUserAddedEvents = new ArrayList<>();
+        List<ProcessCandidateStarterGroupAddedEvent> candidateStarterGroupAddedEvents = new ArrayList<>();
         for (ProcessDefinition processDefinition : processDefinitions) {
             List<IdentityLink> identityLinks = repositoryService.getIdentityLinksForProcessDefinition(processDefinition.getId());
             for (IdentityLink identityLink: identityLinks){
                 if(processCandidateStarterEventConverterHelper.isProcessCandidateStarterUserLink(identityLink)) {
-                    notifyCandidateStarterUserAddedListeners(identityLink);
+                    ProcessCandidateStarterUserAddedEvent processCandidateStarterUserAddedEvent = createCandidateStarterUserEvent(identityLink);
+                    candidateStarterUserAddedEvents.add(processCandidateStarterUserAddedEvent);
+                    notifyCandidateStarterUserAddedListeners(processCandidateStarterUserAddedEvent);
                 } else if(processCandidateStarterEventConverterHelper.isProcessCandidateStarterGroupLink(identityLink)) {
-                    notifyCandidateStarterGroupAddedListeners(identityLink);
+                    ProcessCandidateStarterGroupAddedEvent processCandidateStarterGroupAddedEvent = createCandidateStarterGroupEvent(identityLink);
+                    candidateStarterGroupAddedEvents.add(processCandidateStarterGroupAddedEvent);
+                    notifyCandidateStarterGroupAddedListeners(processCandidateStarterGroupAddedEvent);
                 }
             }
         }
+
+        publishCandidateStarterEvents(candidateStarterUserAddedEvents, candidateStarterGroupAddedEvents);
     }
 
-    private void notifyCandidateStarterUserAddedListeners(IdentityLink identityLink) {
+    private void notifyCandidateStarterUserAddedListeners(ProcessCandidateStarterUserAddedEvent processCandidateStarterUserAddedEvent) {
         for (ProcessRuntimeEventListener<ProcessCandidateStarterUserAddedEvent> listener: candidateStarterUserListeners) {
-            listener.onEvent(createCandidateStarterUserEvent(identityLink));
+            listener.onEvent(processCandidateStarterUserAddedEvent);
         }
     }
 
-    private void notifyCandidateStarterGroupAddedListeners(IdentityLink identityLink) {
+    private void notifyCandidateStarterGroupAddedListeners(ProcessCandidateStarterGroupAddedEvent processCandidateStarterGroupAddedEvent) {
         for (ProcessRuntimeEventListener<ProcessCandidateStarterGroupAddedEvent> listener: candidateStarterGroupListeners) {
-            listener.onEvent(createCandidateStarterGroupEvent(identityLink));
+            listener.onEvent(processCandidateStarterGroupAddedEvent);
         }
     }
 
@@ -82,6 +97,18 @@ public class ProcessCandidateStartersEventProducer extends AbstractActivitiSmart
             new ProcessCandidateStarterGroupImpl(identityLink.getProcessDefinitionId(), identityLink.getGroupId()));
     }
 
+    private void publishCandidateStarterEvents(List<ProcessCandidateStarterUserAddedEvent> candidateStarterUserAddedEvents,
+                                               List<ProcessCandidateStarterGroupAddedEvent> candidateStarterGroupAddedEvents) {
+
+        if(!candidateStarterUserAddedEvents.isEmpty()) {
+            eventPublisher.publishEvent(new ProcessCandidateStarterUserAddedEvents(candidateStarterUserAddedEvents));
+        }
+
+        if(!candidateStarterGroupAddedEvents.isEmpty()) {
+            eventPublisher.publishEvent(new ProcessCandidateStarterGroupAddedEvents(candidateStarterGroupAddedEvents));
+        }
+    }
+
     @Override
     public void doStop() {
         // nothing

activiti-core/activiti-spring-boot-starter/src/main/java/org/activiti/spring/boot/ProcessEngineAutoConfiguration.java

@@ -221,8 +221,12 @@ public class ProcessEngineAutoConfiguration extends AbstractProcessEngineAutoCon
     @ConditionalOnMissingBean
     public ProcessCandidateStartersEventProducer processCandidateStartersEventProducer(RepositoryService repositoryService,
                                                                                        @Autowired(required = false) List<ProcessRuntimeEventListener<ProcessCandidateStarterUserAddedEvent>> candidateStarterUserListeners,
-                                                                                       @Autowired(required = false) List<ProcessRuntimeEventListener<ProcessCandidateStarterGroupAddedEvent>> candidateStarterGroupListeners) {
-        return new ProcessCandidateStartersEventProducer(repositoryService, candidateStarterUserListeners, candidateStarterGroupListeners);
+                                                                                       @Autowired(required = false) List<ProcessRuntimeEventListener<ProcessCandidateStarterGroupAddedEvent>> candidateStarterGroupListeners,
+                                                                                       ApplicationEventPublisher eventPublisher) {
+        return new ProcessCandidateStartersEventProducer(repositoryService,
+                                                         candidateStarterUserListeners,
+                                                         candidateStarterGroupListeners,
+                                                         eventPublisher);
     }
 
     @Bean

activiti-core/activiti-spring-boot-starter/src/test/java/org/activiti/spring/boot/process/ProcessCandidateStarterEventIT.java

@@ -17,6 +17,10 @@ package org.activiti.spring.boot.process;
 
 import org.activiti.api.process.model.ProcessCandidateStarterGroup;
 import org.activiti.api.process.model.ProcessCandidateStarterUser;
+import org.activiti.api.process.runtime.events.ProcessCandidateStarterGroupAddedEvent;
+import org.activiti.api.process.runtime.events.ProcessCandidateStarterUserAddedEvent;
+import org.activiti.api.runtime.event.impl.ProcessCandidateStarterGroupAddedEvents;
+import org.activiti.api.runtime.event.impl.ProcessCandidateStarterUserAddedEvents;
 import org.activiti.engine.RepositoryService;
 import org.activiti.spring.boot.process.listener.ProcessCandidateStarterGroupAddedListener;
 import org.activiti.spring.boot.process.listener.ProcessCandidateStarterGroupRemovedListener;
@@ -59,6 +63,14 @@ public class ProcessCandidateStarterEventIT {
                                 candidateStarterGroupListener.getCandidateStarterGroups());
     }
 
+    @Test
+    public void shouldPublishProcessCandidateStarterAddedEvents() {
+        String processDefinitionId = getProcessDefinitionId();
+        assertPublishedCandidateStartersEvents(processDefinitionId,
+                                               candidateStarterUserListener.getPublishedEvents(),
+                                               candidateStarterGroupListener.getPublishedEvents());
+    }
+
     @Test
     public void shouldTriggerProcessCandidateStarterRemovedEvents() {
         String processDefinitionId = getProcessDefinitionId();
@@ -67,8 +79,8 @@ public class ProcessCandidateStarterEventIT {
         repositoryService.deleteCandidateStarterGroup(processDefinitionId, "activitiTeam");
 
         assertCandidateStarters(processDefinitionId,
-                                candidateStarterUserRemovedListener.getCandidateStarterUsers(),
-                                candidateStarterGroupRemovedListener.getCandidateStarterGroups());
+            candidateStarterUserRemovedListener.getCandidateStarterUsers(),
+            candidateStarterGroupRemovedListener.getCandidateStarterGroups());
     }
 
     private String getProcessDefinitionId() {
@@ -88,4 +100,20 @@ public class ProcessCandidateStarterEventIT {
             .extracting(ProcessCandidateStarterGroup::getProcessDefinitionId, ProcessCandidateStarterGroup::getGroupId)
             .contains(tuple(processDefinitionId, "activitiTeam"));
     }
+
+    private void assertPublishedCandidateStartersEvents(String processDefinitionId,
+                                                        ProcessCandidateStarterUserAddedEvents candidateStarterUsersAddedEvents,
+                                                        ProcessCandidateStarterGroupAddedEvents candidateStarterGroupsAddedEvents) {
+        assertThat(candidateStarterUsersAddedEvents).isNotNull();
+        assertThat(candidateStarterUsersAddedEvents.getEvents())
+            .extracting(ProcessCandidateStarterUserAddedEvent::getEntity)
+            .extracting(ProcessCandidateStarterUser::getProcessDefinitionId, ProcessCandidateStarterUser::getUserId)
+            .contains(tuple(processDefinitionId, "user"));
+
+        assertThat(candidateStarterGroupsAddedEvents).isNotNull();
+        assertThat(candidateStarterGroupsAddedEvents.getEvents())
+            .extracting(ProcessCandidateStarterGroupAddedEvent::getEntity)
+            .extracting(ProcessCandidateStarterGroup::getProcessDefinitionId, ProcessCandidateStarterGroup::getGroupId)
+            .contains(tuple(processDefinitionId, "activitiTeam"));
+    }
 }

activiti-core/activiti-spring-boot-starter/src/test/java/org/activiti/spring/boot/process/listener/ProcessCandidateStarterGroupAddedListener.java

@@ -18,6 +18,8 @@ package org.activiti.spring.boot.process.listener;
 import org.activiti.api.process.model.ProcessCandidateStarterGroup;
 import org.activiti.api.process.runtime.events.ProcessCandidateStarterGroupAddedEvent;
 import org.activiti.api.process.runtime.events.listener.ProcessRuntimeEventListener;
+import org.activiti.api.runtime.event.impl.ProcessCandidateStarterGroupAddedEvents;
+import org.springframework.context.event.EventListener;
 import org.springframework.stereotype.Component;
 
 import java.util.ArrayList;
@@ -27,6 +29,7 @@ import java.util.List;
 public class ProcessCandidateStarterGroupAddedListener implements ProcessRuntimeEventListener<ProcessCandidateStarterGroupAddedEvent> {
 
     private List<ProcessCandidateStarterGroup> candidateStarterGroups = new ArrayList<>();
+    private ProcessCandidateStarterGroupAddedEvents events;
 
     @Override
     public void onEvent(ProcessCandidateStarterGroupAddedEvent event) {
@@ -37,4 +40,13 @@ public class ProcessCandidateStarterGroupAddedListener implements ProcessRuntime
         return candidateStarterGroups;
     }
 
+    @EventListener
+    public void publishedEvent(ProcessCandidateStarterGroupAddedEvents events) {
+        this.events = events;
+    }
+
+    public ProcessCandidateStarterGroupAddedEvents getPublishedEvents() {
+        return events;
+    }
+
 }

activiti-core/activiti-spring-boot-starter/src/test/java/org/activiti/spring/boot/process/listener/ProcessCandidateStarterUserAddedListener.java

@@ -18,6 +18,8 @@ package org.activiti.spring.boot.process.listener;
 import org.activiti.api.process.model.ProcessCandidateStarterUser;
 import org.activiti.api.process.runtime.events.ProcessCandidateStarterUserAddedEvent;
 import org.activiti.api.process.runtime.events.listener.ProcessRuntimeEventListener;
+import org.activiti.api.runtime.event.impl.ProcessCandidateStarterUserAddedEvents;
+import org.springframework.context.event.EventListener;
 import org.springframework.stereotype.Component;
 
 import java.util.ArrayList;
@@ -27,6 +29,7 @@ import java.util.List;
 public class ProcessCandidateStarterUserAddedListener implements ProcessRuntimeEventListener<ProcessCandidateStarterUserAddedEvent> {
 
     private List<ProcessCandidateStarterUser> candidateStarterUsers = new ArrayList<>();
+    private ProcessCandidateStarterUserAddedEvents events;
 
     @Override
     public void onEvent(ProcessCandidateStarterUserAddedEvent event) {
@@ -37,4 +40,13 @@ public class ProcessCandidateStarterUserAddedListener implements ProcessRuntimeE
         return candidateStarterUsers;
     }
 
+    @EventListener
+    public void publishedEvents(ProcessCandidateStarterUserAddedEvents events) {
+        this.events = events;
+    }
+
+    public ProcessCandidateStarterUserAddedEvents getPublishedEvents() {
+        return events;
+    }
+
 }