import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
protected ProcessApplicationRegistration registerProcessApplication(CommandContext commandContext, DeploymentEntity deployment,
    Set<String> processKeysToRegisterFor) {
  ProcessApplicationDeploymentBuilderImpl appDeploymentBuilder = (ProcessApplicationDeploymentBuilderImpl) deploymentBuilder;
  final ProcessApplicationReference appReference = appDeploymentBuilder.getProcessApplicationReference();

  // build set of deployment ids this process app should be registered for:
  Set<String> deploymentsToRegister = new HashSet<String>(Collections.singleton(deployment.getId()));

  if (appDeploymentBuilder.isResumePreviousVersions()) {
    if (ResumePreviousBy.RESUME_BY_PROCESS_DEFINITION_KEY.equals(appDeploymentBuilder.getResumePreviousVersionsBy())) {
      deploymentsToRegister.addAll(resumePreviousByProcessDefinitionKey(commandContext, deployment, processKeysToRegisterFor));
    }else if(ResumePreviousBy.RESUME_BY_DEPLOYMENT_NAME.equals(appDeploymentBuilder.getResumePreviousVersionsBy())){
      deploymentsToRegister.addAll(resumePreviousByDeploymentName(commandContext, deployment));
    }
  }

  // register process application for deployments
  return new RegisterProcessApplicationCmd(deploymentsToRegister, appReference).execute(commandContext);

}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
public Void execute(CommandContext commandContext) {
  DbEntityManagerFactory dbEntityManagerFactory = new DbEntityManagerFactory(Context.getProcessEngineConfiguration().getIdGenerator());
  DbEntityManager entityManager = dbEntityManagerFactory.openSession();

  JobEntity job = entityManager.selectById(JobEntity.class, JOB_ENTITY_ID);
  job.setLockOwner(lockOwner);
  entityManager.forceUpdate(job);

  monitor.sync();

  // flush the changed entity and create a lock for the table
  entityManager.flush();

  monitor.sync();

  // commit transaction and remove the lock
  commandContext.getTransactionContext().commit();

  return null;
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
public VariableMap execute(final CommandContext commandContext) {
  StartFormData startFormData = commandContext.runWithoutAuthorization(new Callable<StartFormData>() {
    public StartFormData call() throws Exception {
      return new GetStartFormCmd(resourceId).execute(commandContext);
    }
  });

  ProcessDefinition definition = startFormData.getProcessDefinition();
  checkGetStartFormVariables((ProcessDefinitionEntity) definition, commandContext);

  VariableMap result = new VariableMapImpl();

  for (FormField formField : startFormData.getFormFields()) {
    if(formVariableNames == null || formVariableNames.contains(formField.getId())) {
      result.put(formField.getId(), createVariable(formField, null));
    }
  }

  return result;
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
public Void execute(CommandContext commandContext) {
  ensureNotNull("UserId", userId);

  IdentityInfoEntity infoEntity = commandContext.getIdentityInfoManager()
    .findUserInfoByUserIdAndKey(userId, "picture");
  
  if(infoEntity != null) {
    String byteArrayId = infoEntity.getValue();
    if(byteArrayId != null) {
      commandContext.getByteArrayManager()
        .deleteByteArrayById(byteArrayId);
    }
    commandContext.getIdentityInfoManager()
      .delete(infoEntity);
  }
  
  
  return null;
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
public InputStream execute(final CommandContext commandContext) {
  ProcessDefinitionEntity processDefinition = Context
          .getProcessEngineConfiguration()
          .getDeploymentCache()
          .findDeployedProcessDefinitionById(processDefinitionId);

  for(CommandChecker checker : commandContext.getProcessEngineConfiguration().getCommandCheckers()) {
    checker.checkReadProcessDefinition(processDefinition);
  }

  final String deploymentId = processDefinition.getDeploymentId();
  final String resourceName = processDefinition.getDiagramResourceName();

  if (resourceName == null ) {
    return null;
  } else {

    InputStream processDiagramStream = commandContext.runWithoutAuthorization(new Callable<InputStream>() {
      public InputStream call() throws Exception {
        return new GetDeploymentResourceCmd(deploymentId, resourceName).execute(commandContext);
      }
    });

    return processDiagramStream;
  }
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
@Override
public void setAssignee(String assignee) {
  ensureTaskActive();
  registerCommandContextCloseListener();

  String oldAssignee = this.assignee;
  if (assignee==null && oldAssignee==null) {
    return;
  }

  addIdentityLinkChanges(IdentityLinkType.ASSIGNEE, oldAssignee, assignee);
  propertyChanged(ASSIGNEE, oldAssignee, assignee);
  this.assignee = assignee;

  CommandContext commandContext = Context.getCommandContext();
  // if there is no command context, then it means that the user is calling the
  // setAssignee outside a service method.  E.g. while creating a new task.
  if (commandContext != null) {
    fireEvent(TaskListener.EVENTNAME_ASSIGNMENT);
    if (commandContext.getDbEntityManager().contains(this)) {
      fireAssigneeAuthorizationProvider(oldAssignee, assignee);
      fireHistoricIdentityLinks();
    }
  }
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
protected void handleStartEvent(EventSubscriptionEntity eventSubscription, Object payload, CommandContext commandContext) {
  String processDefinitionId = eventSubscription.getConfiguration();
  ensureNotNull("Configuration of signal start event subscription '" + eventSubscription.getId() + "' contains no process definition id.",
      processDefinitionId);

  DeploymentCache deploymentCache = Context.getProcessEngineConfiguration().getDeploymentCache();
  ProcessDefinitionEntity processDefinition = deploymentCache.findDeployedProcessDefinitionById(processDefinitionId);
  if (processDefinition == null || processDefinition.isSuspended()) {
    // ignore event subscription
    LOG.debugIgnoringEventSubscription(eventSubscription, processDefinitionId);
  } else {

    ActivityImpl signalStartEvent = processDefinition.findActivity(eventSubscription.getActivityId());
    PvmProcessInstance processInstance = processDefinition.createProcessInstanceForInitial(signalStartEvent);
    processInstance.start();
  }
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
@Override
public Void execute(CommandContext commandContext) {
  ensureNotNull("processDefinitionKey", processDefinitionKey);

  List<ProcessDefinition> processDefinitions = commandContext.getProcessDefinitionManager()
    .findDefinitionsByKeyAndTenantId(processDefinitionKey, tenantId, isTenantIdSet);
  ensureNotEmpty(NotFoundException.class, "No process definition found with key '" + processDefinitionKey + "'",
    "processDefinitions", processDefinitions);

  for (ProcessDefinition processDefinition: processDefinitions) {
    String processDefinitionId = processDefinition.getId();
    deleteProcessDefinitionCmd(commandContext, processDefinitionId, cascade, skipCustomListeners);
  }

  return null;
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
public InputStream execute(CommandContext commandContext) {
  AttachmentEntity attachment = (AttachmentEntity) commandContext
      .getAttachmentManager()
      .findAttachmentByTaskIdAndAttachmentId(taskId, attachmentId);

  if (attachment == null) {
    return null;
  }

  String contentId = attachment.getContentId();
  if (contentId==null) {
    return null;
  }

  ByteArrayEntity byteArray = commandContext
      .getDbEntityManager()
      .selectById(ByteArrayEntity.class, contentId);

  byte[] bytes = byteArray.getBytes();

  return new ByteArrayInputStream(bytes);
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
protected void writeUserOperationLog(CommandContext commandContext,
                                     int numInstances,
                                     boolean async) {

  List<PropertyChange> propertyChanges = new ArrayList<PropertyChange>();
  propertyChanges.add(new PropertyChange("nrOfInstances",
    null,
    numInstances));
  propertyChanges.add(new PropertyChange("async", null, async));

  String operationType;
  if(suspending) {
    operationType = UserOperationLogEntry.OPERATION_TYPE_SUSPEND_JOB;

  } else {
    operationType = UserOperationLogEntry.OPERATION_TYPE_ACTIVATE_JOB;
  }
  commandContext.getOperationLogManager()
      .logProcessInstanceOperation(operationType,
        null,
        null,
        null,
        propertyChanges);
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
protected List<String> collectJobIds(CommandContext commandContext) {
  Set<String> collectedJobIds = new HashSet<String>();

  List<String> jobIds = this.getJobIds();
  if (jobIds != null) {
    collectedJobIds.addAll(jobIds);
  }

  final JobQuery jobQuery = this.jobQuery;
  if (jobQuery != null) {
    for (Job job : jobQuery.list()) {
      collectedJobIds.add(job.getId());
    }
  }

  return new ArrayList<String>(collectedJobIds);
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
@Override
public Batch execute(CommandContext commandContext) {
  List<String> processInstanceIds = collectProcessInstanceIds();

  ensureNotEmpty(BadUserRequestException.class, "processInstanceIds", processInstanceIds);
  checkAuthorizations(commandContext);
  writeUserOperationLog(commandContext,
      deleteReason,
      processInstanceIds.size(),
      true);

  BatchEntity batch = createBatch(commandContext, processInstanceIds);

  batch.createSeedJobDefinition();
  batch.createMonitorJobDefinition();
  batch.createBatchJobDefinition();

  batch.fireHistoricStartEvent();

  batch.createSeedJob();

  return batch;
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
protected void setJobRetriesByJobDefinitionId(CommandContext commandContext) {
  JobDefinitionManager jobDefinitionManager = commandContext.getJobDefinitionManager();
  JobDefinitionEntity jobDefinition = jobDefinitionManager.findById(jobDefinitionId);

  if (jobDefinition != null) {
    String processDefinitionId = jobDefinition.getProcessDefinitionId();
    for (CommandChecker checker : commandContext.getProcessEngineConfiguration().getCommandCheckers()) {
      checker.checkUpdateProcessInstanceByProcessDefinitionId(processDefinitionId);
    }
  }

  commandContext
      .getJobManager()
      .updateFailedJobRetriesByJobDefinitionId(jobDefinitionId, retries);

  PropertyChange propertyChange = new PropertyChange(RETRIES, null, retries);
  commandContext.getOperationLogManager().logJobOperation(getLogEntryOperation(), null, jobDefinitionId, null,
      null, null, propertyChange);
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
@Override
public void execute(BatchJobConfiguration configuration, ExecutionEntity execution, CommandContext commandContext, String tenantId) {
  ByteArrayEntity configurationEntity = commandContext
      .getDbEntityManager()
      .selectById(ByteArrayEntity.class, configuration.getConfigurationByteArrayId());

  BatchConfiguration batchConfiguration = readConfiguration(configurationEntity.getBytes());

  boolean initialLegacyRestrictions = commandContext.isRestrictUserOperationLogToAuthenticatedUsers();
  commandContext.disableUserOperationLog();
  commandContext.setRestrictUserOperationLogToAuthenticatedUsers(true);
  try {
    commandContext.getProcessEngineConfiguration()
        .getHistoryService()
        .deleteHistoricProcessInstances(batchConfiguration.getIds());
  } finally {
    commandContext.enableUserOperationLog();
    commandContext.setRestrictUserOperationLogToAuthenticatedUsers(initialLegacyRestrictions);
  }

  commandContext.getByteArrayManager().delete(configurationEntity);
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
@After
public void cleanup() {
  //remove history level from database
  ((ProcessEngineConfigurationImpl)processEngine.getProcessEngineConfiguration()).getCommandExecutorTxRequired().execute(new Command<Void>() {
    @Override
    public Void execute(CommandContext commandContext) {
      final PropertyEntity historyLevel = commandContext.getPropertyManager().findPropertyById("historyLevel");
      if (historyLevel != null) {
        commandContext.getDbEntityManager().delete(historyLevel);
      }
      return null;
    }
  });
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
@Override
public ProcessInstance execute(CommandContext commandContext) {
  ProcessEngineConfigurationImpl processEngineConfiguration = Context.getProcessEngineConfiguration();
  DeploymentCache deploymentCache = processEngineConfiguration.getDeploymentCache();
  ProcessDefinitionEntity processDefinition = deploymentCache.findDeployedProcessDefinitionById(processDefinitionId);
  ensureNotNull("No process definition found for id = '" + processDefinitionId + "'", "processDefinition", processDefinition);

  for(CommandChecker checker : commandContext.getProcessEngineConfiguration().getCommandCheckers()) {
    checker.checkCreateProcessInstance(processDefinition);
  }

  ExecutionEntity processInstance = null;
  if (businessKey != null) {
    processInstance = processDefinition.createProcessInstance(businessKey);
  } else {
    processInstance = processDefinition.createProcessInstance();
  }

  // if the start event is async, we have to set the variables already here
  // since they are lost after the async continuation otherwise
  // see CAM-2828
  if (processDefinition.getInitial().isAsyncBefore()) {
    // avoid firing history events
    processInstance.setStartContext(new ProcessInstanceStartContext(processInstance.getActivity()));
    FormPropertyHelper.initFormPropertiesOnScope(variables, processInstance);
    processInstance.start();

  } else {
    processInstance.startWithFormProperties(variables);

  }


  return processInstance;
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
public void deleteHistoricProcessInstanceByIds(List<String> processInstanceIds) {
  CommandContext commandContext = Context.getCommandContext();

  commandContext.getHistoricDetailManager().deleteHistoricDetailsByProcessInstanceIds(processInstanceIds);
  commandContext.getHistoricVariableInstanceManager().deleteHistoricVariableInstanceByProcessInstanceIds(processInstanceIds);
  commandContext.getCommentManager().deleteCommentsByProcessInstanceIds(processInstanceIds);
  commandContext.getAttachmentManager().deleteAttachmentsByProcessInstanceIds(processInstanceIds);
  commandContext.getHistoricTaskInstanceManager().deleteHistoricTaskInstancesByProcessInstanceIds(processInstanceIds, false);
  commandContext.getHistoricActivityInstanceManager().deleteHistoricActivityInstancesByProcessInstanceIds(processInstanceIds);
  commandContext.getHistoricIncidentManager().deleteHistoricIncidentsByProcessInstanceIds(processInstanceIds);
  commandContext.getHistoricJobLogManager().deleteHistoricJobLogsByProcessInstanceIds(processInstanceIds);
  commandContext.getHistoricExternalTaskLogManager().deleteHistoricExternalTaskLogsByProcessInstanceIds(processInstanceIds);

  commandContext.getDbEntityManager().deletePreserveOrder(HistoricProcessInstanceEntity.class, "deleteHistoricProcessInstances", processInstanceIds);
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
@Override
protected void preExecute(CommandContext commandContext) {
  if (getJobHandler() instanceof TimerEventJobHandler) {
    TimerJobConfiguration configuration = (TimerJobConfiguration) getJobHandlerConfiguration();
    if (repeat != null && !configuration.isFollowUpJobCreated()) {
      // this timer is a repeating timer and
      // a follow up timer job has not been scheduled yet

      Date newDueDate = calculateRepeat();

      if (newDueDate != null) {
        // the listener is added to the transaction as SYNC on ROLLABCK,
        // when it is necessary to schedule a new timer job invocation.
        // If the transaction does not rollback, it is ignored.
        ProcessEngineConfigurationImpl processEngineConfiguration = Context.getProcessEngineConfiguration();
        CommandExecutor commandExecutor = processEngineConfiguration.getCommandExecutorTxRequiresNew();
        RepeatingFailedJobListener listener = createRepeatingFailedJobListener(commandExecutor);

        commandContext.getTransactionContext().addTransactionListener(
            TransactionState.ROLLED_BACK,
            listener);

        // create a new timer job
        createNewTimerJob(newDueDate);
      }
    }
  }
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
@Override
protected Void executeCmd(CommandContext commandContext) {
  ensureNotNull("tenantId", tenantId);
  ensureNotNull("groupId", groupId);

  commandContext
    .getWritableIdentityProvider()
    .deleteTenantGroupMembership(tenantId, groupId);

  return null;
}
 

import org.camunda.bpm.engine.impl.interceptor.CommandContext; //导入依赖的package包/类
public String execute(CommandContext commandContext) {
  ensureNotNull("historicExternalTaskLogId", historicExternalTaskLogId);

  HistoricExternalTaskLogEntity event = commandContext
      .getHistoricExternalTaskLogManager()
      .findHistoricExternalTaskLogById(historicExternalTaskLogId);

  ensureNotNull("No historic external task log found with id " + historicExternalTaskLogId, "historicExternalTaskLog", event);

  for (CommandChecker checker : commandContext.getProcessEngineConfiguration().getCommandCheckers()) {
    checker.checkReadHistoricExternalTaskLog(event);
  }

  return event.getErrorDetails();
}