protected static void writePlanItem(PlanItem planItem, CmmnModel model, XMLStreamWriter xtw) throws Exception { createCmmnShape(model, planItem.getId(), xtw); for (Criterion criterion : planItem.getEntryCriteria()) { createCmmnShape(model, criterion.getId(), xtw); } for (Criterion criterion : planItem.getExitCriteria()) { createCmmnShape(model, criterion.getId(), xtw); } }
@Override public String toString() { PlanItem planItem = planItemInstanceEntity.getPlanItem(); StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append("[Trigger PlanItem] "); if (planItem.getName() != null) { stringBuilder.append(planItem.getName()); stringBuilder.append(" ("); stringBuilder.append(planItem.getId()); stringBuilder.append(")"); } else { stringBuilder.append(planItem.getId()); } return stringBuilder.toString(); }
protected boolean isStage(PlanItemInstanceEntity planItemInstanceEntity) { return (planItemInstanceEntity.getPlanItem() != null && planItemInstanceEntity.getPlanItem().getPlanItemDefinition() != null && planItemInstanceEntity.getPlanItem().getPlanItemDefinition() instanceof Stage); }
public static boolean isEntryDependency(PlanItem planItem, PlanItem dependency) { for (PlanItem entryDependency : planItem.getEntryDependencies()) { if (entryDependency.getId().equals(dependency.getId())) { return true; } } return false; }
public static boolean isExitDependency(PlanItem planItem, PlanItem dependency) { for (PlanItem exitDependency : planItem.getExitDependencies()) { if (exitDependency.getId().equals(dependency.getId())) { return true; } } return false; }
protected boolean isPlanItemRepeatableOnComplete(PlanItem planItem) { return planItem != null && planItem.getEntryCriteria().isEmpty() && planItem.getItemControl() != null && planItem.getItemControl().getRepetitionRule() != null; }
protected void processElements(List<PlanItem> planItemList, CmmnModel model, ArrayNode elementArray, ArrayNode flowArray, GraphicInfo diagramInfo) { for (PlanItem planItem : planItemList) { ObjectNode elementNode = objectMapper.createObjectNode(); elementNode.put("id", planItem.getId()); elementNode.put("name", planItem.getName()); GraphicInfo graphicInfo = model.getGraphicInfo(planItem.getId()); if (graphicInfo != null) { fillGraphicInfo(elementNode, graphicInfo, true); fillDiagramInfo(graphicInfo, diagramInfo); } PlanItemDefinition planItemDefinition = planItem.getPlanItemDefinition(); String className = planItemDefinition.getClass().getSimpleName(); elementNode.put("type", className); if (planItemDefinition instanceof ServiceTask) { ServiceTask serviceTask = (ServiceTask) planItemDefinition; if (HttpServiceTask.HTTP_TASK.equals(serviceTask.getType())) { elementNode.put("taskType", "http"); } } elementArray.add(elementNode); processCriteria(planItem.getEntryCriteria(), "EntryCriterion", model, elementArray); processCriteria(planItem.getExitCriteria(), "ExitCriterion", model, elementArray); if (planItemDefinition instanceof Stage) { Stage stage = (Stage) planItemDefinition; processElements(stage.getPlanItems(), model, elementArray, flowArray, diagramInfo); } } }
Stage parentStage = planItem.getParentStage(); PlanItemDefinition planItemDefinition = parentStage.findPlanItemDefinitionInStageOrUpwards(planItem.getDefinitionRef()); if (planItemDefinition == null) { throw new FlowableException("No matching plan item definition found for reference " + planItem.getDefinitionRef() + " of plan item " + planItem.getId()); planItem.setPlanItemDefinition(planItemDefinition); if (!planItem.getEntryCriteria().isEmpty()) { resolveEntryCriteria(planItem); if (!planItem.getExitCriteria().isEmpty()) { boolean exitCriteriaAllowed = true; if (planItemDefinition instanceof Task) { resolveExitCriteriaSentry(planItem); } else { LOGGER.warn("Ignoring exit criteria on plan item {}", planItem.getId()); planItem.getExitCriteria().clear(); sentryOnPart.setSourceRef(startTriggerPlanItem.getId()); sentryOnPart.setSource(startTriggerPlanItem); sentryOnPart.setStandardEvent(timerEventListener.getTimerStartTriggerStandardEvent()); planItem.addEntryCriterion(criterion);
public static void writePlanItem(CmmnModel model, PlanItem planItem, XMLStreamWriter xtw) throws Exception { xtw.writeAttribute(ATTRIBUTE_ID, planItem.getId()); if (StringUtils.isNotEmpty(planItem.getName())) { xtw.writeAttribute(ATTRIBUTE_NAME, planItem.getName()); if (StringUtils.isNotEmpty(planItem.getDefinitionRef())) { xtw.writeAttribute(ATTRIBUTE_DEFINITION_REF, planItem.getDefinitionRef()); if (StringUtils.isNotEmpty(planItem.getDocumentation())) { xtw.writeStartElement(ELEMENT_DOCUMENTATION); xtw.writeCharacters(planItem.getDocumentation()); xtw.writeEndElement(); if (planItem.getItemControl() != null) { PlanItemControl itemControl = planItem.getItemControl(); PlanItemControlExport.writeItemControl(itemControl, xtw);
protected List<PlanItem> gatherEventListenerDependencies(PlanItem planItem) { List<PlanItem> eventListenerDependencies = Stream.concat( planItem.getEntryDependencies().stream().filter(p -> p.getPlanItemDefinition() instanceof EventListener), planItem.getExitDependencies().stream().filter(p -> p.getPlanItemDefinition() instanceof EventListener)) .collect(Collectors.toList()); // Special case: if the current plan item is a stage, we need to also verify all event listeners // that reference a child plan item of this stage. Normally this will happen automatically, unless // the child plan item instances haven't been created yet (e.g with nested stages). // As such, we need to check all plan items for which there hasn't been a plan item instance yet. if (planItem.getPlanItemDefinition() instanceof PlanFragment && PlanItemInstanceState.isInTerminalState(planItemInstanceEntity)) { // This is only true when stopping, not when a plan item gets activated (in that case, the child plan items can still be created and no special care is needed) List<PlanItem> childPlanItemsWithDependencies = getChildPlanItemsWithDependencies((PlanFragment) planItem.getPlanItemDefinition()); CaseInstanceEntity caseInstanceEntity = CommandContextUtil .getCaseInstanceEntityManager(commandContext).findById(planItemInstanceEntity.getCaseInstanceId()); Map<String, List<PlanItemInstanceEntity>> childPlanItemInstancesMap = CaseInstanceUtil .findChildPlanItemInstancesMap(caseInstanceEntity, childPlanItemsWithDependencies); for (PlanItem childPlanItemWithDependencies : childPlanItemsWithDependencies) { if (!childPlanItemInstancesMap.containsKey(childPlanItemWithDependencies.getId())) { eventListenerDependencies.addAll(childPlanItemWithDependencies.getEntryDependencies().stream() .filter(p -> p.getPlanItemDefinition() instanceof EventListener).collect(Collectors.toList())); eventListenerDependencies.addAll(childPlanItemWithDependencies.getExitDependencies().stream() .filter(p -> p.getPlanItemDefinition() instanceof EventListener).collect(Collectors.toList())); } } } return eventListenerDependencies; }
planItemInstanceEntity.setCaseDefinitionId(caseDefinitionId); planItemInstanceEntity.setCaseInstanceId(caseInstanceId); if (planItem.getName() != null) { Expression nameExpression = expressionManager.createExpression(planItem.getName()); planItemInstanceEntity.setName(nameExpression.getValue(caseInstanceEntity).toString()); planItemInstanceEntity.setElementId(planItem.getId()); PlanItemDefinition planItemDefinition = planItem.getPlanItemDefinition(); if (planItemDefinition != null) { planItemInstanceEntity.setPlanItemDefinitionId(planItemDefinition.getId());
public Optional<PlanItem> findPlanItem(String planItemId) { return planItems.stream() .filter(planItem -> planItem.getId().equals(planItemId)) .findFirst(); }
List<PlanItem> entryDependentPlanItems = planItemLifeCycleEvent.getPlanItem().getEntryDependentPlanItems(); for (PlanItem entryDependentPlanItem : entryDependentPlanItems) { List<PlanItemInstanceEntity> childPlanItemInstances = CaseInstanceUtil.findChildPlanItemInstances(caseInstanceEntity, entryDependentPlanItem); List<PlanItemInstanceEntity> potentialTerminatedPlanItemInstances = planItemInstanceEntityManager .findByCaseInstanceIdAndPlanItemId(caseInstanceEntity.getId(), entryDependentPlanItem.getId()); || (hasRepetitionRule(entryDependentPlanItem) && evaluateRepetitionRule(caseInstanceEntity, entryDependentPlanItem.getItemControl().getRepetitionRule().getCondition())))) { // (terminated state) the plan item instance should not have been created anytime before List<PlanItemInstanceEntity> parentPlanItemInstances = existingPlanItemInstancesMap.get(parentPlanItem.getId()); if (!entryDependentPlanItem.getEntryCriteria().isEmpty() && hasRepetitionRule(entryDependentPlanItemInstance)) { if (evaluateRepetitionRule(entryDependentPlanItemInstance)) { createPlanItemInstanceDuplicateForRepetition(entryDependentPlanItemInstance);
public static void writeCriteriaElements(PlanItem planItem, XMLStreamWriter xtw) throws Exception { writeEntryCriteriaElements(planItem.getEntryCriteria(), xtw); writeExitCriteriaElements(planItem.getExitCriteria(), xtw); }
PlanItemDefinition newPlanItemDefinition = planItemMoveEntry.getNewPlanItem().getPlanItemDefinition(); Stage stage = newPlanItemDefinition.getParentStage(); for (PlanItemMoveEntry planItemMoveEntry : moveToPlanItems) { PlanItem newPlanItem = planItemMoveEntry.getNewPlanItem(); PlanItemDefinition newPlanItemDefinition = newPlanItem.getPlanItemDefinition(); PlanItemInstanceEntity parentPlanItemInstance = null; if (newPlanItemDefinition.getParentStage() != null && caseInstanceChangeState.getCreatedStageInstances().containsKey(newPlanItemDefinition.getParentStage().getId())) { List<PlanItemInstanceEntity> existingPlanItemInstances = planItemInstanceEntityManager.findByCaseInstanceIdAndPlanItemId(movePlanItemInstanceEntityContainer.getCaseInstanceId(), newPlanItem.getId()); PlanItemInstanceEntity newPlanItemInstance = null; if (!existingPlanItemInstances.isEmpty()) { movePlanItemInstanceEntityContainer.getTenantId(), true); if (newPlanItem.getParentStage() != null) { for (PlanItem stagePlanItem : newPlanItem.getParentStage().getPlanItems()) { if (!stagePlanItem.getId().equals(newPlanItem.getId())) { PlanItemInstanceEntity childStagePlanItemInstance = CommandContextUtil.getPlanItemInstanceEntityManager(commandContext) .createChildPlanItemInstance(stagePlanItem, newPlanItemInstance.getCaseDefinitionId(), newPlanItemInstance.getCaseInstanceId(),
planItem.getEntryDependencies().addAll(PlanItemDependencyUtil.getEntryDependencies(planItem)); planItem.getExitDependencies().addAll(PlanItemDependencyUtil.getExitDependencies(planItem)); planItem.getEntryDependencies().forEach(entryDependency -> entryDependency.addEntryDependentPlanItem(planItem)); planItem.getExitDependencies().forEach(exitDependency -> exitDependency.addExitDependentPlanItem(planItem)); for (Criterion criterion : planItem.getEntryCriteria()) { Sentry sentry = criterion.getSentry(); if (sentry.getOnParts().size() > 0) {
protected void internalGetChildPlanItemsWithDependencies(PlanFragment planFragment, List<PlanItem> childPlanItemsWithDependencies) { for (PlanItem planItem : planFragment.getPlanItems()) { if (!planItem.getEntryDependencies().isEmpty() || !planItem.getExitDependencies().isEmpty()) { childPlanItemsWithDependencies.add(planItem); if (planItem.getPlanItemDefinition() instanceof PlanFragment) { internalGetChildPlanItemsWithDependencies((PlanFragment) planItem.getPlanItemDefinition(), childPlanItemsWithDependencies); } } } }
&& evaluateCriteriaOperation.getCaseInstanceEntityId().equals(caseInstanceEntityId) && evaluateCriteriaOperation.getPlanItemLifeCycleEvent().getTransition().equals(planItemLifeCycleEvent.getTransition()) && evaluateCriteriaOperation.getPlanItemLifeCycleEvent().getPlanItem().getId().equals(planItemLifeCycleEvent.getPlanItem().getId()) && evaluateCriteriaOperation.isEvaluateCaseInstanceCompleted() == evaluateCaseInstanceCompleted) { LOGGER.debug("Deferred criteria evaluation for case instance with id '{}' to later in the execution. Plan item = {}, Plan item definition = {}, transition = {}", caseInstanceEntityId, planItemLifeCycleEvent.getPlanItem().getId(), planItemLifeCycleEvent.getPlanItem().getPlanItemDefinition(), planItemLifeCycleEvent.getTransition()); plannedOperations.remove();
if (planItem.getEntryCriteria().isEmpty() || satisfiedEntryCriterion != null) { boolean activatePlanItemInstance = true; if (!planItem.getEntryCriteria().isEmpty() && hasRepetitionRule(planItemInstanceEntity)) { boolean isRepeating = evaluateRepetitionRule(planItemInstanceEntity); if (isRepeating) { if (planItem.getPlanItemDefinition() instanceof EventListener) { activatePlanItemInstance = false; // event listeners occur, they don't become active CommandContextUtil.getAgenda(commandContext).planExitPlanItemInstanceOperation(planItemInstanceEntity, satisfiedExitCriterion); } else if (planItem.getPlanItemDefinition() instanceof Stage) { planItemInstanceEntity.setCompleteable(false); // an active child = stage cannot be completed anymore } else { Stage stage = (Stage) planItemInstanceEntity.getPlanItem().getPlanItemDefinition(); if (isStageCompletable(planItemInstanceEntity, stage)) { criteriaChanged = true;
protected String evaluateEntryCriteria(PlanItemInstanceEntity planItemInstanceEntity, PlanItem planItem) { List<Criterion> criteria = planItem.getEntryCriteria(); if (criteria != null && !criteria.isEmpty()) { return evaluateCriteria(planItemInstanceEntity, criteria); } return null; }