import org.camunda.bpm.engine.ManagementService; //导入依赖的package包/类
public void waitForJobExecutorToProcessAllJobs(long maxMillisToWait, long intervalMillis, JobExecutor jobExecutor, ManagementService managementService, boolean shutdown) {

    try {
      Timer timer = new Timer();
      InteruptTask task = new InteruptTask(Thread.currentThread());
      timer.schedule(task, maxMillisToWait);
      boolean areJobsAvailable = true;
      try {
        while (areJobsAvailable && !task.isTimeLimitExceeded()) {
          Thread.sleep(intervalMillis);
          areJobsAvailable = areJobsAvailable(managementService);
        }
      } catch (InterruptedException e) {
      } finally {
        timer.cancel();
      }
      if (areJobsAvailable) {
        throw new ProcessEngineException("time limit of " + maxMillisToWait + " was exceeded");
      }

    } finally {
      if (shutdown) {
        jobExecutor.shutdown();
      }
    }
  }
 

import org.camunda.bpm.engine.ManagementService; //导入依赖的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.ManagementService; //导入依赖的package包/类
@Before
public void setUpRuntimeData() {
  mockManagementService = mock(ManagementService.class);

  namedProcessEngine = getProcessEngine(MockProvider.EXAMPLE_PROCESS_ENGINE_NAME);
  when(namedProcessEngine.getManagementService()).thenReturn(mockManagementService);

  List<JobDefinition> mockJobDefinitions = Collections.singletonList(MockProvider.createMockJobDefinition());
  mockQuery = setUpMockJobDefinitionQuery(mockJobDefinitions);

  mockSuspensionStateSelectBuilder = mock(UpdateJobDefinitionSuspensionStateSelectBuilder.class);
  when(mockManagementService.updateJobDefinitionSuspensionState()).thenReturn(mockSuspensionStateSelectBuilder);

  mockSuspensionStateBuilder = mock(UpdateJobDefinitionSuspensionStateTenantBuilder.class);
  when(mockSuspensionStateSelectBuilder.byJobDefinitionId(anyString())).thenReturn(mockSuspensionStateBuilder);
  when(mockSuspensionStateSelectBuilder.byProcessDefinitionId(anyString())).thenReturn(mockSuspensionStateBuilder);
  when(mockSuspensionStateSelectBuilder.byProcessDefinitionKey(anyString())).thenReturn(mockSuspensionStateBuilder);
}
 

import org.camunda.bpm.engine.ManagementService; //导入依赖的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.ManagementService; //导入依赖的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.ManagementService; //导入依赖的package包/类
protected void executeJob(Job job) {
  ManagementService managementService = rule.getManagementService();

  while (job != null && job.getRetries() > 0) {
    try {
      managementService.executeJob(job.getId());
    }
    catch (Exception e) {
      // ignore
    }

    job = managementService.createJobQuery().jobId(job.getId()).singleResult();
  }
}
 

import org.camunda.bpm.engine.ManagementService; //导入依赖的package包/类
@Override
public void trigger(String processInstanceId) {
  ManagementService managementService = engine.getManagementService();
  Job timerJob = managementService.createJobQuery().processInstanceId(processInstanceId).activityId(activityId).singleResult();

  if (timerJob == null) {
    throw new ProcessEngineException("No job for this event found in context of process instance " + processInstanceId);
  }

  managementService.executeJob(timerJob.getId());
}
 

import org.camunda.bpm.engine.ManagementService; //导入依赖的package包/类
public void setRetries(Batch batch, int count, int retries) {
  List<Job> jobs = getExecutionJobs(batch);
  assertTrue(jobs.size() >= count);

  ManagementService managementService = getManagementService();
  for (int i = 0; i < count; i++) {
    managementService.setJobRetries(jobs.get(i).getId(), retries);
  }

}
 

import org.camunda.bpm.engine.ManagementService; //导入依赖的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.ManagementService; //导入依赖的package包/类
protected ManagementService getManagementService() {
  if (engineRule != null) {
    return engineRule.getManagementService();
  }
  else {
    return testCase.getProcessEngine().getManagementService();
  }
}
 

import org.camunda.bpm.engine.ManagementService; //导入依赖的package包/类
public boolean areJobsAvailable(ManagementService managementService) {
  return !managementService
    .createJobQuery()
    .executable()
    .list()
    .isEmpty();
}
 

import org.camunda.bpm.engine.ManagementService; //导入依赖的package包/类
@Override
public List<StatisticsResultDto> getActivityStatistics(Boolean includeFailedJobs, Boolean includeIncidents, String includeIncidentsForType) {
  if (includeIncidents != null && includeIncidentsForType != null) {
    throw new InvalidRequestException(Status.BAD_REQUEST, "Only one of the query parameter includeIncidents or includeIncidentsForType can be set.");
  }

  ManagementService mgmtService = engine.getManagementService();
  ActivityStatisticsQuery query = mgmtService.createActivityStatisticsQuery(processDefinitionId);

  if (includeFailedJobs != null && includeFailedJobs) {
    query.includeFailedJobs();
  }

  if (includeIncidents != null && includeIncidents) {
    query.includeIncidents();
  } else if (includeIncidentsForType != null) {
    query.includeIncidentsForType(includeIncidentsForType);
  }

  List<ActivityStatistics> queryResults = query.list();

  List<StatisticsResultDto> results = new ArrayList<StatisticsResultDto>();
  for (ActivityStatistics queryResult : queryResults) {
    StatisticsResultDto dto = ActivityStatisticsResultDto.fromActivityStatistics(queryResult);
    results.add(dto);
  }

  return results;
}
 

import org.camunda.bpm.engine.ManagementService; //导入依赖的package包/类
public JobDefinitionDto getJobDefinition() {
  ManagementService managementService = engine.getManagementService();
  JobDefinition jobDefinition = managementService.createJobDefinitionQuery().jobDefinitionId(jobDefinitionId).singleResult();

  if (jobDefinition == null) {
    throw new InvalidRequestException(Status.NOT_FOUND, "Job Definition with id " + jobDefinitionId + " does not exist");
  }

  return JobDefinitionDto.fromJobDefinition(jobDefinition);
}
 

import org.camunda.bpm.engine.ManagementService; //导入依赖的package包/类
@Override
public JobDto getJob() {
  ManagementService managementService = engine.getManagementService();
  Job job = managementService.createJobQuery().jobId(jobId).singleResult();

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

  return JobDto.fromJob(job);
}
 

import org.camunda.bpm.engine.ManagementService; //导入依赖的package包/类
@Override
public BatchDto setRetriesByProcessHistoricQueryBased(SetJobRetriesByProcessDto setJobRetriesDto) {
  List<String> processInstanceIds = new ArrayList<String>();

  HistoricProcessInstanceQueryDto queryDto = setJobRetriesDto.getHistoricProcessInstanceQuery();
  if (queryDto != null) {
    HistoricProcessInstanceQuery query = queryDto.toQuery(getProcessEngine());
    List<HistoricProcessInstance> historicProcessInstances = query.list();

    for (HistoricProcessInstance historicProcessInstance: historicProcessInstances) {
      processInstanceIds.add(historicProcessInstance.getId());
    }
  }

  if (setJobRetriesDto.getProcessInstances() != null) {
    processInstanceIds.addAll(setJobRetriesDto.getProcessInstances());
  }

  try {
    ManagementService managementService = getProcessEngine().getManagementService();
    Batch batch = managementService.setJobRetriesAsync(
      processInstanceIds,
      (ProcessInstanceQuery) null,
      setJobRetriesDto.getRetries());

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

import org.camunda.bpm.engine.ManagementService; //导入依赖的package包/类
@Override
public List<StatisticsResultDto> getStatistics(Boolean includeFailedJobs, Boolean includeRootIncidents, Boolean includeIncidents, String includeIncidentsForType) {
  if (includeIncidents != null && includeIncidentsForType != null) {
    throw new InvalidRequestException(Status.BAD_REQUEST, "Only one of the query parameter includeIncidents or includeIncidentsForType can be set.");
  }

  if (includeIncidents != null && includeRootIncidents != null) {
    throw new InvalidRequestException(Status.BAD_REQUEST, "Only one of the query parameter includeIncidents or includeRootIncidents can be set.");
  }

  if (includeRootIncidents != null && includeIncidentsForType != null) {
    throw new InvalidRequestException(Status.BAD_REQUEST, "Only one of the query parameter includeRootIncidents or includeIncidentsForType can be set.");
  }

  ManagementService mgmtService = getProcessEngine().getManagementService();
  ProcessDefinitionStatisticsQuery query = mgmtService.createProcessDefinitionStatisticsQuery();

  if (includeFailedJobs != null && includeFailedJobs) {
    query.includeFailedJobs();
  }

  if (includeIncidents != null && includeIncidents) {
    query.includeIncidents();
  } else if (includeIncidentsForType != null) {
    query.includeIncidentsForType(includeIncidentsForType);
  } else if (includeRootIncidents != null && includeRootIncidents) {
    query.includeRootIncidents();
  }

  List<ProcessDefinitionStatistics> queryResults = query.list();

  List<StatisticsResultDto> results = new ArrayList<StatisticsResultDto>();
  for (ProcessDefinitionStatistics queryResult : queryResults) {
    StatisticsResultDto dto = ProcessDefinitionStatisticsResultDto.fromProcessDefinitionStatistics(queryResult);
    results.add(dto);
  }

  return results;
}
 

import org.camunda.bpm.engine.ManagementService; //导入依赖的package包/类
@Before
public void setUpRuntimeData() {

  mockQuery = mock(JobQuery.class);
  Job mockedJob = new MockJobBuilder()
    .id(MockProvider.EXAMPLE_JOB_ID)
    .processInstanceId(MockProvider.EXAMPLE_PROCESS_INSTANCE_ID)
    .executionId(MockProvider.EXAMPLE_EXECUTION_ID)
    .retries(MockProvider.EXAMPLE_JOB_RETRIES)
    .exceptionMessage(MockProvider.EXAMPLE_JOB_NO_EXCEPTION_MESSAGE)
    .dueDate(new Date())
    .priority(MockProvider.EXAMPLE_JOB_PRIORITY)
    .jobDefinitionId(MockProvider.EXAMPLE_JOB_DEFINITION_ID)
    .tenantId(MockProvider.EXAMPLE_TENANT_ID)
    .build();

  when(mockQuery.singleResult()).thenReturn(mockedJob);
  when(mockQuery.jobId(MockProvider.EXAMPLE_JOB_ID)).thenReturn(mockQuery);

  mockManagementService = mock(ManagementService.class);
  when(mockManagementService.createJobQuery()).thenReturn(mockQuery);

  mockSuspensionStateSelectBuilder = mock(UpdateJobSuspensionStateSelectBuilder.class);
  when(mockManagementService.updateJobSuspensionState()).thenReturn(mockSuspensionStateSelectBuilder);

  mockSuspensionStateBuilder = mock(UpdateJobSuspensionStateTenantBuilder.class);
  when(mockSuspensionStateSelectBuilder.byJobId(anyString())).thenReturn(mockSuspensionStateBuilder);
  when(mockSuspensionStateSelectBuilder.byJobDefinitionId(anyString())).thenReturn(mockSuspensionStateBuilder);
  when(mockSuspensionStateSelectBuilder.byProcessInstanceId(anyString())).thenReturn(mockSuspensionStateBuilder);
  when(mockSuspensionStateSelectBuilder.byProcessDefinitionId(anyString())).thenReturn(mockSuspensionStateBuilder);
  when(mockSuspensionStateSelectBuilder.byProcessDefinitionKey(anyString())).thenReturn(mockSuspensionStateBuilder);

  namedProcessEngine = getProcessEngine(MockProvider.EXAMPLE_PROCESS_ENGINE_NAME);
  when(namedProcessEngine.getManagementService()).thenReturn(mockManagementService);
}
 

import org.camunda.bpm.engine.ManagementService; //导入依赖的package包/类
@Before
public void setUpBatchQueryMock() {
  Batch batchMock = MockProvider.createMockBatch();

  queryMock = mock(BatchQuery.class);
  when(queryMock.batchId(eq(MockProvider.EXAMPLE_BATCH_ID))).thenReturn(queryMock);
  when(queryMock.singleResult()).thenReturn(batchMock);

  managementServiceMock = mock(ManagementService.class);
  when(managementServiceMock.createBatchQuery()).thenReturn(queryMock);

  when(processEngine.getManagementService()).thenReturn(managementServiceMock);
}
 

import org.camunda.bpm.engine.ManagementService; //导入依赖的package包/类
@Bean
public ManagementService managementService() throws Exception {
	return processEngine().getObject().getManagementService();
}
 

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