Java ExecutionEntity类代码示例

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
public void insert(CassandraPersistenceSession session, ExecutionEntity entity) {
  
  Session s = session.getSession();
  
  if(entity.isProcessInstanceExecution()) {
    session.addStatement(s.prepare(INSERT).bind(
        entity.getId(),
        entity.getRevision(),
        entity.getBusinessKey()));
  }
  
  session.addStatement(createUpdateStatement(session, entity));

  for(IndexHandler<ExecutionEntity> index:indexHandlers.values()){
    session.addStatement(index.getInsertStatement(session,entity));    
  }
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
public void delete(CassandraPersistenceSession session, ExecutionEntity entity) {
  
  if(entity.isProcessInstanceExecution()) {
    session.addStatement(QueryBuilder.delete().all()
        .from(ProcessInstanceTableHandler.TABLE_NAME).where(eq("id", entity.getProcessInstanceId()))
        .onlyIf(eq("version", entity.getRevision())),
        entity.getProcessInstanceId());
    session.batchShouldNotLock(entity.getProcessInstanceId());
  }
  else {
    session.addStatement(QueryBuilder.delete().mapElt("executions", entity.getId())
        .from(ProcessInstanceTableHandler.TABLE_NAME).where(eq("id", entity.getProcessInstanceId())),
        entity.getProcessInstanceId());
  }
  
  for(IndexHandler<ExecutionEntity> index:indexHandlers.values()){
    session.addIndexStatement(index.getDeleteStatement(session,entity), entity.getProcessInstanceId());    
  }
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
/**
 * This method should filter the result map by everything in the query 
 * except process instance id, execution id and process business key
 * Right now only filters by variables and event subscriptions
 */
protected List<ExecutionEntity> filter(Map<String, ExecutionEntity> resultMap, CassandraPersistenceSession session, ExecutionQueryImpl executionQuery){
  if(resultMap.isEmpty()){
    throw new IllegalArgumentException("Do not filter empty resultMap.");
  }
  if(executionQuery.getQueryVariableValues() != null && !executionQuery.getQueryVariableValues().isEmpty()) {
    filterByVariables(executionQuery.getQueryVariableValues(), resultMap, session);
  }
  if(executionQuery.getEventSubscriptions() != null && !executionQuery.getEventSubscriptions().isEmpty()) {
    filterByEventSubscriptions(executionQuery.getEventSubscriptions(), resultMap, session);
  }
  if(resultMap.isEmpty()){
    return Collections.emptyList();
  }
  else{
    return new ArrayList<ExecutionEntity>(resultMap.values());        
  }
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
protected void filterByEventSubscriptions(List<EventSubscriptionQueryValue> eventSubscriptions, Map<String, ExecutionEntity> resultMap, CassandraPersistenceSession session) {
  Set<String> filteredExecutionIds = new HashSet<String>();

  for(ExecutionEntity executionEntity : resultMap.values() ){
    for (EventSubscriptionQueryValue queriedEventSubscription : eventSubscriptions) {
      boolean found=false;
      for(EventSubscriptionEntity eventSubscriptionEntity : executionEntity.getEventSubscriptions()) {
        if(queriedEventSubscription.getEventType().equals(eventSubscriptionEntity.getEventType()) &&
            (queriedEventSubscription.getEventName()==null || queriedEventSubscription.getEventName().equals(eventSubscriptionEntity.getEventName()))) {
          found=true;
          break;
        }
      }
      if(!found){
        filteredExecutionIds.add(executionEntity.getId());
        break;
      }
    }
  }
  
  for (String filteredExecution : filteredExecutionIds) {
    resultMap.remove(filteredExecution);
  }
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
@Override
public List<EventSubscriptionEntity> executeQuery(CassandraPersistenceSession session, ListQueryParameterObject parameter) {
  @SuppressWarnings("unchecked")
  Map<String, String> map=((Map<String, String>)parameter.getParameter());
  List<EventSubscriptionEntity> result=new ArrayList<EventSubscriptionEntity>();
  ExecutionEntity entity=session.selectById(ExecutionEntity.class, map.get("executionId"));
  if(entity==null){
    return result;
  }
  for(EventSubscriptionEntity eventSubscriptionEntity:entity.getEventSubscriptions()){
    if(eventSubscriptionEntity.getEventType().equals(map.get("eventType"))){
      result.add(eventSubscriptionEntity);
    }
  }
  return result;
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
public void write(SettableData<?> data, ExecutionEntity entity) {
  data.setString("id", entity.getId())
  .setString("proc_inst_id", entity.getProcessInstanceId())
  .setString("parent_id", entity.getParentId())
  .setString("proc_def_id", entity.getProcessDefinitionId())
  .setString("super_exec", entity.getSuperExecutionId())
  .setString("super_case_exec", entity.getSuperCaseExecutionId())
  .setString("case_inst_id", entity.getCaseInstanceId())
  .setString("act_inst_id", entity.getActivityInstanceId())
  .setString("act_id", entity.getActivityId())
  .setBool("is_active", entity.isActive())
  .setBool("is_concurrent", entity.isConcurrent())
  .setBool("is_scope", entity.isScope())
  .setBool("is_event_scope", entity.isEventScope())
  .setInt("suspension_state", entity.getSuspensionState())
  .setInt("cached_ent_state", entity.getCachedEntityState())
  .setLong("sequence_counter", entity.getSequenceCounter());
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
public ExecutionEntity read(GettableData data) {
  ExecutionEntity executionEntity = new ExecutionEntity();
  executionEntity.setId(data.getString("id"));
  executionEntity.setProcessInstanceId(data.getString("proc_inst_id"));
  executionEntity.setParentId(data.getString("parent_id"));
  executionEntity.setProcessDefinitionId(data.getString("proc_def_id"));
  executionEntity.setSuperExecutionId(data.getString("super_exec"));
  executionEntity.setSuperCaseExecutionId(data.getString("super_case_exec"));
  executionEntity.setCaseInstanceId(data.getString("case_inst_id"));
  executionEntity.setActivityInstanceId(data.getString("act_inst_id"));
  executionEntity.setActivityId(data.getString("act_id"));
  executionEntity.setActive(data.getBool("is_active"));
  executionEntity.setConcurrent(data.getBool("is_concurrent"));
  executionEntity.setScope(data.getBool("is_scope"));
  executionEntity.setEventScope(data.getBool("is_event_scope"));
  executionEntity.setSuspensionState(data.getInt("suspension_state"));
  executionEntity.setCachedEntityState(data.getInt("cached_ent_state"));
  executionEntity.setSequenceCounter(data.getLong("sequence_counter"));

  return executionEntity;
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
public boolean evaluate(ExecutionEntity executionEntity) {
  if (script == null) {
    return true;
  }

  Context.getProcessEngineConfiguration().getScriptFactory();

  ExecutableScript executableScript = Context.getProcessEngineConfiguration()
      .getScriptFactory()
      .createScriptFromSource(scriptingLanguage, script);

  Object result = Context.getProcessEngineConfiguration()
      .getScriptingEnvironment()
      .execute(executableScript, executionEntity);

  if (result == null) {
    throw new DebuggerException("Breakpoint condition evaluates to null: " + script);
  } else if (!(result instanceof Boolean)) {
    throw new DebuggerException("Script does not return boolean value: " + script);
  }

  return (Boolean) result;
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
public boolean breakOnOperation(AtomicOperation operation, ExecutionEntity execution) {
  boolean shouldBreak = true;

  shouldBreak &= processDefinitionId.equals(execution.getProcessDefinitionId());

  if(AT_TRANSITION.equals(breakPointSpec)) {
    shouldBreak &= transitionId.equals(execution.getCurrentTransitionId());
  } else {
    shouldBreak &= activityId.equals(execution.getActivityId());
  }

  shouldBreak &= breakPointSpec.breakOnOperation(operation);

  if (shouldBreak && condition != null) {
    shouldBreak &= condition.evaluate(execution);
  }

  return shouldBreak;
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
public void execute(DebugSessionImpl debugSession, SuspendedExecutionImpl suspendedExecution) {
  CodeCompleterBuilder builder = new CodeCompleterBuilder();

  if (scopeId != null) {
    synchronized (suspendedExecution) {
      if(!suspendedExecution.isResumed) {
        ExecutionEntity executionEntity = suspendedExecution.getExecution();
        ScriptBindingsFactory bindingsFactory = Context.getProcessEngineConfiguration()
            .getScriptingEngines().getScriptBindingsFactory();
        Bindings scopeBindings = bindingsFactory.createBindings(executionEntity, new SimpleBindings());
        builder.bindings(scopeBindings);
      }
    }
  }

  List<CodeCompletionHint> hints = builder.buildCompleter().complete(prefix);
  debugSession.fireCodeCompletion(hints);
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
protected void assignExecutionsToActivities(List<ExecutionEntity> leaves) {
  for (ExecutionEntity leaf : leaves) {
    ScopeImpl activity = leaf.getActivity();

    if (activity != null) {
      if (leaf.getActivityInstanceId() != null) {
        EnsureUtil.ensureNotNull("activity", activity);
        submitExecution(leaf, activity);
      }
      mergeScopeExecutions(leaf);


    }
    else if (leaf.isProcessInstanceExecution()) {
      submitExecution(leaf, leaf.getProcessDefinition());
    }
  }
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
@Override
public boolean validate(final Object submittedValue, final FormFieldValidatorContext validatorContext) {

  final DelegateExecution execution = validatorContext.getExecution();

  if(shouldPerformPaContextSwitch(validatorContext.getExecution())) {
    ProcessApplicationReference processApplicationReference = ProcessApplicationContextUtil.getTargetProcessApplication((ExecutionEntity) execution);

    return Context.executeWithinProcessApplication(new Callable<Boolean>() {
      public Boolean call() throws Exception {
        return doValidate(submittedValue, validatorContext);
      }
    }, processApplicationReference, new InvocationContext(execution));

  } else {
    return doValidate(submittedValue, validatorContext);

  }

}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
@Override
public Incident execute(CommandContext commandContext) {
  EnsureUtil.ensureNotNull(BadUserRequestException.class, "Execution id cannot be null", "executionId", executionId);
  EnsureUtil.ensureNotNull(BadUserRequestException.class, "incidentType", incidentType);

  ExecutionEntity execution = commandContext.getExecutionManager().findExecutionById(executionId);
  EnsureUtil.ensureNotNull(BadUserRequestException.class,
      "Cannot find an execution with executionId '" + executionId + "'", "execution", execution);
  EnsureUtil.ensureNotNull(BadUserRequestException.class, "Execution must be related to an activity", "activity",
      execution.getActivity());

  for (CommandChecker checker : commandContext.getProcessEngineConfiguration().getCommandCheckers()) {
    checker.checkUpdateProcessInstance(execution);
  }

  return execution.createIncident(incidentType, configuration, message);
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
@Test
public void resolveIncident() {
  testRule.deployAndGetDefinition(ProcessModels.TWO_TASKS_PROCESS);

  ProcessInstance processInstance = engineRule.getRuntimeService().startProcessInstanceByKey("Process");
  ExecutionEntity execution = (ExecutionEntity) engineRule.getRuntimeService().createExecutionQuery().active().singleResult();

  authRule.disableAuthorization();
  Incident incident = engineRule.getRuntimeService()
      .createIncident("foo", execution.getId(), execution.getActivityId(), "bar");

  authRule
      .init(scenario)
      .withUser("userId")
      .bindResource("processInstance", processInstance.getId())
      .bindResource("processDefinition", "Process")
      .start();

  // when
  engineRule.getRuntimeService().resolveIncident(incident.getId());

  // then
  authRule.assertScenario(scenario);
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入依赖的package包/类
public UserOperationLogContextEntryBuilder inContextOf(ExecutionEntity processInstance, List<PropertyChange> propertyChanges) {

    if (propertyChanges == null || propertyChanges.isEmpty()) {
      if (OPERATION_TYPE_CREATE.equals(entry.getOperationType())) {
        propertyChanges = Arrays.asList(PropertyChange.EMPTY_CHANGE);
      }
    }
    entry.setPropertyChanges(propertyChanges);
    entry.setProcessInstanceId(processInstance.getProcessInstanceId());
    entry.setProcessDefinitionId(processInstance.getProcessDefinitionId());
    entry.setExecutionId(processInstance.getId());
    entry.setCaseInstanceId(processInstance.getCaseInstanceId());

    ResourceDefinitionEntity definition = processInstance.getProcessDefinition();
    if (definition != null) {
      entry.setProcessDefinitionKey(definition.getKey());
      entry.setDeploymentId(definition.getDeploymentId());
    }

    return this;
  }