public void testEngineEventsTest() {
  // Fetch the listener to check received events
  TestActivitiEventListener listener = (TestActivitiEventListener) processEngineConfiguration.getBeans().get("eventListener");
  assertNotNull(listener);

  // Check create-event
  assertEquals(1, listener.getEventsReceived().size());
  assertEquals(ActivitiEventType.ENGINE_CREATED, listener.getEventsReceived().get(0).getType());
  listener.clearEventsReceived();

  // Check close-event
  processEngine.close();
  assertEquals(1, listener.getEventsReceived().size());
  assertEquals(ActivitiEventType.ENGINE_CLOSED, listener.getEventsReceived().get(0).getType());

}
 

@Deployment
public void testActivitySignalBoundaryEventsOnSubProcess() throws Exception {
  ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("signalOnSubProcess");
  assertNotNull(processInstance);

  Execution executionWithSignal = runtimeService.createExecutionQuery().activityId("userTaskInsideProcess").singleResult();
  assertNotNull(executionWithSignal);

  runtimeService.signalEventReceived("signalName");
  assertEquals(1, listener.getEventsReceived().size());

  // Next, an signal-event is expected, as a result of the message
  assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiActivityCancelledEvent);
  ActivitiActivityCancelledEvent signalEvent = (ActivitiActivityCancelledEvent) listener.getEventsReceived().get(0);
  assertEquals(ActivitiEventType.ACTIVITY_CANCELLED, signalEvent.getType());
  assertEquals("userTaskInsideProcess", signalEvent.getActivityId());
  assertEquals(executionWithSignal.getId(), signalEvent.getExecutionId());
  assertEquals(executionWithSignal.getProcessInstanceId(), signalEvent.getProcessInstanceId());
  assertEquals(processInstance.getProcessDefinitionId(), signalEvent.getProcessDefinitionId());
  assertNotNull(signalEvent.getCause());
  assertTrue(signalEvent.getCause() instanceof SignalEventSubscriptionEntity);
  SignalEventSubscriptionEntity cause = (SignalEventSubscriptionEntity) signalEvent.getCause();
  assertEquals("signalName", cause.getEventName());
}
 

@Override
public void insert(CommentEntity commentEntity) {
  checkHistoryEnabled();
  
  insert(commentEntity, false);

  Comment comment = (Comment) commentEntity;
  if (getEventDispatcher().isEnabled()) {
    // Forced to fetch the process-instance to associate the right
    // process definition
    String processDefinitionId = null;
    String processInstanceId = comment.getProcessInstanceId();
    if (comment.getProcessInstanceId() != null) {
      ExecutionEntity process = getExecutionEntityManager().findById(comment.getProcessInstanceId());
      if (process != null) {
        processDefinitionId = process.getProcessDefinitionId();
      }
    }
    getEventDispatcher().dispatchEvent(
        ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_CREATED, commentEntity, processInstanceId, processInstanceId, processDefinitionId));
    getEventDispatcher().dispatchEvent(
        ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_INITIALIZED, commentEntity, processInstanceId, processInstanceId, processDefinitionId));
  }
}
 

@Override
public void execute(DelegateExecution execution) {
  CommandContext commandContext = Context.getCommandContext();
  ExecutionEntity executionEntity = (ExecutionEntity) execution;
  
  String messageName = null;
  if (StringUtils.isNotEmpty(messageEventDefinition.getMessageRef())) {
    messageName = messageEventDefinition.getMessageRef();
  } else {
    Expression messageExpression = commandContext.getProcessEngineConfiguration().getExpressionManager()
        .createExpression(messageEventDefinition.getMessageExpression());
    messageName = messageExpression.getValue(execution).toString();
  }
  
  commandContext.getEventSubscriptionEntityManager().insertMessageEvent(messageName, executionEntity);
  
  if (commandContext.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
      commandContext.getProcessEngineConfiguration().getEventDispatcher()
              .dispatchEvent(ActivitiEventBuilder.createMessageEvent(ActivitiEventType.ACTIVITY_MESSAGE_WAITING, executionEntity.getActivityId(), messageName,
                      null, executionEntity.getId(), executionEntity.getProcessInstanceId(), executionEntity.getProcessDefinitionId()));
    }
}
 

public void insert() {
  Context.getCommandContext()
    .getDbSqlSession()
    .insert(this);
  
  // add link to execution
  if (executionId != null) {
    ExecutionEntity execution = Context.getCommandContext()
      .getExecutionEntityManager()
      .findExecutionById(executionId);
    execution.addTimerJob(this);
    
    // Inherit tenant if (if applicable)
    if (execution.getTenantId() != null) {
      setTenantId(execution.getTenantId());
    }
  }
  
  if (Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
    Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
        ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_CREATED, this));
    Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
        ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_INITIALIZED, this));
  }
}
 

public void insert(PersistentObject persistentObject) {
  checkHistoryEnabled();
  super.insert(persistentObject);
  
  Comment comment = (Comment) persistentObject;
  if(getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
  	// Forced to fetch the process-instance to associate the right process definition
  	String processDefinitionId = null;
  	String processInstanceId = comment.getProcessInstanceId();
  	if(comment.getProcessInstanceId() != null) {
  		ExecutionEntity process = getProcessInstanceManager().findExecutionById(comment.getProcessInstanceId());
  		if(process != null) {
  			processDefinitionId = process.getProcessDefinitionId();
  		}
  	}
  	getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
  			ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_CREATED, persistentObject, processInstanceId, processInstanceId, processDefinitionId));
  	getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
  			ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_INITIALIZED, persistentObject, processInstanceId, processInstanceId, processDefinitionId));
  }
}
 

public void insert(ExecutionEntity execution) {
  CommandContext commandContext = Context.getCommandContext();
  DbSqlSession dbSqlSession = commandContext.getDbSqlSession();
  dbSqlSession.insert(this);
  
  // Inherit tenant id (if applicable)
  if (execution != null && execution.getTenantId() != null) {
  	setTenantId(execution.getTenantId());
  }
  
  if(execution != null) {
    execution.addTask(this);
  }
  
  commandContext.getHistoryManager().recordTaskCreated(this, execution);
  
  if(commandContext.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
  	commandContext.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
  			ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_CREATED, this));
  	commandContext.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
  			ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_INITIALIZED, this));
  }
}
 

protected void initializeDefaultHandlers() {
	
	// Initialization of all event handlers
	
	addEventHandler(ActivitiEventType.TASK_CREATED, TaskCreatedEventHandler.class);
	addEventHandler(ActivitiEventType.TASK_COMPLETED, TaskCompletedEventHandler.class);
	addEventHandler(ActivitiEventType.TASK_ASSIGNED, TaskAssignedEventHandler.class);
	
	addEventHandler(ActivitiEventType.SEQUENCEFLOW_TAKEN, SequenceFlowTakenEventHandler.class);
	
	addEventHandler(ActivitiEventType.ACTIVITY_COMPLETED, ActivityCompletedEventHandler.class);
	addEventHandler(ActivitiEventType.ACTIVITY_STARTED, ActivityStartedEventHandler.class);
	addEventHandler(ActivitiEventType.ACTIVITY_SIGNALED, ActivitySignaledEventHandler.class);
	addEventHandler(ActivitiEventType.ACTIVITY_MESSAGE_RECEIVED, ActivityMessageEventHandler.class);
	addEventHandler(ActivitiEventType.ACTIVITY_COMPENSATE, ActivityCompensatedEventHandler.class);
	addEventHandler(ActivitiEventType.ACTIVITY_ERROR_RECEIVED, ActivityErrorReceivedEventHandler.class);
	
	addEventHandler(ActivitiEventType.VARIABLE_CREATED, VariableCreatedEventHandler.class);
	addEventHandler(ActivitiEventType.VARIABLE_DELETED, VariableDeletedEventHandler.class);
	addEventHandler(ActivitiEventType.VARIABLE_UPDATED, VariableUpdatedEventHandler.class);
}
 

public static void propagateError(String errorCode, ActivityExecution execution) {

    while (execution != null) {
      String eventHandlerId = findLocalErrorEventHandler(execution, errorCode);
      if (eventHandlerId != null) {
        executeCatch(eventHandlerId, execution, errorCode);
        break;
      }
      
      if (execution.isProcessInstanceType()) {
        // dispatch process completed event
        if (Context.getProcessEngineConfiguration() != null && Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
          Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
                  ActivitiEventBuilder.createEntityEvent(ActivitiEventType.PROCESS_COMPLETED_WITH_ERROR_END_EVENT, execution));
        }
      }
      execution = getSuperExecution(execution);
    }
    if (execution == null) {
      throw new BpmnError(errorCode, "No catching boundary event found for error with errorCode '"
              + errorCode + "', neither in same process nor in parent process");
    }
  }
 

protected Object execute(CommandContext commandContext, ExecutionEntity execution) {
  if (Activiti5Util.isActiviti5ProcessDefinitionId(commandContext, execution.getProcessDefinitionId())) {
    Activiti5CompatibilityHandler activiti5CompatibilityHandler = Activiti5Util.getActiviti5CompatibilityHandler();
    activiti5CompatibilityHandler.trigger(executionId, processVariables);
    return null;
  }

  if (processVariables != null) {
    execution.setVariables(processVariables);
  }

  if (transientVariables != null) {
    execution.setTransientVariables(transientVariables);
  }

  Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
      ActivitiEventBuilder.createSignalEvent(ActivitiEventType.ACTIVITY_SIGNALED, execution.getCurrentActivityId(), null,
          null, execution.getId(), execution.getProcessInstanceId(), execution.getProcessDefinitionId()));

  Context.getAgenda().planTriggerExecutionOperation(execution);
  return null;
}
 

protected void endAllHistoricActivities(String processInstanceId, String deleteReason) {

    if (!Context.getProcessEngineConfiguration().getHistoryLevel().isAtLeast(HistoryLevel.ACTIVITY)) {
      return;
    }

    List<HistoricActivityInstanceEntity> historicActivityInstances = Context.getCommandContext().getHistoricActivityInstanceEntityManager()
      .findUnfinishedHistoricActivityInstancesByProcessInstanceId(processInstanceId);

    for (HistoricActivityInstanceEntity historicActivityInstance : historicActivityInstances) {
      historicActivityInstance.markEnded(deleteReason);

      // Fire event
      ProcessEngineConfigurationImpl config = Context.getProcessEngineConfiguration();
      if (config != null && config.getEventDispatcher().isEnabled()) {
        config.getEventDispatcher().dispatchEvent(
            ActivitiEventBuilder.createEntityEvent(ActivitiEventType.HISTORIC_ACTIVITY_INSTANCE_ENDED, historicActivityInstance));
      }
    }

  }
 

@Override
public void delete(VariableInstanceEntity entity, boolean fireDeleteEvent) {
  super.delete(entity, false);
  ByteArrayRef byteArrayRef = entity.getByteArrayRef();
  if (byteArrayRef != null) {
    byteArrayRef.delete();
  }
  entity.setDeleted(true);
  
  if (entity.getExecutionId() != null && isExecutionRelatedEntityCountEnabledGlobally()) {
    CountingExecutionEntity executionEntity = (CountingExecutionEntity) getExecutionEntityManager().findById(entity.getExecutionId());
    if (isExecutionRelatedEntityCountEnabled(executionEntity)) {
      executionEntity.setVariableCount(executionEntity.getVariableCount() - 1);
    }
  }

  ActivitiEventDispatcher eventDispatcher =  getEventDispatcher();
  if (fireDeleteEvent && eventDispatcher.isEnabled()) {
    eventDispatcher.dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_DELETED, entity));
    
    eventDispatcher.dispatchEvent(createVariableDeleteEvent(entity));
  }
  
}
 

/**
 * Sets the version on each process definition entity, and the identifier.  If the map contains
 * an older version for a process definition, then the version is set to that older entity's
 * version plus one; otherwise it is set to 1.  Also dispatches an ENTITY_CREATED event.
 */
protected void setProcessDefinitionVersionsAndIds(ParsedDeployment parsedDeployment,
    Map<ProcessDefinitionEntity, ProcessDefinitionEntity> mapNewToOldProcessDefinitions) {
  CommandContext commandContext = Context.getCommandContext();

  for (ProcessDefinitionEntity processDefinition : parsedDeployment.getAllProcessDefinitions()) {
    int version = 1;
    
    ProcessDefinitionEntity latest = mapNewToOldProcessDefinitions.get(processDefinition);
    if (latest != null) {
      version = latest.getVersion() + 1;
    }
    
    processDefinition.setVersion(version);
    processDefinition.setId(getIdForNewProcessDefinition(processDefinition));
    
    if (commandContext.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
      commandContext.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_CREATED, processDefinition));
    }
  }
}
 

public void testJobCanceledAndTimerStartEventOnProcessRedeploy() throws Exception {
  // GIVEN deploy process definition
  String deployment1 = repositoryService.createDeployment().addClasspathResource("org/activiti/engine/test/api/event/JobEventsTest.testTimerFiredForTimerStart.bpmn20.xml").deploy().getId();
  checkEventCount(1, ActivitiEventType.TIMER_SCHEDULED);
  listener.clearEventsReceived();

  // WHEN
  String deployment2 = repositoryService.createDeployment().addClasspathResource("org/activiti/engine/test/api/event/JobEventsTest.testTimerFiredForTimerStart.bpmn20.xml").deploy().getId();

  // THEN
  checkEventCount(1, ActivitiEventType.JOB_CANCELED);
  checkEventCount(1, ActivitiEventType.TIMER_SCHEDULED);

  listener.clearEventsReceived();

  repositoryService.deleteDeployment(deployment2);
  checkEventCount(1, ActivitiEventType.JOB_CANCELED);
  checkEventCount(1, ActivitiEventType.TIMER_SCHEDULED);

  listener.clearEventsReceived();

  repositoryService.deleteDeployment(deployment1);
  checkEventCount(1, ActivitiEventType.JOB_CANCELED);
}
 

/**
 * Test events related to message events, called from the API.
 */
@Deployment
public void testActivityMessageEvents() throws Exception {
  ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("messageProcess");
  assertNotNull(processInstance);

  Execution executionWithMessage = runtimeService.createExecutionQuery().activityId("shipOrder").singleResult();
  assertNotNull(executionWithMessage);

  runtimeService.messageEventReceived("messageName", executionWithMessage.getId());
  assertEquals(2, listener.getEventsReceived().size());

  // First, an ACTIVITY_MESSAGE_WAITING event is expected
  assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiMessageEvent);
  ActivitiMessageEvent messageEvent = (ActivitiMessageEvent) listener.getEventsReceived().get(0);
  assertEquals(ActivitiEventType.ACTIVITY_MESSAGE_WAITING, messageEvent.getType());
  assertEquals("shipOrder", messageEvent.getActivityId());
  assertEquals(executionWithMessage.getId(), messageEvent.getExecutionId());
  assertEquals(executionWithMessage.getProcessInstanceId(), messageEvent.getProcessInstanceId());
  assertEquals(processInstance.getProcessDefinitionId(), messageEvent.getProcessDefinitionId());
  assertEquals("messageName", messageEvent.getMessageName());
  assertNull(messageEvent.getMessageData());

  // Second, an ACTIVITY_MESSAGE_RECEIVED event is expected
  assertTrue(listener.getEventsReceived().get(1) instanceof ActivitiMessageEvent);
  messageEvent = (ActivitiMessageEvent) listener.getEventsReceived().get(1);
  assertEquals(ActivitiEventType.ACTIVITY_MESSAGE_RECEIVED, messageEvent.getType());
  assertEquals("shipOrder", messageEvent.getActivityId());
  assertEquals(executionWithMessage.getId(), messageEvent.getExecutionId());
  assertEquals(executionWithMessage.getProcessInstanceId(), messageEvent.getProcessInstanceId());
  assertEquals(processInstance.getProcessDefinitionId(), messageEvent.getProcessDefinitionId());
  assertEquals("messageName", messageEvent.getMessageName());
  assertNull(messageEvent.getMessageData());

  assertDatabaseEventPresent(ActivitiEventType.ACTIVITY_MESSAGE_RECEIVED);
}
 

public Object execute(CommandContext commandContext) {
  AttachmentEntity attachment = commandContext
    .getDbSqlSession()
    .selectById(AttachmentEntity.class, attachmentId);

  commandContext
    .getDbSqlSession()
    .delete(attachment);
  
  if (attachment.getContentId() != null) {
    commandContext
      .getByteArrayEntityManager()
      .deleteByteArrayById(attachment.getContentId());
  }
  
  if (attachment.getTaskId()!=null) {
    commandContext.getHistoryManager()
      .createAttachmentComment(attachment.getTaskId(), attachment.getProcessInstanceId(), attachment.getName(), false);
  }
  
  if(commandContext.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
  	// Forced to fetch the process-instance to associate the right process definition
  	String processDefinitionId = null;
  	String processInstanceId = attachment.getProcessInstanceId();
  	if(attachment.getProcessInstanceId() != null) {
  		ExecutionEntity process = commandContext.getExecutionEntityManager().findExecutionById(processInstanceId);
  		if(process != null) {
  			processDefinitionId = process.getProcessDefinitionId();
  		}
  	}
  	commandContext.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
  			ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_DELETED, attachment, processInstanceId, processInstanceId, processDefinitionId));
  }
  return null;
}
 

public void close() {
  ProcessEngines.unregister(this);
  if (asyncExecutor != null && asyncExecutor.isActive()) {
    asyncExecutor.shutdown();
  }

  commandExecutor.execute(processEngineConfiguration.getSchemaCommandConfig(), new SchemaOperationProcessEngineClose());

  if (processEngineConfiguration.getProcessEngineLifecycleListener() != null) {
    processEngineConfiguration.getProcessEngineLifecycleListener().onProcessEngineClosed(this);
  }
  
  processEngineConfiguration.getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createGlobalEvent(ActivitiEventType.ENGINE_CLOSED));
}
 

/**
 * Test events related to message events, called from the API, targeting an event-subprocess.
 */
@Deployment
public void testActivityMessageEventsInEventSubprocess() throws Exception {
	ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("messageProcess");
	assertNotNull(processInstance);

	Execution executionWithMessage = runtimeService.createExecutionQuery().activityId("shipOrder").singleResult();
	assertNotNull(executionWithMessage);

	runtimeService.messageEventReceived("messageName", executionWithMessage.getId());

	// Only a message-event should be present, no signal-event, since the
	// event-subprocess is
	// not signaled, but executed instead
	assertEquals(1, listener.getEventsReceived().size());

	// A message-event is expected
	assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiMessageEvent);
	ActivitiMessageEvent messageEvent = (ActivitiMessageEvent) listener.getEventsReceived().get(0);
	assertEquals(ActivitiEventType.ACTIVITY_MESSAGE_RECEIVED, messageEvent.getType());
	assertEquals("catchMessage", messageEvent.getActivityId());
	assertEquals(executionWithMessage.getId(), messageEvent.getExecutionId());
	assertEquals(executionWithMessage.getProcessInstanceId(), messageEvent.getProcessInstanceId());
	assertEquals(processInstance.getProcessDefinitionId(), messageEvent.getProcessDefinitionId());
	assertEquals("messageName", messageEvent.getMessageName());
	assertNull(messageEvent.getMessageData());
}
 

/**
 * Test TIMER_FIRED event for timer start bpmn event.
 */
@Deployment
public void testTimerFiredForTimerStart() throws Exception {
  Clock clock = processEngineConfiguration.getClock();
  
  // there should be one job after process definition deployment
  
  // Force timer to start the process
  Calendar tomorrow = Calendar.getInstance();
  tomorrow.add(Calendar.DAY_OF_YEAR, 1);
  clock.setCurrentCalendar(tomorrow);
  processEngineConfiguration.setClock(clock);
  waitForJobExecutorToProcessAllJobs(2000, 200);

  // Check Timer fired event has been dispatched
  assertEquals(6, listener.getEventsReceived().size());
  
  // timer entity created first
  assertEquals(ActivitiEventType.ENTITY_CREATED, listener.getEventsReceived().get(0).getType());
  // timer entity initialized
  assertEquals(ActivitiEventType.ENTITY_INITIALIZED, listener.getEventsReceived().get(1).getType());
  // timer entity deleted
  assertEquals(ActivitiEventType.ENTITY_DELETED, listener.getEventsReceived().get(2).getType());
  // job fired
  assertEquals(ActivitiEventType.TIMER_FIRED, listener.getEventsReceived().get(3).getType());
  // job executed successfully
  assertEquals(ActivitiEventType.JOB_EXECUTION_SUCCESS, listener.getEventsReceived().get(5).getType());
  
  checkEventCount(0, ActivitiEventType.JOB_CANCELED);
  
  processEngineConfiguration.resetClock();
}
 

protected static void dispatchStateChangeEvent(Object entity, SuspensionState state) {
	if(Context.getCommandContext() != null && Context.getCommandContext().getEventDispatcher().isEnabled()) {
  	ActivitiEventType eventType = null;
  	if(state == SuspensionState.ACTIVE) {
  		eventType = ActivitiEventType.ENTITY_ACTIVATED;
  	} else {
  		eventType = ActivitiEventType.ENTITY_SUSPENDED;
  	}
  	Context.getCommandContext().getEventDispatcher().dispatchEvent(
  			ActivitiEventBuilder.createEntityEvent(eventType, entity));
  }
}
 

public ProcessEngineImpl(ProcessEngineConfigurationImpl processEngineConfiguration) {
  this.processEngineConfiguration = processEngineConfiguration;
  this.name = processEngineConfiguration.getProcessEngineName();
  this.repositoryService = processEngineConfiguration.getRepositoryService();
  this.runtimeService = processEngineConfiguration.getRuntimeService();
  this.historicDataService = processEngineConfiguration.getHistoryService();
  this.identityService = processEngineConfiguration.getIdentityService();
  this.taskService = processEngineConfiguration.getTaskService();
  this.formService = processEngineConfiguration.getFormService();
  this.managementService = processEngineConfiguration.getManagementService();
  this.dynamicBpmnService = processEngineConfiguration.getDynamicBpmnService();
  this.asyncExecutor = processEngineConfiguration.getAsyncExecutor();
  this.commandExecutor = processEngineConfiguration.getCommandExecutor();
  this.sessionFactories = processEngineConfiguration.getSessionFactories();
  this.transactionContextFactory = processEngineConfiguration.getTransactionContextFactory();
  this.formEngineRepositoryService = processEngineConfiguration.getFormEngineRepositoryService();
  this.formEngineFormService = processEngineConfiguration.getFormEngineFormService();

  if (processEngineConfiguration.isUsingRelationalDatabase() && processEngineConfiguration.getDatabaseSchemaUpdate() != null) {
    commandExecutor.execute(processEngineConfiguration.getSchemaCommandConfig(), new SchemaOperationsProcessEngineBuild());
  }

  if (name == null) {
    log.info("default activiti ProcessEngine created");
  } else {
    log.info("ProcessEngine {} created", name);
  }

  ProcessEngines.registerProcessEngine(this);

  if (asyncExecutor != null && asyncExecutor.isAutoActivate()) {
    asyncExecutor.start();
  }

  if (processEngineConfiguration.getProcessEngineLifecycleListener() != null) {
    processEngineConfiguration.getProcessEngineLifecycleListener().onProcessEngineBuilt(this);
  }

  processEngineConfiguration.getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createGlobalEvent(ActivitiEventType.ENGINE_CREATED));
}
 

public ActivitiEntityEventImpl(Object entity, ActivitiEventType type) {
super(type);
if(entity == null) {
	throw new ActivitiIllegalArgumentException("Entity cannot be null.");
}
 this.entity = entity;
}
 

/**
 * Test +-->Task1 Start-<> +-->Task1
 * 
 * process on PROCESS_COMPLETED event
 */
@Deployment(resources = { "org/activiti/engine/test/api/event/ProcessInstanceEventsTest.parallelGatewayNoEndProcess.bpmn20.xml" })
public void testProcessCompleted_ParallelGatewayNoEnd() throws Exception {
  this.runtimeService.startProcessInstanceByKey("noEndProcess");

  assertEquals("ActivitiEventType.PROCESS_COMPLETED was expected 1 time.", 1, listener.filterEvents(ActivitiEventType.PROCESS_COMPLETED).size());
}
 

@Override
public void recordActivityStart(ExecutionEntity executionEntity) {
  if (isHistoryLevelAtLeast(HistoryLevel.ACTIVITY)) {
    if (executionEntity.getActivityId() != null && executionEntity.getCurrentFlowElement() != null) {
      
      HistoricActivityInstanceEntity historicActivityInstanceEntity = null;
      
      // Historic activity instance could have been created (but only in cache, never persisted)
      // for example when submitting form properties
      HistoricActivityInstanceEntity historicActivityInstanceEntityFromCache = 
          getHistoricActivityInstanceFromCache(executionEntity.getId(), executionEntity.getActivityId(), true);
      if (historicActivityInstanceEntityFromCache != null) {
        historicActivityInstanceEntity = historicActivityInstanceEntityFromCache;
      } else {
        historicActivityInstanceEntity = createHistoricActivityInstanceEntity(executionEntity);
      }
      
      // Fire event
      ActivitiEventDispatcher activitiEventDispatcher = getEventDispatcher();
      if (activitiEventDispatcher != null && activitiEventDispatcher.isEnabled()) {
        activitiEventDispatcher.dispatchEvent(
            ActivitiEventBuilder.createEntityEvent(ActivitiEventType.HISTORIC_ACTIVITY_INSTANCE_CREATED, historicActivityInstanceEntity));
      }
      
    }
  }
}
 

public static ActivitiEvent createEvent(ActivitiEventType type, String executionId, String processInstanceId, String processDefinitionId) {
	ActivitiEventImpl newEvent = new ActivitiEventImpl(type);
	newEvent.setExecutionId(executionId);
	newEvent.setProcessDefinitionId(processDefinitionId);
	newEvent.setProcessInstanceId(processInstanceId);
	return newEvent;
}
 

@Deployment
public void testThrowMessage() throws Exception {
	MessageThrowingEventListener listener = null;
	
	try {
		listener = new MessageThrowingEventListener();
		listener.setMessageName("Message");
		
		processEngineConfiguration.getEventDispatcher().addEventListener(listener, ActivitiEventType.TASK_ASSIGNED);
		
		ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("testMessage");
		assertNotNull(processInstance);
		
		// Fetch the task and re-assig it to trigger the event-listener
		Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId())
				.singleResult();
		assertNotNull(task);
		taskService.setAssignee(task.getId(), "kermit");
		
		// Boundary-event should have been messaged and a new task should be available, on top of the already
		// existing one, since the cancelActivity='false'
		task = taskService.createTaskQuery().processInstanceId(processInstance.getId())
				.taskDefinitionKey("subTask")
				.singleResult();
		assertNotNull(task);
		assertEquals("kermit", task.getAssignee());
		
		Task boundaryTask = taskService.createTaskQuery().processInstanceId(processInstance.getId())
				.taskDefinitionKey("boundaryTask")
				.singleResult();
		assertNotNull(boundaryTask);
		
		
	} finally {
	  processEngineConfiguration.getEventDispatcher().removeEventListener(listener);
	}
}
 

@Deployment(resources = {
        "org/activiti5/engine/test/bpmn/event/error/BoundaryErrorEventTest.testCatchErrorOnCallActivity-parent.bpmn20.xml",
        "org/activiti5/engine/test/bpmn/event/error/BoundaryErrorEventTest.subprocess.bpmn20.xml"
})
public void testProcessCompletedEvents_callActivityErrorEndEvent() throws Exception {
  ProcessInstance pi = runtimeService.startProcessInstanceByKey("catchErrorOnCallActivity");

  Task task = taskService.createTaskQuery().singleResult();
  assertEquals("Task in subprocess", task.getName());
  List<ProcessInstance> subProcesses = runtimeService.createProcessInstanceQuery().superProcessInstanceId(pi.getId()).list();
  assertEquals(1, subProcesses.size());

  // Completing the task will reach the end error event,
  // which is caught on the call activity boundary
  taskService.complete(task.getId());

  List<ActivitiEvent> processCompletedEvents = listener.filterEvents(ActivitiEventType.PROCESS_COMPLETED_WITH_ERROR_END_EVENT);
  assertEquals("There should be exactly one ActivitiEventType.PROCESS_COMPLETED_WITH_ERROR_END_EVENT event after the task complete.", 1, processCompletedEvents.size());
  ActivitiEntityEvent processCompletedEvent = (ActivitiEntityEvent) processCompletedEvents.get(0);
  assertEquals(subProcesses.get(0).getId(), processCompletedEvent.getExecutionId());

  task = taskService.createTaskQuery().singleResult();
  assertEquals("Escalated Task", task.getName());

  // Completing the task will end the process instance
  taskService.complete(task.getId());
  assertProcessEnded(pi.getId());
}
 

@Deployment
public void testThrowError() throws Exception {
	ErrorThrowingEventListener listener = null;
	
	try {
		listener = new ErrorThrowingEventListener();
		
		processEngineConfiguration.getEventDispatcher().addEventListener(listener, ActivitiEventType.TASK_ASSIGNED);
		
		ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("testError");
		assertNotNull(processInstance);
		
		// Fetch the task and assign it. Should cause error-event to be dispatched
		Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId())
				.taskDefinitionKey("userTask")
				.singleResult();
		assertNotNull(task);
		taskService.setAssignee(task.getId(), "kermit");

		// Error-handling should have been called, and "escalate" task should be available instead of original one
		task = taskService.createTaskQuery().processInstanceId(processInstance.getId())
				.taskDefinitionKey("escalatedTask")
				.singleResult();
		assertNotNull(task);
		
		
	} finally {
	  processEngineConfiguration.getEventDispatcher().removeEventListener(listener);
	}
}
 

@Deployment
public void testThrowMessage() throws Exception {
  MessageThrowingEventListener listener = null;
  try {
    listener = new MessageThrowingEventListener();
    listener.setMessageName("Message");

    processEngineConfiguration.getEventDispatcher().addEventListener(listener, ActivitiEventType.TASK_ASSIGNED);

    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("testMessage");
    assertNotNull(processInstance);

    // Fetch the task and re-assig it to trigger the event-listener
    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
    assertNotNull(task);
    taskService.setAssignee(task.getId(), "kermit");

    // Boundary-event should have been messaged and a new task should be
    // available, on top of the already
    // existing one, since the cancelActivity='false'
    task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).taskDefinitionKey("subTask").singleResult();
    assertNotNull(task);
    assertEquals("kermit", task.getAssignee());

    Task boundaryTask = taskService.createTaskQuery().processInstanceId(processInstance.getId()).taskDefinitionKey("boundaryTask").singleResult();
    assertNotNull(boundaryTask);

  } finally {
    processEngineConfiguration.getEventDispatcher().removeEventListener(listener);
  }
}
 

/**
 * @param type type of event
 * @param entity the entity this event targets
 * @param cause the cause of the event
 * @return an {@link ActivitiEntityEvent} that is also instance of {@link ActivitiExceptionEvent}. 
 * In case an {@link ExecutionContext} is active, the execution related event fields will be populated.
 */
public static ActivitiEntityEvent createEntityExceptionEvent(ActivitiEventType type, Object entity, Throwable cause) {
	ActivitiEntityExceptionEventImpl newEvent = new ActivitiEntityExceptionEventImpl(entity, type, cause);

	// In case an execution-context is active, populate the event fields related to the execution
	populateEventWithCurrentContext(newEvent);
	return newEvent;
}