Java ExternalTaskService类代码示例

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;
}