import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的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.ExternalTaskService; //导入依赖的package包/类
@Override
public String getErrorDetails() {
  ExternalTaskService externalTaskService = engine.getExternalTaskService();

  try {
    return externalTaskService.getExternalTaskErrorDetails(externalTaskId);
  } catch (NotFoundException e) {
    throw new RestException(Status.NOT_FOUND, e, "External task with id " + externalTaskId + " does not exist");
  }
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
@Override
public void setRetries(RetriesDto dto) {
  ExternalTaskService externalTaskService = engine.getExternalTaskService();

  try {
    externalTaskService.setRetries(externalTaskId, dto.getRetries());
  } catch (NotFoundException e) {
    throw new RestException(Status.NOT_FOUND, e, "External task with id " + externalTaskId + " does not exist");
  }
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
@Override
public void setPriority(PriorityDto dto) {
  ExternalTaskService externalTaskService = engine.getExternalTaskService();

  try {
    externalTaskService.setPriority(externalTaskId, dto.getPriority());
  } catch (NotFoundException e) {
    throw new RestException(Status.NOT_FOUND, e, "External task with id " + externalTaskId + " does not exist");
  }
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
@Override
public void unlock() {
  ExternalTaskService externalTaskService = engine.getExternalTaskService();

  try {
    externalTaskService.unlock(externalTaskId);
  } catch (NotFoundException e) {
    throw new RestException(Status.NOT_FOUND, e, "External task with id " + externalTaskId + " does not exist");
  }
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
protected UpdateExternalTaskRetriesBuilder updateRetries(SetRetriesForExternalTasksDto retriesDto) {

    ExternalTaskService externalTaskService = getProcessEngine().getExternalTaskService();

    List<String> externalTaskIds = retriesDto.getExternalTaskIds();
    List<String> processInstanceIds = retriesDto.getProcessInstanceIds();

    ExternalTaskQuery externalTaskQuery = null;
    ProcessInstanceQuery processInstanceQuery = null;
    HistoricProcessInstanceQuery historicProcessInstanceQuery = null;

    ExternalTaskQueryDto externalTaskQueryDto = retriesDto.getExternalTaskQuery();
    if (externalTaskQueryDto != null) {
      externalTaskQuery = externalTaskQueryDto.toQuery(getProcessEngine());
    }

    ProcessInstanceQueryDto processInstanceQueryDto = retriesDto.getProcessInstanceQuery();
    if (processInstanceQueryDto != null) {
      processInstanceQuery = processInstanceQueryDto.toQuery(getProcessEngine());
    }

    HistoricProcessInstanceQueryDto historicProcessInstanceQueryDto = retriesDto.getHistoricProcessInstanceQuery();
    if (historicProcessInstanceQueryDto != null) {
      historicProcessInstanceQuery = historicProcessInstanceQueryDto.toQuery(getProcessEngine());
    }

    return externalTaskService.updateRetries()
      .externalTaskIds(externalTaskIds)
      .processInstanceIds(processInstanceIds)
      .externalTaskQuery(externalTaskQuery)
      .processInstanceQuery(processInstanceQuery)
      .historicProcessInstanceQuery(historicProcessInstanceQuery);
  }
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
public ExternalTaskService getExternalTaskService() {
  return processEngine.getExternalTaskService();
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
public static ExternalTaskQueryMock mockExternalTaskQuery(final ExternalTaskService serviceMock) {
  return new ExternalTaskQueryMock().forService(serviceMock);
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
public ExternalTaskQueryMock() {
 super(ExternalTaskQuery.class, ExternalTaskService.class);
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
public static ExternalTaskQueryMock mockExternalTaskQuery(final ExternalTaskService serviceMock) {
  return QueryMocks.mockExternalTaskQuery(serviceMock);
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
@Override
public ExternalTaskService getExternalTaskService() {
  return innerRule.getExternalTaskService();
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
@Override
public ExternalTaskService getExternalTaskService() {
  return delegate.getExternalTaskService();
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
@Override
public ExternalTaskService getExternalTaskService() {
  return outerRule.getExternalTaskService();
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
@Override
public ExternalTaskService getExternalTaskService() {
  return processEngine.getExternalTaskService();
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
public ExternalTaskService getExternalTaskService() {
  return externalTaskService;
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
public void setExternalTaskService(ExternalTaskService externalTaskService) {
  this.externalTaskService = externalTaskService;
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
@Override
public ExternalTaskService getExternalTaskService() {
  return externalTaskService;
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
@Before
public void setUpRuntimeData() {
  externalTaskService = mock(ExternalTaskService.class);
  when(processEngine.getExternalTaskService()).thenReturn(externalTaskService);

  runtimeServiceMock = mock(RuntimeServiceImpl.class);
  when(processEngine.getRuntimeService()).thenReturn(runtimeServiceMock);

  historyServiceMock = mock(HistoryServiceImpl.class);
  when(processEngine.getHistoryService()).thenReturn(historyServiceMock);

  // locked external task
  lockedExternalTaskMock = MockProvider.createMockLockedExternalTask();

  // fetching
  fetchTopicBuilder = mock(ExternalTaskQueryTopicBuilder.class);
  when(externalTaskService.fetchAndLock(anyInt(), any(String.class))).thenReturn(fetchTopicBuilder);
  when(externalTaskService.fetchAndLock(anyInt(), any(String.class), any(Boolean.class))).thenReturn(fetchTopicBuilder);

  when(fetchTopicBuilder.topic(any(String.class), anyLong())).thenReturn(fetchTopicBuilder);
  when(fetchTopicBuilder.variables(anyListOf(String.class))).thenReturn(fetchTopicBuilder);
  when(fetchTopicBuilder.variables(any(String[].class))).thenReturn(fetchTopicBuilder);
  when(fetchTopicBuilder.enableCustomObjectDeserialization()).thenReturn(fetchTopicBuilder);
  when(fetchTopicBuilder.topic(any(String.class), anyLong())).thenReturn(fetchTopicBuilder);
  when(fetchTopicBuilder.businessKey(any(String.class))).thenReturn(fetchTopicBuilder);
  when(fetchTopicBuilder.processInstanceVariableEquals(anyMapOf(String.class, Object.class))).thenReturn(fetchTopicBuilder);

  Batch batch = createMockBatch();
  updateRetriesBuilder = mock(UpdateExternalTaskRetriesBuilder.class);
  when(externalTaskService.updateRetries()).thenReturn(updateRetriesBuilder);

  when(updateRetriesBuilder.externalTaskIds(anyListOf(String.class))).thenReturn(updateRetriesBuilder);
  when(updateRetriesBuilder.processInstanceIds(anyListOf(String.class))).thenReturn(updateRetriesBuilder);
  when(updateRetriesBuilder.externalTaskQuery(any(ExternalTaskQuery.class))).thenReturn(updateRetriesBuilder);
  when(updateRetriesBuilder.processInstanceQuery(any(ProcessInstanceQuery.class))).thenReturn(updateRetriesBuilder);
  when(updateRetriesBuilder.historicProcessInstanceQuery(any(HistoricProcessInstanceQuery.class))).thenReturn(updateRetriesBuilder);
  when(updateRetriesBuilder.setAsync(anyInt())).thenReturn(batch);

  // querying
  externalTaskQueryMock = mock(ExternalTaskQuery.class);
  when(externalTaskQueryMock.externalTaskId(any(String.class))).thenReturn(externalTaskQueryMock);
  when(externalTaskService.createExternalTaskQuery()).thenReturn(externalTaskQueryMock);

  // external task
  externalTaskMock = MockProvider.createMockExternalTask();
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
@Before
public void setUpRuntimeData() {
  namedProcessEngine = getProcessEngine(EXAMPLE_ENGINE_NAME);
  mockRepoService = mock(RepositoryService.class);
  mockRuntimeService = mock(RuntimeService.class);
  mockTaskService = mock(TaskService.class);
  mockIdentityService = mock(IdentityService.class);
  mockManagementService = mock(ManagementService.class);
  mockHistoryService = mock(HistoryService.class);
  mockCaseService = mock(CaseService.class);
  mockFilterService = mock(FilterService.class);
  mockExternalTaskService = mock(ExternalTaskService.class);

  when(namedProcessEngine.getRepositoryService()).thenReturn(mockRepoService);
  when(namedProcessEngine.getRuntimeService()).thenReturn(mockRuntimeService);
  when(namedProcessEngine.getTaskService()).thenReturn(mockTaskService);
  when(namedProcessEngine.getIdentityService()).thenReturn(mockIdentityService);
  when(namedProcessEngine.getManagementService()).thenReturn(mockManagementService);
  when(namedProcessEngine.getHistoryService()).thenReturn(mockHistoryService);
  when(namedProcessEngine.getCaseService()).thenReturn(mockCaseService);
  when(namedProcessEngine.getFilterService()).thenReturn(mockFilterService);
  when(namedProcessEngine.getExternalTaskService()).thenReturn(mockExternalTaskService);

  createProcessDefinitionMock();
  createProcessInstanceMock();
  createTaskMock();
  createIdentityMocks();
  createExecutionMock();
  createVariableInstanceMock();
  createJobDefinitionMock();
  createIncidentMock();
  createDeploymentMock();
  createMessageCorrelationBuilderMock();
  createCaseDefinitionMock();
  createCaseInstanceMock();
  createCaseExecutionMock();
  createFilterMock();
  createExternalTaskMock();

  createHistoricActivityInstanceMock();
  createHistoricProcessInstanceMock();
  createHistoricVariableInstanceMock();
  createHistoricActivityStatisticsMock();
  createHistoricDetailMock();
  createHistoricTaskInstanceMock();
  createHistoricIncidentMock();
  createHistoricJobLogMock();
  createHistoricExternalTaskLogMock();
}
 

import org.camunda.bpm.engine.ExternalTaskService; //导入依赖的package包/类
@Bean(name = "externalTaskService")
@Override
public ExternalTaskService getExternalTaskService() {
  return processEngine.getExternalTaskService();
}