import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
protected VariableMap collectInitialVariables(CommandContext commandContext, HistoricProcessInstance processInstance) {
  HistoryService historyService = commandContext.getProcessEngineConfiguration().getHistoryService();

  HistoricActivityInstance startActivityInstance = resolveStartActivityInstance(processInstance);

  HistoricDetailQueryImpl query = (HistoricDetailQueryImpl) historyService.createHistoricDetailQuery()
      .variableUpdates()
      .executionId(processInstance.getId())
      .activityInstanceId(startActivityInstance.getId());

  List<HistoricDetail> historicDetails = query
      .sequenceCounter(1)
      .list();

  VariableMap variables = new VariableMapImpl();
  for (HistoricDetail detail : historicDetails) {
    HistoricVariableUpdate variableUpdate = (HistoricVariableUpdate) detail;
    variables.putValueTyped(variableUpdate.getVariableName(), variableUpdate.getTypedValue());
  }

  return variables;
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
protected HistoricActivityInstance resolveStartActivityInstance(HistoricProcessInstance processInstance) {
  HistoryService historyService = Context.getProcessEngineConfiguration().getHistoryService();

  String processInstanceId = processInstance.getId();
  String startActivityId = processInstance.getStartActivityId();

  ensureNotNull("startActivityId", startActivityId);

  List<HistoricActivityInstance> historicActivityInstances = historyService
      .createHistoricActivityInstanceQuery()
      .processInstanceId(processInstanceId)
      .activityId(startActivityId)
      .orderPartiallyByOccurrence()
      .asc()
      .list();

  ensureNotEmpty("historicActivityInstances", historicActivityInstances);

  HistoricActivityInstance startActivityInstance = historicActivityInstances.get(0);
  return startActivityInstance;
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
public HistoricDecisionInstanceDto getHistoricDecisionInstance(Boolean includeInputs, Boolean includeOutputs, Boolean disableBinaryFetching, Boolean disableCustomObjectDeserialization) {
  HistoryService historyService = engine.getHistoryService();

  HistoricDecisionInstanceQuery query = historyService.createHistoricDecisionInstanceQuery().decisionInstanceId(decisionInstanceId);
  if (includeInputs != null && includeInputs) {
    query.includeInputs();
  }
  if (includeOutputs != null && includeOutputs) {
    query.includeOutputs();
  }
  if (disableBinaryFetching != null && disableBinaryFetching) {
    query.disableBinaryFetching();
  }
  if (disableCustomObjectDeserialization != null && disableCustomObjectDeserialization) {
    query.disableCustomObjectDeserialization();
  }

  HistoricDecisionInstance instance = query.singleResult();

  if (instance == null) {
    throw new InvalidRequestException(Status.NOT_FOUND, "Historic decision instance with id '" + decisionInstanceId + "' does not exist");
  }

  return HistoricDecisionInstanceDto.fromHistoricDecisionInstance(instance);
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
@Override
public BatchDto deleteAsync(DeleteHistoricProcessInstancesDto dto) {
  HistoryService historyService = processEngine.getHistoryService();

  HistoricProcessInstanceQuery historicProcessInstanceQuery = null;
  if (dto.getHistoricProcessInstanceQuery() != null) {
    historicProcessInstanceQuery = dto.getHistoricProcessInstanceQuery().toQuery(processEngine);
  }

  try {
    Batch batch = historyService.deleteHistoricProcessInstancesAsync(
        dto.getHistoricProcessInstanceIds(),
        historicProcessInstanceQuery,
        dto.getDeleteReason());
    return BatchDto.fromBatch(batch);

  } catch (BadUserRequestException e) {
    throw new InvalidRequestException(Status.BAD_REQUEST, e.getMessage());
  }
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
@Before
public void setUpRuntimeData() {
  runtimeServiceMock = mock(RuntimeService.class);
  when(processEngine.getRuntimeService()).thenReturn(runtimeServiceMock);
  
  historyServiceMock = mock(HistoryService.class);
  when(processEngine.getHistoryService()).thenReturn(historyServiceMock);

  builderMock = mock(RestartProcessInstanceBuilder.class);
  when(builderMock.startAfterActivity(anyString())).thenReturn(builderMock);
  when(builderMock.startBeforeActivity(anyString())).thenReturn(builderMock);
  when(builderMock.startTransition(anyString())).thenReturn(builderMock);
  when(builderMock.processInstanceIds(anyListOf(String.class))).thenReturn(builderMock);
  when(builderMock.historicProcessInstanceQuery(any(HistoricProcessInstanceQuery.class))).thenReturn(builderMock);
  when(builderMock.skipCustomListeners()).thenReturn(builderMock);
  when(builderMock.skipIoMappings()).thenReturn(builderMock);
  when(builderMock.initialSetOfVariables()).thenReturn(builderMock);
  when(builderMock.withoutBusinessKey()).thenReturn(builderMock);

  Batch batchMock = createMockBatch();
  when(builderMock.executeAsync()).thenReturn(batchMock);

  when(runtimeServiceMock.restartProcessInstances(anyString())).thenReturn(builderMock);
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
private void mockServices(ProcessEngine engine) {
  RepositoryService repoService = mock(RepositoryService.class);
  IdentityService identityService = mock(IdentityService.class);
  TaskService taskService = mock(TaskService.class);
  RuntimeService runtimeService = mock(RuntimeService.class);
  FormService formService = mock(FormService.class);
  HistoryService historyService = mock(HistoryService.class);
  ManagementService managementService = mock(ManagementService.class);
  CaseService caseService = mock(CaseService.class);
  FilterService filterService = mock(FilterService.class);
  ExternalTaskService externalTaskService = mock(ExternalTaskService.class);

  when(engine.getRepositoryService()).thenReturn(repoService);
  when(engine.getIdentityService()).thenReturn(identityService);
  when(engine.getTaskService()).thenReturn(taskService);
  when(engine.getRuntimeService()).thenReturn(runtimeService);
  when(engine.getFormService()).thenReturn(formService);
  when(engine.getHistoryService()).thenReturn(historyService);
  when(engine.getManagementService()).thenReturn(managementService);
  when(engine.getCaseService()).thenReturn(caseService);
  when(engine.getFilterService()).thenReturn(filterService);
  when(engine.getExternalTaskService()).thenReturn(externalTaskService);
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
protected void logActivityResults(PerfTestPass pass, PerfTestRun run, HistoryService historyService) {
  String processInstanceId = run.getVariable(PerfTestConstants.PROCESS_INSTANCE_ID);
  List<ActivityPerfTestResult> activityResults = new ArrayList<ActivityPerfTestResult>();

  HistoricProcessInstance processInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
  Date startTime = processInstance.getStartTime();

  List<HistoricActivityInstance> activityInstances = historyService.createHistoricActivityInstanceQuery()
    .processInstanceId(processInstanceId)
    .orderByHistoricActivityInstanceStartTime()
    .asc()
    .list();

  for (HistoricActivityInstance activityInstance : activityInstances) {
    if (watchAllActivities || activityIds.contains(activityInstance.getActivityId())) {
      ActivityPerfTestResult result = new ActivityPerfTestResult(activityInstance);
      if (activityInstance.getActivityType().equals("startEvent")) {
        result.setStartTime(startTime);
      }
      activityResults.add(result);
    }
  }

  pass.logActivityResult(processInstanceId, activityResults);
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
public static void clearUserOperationLog(ProcessEngineConfigurationImpl processEngineConfiguration) {
  if (processEngineConfiguration.getHistoryLevel().equals(HistoryLevel.HISTORY_LEVEL_FULL)) {
    HistoryService historyService = processEngineConfiguration.getHistoryService();
    List<UserOperationLogEntry> logs = historyService.createUserOperationLogQuery().list();
    for (UserOperationLogEntry log : logs) {
      historyService.deleteUserOperationLogEntry(log.getId());
    }
  }
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
protected VariableMap collectLastVariables(CommandContext commandContext, HistoricProcessInstance processInstance) {
  HistoryService historyService = commandContext.getProcessEngineConfiguration().getHistoryService();

  List<HistoricVariableInstance> historicVariables = historyService.createHistoricVariableInstanceQuery()
      .executionIdIn(processInstance.getId())
      .list();

  VariableMap variables = new VariableMapImpl();
  for (HistoricVariableInstance variable : historicVariables) {
    variables.putValueTyped(variable.getName(), variable.getTypedValue());
  }

  return variables;
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
private void removeAllRunningAndHistoricBatches() {
  HistoryService historyService = engineRule.getHistoryService();
  ManagementService managementService = engineRule.getManagementService();

  for (Batch batch : managementService.createBatchQuery().list()) {
    managementService.deleteBatch(batch.getId(), true);
  }

  // remove history of completed batches
  for (HistoricBatch historicBatch : historyService.createHistoricBatchQuery().list()) {
    historyService.deleteHistoricBatch(historicBatch.getId());
  }
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
@After
public void removeAllRunningAndHistoricBatches() {
  HistoryService historyService = rule.getHistoryService();
  ManagementService managementService = rule.getManagementService();
  for (Batch batch : managementService.createBatchQuery().list()) {
    managementService.deleteBatch(batch.getId(), true);
  }
  // remove history of completed batches
  for (HistoricBatch historicBatch : historyService.createHistoricBatchQuery().list()) {
    historyService.deleteHistoricBatch(historicBatch.getId());
  }
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
/**
 * Remove all batches and historic batches. Usually called in {@link org.junit.After} method.
 */
public void removeAllRunningAndHistoricBatches() {
  HistoryService historyService = getHistoryService();
  ManagementService managementService = getManagementService();

  for (Batch batch : managementService.createBatchQuery().list()) {
    managementService.deleteBatch(batch.getId(), true);
  }

  // remove history of completed batches
  for (HistoricBatch historicBatch : historyService.createHistoricBatchQuery().list()) {
    historyService.deleteHistoricBatch(historicBatch.getId());
  }

}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
protected HistoryService getHistoryService() {
  if (engineRule != null) {
    return engineRule.getHistoryService();
  }
  else {
    return testCase.getProcessEngine().getHistoryService();
  }
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
public void execute(DelegateExecution execution) throws Exception {
  HistoryService historyService = execution.getProcessEngineServices().getHistoryService();

  HistoricVariableInstance variableInstance = historyService
      .createHistoricVariableInstanceQuery()
      .variableName("listVar")
      .singleResult();

  List<String> list = (List<String>) variableInstance.getValue();

  // implicit update of the list, should not trigger an update
  // of the value since we deal with historic variables
  list.add(NEW_ELEMENT);
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
public HistoricActivityInstanceDto getHistoricActivityInstance() {
  HistoryService historyService = engine.getHistoryService();
  HistoricActivityInstance instance = historyService.createHistoricActivityInstanceQuery()
    .activityInstanceId(activityInstanceId).singleResult();

  if (instance == null) {
    throw new InvalidRequestException(Status.NOT_FOUND, "Historic activity instance with id '" + activityInstanceId + "' does not exist");
  }

  return HistoricActivityInstanceDto.fromHistoricActivityInstance(instance);
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
public HistoricCaseInstanceDto getHistoricCaseInstance() {
  HistoryService historyService = engine.getHistoryService();
  HistoricCaseInstance instance = historyService.createHistoricCaseInstanceQuery().caseInstanceId(caseInstanceId).singleResult();

  if (instance == null) {
    throw new InvalidRequestException(Status.NOT_FOUND, "Historic case instance with id '" + caseInstanceId + "' does not exist");
  }

  return HistoricCaseInstanceDto.fromHistoricCaseInstance(instance);
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
@Override
public HistoricProcessInstanceDto getHistoricProcessInstance() {
  HistoryService historyService = engine.getHistoryService();
  HistoricProcessInstance instance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();

  if (instance == null) {
    throw new InvalidRequestException(Status.NOT_FOUND, "Historic process instance with id " + processInstanceId + " does not exist");
  }

  return HistoricProcessInstanceDto.fromHistoricProcessInstance(instance);
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
@Override
public HistoricExternalTaskLogDto getHistoricExternalTaskLog() {
  HistoryService historyService = engine.getHistoryService();
  HistoricExternalTaskLog historicExternalTaskLog = historyService
    .createHistoricExternalTaskLogQuery()
    .logId(id)
    .singleResult();

  if (historicExternalTaskLog == null) {
    throw new InvalidRequestException(Status.NOT_FOUND, "Historic external task log with id " + id + " does not exist");
  }

  return HistoricExternalTaskLogDto.fromHistoricExternalTaskLog(historicExternalTaskLog);
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
public HistoricCaseActivityInstanceDto getHistoricCaseActivityInstance() {
  HistoryService historyService = engine.getHistoryService();
  HistoricCaseActivityInstance instance = historyService.createHistoricCaseActivityInstanceQuery()
    .caseActivityInstanceId(caseActivityInstanceId).singleResult();

  if (instance == null) {
    throw new InvalidRequestException(Status.NOT_FOUND, "Historic case activity instance with id '" + caseActivityInstanceId + "' does not exist");
  }

  return HistoricCaseActivityInstanceDto.fromHistoricCaseActivityInstance(instance);
}
 

import org.camunda.bpm.engine.HistoryService; //导入依赖的package包/类
public HistoricJobLogDto getHistoricJobLog() {
  HistoryService historyService = engine.getHistoryService();
  HistoricJobLog historicJobLog = historyService
      .createHistoricJobLogQuery()
      .logId(id)
      .singleResult();

  if (historicJobLog == null) {
    throw new InvalidRequestException(Status.NOT_FOUND, "Historic job log with id " + id + " does not exist");
  }

  return HistoricJobLogDto.fromHistoricJobLog(historicJobLog);
}