public ProcessDefinitionQuery eventSubscription(String eventType, String eventName) {
   ensureNotNull("event type", eventType);
   ensureNotNull("event name", eventName);
   this.eventSubscriptionType = eventType;
   this.eventSubscriptionName = eventName;
   return this;
 }
  public String execute(CommandContext commandContext) {
    ensureNotNull("entityClass", entityClass);

    commandContext.getAuthorizationManager().checkCamundaAdmin();

    return commandContext.getTableDataManager().getTableName(entityClass, true);
  }
  public void createSentryParts() {
    CmmnActivity activity = getActivity();
    ensureNotNull("Case execution '" + id + "': has no current activity", "activity", activity);

    List<CmmnSentryDeclaration> sentries = activity.getSentries();

    if (sentries != null && !sentries.isEmpty()) {

      for (CmmnSentryDeclaration sentryDeclaration : sentries) {

        CmmnIfPartDeclaration ifPartDeclaration = sentryDeclaration.getIfPart();
        if (ifPartDeclaration != null) {
          CmmnSentryPart ifPart = createIfPart(sentryDeclaration, ifPartDeclaration);
          addSentryPart(ifPart);
        }

        List<CmmnOnPartDeclaration> onPartDeclarations = sentryDeclaration.getOnParts();

        for (CmmnOnPartDeclaration onPartDeclaration : onPartDeclarations) {
          CmmnSentryPart onPart = createOnPart(sentryDeclaration, onPartDeclaration);
          addSentryPart(onPart);
        }

        List<CmmnVariableOnPartDeclaration> variableOnPartDeclarations =
            sentryDeclaration.getVariableOnParts();
        for (CmmnVariableOnPartDeclaration variableOnPartDeclaration : variableOnPartDeclarations) {
          CmmnSentryPart variableOnPart =
              createVariableOnPart(sentryDeclaration, variableOnPartDeclaration);
          addSentryPart(variableOnPart);
        }
      }
    }
  }
  protected void checkAndFireEntryCriteria(List<String> satisfiedSentries) {
    if (isAvailable() || isNew()) {
      // do that only, when this child case execution
      // is available

      CmmnActivity activity = getActivity();
      ensureNotNull(
          PvmException.class,
          "Case execution '" + getId() + "': has no current activity.",
          "activity",
          activity);

      List<CmmnSentryDeclaration> criteria = activity.getEntryCriteria();
      for (CmmnSentryDeclaration sentryDeclaration : criteria) {
        if (sentryDeclaration != null && satisfiedSentries.contains(sentryDeclaration.getId())) {
          if (isAvailable()) {
            fireEntryCriteria();
          } else {
            entryCriterionSatisfied = true;
          }
          break;
        }
      }
    }
  }
  public void execute(
      String configuration,
      ExecutionEntity execution,
      CommandContext commandContext,
      String tenantId) {
    String activityId = getKey(configuration);
    ActivityImpl intermediateEventActivity =
        execution.getProcessDefinition().findActivity(activityId);

    ensureNotNull(
        "Error while firing timer: intermediate event activity " + configuration + " not found",
        "intermediateEventActivity",
        intermediateEventActivity);

    try {
      if (activityId.equals(execution.getActivityId())) {
        // Regular Intermediate timer catch
        execution.signal("signal", null);
      } else {
        // Event based gateway
        execution.executeEventHandlerActivity(intermediateEventActivity);
      }

    } catch (RuntimeException e) {
      throw e;
    } catch (Exception e) {
      throw new ProcessEngineException("exception during timer execution: " + e.getMessage(), e);
    }
  }
 @Override
 public HistoricDecisionInstanceQuery decisionRequirementsDefinitionKey(
     String decisionRequirementsDefinitionKey) {
   ensureNotNull(
       NotValidException.class,
       "decisionRequirementsDefinitionKey",
       decisionRequirementsDefinitionKey);
   this.decisionRequirementsDefinitionKey = decisionRequirementsDefinitionKey;
   return this;
 }
  public TaskFormData execute(CommandContext commandContext) {
    TaskManager taskManager = commandContext.getTaskManager();
    TaskEntity task = taskManager.findTaskById(taskId);
    ensureNotNull("No task found for taskId '" + taskId + "'", "task", task);

    AuthorizationManager authorizationManager = commandContext.getAuthorizationManager();
    authorizationManager.checkReadTask(task);

    if (task.getTaskDefinition() != null) {
      TaskFormHandler taskFormHandler = task.getTaskDefinition().getTaskFormHandler();
      ensureNotNull(
          "No taskFormHandler specified for task '" + taskId + "'",
          "taskFormHandler",
          taskFormHandler);

      return taskFormHandler.createTaskForm(task);
    } else {
      // Standalone task, no TaskFormData available
      return null;
    }
  }
  public DecisionRequirementsDefinition execute(CommandContext commandContext) {
    ensureNotNull("decisionRequirementsDefinitionId", decisionRequirementsDefinitionId);
    DeploymentCache deploymentCache = Context.getProcessEngineConfiguration().getDeploymentCache();
    DecisionRequirementsDefinitionEntity decisionRequirementsDefinition =
        deploymentCache.findDeployedDecisionRequirementsDefinitionById(
            decisionRequirementsDefinitionId);

    for (CommandChecker checker :
        commandContext.getProcessEngineConfiguration().getCommandCheckers()) {
      checker.checkReadDecisionRequirementsDefinition(decisionRequirementsDefinition);
    }

    return decisionRequirementsDefinition;
  }
  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());
      }
    }
  }
  @Override
  public DmnDecisionTableResult execute(CommandContext commandContext) {
    ensureNotNull("decision definition id is null", "processDefinitionId", decisionDefinitionId);

    ProcessEngineConfigurationImpl processEngineConfiguration =
        commandContext.getProcessEngineConfiguration();
    DeploymentCache deploymentCache = processEngineConfiguration.getDeploymentCache();

    DecisionDefinitionEntity decisionDefinition =
        deploymentCache.findDeployedDecisionDefinitionById(decisionDefinitionId);

    // check authorization
    AuthorizationManager authorizationManager = commandContext.getAuthorizationManager();
    authorizationManager.checkEvaluateDecision(decisionDefinition.getKey());

    return doEvaluateDecision(decisionDefinition, variables);
  }
  protected void checkAndFireExitCriteria(List<String> satisfiedSentries) {
    if (isActive()) {
      CmmnActivity activity = getActivity();
      ensureNotNull(
          PvmException.class,
          "Case execution '" + getId() + "': has no current activity.",
          "activity",
          activity);

      // trigger first exitCriteria
      List<CmmnSentryDeclaration> exitCriteria = activity.getExitCriteria();
      for (CmmnSentryDeclaration sentryDeclaration : exitCriteria) {

        if (sentryDeclaration != null && satisfiedSentries.contains(sentryDeclaration.getId())) {
          fireExitCriteria();
          break;
        }
      }
    }
  }
  protected CmmnSentryPart createOnPart(
      CmmnSentryDeclaration sentryDeclaration, CmmnOnPartDeclaration onPartDeclaration) {
    CmmnSentryPart sentryPart = createSentryPart(sentryDeclaration, PLAN_ITEM_ON_PART);

    // set the standard event
    String standardEvent = onPartDeclaration.getStandardEvent();
    sentryPart.setStandardEvent(standardEvent);

    // set source case execution
    CmmnActivity source = onPartDeclaration.getSource();
    ensureNotNull(
        "The source of sentry '" + sentryDeclaration.getId() + "' is null.", "source", source);

    String sourceActivityId = source.getId();
    sentryPart.setSource(sourceActivityId);

    // TODO: handle also sentryRef!!! (currently not implemented on purpose)

    return sentryPart;
  }
 public ProcessDefinitionQueryImpl deploymentId(String deploymentId) {
   ensureNotNull("deploymentId", deploymentId);
   this.deploymentId = deploymentId;
   return this;
 }
 public ProcessDefinitionQueryImpl processDefinitionVersion(Integer version) {
   ensureNotNull("version", version);
   ensurePositive("version", version.longValue());
   this.version = version;
   return this;
 }
 public TableMetaData execute(CommandContext commandContext) {
   ensureNotNull("tableName", tableName);
   return commandContext.getTableDataManager().getTableMetaData(tableName);
 }
  public ProcessDefinitionQuery versionTag(String versionTag) {
    ensureNotNull("versionTag", versionTag);
    this.versionTag = versionTag;

    return this;
  }
 public ProcessDefinitionQueryImpl tenantIdIn(String... tenantIds) {
   ensureNotNull("tenantIds", (Object[]) tenantIds);
   this.tenantIds = tenantIds;
   isTenantIdSet = true;
   return this;
 }
 public ProcessDefinitionQuery incidentMessageLike(String incidentMessageLike) {
   ensureNotNull("incident messageLike", incidentMessageLike);
   this.incidentMessageLike = incidentMessageLike;
   return this;
 }
 public ProcessDefinitionQuery incidentId(String incidentId) {
   ensureNotNull("incident id", incidentId);
   this.incidentId = incidentId;
   return this;
 }
 public ProcessDefinitionQuery incidentType(String incidentType) {
   ensureNotNull("incident type", incidentType);
   this.incidentType = incidentType;
   return this;
 }
 public ProcessDefinitionQueryImpl processDefinitionKeyLike(String keyLike) {
   ensureNotNull("keyLike", keyLike);
   this.keyLike = keyLike;
   return this;
 }
 public ProcessDefinitionQueryImpl processDefinitionNameLike(String nameLike) {
   ensureNotNull("nameLike", nameLike);
   this.nameLike = nameLike;
   return this;
 }
  protected boolean isSentryPartsSatisfied(
      String sentryId, List<? extends CmmnSentryPart> sentryParts) {
    // if part will be evaluated in the end
    CmmnSentryPart ifPart = null;

    if (sentryParts != null && !sentryParts.isEmpty()) {
      for (CmmnSentryPart sentryPart : sentryParts) {

        if (PLAN_ITEM_ON_PART.equals(sentryPart.getType())) {

          if (!sentryPart.isSatisfied()) {
            return false;
          }

        } else if (VARIABLE_ON_PART.equals(sentryPart.getType())) {
          if (!sentryPart.isSatisfied()) {
            return false;
          }
        } else {
            /* IF_PART.equals(sentryPart.getType) == true */

          ifPart = sentryPart;

          // once the ifPart has been satisfied the whole sentry is satisfied
          if (ifPart.isSatisfied()) {
            return true;
          }
        }
      }
    }

    if (ifPart != null) {

      CmmnExecution execution = ifPart.getCaseExecution();
      ensureNotNull("Case execution of sentry '" + ifPart.getSentryId() + "': is null", execution);

      CmmnActivity activity = ifPart.getCaseExecution().getActivity();
      ensureNotNull("Case execution '" + id + "': has no current activity", "activity", activity);

      CmmnSentryDeclaration sentryDeclaration = activity.getSentry(sentryId);
      ensureNotNull(
          "Case execution '" + id + "': has no declaration for sentry '" + sentryId + "'",
          "sentryDeclaration",
          sentryDeclaration);

      CmmnIfPartDeclaration ifPartDeclaration = sentryDeclaration.getIfPart();
      ensureNotNull(
          "Sentry declaration '"
              + sentryId
              + "' has no definied ifPart, but there should be one defined for case execution '"
              + id
              + "'.",
          "ifPartDeclaration",
          ifPartDeclaration);

      Expression condition = ifPartDeclaration.getCondition();
      ensureNotNull(
          "A condition was expected for ifPart of Sentry declaration '"
              + sentryId
              + "' for case execution '"
              + id
              + "'.",
          "condition",
          condition);

      Object result = condition.getValue(this);
      ensureInstanceOf("condition expression returns non-Boolean", "result", result, Boolean.class);

      Boolean booleanResult = (Boolean) result;
      ifPart.setSatisfied(booleanResult);
      return booleanResult;
    }

    // if all onParts are satisfied and there is no
    // ifPart then the whole sentry is satisfied.
    return true;
  }
 public ProcessDefinitionQueryImpl processDefinitionKey(String key) {
   ensureNotNull("key", key);
   this.key = key;
   return this;
 }
 public HistoricTaskInstanceQuery activityInstanceIdIn(String... activityInstanceIds) {
   ensureNotNull("activityInstanceIds", activityInstanceIds);
   this.activityInstanceIds = activityInstanceIds;
   return this;
 }
 public ProcessDefinitionQueryImpl startableByUser(String userId) {
   ensureNotNull("userId", userId);
   this.authorizationUserId = userId;
   return this;
 }
 public ProcessDefinitionQueryImpl processDefinitionCategoryLike(String categoryLike) {
   ensureNotNull("categoryLike", categoryLike);
   this.categoryLike = categoryLike;
   return this;
 }
 public ProcessDefinitionQueryImpl processDefinitionCategory(String category) {
   ensureNotNull("category", category);
   this.category = category;
   return this;
 }
  public ProcessDefinitionQuery versionTagLike(String versionTagLike) {
    ensureNotNull("versionTagLike", versionTagLike);
    this.versionTagLike = versionTagLike;

    return this;
  }
 public ProcessDefinitionQueryImpl processDefinitionResourceNameLike(String resourceNameLike) {
   ensureNotNull("resourceNameLike", resourceNameLike);
   this.resourceNameLike = resourceNameLike;
   return this;
 }