import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
public static void init() throws SQLException {
  Bus.register(new OrderCamunda());
  
  // Configure Camunda engine (in this case using in memory H2)
  StandaloneInMemProcessEngineConfiguration conf = new StandaloneInMemProcessEngineConfiguration();
  conf.setJobExecutorActivate(true);
  conf.setHistoryLevel(HistoryLevel.HISTORY_LEVEL_FULL);
  conf.setJdbcUsername("sa");
  conf.setJdbcPassword("sa");
  camunda = conf.buildProcessEngine();
  // and start H2 database server to allow inspection from the outside
  Server.createTcpServer(new String[] { "-tcpPort", "8092", "-tcpAllowOthers" }).start();
  
  // Define flow
  BpmnModelInstance flow = extendedFlowOfActivities();
      
  // Deploy finished flow to Camunda
  camunda.getRepositoryService().createDeployment() //
      .addModelInstance("order.bpmn", flow) //
      .deploy();
  
  // Only for demo: write flow to file, so we can open it in modeler
  Bpmn.writeModelToFile(new File("order.bpmn"), flow);
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
@Deployment(resources = ONE_TASK_PROCESS)
public void testSelectHistoricVariableInstances() throws JSONException {
  if (processEngineConfiguration.getHistoryLevel().getId() >=
      HistoryLevel.HISTORY_LEVEL_AUDIT.getId()) {
    ProcessInstance instance = runtimeService.startProcessInstanceByKey("oneTaskProcess");

    JsonSerializable bean = new JsonSerializable("a String", 42, false);
    runtimeService.setVariable(instance.getId(), "simpleBean", objectValue(bean).serializationDataFormat(JSON_FORMAT_NAME).create());

    HistoricVariableInstance historicVariable = historyService.createHistoricVariableInstanceQuery().singleResult();
    assertNotNull(historicVariable.getValue());
    assertNull(historicVariable.getErrorMessage());

    assertEquals(ValueType.OBJECT.getName(), historicVariable.getTypeName());
    assertEquals(ValueType.OBJECT.getName(), historicVariable.getVariableTypeName());

    JsonSerializable historyValue = (JsonSerializable) historicVariable.getValue();
    assertEquals(bean.getStringProperty(), historyValue.getStringProperty());
    assertEquals(bean.getIntProperty(), historyValue.getIntProperty());
    assertEquals(bean.getBooleanProperty(), historyValue.getBooleanProperty());
  }
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
@Deployment(resources = ONE_TASK_PROCESS)
public void testSelectHistoricSerializedValues() throws JSONException {
  if (processEngineConfiguration.getHistoryLevel().getId() >=
      HistoryLevel.HISTORY_LEVEL_AUDIT.getId()) {


    ProcessInstance instance = runtimeService.startProcessInstanceByKey("oneTaskProcess");

    JsonSerializable bean = new JsonSerializable("a String", 42, false);
    runtimeService.setVariable(instance.getId(), "simpleBean", objectValue(bean).serializationDataFormat(JSON_FORMAT_NAME));

    HistoricVariableInstance historicVariable = historyService.createHistoricVariableInstanceQuery().singleResult();
    assertNotNull(historicVariable.getValue());
    assertNull(historicVariable.getErrorMessage());

    ObjectValue typedValue = (ObjectValue) historicVariable.getTypedValue();
    assertEquals(JSON_FORMAT_NAME, typedValue.getSerializationDataFormat());
    JSONAssert.assertEquals(bean.toExpectedJsonString(),new String(typedValue.getValueSerialized()), true);
    assertEquals(JsonSerializable.class.getName(), typedValue.getObjectTypeName());
  }
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
protected void fireHistoricIncidentEvent(final HistoryEventType eventType) {
  ProcessEngineConfigurationImpl processEngineConfiguration = Context.getProcessEngineConfiguration();

  HistoryLevel historyLevel = processEngineConfiguration.getHistoryLevel();
  if(historyLevel.isHistoryEventProduced(eventType, this)) {

    HistoryEventProcessor.processHistoryEvents(new HistoryEventProcessor.HistoryEventCreator() {
      @Override
      public HistoryEvent createHistoryEvent(HistoryEventProducer producer) {

        HistoryEvent event = null;
        if (HistoryEvent.INCIDENT_CREATE.equals(eventType.getEventName())) {
          event = producer.createHistoricIncidentCreateEvt(IncidentEntity.this);

        } else if (HistoryEvent.INCIDENT_RESOLVE.equals(eventType.getEventName())) {
          event = producer.createHistoricIncidentResolveEvt(IncidentEntity.this);

        } else if (HistoryEvent.INCIDENT_DELETE.equals(eventType.getEventName())) {
          event = producer.createHistoricIncidentDeleteEvt(IncidentEntity.this);
        }
        return event;
      }
    });
  }
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
public void markTaskInstanceEnded(String taskId, final String deleteReason) {
  ProcessEngineConfigurationImpl configuration = Context.getProcessEngineConfiguration();

  final TaskEntity taskEntity = Context.getCommandContext()
      .getDbEntityManager()
      .selectById(TaskEntity.class, taskId);

  HistoryLevel historyLevel = configuration.getHistoryLevel();
  if(historyLevel.isHistoryEventProduced(HistoryEventTypes.TASK_INSTANCE_COMPLETE, taskEntity)) {

    HistoryEventProcessor.processHistoryEvents(new HistoryEventProcessor.HistoryEventCreator() {
      @Override
      public HistoryEvent createHistoryEvent(HistoryEventProducer producer) {
        return producer.createTaskInstanceCompleteEvt(taskEntity, deleteReason);
      }
    });
  }
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
@Override
public void fireHistoricProcessStartEvent() {
  ProcessEngineConfigurationImpl configuration = Context.getProcessEngineConfiguration();
  HistoryLevel historyLevel = configuration.getHistoryLevel();
  // TODO: This smells bad, as the rest of the history is done via the
  // ParseListener
  if (historyLevel.isHistoryEventProduced(HistoryEventTypes.PROCESS_INSTANCE_START, processInstance)) {

    HistoryEventProcessor.processHistoryEvents(new HistoryEventProcessor.HistoryEventCreator() {
      @Override
      public HistoryEvent createHistoryEvent(HistoryEventProducer producer) {
        return producer.createProcessInstanceStartEvt(processInstance);
      }
    });
  }
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
public void fireHistoricIdentityLinkEvent(final HistoryEventType eventType) {
  ProcessEngineConfigurationImpl processEngineConfiguration = Context.getProcessEngineConfiguration();

  HistoryLevel historyLevel = processEngineConfiguration.getHistoryLevel();
  if(historyLevel.isHistoryEventProduced(eventType, this)) {

    HistoryEventProcessor.processHistoryEvents(new HistoryEventProcessor.HistoryEventCreator() {
      @Override
      public HistoryEvent createHistoryEvent(HistoryEventProducer producer) {
        HistoryEvent event = null;
        if (HistoryEvent.IDENTITY_LINK_ADD.equals(eventType.getEventName())) {
          event = producer.createHistoricIdentityLinkAddEvent(IdentityLinkEntity.this);
        } else if (HistoryEvent.IDENTITY_LINK_DELETE.equals(eventType.getEventName())) {
          event = producer.createHistoricIdentityLinkDeleteEvent(IdentityLinkEntity.this);
        }
        return event;
      }
    });

  }
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
@Override
public HistoryLevel execute(final CommandContext commandContext) {
  final Integer databaseHistoryLevel = HistoryLevelSetupCommand.databaseHistoryLevel(commandContext);

  HistoryLevel result = null;

  if (databaseHistoryLevel != null) {
    for (final HistoryLevel historyLevel : historyLevels) {
      if (historyLevel.getId() == databaseHistoryLevel) {
        result = historyLevel;
        break;
      }
    }

    if (result != null) {
      return result;
    }
    else {
      // if a custom non-null value is not registered, throw an exception.
      throw new ProcessEngineException(String.format("The configured history level with id='%s' is not registered in this config.", databaseHistoryLevel));
    }
  }
  else {
    return null;
  }
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
@Override
protected void triggerHistoryEvent(CommandContext commandContext){
  HistoryLevel historyLevel = commandContext.getProcessEngineConfiguration().getHistoryLevel();
  List<ProcessInstance> updatedProcessInstances = obtainProcessInstances(commandContext);
  //suspension state is not updated synchronously
  if (getNewSuspensionState() != null && updatedProcessInstances != null) {
    for (final ProcessInstance processInstance: updatedProcessInstances) {

      if (historyLevel.isHistoryEventProduced(HistoryEventTypes.PROCESS_INSTANCE_UPDATE, processInstance)) {
        HistoryEventProcessor.processHistoryEvents(new HistoryEventProcessor.HistoryEventCreator() {
          @Override
          public HistoryEvent createHistoryEvent(HistoryEventProducer producer) {
            HistoricProcessInstanceEventEntity processInstanceUpdateEvt = (HistoricProcessInstanceEventEntity)
                producer.createProcessInstanceUpdateEvt((DelegateExecution) processInstance);
            if (SuspensionState.SUSPENDED.getStateCode() == getNewSuspensionState().getStateCode()) {
              processInstanceUpdateEvt.setState(HistoricProcessInstance.STATE_SUSPENDED);
            } else {
              processInstanceUpdateEvt.setState(HistoricProcessInstance.STATE_ACTIVE);
            }
            return processInstanceUpdateEvt;
          }
        });
      }
    }
  }
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
public void triggerHistoryEvent(List<ProcessInstance> subProcesslist) {
  ProcessEngineConfigurationImpl configuration = Context.getProcessEngineConfiguration();
  HistoryLevel historyLevel = configuration.getHistoryLevel();

  for (final ProcessInstance processInstance : subProcesslist) {
    // TODO: This smells bad, as the rest of the history is done via the
    // ParseListener
    if (historyLevel.isHistoryEventProduced(HistoryEventTypes.PROCESS_INSTANCE_UPDATE, processInstance)) {

      HistoryEventProcessor.processHistoryEvents(new HistoryEventProcessor.HistoryEventCreator() {
        @Override
        public HistoryEvent createHistoryEvent(HistoryEventProducer producer) {
          return producer.createProcessInstanceUpdateEvt((DelegateExecution) processInstance);
        }
      });
    }
  }
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
public void test() throws InterruptedException {
  ThreadControl thread1 = executeControllableCommand(new ControllableUpdateHistoryLevelCommand());
  thread1.waitForSync();

  ThreadControl thread2 = executeControllableCommand(new ControllableUpdateHistoryLevelCommand());
  thread2.waitForSync();

  thread1.makeContinue();
  thread1.waitForSync();

  thread2.makeContinue();

  Thread.sleep(2000);

  thread1.waitUntilDone();

  thread2.waitForSync();
  thread2.waitUntilDone();

  assertNull(thread1.exception);
  assertNull(thread2.exception);
  HistoryLevel historyLevel = processEngineConfiguration.getHistoryLevel();
  assertEquals("full", historyLevel.getName());
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
@Test
public void usesDefaultValueAuditWhenNoValueIsConfigured() {
  final ProcessEngineConfigurationImpl config = config("true", ProcessEngineConfiguration.HISTORY_AUTO);
  ProcessEngineImpl processEngine = buildEngine(config);

  final Integer level = config.getCommandExecutorSchemaOperations().execute(new Command<Integer>() {
    @Override
    public Integer execute(CommandContext commandContext) {
      return HistoryLevelSetupCommand.databaseHistoryLevel(commandContext);
    }
  });

  assertThat(level, equalTo(HistoryLevel.HISTORY_LEVEL_AUDIT.getId()));

  assertThat(processEngine.getProcessEngineConfiguration().getHistoryLevel(), equalTo(HistoryLevel.HISTORY_LEVEL_AUDIT));
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
@Test
public void testSubmitTaskFormForStandaloneTask() {
  // given
  String id = "standaloneTask";
  Task task = taskService.newTask(id);
  taskService.saveTask(task);

  // when
  formService.submitTaskForm(task.getId(), Variables.createVariables().putValue("foo", "bar"));


  if (processEngineConfiguration.getHistoryLevel().getId() >= HistoryLevel.HISTORY_LEVEL_AUDIT.getId()) {
    HistoricVariableInstance variableInstance = historyService
      .createHistoricVariableInstanceQuery()
      .taskIdIn(id)
      .singleResult();

    assertNotNull(variableInstance);
    assertEquals("foo", variableInstance.getName());
    assertEquals("bar", variableInstance.getValue());
  }

  taskService.deleteTask(id, true);
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
@Test
public void testDeleteCascadeProcessDefinitionWithAuthenticatedTenant() {
  //given deployment with a process definition and process instance
  BpmnModelInstance bpmnModel = Bpmn.createExecutableProcess("process").startEvent().userTask().endEvent().done();
  testRule.deployForTenant(TENANT_ONE, bpmnModel);
  ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
  ProcessDefinition processDefinition = processDefinitionQuery.processDefinitionKey("process").singleResult();
  engineRule.getRuntimeService().createProcessInstanceByKey("process").executeWithVariablesInReturn();

  //and user with tenant authentication
  identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE));

  //when the corresponding process definition is cascading deleted from the deployment
  repositoryService.deleteProcessDefinition(processDefinition.getId(), true);

  //then exist no process instance and one definition
  identityService.clearAuthentication();
  assertEquals(0, engineRule.getRuntimeService().createProcessInstanceQuery().count());
  if (processEngineConfiguration.getHistoryLevel().getId() >= HistoryLevel.HISTORY_LEVEL_ACTIVITY.getId()) {
    assertEquals(0, engineRule.getHistoryService().createHistoricActivityInstanceQuery().count());
  }
  assertThat(repositoryService.createProcessDefinitionQuery().count(), is(1L));
  assertThat(repositoryService.createProcessDefinitionQuery().tenantIdIn(TENANT_ONE).count(), is(1L));
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
@Test
public void testDeleteCascadeProcessDefinitionDisabledTenantCheck() {
  //given deployment with a process definition and process instances
  BpmnModelInstance bpmnModel = Bpmn.createExecutableProcess("process").startEvent().userTask().endEvent().done();
  testRule.deployForTenant(TENANT_ONE, bpmnModel);
  //tenant check disabled
  processEngineConfiguration.setTenantCheckEnabled(false);
  ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
  ProcessDefinition processDefinition = processDefinitionQuery.processDefinitionKey("process").singleResult();
  engineRule.getRuntimeService().createProcessInstanceByKey("process").executeWithVariablesInReturn();
  //user with no authentication
  identityService.setAuthentication("user", null, null);

  //when the corresponding process definition is cascading deleted from the deployment
  repositoryService.deleteProcessDefinition(processDefinition.getId(), true);

  //then exist no process instance and one definition, because test case deployes per default one definition
  identityService.clearAuthentication();
  assertEquals(0, engineRule.getRuntimeService().createProcessInstanceQuery().count());
  if (processEngineConfiguration.getHistoryLevel().getId() >= HistoryLevel.HISTORY_LEVEL_ACTIVITY.getId()) {
    assertEquals(0, engineRule.getHistoryService().createHistoricActivityInstanceQuery().count());
  }
  assertThat(repositoryService.createProcessDefinitionQuery().count(), is(1L));
  assertThat(repositoryService.createProcessDefinitionQuery().tenantIdIn(TENANT_ONE).count(), is(1L));
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
@Test
public void testDeleteProcessDefinitionCascade() {
  // given process definition and a process instance
  BpmnModelInstance bpmnModel = Bpmn.createExecutableProcess("process").startEvent().userTask().endEvent().done();
  deployment = repositoryService.createDeployment()
                                .addModelInstance("process.bpmn", bpmnModel)
                                .deploy();
  ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionKey("process").singleResult();
  runtimeService.createProcessInstanceByKey("process").executeWithVariablesInReturn();

  //when the corresponding process definition is cascading deleted from the deployment
  repositoryService.deleteProcessDefinition(processDefinition.getId(), true);

  //then exist no process instance and no definition
  assertEquals(0, runtimeService.createProcessInstanceQuery().count());
  assertEquals(0, repositoryService.createProcessDefinitionQuery().count());
  if (processEngineConfiguration.getHistoryLevel().getId() >= HistoryLevel.HISTORY_LEVEL_ACTIVITY.getId()) {
    assertEquals(0, engineRule.getHistoryService().createHistoricActivityInstanceQuery().count());
  }
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
@Test
public void testDeleteProcessDefinitionCascade() {
  // given process definition and a process instance
  BpmnModelInstance bpmnModel = Bpmn.createExecutableProcess(PROCESS_DEFINITION_KEY).startEvent().userTask().endEvent().done();
  testHelper.deploy(bpmnModel);

  ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionKey(PROCESS_DEFINITION_KEY).singleResult();
  runtimeService.createProcessInstanceByKey(PROCESS_DEFINITION_KEY).executeWithVariablesInReturn();

  authRule.init(scenario)
    .withUser("userId")
    .start();

  //when the corresponding process definition is cascading deleted from the deployment
  repositoryService.deleteProcessDefinition(processDefinition.getId(), true);

  //then exist no process instance and no definition
  if (authRule.assertScenario(scenario)) {
    assertEquals(0, runtimeService.createProcessInstanceQuery().count());
    assertEquals(0, repositoryService.createProcessDefinitionQuery().count());
    if (processEngineConfiguration.getHistoryLevel().getId() >= HistoryLevel.HISTORY_LEVEL_ACTIVITY.getId()) {
      assertEquals(0, engineRule.getHistoryService().createHistoricActivityInstanceQuery().count());
    }
  }
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
protected void clearDatabase() {
  CommandExecutor commandExecutor = processEngineConfiguration.getCommandExecutorTxRequired();
  commandExecutor.execute(new Command<Object>() {
    public Object execute(CommandContext commandContext) {
      HistoryLevel historyLevel = Context.getProcessEngineConfiguration().getHistoryLevel();
      if (historyLevel.equals(HistoryLevel.HISTORY_LEVEL_FULL)) {
        commandContext.getHistoricJobLogManager().deleteHistoricJobLogsByHandlerType(TimerSuspendProcessDefinitionHandler.TYPE);
        List<HistoricIncident> incidents = Context.getProcessEngineConfiguration().getHistoryService().createHistoricIncidentQuery().list();
        for (HistoricIncident incident : incidents) {
          commandContext.getHistoricIncidentManager().delete((HistoricIncidentEntity) incident);
        }
      }

      return null;
    }
  });
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
public void testStandaloneTaskCompleteTask() {
  // given
  String taskId = "myTask";
  createTask(taskId);

  createGrantAuthorization(TASK, taskId, userId, UPDATE);

  // when
  taskService.complete(taskId);

  // then
  Task task = selectSingleTask();
  assertNull(task);

  if (!processEngineConfiguration.getHistoryLevel().equals(HistoryLevel.HISTORY_LEVEL_NONE)) {
    historyService.deleteHistoricTaskInstance(taskId);
  }
}
 

import org.camunda.bpm.engine.impl.history.HistoryLevel; //导入依赖的package包/类
public void testStandaloneTaskCompleteWithTaskWorkPermission() {
  // given
  String taskId = "myTask";
  createTask(taskId);

  createGrantAuthorization(TASK, taskId, userId, TASK_WORK);

  // when
  taskService.complete(taskId);

  // then
  Task task = selectSingleTask();
  assertNull(task);

  if (!processEngineConfiguration.getHistoryLevel().equals(HistoryLevel.HISTORY_LEVEL_NONE)) {
    historyService.deleteHistoricTaskInstance(taskId);
  }
}