Added dispatching of entity-related events

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/ActivitiEventType.java

@@ -141,9 +141,24 @@ public enum ActivitiEventType {
 	 * the task completion. In that case, a {@link #ACTIVITY_COMPLETED} will be dispatched after an event of this type
 	 * for the activity corresponding to the task. 
 	 */
-	TASK_COMPLETED;
+	TASK_COMPLETED,
 	
+	/**
+	 * A new membership has been created.
+	 */
+	MEMBERSHIP_CREATED,
 	
+	/**
+	 * A single membership has been deleted.
+	 */
+	MEMBERSHIP_DELETED,
+	
+	/**
+	 * All memberships in the related group have been deleted. No individual {@link #MEMBERSHIP_DELETED} events will
+	 * be dispatched due to possible performance reasons. The event is dispatched before the memberships are deleted,
+	 * so they can still be accessed in the dispatch method of the listener.
+	 */
+	MEMBERSHIPS_DELETED;
 	
 	public static final ActivitiEventType[] EMPTY_ARRAY =  new ActivitiEventType[] {};
 	

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/ActivitiMembershipEvent.java

+/* 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.engine.delegate.event;
+
+/**
+ * An event related to group memberships.
+ * 
+ * @author Frederik Heremans
+ */
+public interface ActivitiMembershipEvent extends ActivitiEvent {
+
+	/**
+	 * @return related user. Returns null, if not related to a sigle user but rather to all
+	 * members of the group.
+	 */
+	String getUserId();
+	
+	/**
+	 * @return related group
+	 */
+	String getGroupId();
+}

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/impl/ActivitiEventBuilder.java

@@ -18,6 +18,7 @@ import org.activiti.engine.delegate.event.ActivitiEntityEvent;
 import org.activiti.engine.delegate.event.ActivitiEvent;
 import org.activiti.engine.delegate.event.ActivitiEventType;
 import org.activiti.engine.delegate.event.ActivitiExceptionEvent;
+import org.activiti.engine.delegate.event.ActivitiMembershipEvent;
 import org.activiti.engine.delegate.event.ActivitiMessageEvent;
 import org.activiti.engine.delegate.event.ActivitiSignalEvent;
 import org.activiti.engine.delegate.event.ActivitiVariableEvent;
@@ -149,6 +150,13 @@ public class ActivitiEventBuilder {
 		return newEvent;
 	}
 	
+	public static ActivitiMembershipEvent createMembershipEvent(ActivitiEventType type, String groupId, String userId) {
+		ActivitiMembershipEventImpl newEvent = new ActivitiMembershipEventImpl(type);
+		newEvent.setUserId(userId);
+		newEvent.setGroupId(groupId);
+		return newEvent;
+	}
+	
 	protected static void populateEventWithCurrentContext(ActivitiEventImpl event) {
 		boolean extractedFromContext = false;
 		if(Context.isExecutionContextActive()) {

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/impl/ActivitiMembershipEventImpl.java

+/* 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.engine.delegate.event.impl;
+
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.ActivitiMembershipEvent;
+
+/**
+ * Implementation of {@link ActivitiMembershipEvent}.
+ * @author Frederik Heremans
+ */
+public class ActivitiMembershipEventImpl extends ActivitiEventImpl implements ActivitiMembershipEvent {
+
+	protected String userId;
+	protected String groupId;
+	
+	public ActivitiMembershipEventImpl(ActivitiEventType type) {
+	  super(type);
+  }
+	
+	public void setUserId(String userId) {
+	  this.userId = userId;
+  }
+	
+	public String getUserId() {
+	  return userId;
+  }
+	
+	public void setGroupId(String groupId) {
+	  this.groupId = groupId;
+  }
+	
+	public String getGroupId() {
+	  return groupId;
+  }
+}

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/GroupEntityManager.java

@@ -13,6 +13,8 @@
 
 package org.activiti.engine.impl.persistence.entity;
 
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
 import org.activiti.engine.identity.Group;
 import org.activiti.engine.identity.GroupQuery;
 import org.activiti.engine.impl.GroupQueryImpl;
@@ -40,18 +42,41 @@ public class GroupEntityManager extends AbstractManager implements GroupIdentity
 
   public void insertGroup(Group group) {
     getDbSqlSession().insert((PersistentObject) group);
+    
+    if(getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+    	getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+    			ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_CREATED, group));
+    }
   }
 
   public void updateGroup(GroupEntity updatedGroup) {
     CommandContext commandContext = Context.getCommandContext();
     DbSqlSession dbSqlSession = commandContext.getDbSqlSession();
     dbSqlSession.update(updatedGroup);
+    
+    if(getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+    	getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+    			ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_UPDATED, updatedGroup));
+    }
   }
 
   public void deleteGroup(String groupId) {
     GroupEntity group = getDbSqlSession().selectById(GroupEntity.class, groupId);
-    getDbSqlSession().delete("deleteMembershipsByGroupId", groupId);
-    getDbSqlSession().delete(group);
+    
+    if(group != null) {
+    	if(getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+      	getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+      			ActivitiEventBuilder.createMembershipEvent(ActivitiEventType.MEMBERSHIPS_DELETED, groupId, null));
+      }
+    	
+    	getDbSqlSession().delete("deleteMembershipsByGroupId", groupId);
+    	getDbSqlSession().delete(group);
+    	
+    	if(getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+    		getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+    				ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_DELETED, group));
+    	}
+    }
   }
 
   public GroupQuery createNewGroupQuery() {

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/MembershipEntityManager.java

@@ -16,6 +16,8 @@ package org.activiti.engine.impl.persistence.entity;
 import java.util.HashMap;
 import java.util.Map;
 
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
 import org.activiti.engine.impl.persistence.AbstractManager;
 
 
@@ -29,6 +31,11 @@ public class MembershipEntityManager extends AbstractManager implements Membersh
     membershipEntity.setUserId(userId);
     membershipEntity.setGroupId(groupId);
     getDbSqlSession().insert(membershipEntity);
+    
+    if(getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+    	getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+    			ActivitiEventBuilder.createMembershipEvent(ActivitiEventType.MEMBERSHIP_CREATED, groupId, userId));
+    }
   }
 
   public void deleteMembership(String userId, String groupId) {
@@ -36,6 +43,11 @@ public class MembershipEntityManager extends AbstractManager implements Membersh
     parameters.put("userId", userId);
     parameters.put("groupId", groupId);
     getDbSqlSession().delete("deleteMembership", parameters);
+    
+    if(getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+    	getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+    			ActivitiEventBuilder.createMembershipEvent(ActivitiEventType.MEMBERSHIP_DELETED, groupId, userId));
+    }
   }
   
 

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/UserEntityManager.java

@@ -13,6 +13,8 @@
 
 package org.activiti.engine.impl.persistence.entity;
 
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
 import org.activiti.engine.identity.Group;
 import org.activiti.engine.identity.User;
 import org.activiti.engine.identity.UserQuery;
@@ -42,12 +44,22 @@ public class UserEntityManager extends AbstractManager implements UserIdentityMa
 
   public void insertUser(User user) {
     getDbSqlSession().insert((PersistentObject) user);
+    
+    if(getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+    	getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+    			ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_CREATED, user));
+    }
   }
   
   public void updateUser(UserEntity updatedUser) {
     CommandContext commandContext = Context.getCommandContext();
     DbSqlSession dbSqlSession = commandContext.getDbSqlSession();
     dbSqlSession.update(updatedUser);
+    
+    if(getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+    	getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+    			ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_UPDATED, updatedUser));
+    }
   }
 
   public UserEntity findUserById(String userId) {
@@ -65,6 +77,11 @@ public class UserEntityManager extends AbstractManager implements UserIdentityMa
       getDbSqlSession().delete("deleteMembershipsByUserId", userId);
 
       user.delete();
+      
+      if(getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+      	getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+      			ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_DELETED, user));
+      }
     }
   }
   

modules/activiti-engine/src/test/java/org/activiti/engine/test/api/event/GroupEventsTest.java

+/* 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.engine.test.api.event;
+
+import org.activiti.engine.delegate.event.ActivitiEntityEvent;
+import org.activiti.engine.delegate.event.ActivitiEvent;
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.ActivitiMembershipEvent;
+import org.activiti.engine.identity.Group;
+import org.activiti.engine.identity.User;
+import org.activiti.engine.impl.test.PluggableActivitiTestCase;
+
+/**
+ * Test case for all {@link ActivitiEvent}s related to groups.
+ * 
+ * @author Frederik Heremans
+ */
+public class GroupEventsTest extends PluggableActivitiTestCase {
+
+	private TestActivitiEntityEventListener listener;
+
+	/**
+	 * Test create, update and delete events of Groups.
+	 */
+	public void testGroupEntityEvents() throws Exception {
+		Group group = null;
+		try {
+			group = identityService.newGroup("fred");
+			group.setName("name");
+			group.setType("type");
+			identityService.saveGroup(group);
+
+			assertEquals(1, listener.getEventsReceived().size());
+			ActivitiEntityEvent event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(ActivitiEventType.ENTITY_CREATED, event.getType());
+			assertTrue(event.getEntity() instanceof Group);
+			Group groupFromEvent = (Group) event.getEntity();
+			assertEquals("fred", groupFromEvent.getId());
+			assertNull(event.getProcessDefinitionId());
+			assertNull(event.getExecutionId());
+			assertNull(event.getProcessInstanceId());
+			listener.clearEventsReceived();
+
+			// Update Group
+			group.setName("Another name");
+			identityService.saveGroup(group);
+			assertEquals(1, listener.getEventsReceived().size());
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(ActivitiEventType.ENTITY_UPDATED, event.getType());
+			assertTrue(event.getEntity() instanceof Group);
+			groupFromEvent = (Group) event.getEntity();
+			assertEquals("fred", groupFromEvent.getId());
+			assertEquals("Another name", groupFromEvent.getName());
+			assertNull(event.getProcessDefinitionId());
+			assertNull(event.getExecutionId());
+			assertNull(event.getProcessInstanceId());
+			listener.clearEventsReceived();
+
+			// Delete Group
+			identityService.deleteGroup(group.getId());
+			
+			assertEquals(1, listener.getEventsReceived().size());
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(ActivitiEventType.ENTITY_DELETED, event.getType());
+			assertTrue(event.getEntity() instanceof Group);
+			groupFromEvent = (Group) event.getEntity();
+			assertEquals("fred", groupFromEvent.getId());
+			assertNull(event.getProcessDefinitionId());
+			assertNull(event.getExecutionId());
+			assertNull(event.getProcessInstanceId());
+			listener.clearEventsReceived();
+
+		} finally {
+			if (group != null && group.getId() != null) {
+				identityService.deleteGroup(group.getId());
+			}
+		}
+	}
+
+	/**
+	 * Test create, update and delete events of Groups.
+	 */
+	public void testGroupMembershipEvents() throws Exception {
+		TestActivitiEventListener membershipListener = new TestActivitiEventListener();
+		processEngineConfiguration.getEventDispatcher().addEventListener(membershipListener);
+		
+		User user = null;
+		Group group = null;
+		try {
+			user = identityService.newUser("kermit");
+			identityService.saveUser(user);
+			
+			group = identityService.newGroup("sales");
+			identityService.saveGroup(group);
+			
+			// Add membership
+			membershipListener.clearEventsReceived();
+			identityService.createMembership("kermit", "sales");
+			assertEquals(1, membershipListener.getEventsReceived().size());
+			assertTrue(membershipListener.getEventsReceived().get(0) instanceof ActivitiMembershipEvent);
+			ActivitiMembershipEvent event = (ActivitiMembershipEvent) membershipListener.getEventsReceived().get(0);
+			assertEquals(ActivitiEventType.MEMBERSHIP_CREATED, event.getType());
+			assertEquals("sales", event.getGroupId());
+			assertEquals("kermit", event.getUserId());
+			assertNull(event.getExecutionId());
+			assertNull(event.getProcessDefinitionId());
+			assertNull(event.getProcessInstanceId());
+			membershipListener.clearEventsReceived();
+			
+			// Delete membership
+			identityService.deleteMembership("kermit", "sales");
+			assertEquals(1, membershipListener.getEventsReceived().size());
+			assertTrue(membershipListener.getEventsReceived().get(0) instanceof ActivitiMembershipEvent);
+			event = (ActivitiMembershipEvent) membershipListener.getEventsReceived().get(0);
+			assertEquals(ActivitiEventType.MEMBERSHIP_DELETED, event.getType());
+			assertEquals("sales", event.getGroupId());
+			assertEquals("kermit", event.getUserId());
+			assertNull(event.getExecutionId());
+			assertNull(event.getProcessDefinitionId());
+			assertNull(event.getProcessInstanceId());
+			membershipListener.clearEventsReceived();
+			
+			// Deleting group will dispatch an event, informing ALL memberships are deleted
+			identityService.createMembership("kermit", "sales");
+			membershipListener.clearEventsReceived();
+			identityService.deleteGroup(group.getId());
+			
+			assertEquals(2, membershipListener.getEventsReceived().size());
+			assertTrue(membershipListener.getEventsReceived().get(0) instanceof ActivitiMembershipEvent);
+			event = (ActivitiMembershipEvent) membershipListener.getEventsReceived().get(0);
+			assertEquals(ActivitiEventType.MEMBERSHIPS_DELETED, event.getType());
+			assertEquals("sales", event.getGroupId());
+			assertNull(event.getUserId());
+			assertNull(event.getExecutionId());
+			assertNull(event.getProcessDefinitionId());
+			assertNull(event.getProcessInstanceId());
+			membershipListener.clearEventsReceived();
+		} finally {
+			processEngineConfiguration.getEventDispatcher().removeEventListener(membershipListener);
+			if(user != null) {
+				identityService.deleteUser(user.getId());
+			}
+			if(group != null) {
+				identityService.deleteGroup(group.getId());
+			}
+		}
+	}
+	
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+		listener = new TestActivitiEntityEventListener(Group.class);
+		processEngineConfiguration.getEventDispatcher().addEventListener(listener);
+	}
+
+	@Override
+	protected void tearDown() throws Exception {
+		super.tearDown();
+
+		if (listener != null) {
+			processEngineConfiguration.getEventDispatcher().removeEventListener(listener);
+		}
+	}
+}

modules/activiti-engine/src/test/java/org/activiti/engine/test/api/event/UserEventsTest.java

+/* 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.engine.test.api.event;
+
+import org.activiti.engine.delegate.event.ActivitiEntityEvent;
+import org.activiti.engine.delegate.event.ActivitiEvent;
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.identity.User;
+import org.activiti.engine.impl.test.PluggableActivitiTestCase;
+
+/**
+ * Test case for all {@link ActivitiEvent}s related to users.
+ * 
+ * @author Frederik Heremans
+ */
+public class UserEventsTest extends PluggableActivitiTestCase {
+
+	private TestActivitiEntityEventListener listener;
+
+	/**
+	 * Test create, update and delete events of users.
+	 */
+	public void testUserEntityEvents() throws Exception {
+		User user = null;
+		try {
+			user = identityService.newUser("fred");
+			user.setFirstName("Frederik");
+			user.setLastName("Heremans");
+			identityService.saveUser(user);
+
+			assertEquals(1, listener.getEventsReceived().size());
+			ActivitiEntityEvent event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(ActivitiEventType.ENTITY_CREATED, event.getType());
+			assertTrue(event.getEntity() instanceof User);
+			User userFromEvent = (User) event.getEntity();
+			assertEquals("fred", userFromEvent.getId());
+			assertNull(event.getProcessDefinitionId());
+			assertNull(event.getExecutionId());
+			assertNull(event.getProcessInstanceId());
+			listener.clearEventsReceived();
+
+			// Update user
+			user.setFirstName("Anna");
+			identityService.saveUser(user);
+			assertEquals(1, listener.getEventsReceived().size());
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(ActivitiEventType.ENTITY_UPDATED, event.getType());
+			assertTrue(event.getEntity() instanceof User);
+			userFromEvent = (User) event.getEntity();
+			assertEquals("fred", userFromEvent.getId());
+			assertEquals("Anna", userFromEvent.getFirstName());
+			assertNull(event.getProcessDefinitionId());
+			assertNull(event.getExecutionId());
+			assertNull(event.getProcessInstanceId());
+			listener.clearEventsReceived();
+
+			// Delete user
+			identityService.deleteUser(user.getId());
+			
+			assertEquals(1, listener.getEventsReceived().size());
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(ActivitiEventType.ENTITY_DELETED, event.getType());
+			assertTrue(event.getEntity() instanceof User);
+			userFromEvent = (User) event.getEntity();
+			assertEquals("fred", userFromEvent.getId());
+			assertNull(event.getProcessDefinitionId());
+			assertNull(event.getExecutionId());
+			assertNull(event.getProcessInstanceId());
+			listener.clearEventsReceived();
+
+		} finally {
+			if (user != null && user.getId() != null) {
+				identityService.deleteUser(user.getId());
+			}
+		}
+	}
+
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+		listener = new TestActivitiEntityEventListener(User.class);
+		processEngineConfiguration.getEventDispatcher().addEventListener(listener);
+	}
+
+	@Override
+	protected void tearDown() throws Exception {
+		super.tearDown();
+
+		if (listener != null) {
+			processEngineConfiguration.getEventDispatcher().removeEventListener(listener);
+		}
+	}
+}