Entity created Event for sub process is fired twice.

modules/activiti-engine/src/main/java/org/activiti/engine/impl/db/DbSqlSession.java

@@ -36,6 +36,9 @@ import org.activiti.engine.ActivitiOptimisticLockingException;
 import org.activiti.engine.ActivitiWrongDbException;
 import org.activiti.engine.ProcessEngine;
 import org.activiti.engine.ProcessEngineConfiguration;
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.ActivitiVariableEvent;
+import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
 import org.activiti.engine.impl.DeploymentQueryImpl;
 import org.activiti.engine.impl.ExecutionQueryImpl;
 import org.activiti.engine.impl.GroupQueryImpl;
@@ -480,7 +483,8 @@ public class DbSqlSession implements Session {
   // flush ////////////////////////////////////////////////////////////////////
 
   public void flush() {
-    removeUnnecessaryOperations();
+    List<DeleteOperation> removedOperations = removeUnnecessaryOperations();
+
     flushDeserializedObjects();
     List<PersistentObject> updatedObjects = getUpdatedObjects();
     
@@ -500,15 +504,16 @@ public class DbSqlSession implements Session {
 
     flushInserts();
     flushUpdates(updatedObjects);
-    flushDeletes();
+    flushDeletes(removedOperations);
   }
 
   /**
    * Clears all deleted and inserted objects from the cache, 
    * and removes inserts and deletes that cancel each other.
    */
-  protected void removeUnnecessaryOperations() {
-    
+  protected List<DeleteOperation> removeUnnecessaryOperations() {
+    List<DeleteOperation> removedDeleteOperations = new ArrayList<DeleteOperation>();
+
     for (Iterator<DeleteOperation> deleteIt = deleteOperations.iterator(); deleteIt.hasNext();) {
       DeleteOperation deleteOperation = deleteIt.next();
       
@@ -520,6 +525,8 @@ public class DbSqlSession implements Session {
           // remove the insert and the delete, they cancel each other
           insertIt.remove();
           deleteIt.remove();
+          // add removed operations to be able to fire events
+          removedDeleteOperations.add( deleteOperation);
         }
       }
       
@@ -530,7 +537,8 @@ public class DbSqlSession implements Session {
     for (PersistentObject insertedObject: insertedObjects) {
       cacheRemove(insertedObject.getClass(), insertedObject.getId());
     }
-    
+
+    return removedDeleteOperations;
   }
 
   protected void flushDeserializedObjects() {
@@ -629,12 +637,61 @@ public class DbSqlSession implements Session {
     updatedObjects.clear();
   }
 
-  protected void flushDeletes() {
-    for (DeleteOperation delete: deleteOperations) {
+  protected void flushDeletes(List<DeleteOperation> removedOperations) {
+    boolean dispatchEvent = Context.getProcessEngineConfiguration().getEventDispatcher()
+      .isEnabled();
+
+    flushRegularDeletes(dispatchEvent);
+
+    if (dispatchEvent) {
+      dispatchEventsForRemovedOperations(removedOperations);
+    }
+
+    deleteOperations.clear();
+  }
+
+  protected void dispatchEventsForRemovedOperations(List<DeleteOperation> removedOperations) {
+    for (DeleteOperation delete : removedOperations) {
+      // dispatch removed delete events
+      if (delete instanceof CheckedDeleteOperation) {
+        CheckedDeleteOperation checkedDeleteOperation = (CheckedDeleteOperation) delete;
+        PersistentObject persistentObject = checkedDeleteOperation.getPersistentObject();
+        if (persistentObject instanceof VariableInstanceEntity) {
+          VariableInstanceEntity variableInstance = (VariableInstanceEntity) persistentObject;
+          Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+            createVariableDeleteEvent(variableInstance)
+          );
+        }
+      }
+    }
+  }
+
+  protected static ActivitiVariableEvent createVariableDeleteEvent(VariableInstanceEntity variableInstance) {
+    return ActivitiEventBuilder.createVariableEvent(ActivitiEventType.VARIABLE_DELETED, variableInstance.getName(), null, variableInstance.getTaskId(),
+      variableInstance.getExecutionId(), variableInstance.getProcessInstanceId(), null);
+  }
+
+  protected void flushRegularDeletes(boolean dispatchEvent) {
+    for (DeleteOperation delete : deleteOperations) {
       log.debug("executing: {}", delete);
+
       delete.execute();
+
+      //  fire event for variable delete operation. (BulkDeleteOperation is not taken into account)
+      if (dispatchEvent) {
+        //  prepare delete event to fire for variable delete operation. (BulkDeleteOperation is not taken into account)
+        if (delete instanceof CheckedDeleteOperation) {
+          CheckedDeleteOperation checkedDeleteOperation = (CheckedDeleteOperation) delete;
+          PersistentObject persistentObject = checkedDeleteOperation.getPersistentObject();
+          if (persistentObject instanceof VariableInstanceEntity) {
+            VariableInstanceEntity variableInstance = (VariableInstanceEntity) persistentObject;
+            Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+              createVariableDeleteEvent(variableInstance)
+            );
+          }
+        }
+      }
     }
-    deleteOperations.clear();
   }
 
   public void close() {

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

@@ -1091,27 +1091,6 @@ public class ExecutionEntity extends VariableScopeImpl implements ActivityExecut
     					variableInstance.getExecutionId(), getProcessInstanceId(), getProcessDefinitionId()));
     }
   }
-  
-  @Override
-  protected void deleteVariableInstanceForExplicitUserCall(VariableInstanceEntity variableInstance,
-      ExecutionEntity sourceActivityExecution) {
-  	boolean dispatchEvent = Context.getProcessEngineConfiguration().getEventDispatcher()
-  			.isEnabled();
-  	
-  	Object oldValue = null;
-  	if(dispatchEvent) {
-  		oldValue = variableInstance.getValue();
-  	}
-    super.deleteVariableInstanceForExplicitUserCall(variableInstance, sourceActivityExecution);
-    
-    if(dispatchEvent) {
-      if(dispatchEvent) {
-      	Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
-      			ActivitiEventBuilder.createVariableEvent(ActivitiEventType.VARIABLE_DELETED, variableInstance.getName(), oldValue, variableInstance.getTaskId(), 
-      					variableInstance.getExecutionId(), getProcessInstanceId(), getProcessDefinitionId()));
-      }
-    }
-  }
 
   // persistent state /////////////////////////////////////////////////////////
 

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

@@ -307,27 +307,6 @@ public class TaskEntity extends VariableScopeImpl implements Task, DelegateTask,
     					variableInstance.getExecutionId(), getProcessInstanceId(), getProcessDefinitionId()));
     }
   }
-  
-  @Override
-  protected void deleteVariableInstanceForExplicitUserCall(VariableInstanceEntity variableInstance,
-      ExecutionEntity sourceActivityExecution) {
-  	boolean dispatchEvent = Context.getProcessEngineConfiguration().getEventDispatcher()
-  			.isEnabled();
-  	
-  	Object oldValue = null;
-  	if(dispatchEvent) {
-  		oldValue = variableInstance.getValue();
-  	}
-    super.deleteVariableInstanceForExplicitUserCall(variableInstance, sourceActivityExecution);
-    
-    if(dispatchEvent) {
-      if(dispatchEvent) {
-      	Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
-      			ActivitiEventBuilder.createVariableEvent(ActivitiEventType.VARIABLE_DELETED, variableInstance.getName(), oldValue, variableInstance.getTaskId(), 
-      					variableInstance.getExecutionId(), getProcessInstanceId(), getProcessDefinitionId()));
-      }
-    }
-  }
 
   // execution ////////////////////////////////////////////////////////////////
 

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

@@ -12,9 +12,6 @@
  */
 package org.activiti.engine.test.api.event;
 
-import java.util.HashMap;
-import java.util.Map;
-
 import org.activiti.engine.delegate.event.ActivitiEvent;
 import org.activiti.engine.delegate.event.ActivitiEventType;
 import org.activiti.engine.delegate.event.ActivitiVariableEvent;
@@ -25,6 +22,9 @@ import org.activiti.engine.runtime.ProcessInstance;
 import org.activiti.engine.task.Task;
 import org.activiti.engine.test.Deployment;
 
+import java.util.HashMap;
+import java.util.Map;
+
 /**
  * Test case for all {@link ActivitiEvent}s related to variables.
  * 
@@ -74,12 +74,14 @@ public class VariableEventsTest extends PluggableActivitiTestCase {
 		assertEquals(1, listener.getEventsReceived().size());
 		event = (ActivitiVariableEvent) listener.getEventsReceived().get(0);
 		assertEquals(ActivitiEventType.VARIABLE_DELETED, event.getType());
-		assertEquals(processInstance.getProcessDefinitionId(), event.getProcessDefinitionId());
+        // process definition Id can't be recognized in  DB flush
+        assertEquals(null, event.getProcessDefinitionId());
 		assertEquals(processInstance.getId(), event.getExecutionId());
 		assertEquals(processInstance.getId(), event.getProcessInstanceId());
 		assertNull(event.getTaskId());
 		assertEquals("testVariable", event.getVariableName());
-		assertEquals("Updated value", event.getVariableValue());
+        // deleted variable value is always null
+		assertEquals(null, event.getVariableValue());
 		listener.clearEventsReceived();
 
 		// Create, update and delete multiple variables
@@ -103,10 +105,25 @@ public class VariableEventsTest extends PluggableActivitiTestCase {
 		runtimeService.removeVariable(processInstance.getId(), "unexistingVariable");
 		assertTrue(listener.getEventsReceived().isEmpty());
 	}
-	
-	/**
-	 * Test create event of variables when process is started with variables passed in.
-	 */
+
+    @Deployment(resources = {"org/activiti/engine/test/api/runtime/oneTaskProcess.bpmn20.xml"})
+    public void testStartEndProcessInstanceVariableEvents() throws Exception {
+        Map<String, Object> variables = new HashMap<String, Object>();
+        variables.put("var1", "value1");
+        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess", variables);
+
+        assertEquals(1, listener.getEventsReceived().size());
+        assertEquals(ActivitiEventType.VARIABLE_CREATED, listener.getEventsReceived().get(0).getType());
+
+        Task task = taskService.createTaskQuery().processInstanceId( processInstance.getId()).singleResult();
+        taskService.complete(task.getId());
+
+        assertEquals(2, listener.getEventsReceived().size());
+        assertEquals(ActivitiEventType.VARIABLE_DELETED, listener.getEventsReceived().get(1).getType());
+    }
+    /**
+     * Test create event of variables when process is started with variables passed in.
+     */
 	@Deployment(resources = { "org/activiti/engine/test/api/runtime/oneTaskProcess.bpmn20.xml" })
 	public void testProcessInstanceVariableEventsOnStart() throws Exception {
 		
@@ -156,7 +173,7 @@ public class VariableEventsTest extends PluggableActivitiTestCase {
 	 * Test variable events when done within a process (eg. execution-listener)
 	 */
 	@Deployment
-	public void testProcessInstanceVariableEventsWithinProcess() throws Exception {
+	public void ActivitiEventType() throws Exception {
 		ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("variableProcess");
 		assertNotNull(processInstance);
 
@@ -231,12 +248,13 @@ public class VariableEventsTest extends PluggableActivitiTestCase {
 		
 		event = (ActivitiVariableEvent) listener.getEventsReceived().get(2);
 		assertEquals(ActivitiEventType.VARIABLE_DELETED, event.getType());
-		assertEquals(processInstance.getProcessDefinitionId(), event.getProcessDefinitionId());
+		assertEquals(null, event.getProcessDefinitionId()); // process definition Id is set to null
 		assertEquals(processInstance.getId(), event.getExecutionId());
 		assertEquals(processInstance.getId(), event.getProcessInstanceId());
 		assertEquals(task.getId(), event.getTaskId());
 		assertEquals("testVariable", event.getVariableName());
-		assertEquals("Updated value", event.getVariableValue());
+    // deleted values are always null
+		assertEquals(null, event.getVariableValue());
 		listener.clearEventsReceived();
 	}
 	
@@ -277,12 +295,14 @@ public class VariableEventsTest extends PluggableActivitiTestCase {
 		// Check delete event
 		event = (ActivitiVariableEvent) listener.getEventsReceived().get(2);
 		assertEquals(ActivitiEventType.VARIABLE_DELETED, event.getType());
-		assertEquals(processInstance.getProcessDefinitionId(), event.getProcessDefinitionId());
+    // process definition Id can't be recognized in  DB flush
+		assertEquals(null, event.getProcessDefinitionId());
 		assertEquals(processInstance.getId(), event.getExecutionId());
 		assertEquals(processInstance.getId(), event.getProcessInstanceId());
 		assertEquals(task.getId(), event.getTaskId());
 		assertEquals("variable", event.getVariableName());
-		assertEquals(456, event.getVariableValue());
+    // deleted variable value is always null
+		assertEquals(null, event.getVariableValue());
 	}
 
 	/**
@@ -323,7 +343,8 @@ public class VariableEventsTest extends PluggableActivitiTestCase {
 			assertNull(event.getProcessInstanceId());
 			assertEquals(newTask.getId(), event.getTaskId());
 			assertEquals("testVariable", event.getVariableName());
-			assertEquals(456, event.getVariableValue());
+      // deleted variable value is always null
+			assertEquals(null, event.getVariableValue());
 		} finally {
 			
 			// Cleanup task and history to ensure a clean DB after test success/failure