protected boolean isStage(PlanItemInstanceEntity planItemInstanceEntity) { return (planItemInstanceEntity.getPlanItem() != null && planItemInstanceEntity.getPlanItem().getPlanItemDefinition() != null && planItemInstanceEntity.getPlanItem().getPlanItemDefinition() instanceof Stage); }
protected boolean isAsync() { if (planItemInstanceEntity.getPlanItem().getPlanItemDefinition() instanceof Task) { Task task = (Task) planItemInstanceEntity.getPlanItem().getPlanItemDefinition(); if (task.isAsync()) { return true; } } return false; }
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); } } } }
@Override protected void executeParse(CmmnParserImpl cmmnParser, CmmnParseResult cmmnParseResult, T element) { if (!(element instanceof PlanItem)) { throw new FlowableException("Programmatic error: passed element is not a PlanItem instance, but an instance of " + element.getClass()); } PlanItem planItem = (PlanItem) element; executePlanItemParse(cmmnParser, cmmnParseResult, planItem, (T) planItem.getPlanItemDefinition()); }
public void parseElement(CmmnParser cmmnParser, CmmnParseResult cmmnParseResult, BaseElement baseElement) { List<CmmnParseHandler> handlers = null; if (baseElement instanceof PlanItem) { // The plan item definition defines the actual behavior PlanItem planItem = (PlanItem) baseElement; handlers = parseHandlers.get(planItem.getPlanItemDefinition().getClass()); if (handlers == null) { LOGGER.warn("Could not find matching parse handler for planItem '{}' with planItemDefinition '{}'. This is likely a bug.", baseElement.getId(), planItem.getPlanItemDefinition()); } else { handlers.forEach(handler -> handler.parse(cmmnParser, cmmnParseResult, planItem)); // Note: passing plan item, NOT plan item definition } } else { handlers = parseHandlers.get(baseElement.getClass()); if (handlers == null) { LOGGER.warn("Could not find matching parse handler for '{}' this is likely a bug.", baseElement.getId()); } else { handlers.forEach(handler -> handler.parse(cmmnParser, cmmnParseResult, baseElement)); } } }
@Override protected boolean isEvaluateRepetitionRule() { if (planItemInstanceEntity.getPlanItem() != null && planItemInstanceEntity.getPlanItem().getPlanItemDefinition() instanceof EventListener) { // Only event listeners can be repeating on occur return true; } else { return false; } }
protected boolean isStageAncestorOfAnyPlanItemInstance(String stageId, List<PlanItemInstanceEntity> planItemInstances) { for (PlanItemInstanceEntity planItemInstance : planItemInstances) { PlanItemDefinition planItemDefinition = planItemInstance.getPlanItem().getPlanItemDefinition(); if (isStageAncestor(stageId, planItemDefinition)) { return true; } } return false; }
protected boolean isStageAncestorOfAnyNewPlanItemDefinitions(String stageId, List<PlanItemMoveEntry> planItems) { for (PlanItemMoveEntry planItemMoveEntry : planItems) { if (isStageAncestor(stageId, planItemMoveEntry.getNewPlanItem().getPlanItemDefinition())) { return true; } } return false; }
protected Stage getStage(PlanItemInstanceEntity planItemInstanceEntity) { PlanItemDefinition planItemDefinition = planItemInstanceEntity.getPlanItem().getPlanItemDefinition(); if (planItemDefinition instanceof Stage) { return (Stage) planItemDefinition; } else { return planItemDefinition.getParentStage(); } }
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; }
@Override public void run() { if (PlanItemInstanceState.ACTIVE.equals(planItemInstanceEntity.getState()) || (planItemInstanceEntity.getPlanItem() != null && planItemInstanceEntity.getPlanItem().getPlanItemDefinition() instanceof EventListener && PlanItemInstanceState.AVAILABLE.equals(planItemInstanceEntity.getState())) ){ executeTrigger(); } }
public static boolean isPossible(PlanItemInstance planItemInstance, String transition) { if (((PlanItemInstanceEntity) planItemInstance).getPlanItem().getPlanItemDefinition() instanceof EventListener) { return isEventListenerTransitionPossible(planItemInstance.getState(), transition); } else { return isPlanItemTransitionPossible(planItemInstance.getState(), transition); } }
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); } } }
@Override protected void internalExecute() { planItemInstanceEntity.setLastStartedTime(getCurrentTime(commandContext)); CommandContextUtil.getCmmnHistoryManager(commandContext).recordPlanItemInstanceStarted(planItemInstanceEntity); createAsyncJob((Task) planItemInstanceEntity.getPlanItem().getPlanItemDefinition()); }
protected void processSentries(Stage planModelStage, PlanFragment planFragment) { for (Sentry sentry : planFragment.getSentries()) { for (SentryOnPart onPart : sentry.getOnParts()) { PlanItem planItem = planModelStage.findPlanItemInPlanFragmentOrDownwards(onPart.getSourceRef()); if (planItem != null) { onPart.setSource(planItem); } else { throw new FlowableException("Could not resolve on part source reference " + onPart.getSourceRef() + " of sentry " + sentry.getId()); } } } for (PlanItem planItem : planFragment.getPlanItems()) { if (planItem.getPlanItemDefinition() instanceof PlanFragment) { processSentries(planModelStage, (PlanFragment) planItem.getPlanItemDefinition()); } } }
public static void callLifecycleListeners(CommandContext commandContext, DelegatePlanItemInstance planItemInstance, String oldState, String newState) { if (Objects.equals(oldState, newState)) { return; } // Lifecycle listeners on the element itself PlanItemDefinition planItemDefinition = planItemInstance.getPlanItem().getPlanItemDefinition(); if (planItemDefinition != null) { List<FlowableListener> flowableListeners = planItemDefinition.getLifecycleListeners(); if (flowableListeners != null && !flowableListeners.isEmpty()) { CmmnListenerNotificationHelper listenerNotificationHelper = CommandContextUtil.getCmmnEngineConfiguration(commandContext).getListenerNotificationHelper(); for (FlowableListener flowableListener : flowableListeners) { if (stateMatches(flowableListener.getSourceState(), oldState) && stateMatches(flowableListener.getTargetState(), newState)) { PlanItemInstanceLifecycleListener lifecycleListener = listenerNotificationHelper.createLifecycleListener(flowableListener); executeLifecycleListener(planItemInstance, oldState, newState, lifecycleListener); } } } } // Lifecycle listeners defined on the cmmn engine configuration Map<String, List<PlanItemInstanceLifecycleListener>> planItemInstanceLifeCycleListeners = CommandContextUtil.getCmmnEngineConfiguration(commandContext).getPlanItemInstanceLifecycleListeners(); if (planItemInstanceLifeCycleListeners != null && !planItemInstanceLifeCycleListeners.isEmpty()) { List<PlanItemInstanceLifecycleListener> specificListeners = planItemInstanceLifeCycleListeners.get(planItemInstance.getPlanItemDefinitionType()); executeListeners(specificListeners, planItemInstance, oldState, newState); List<PlanItemInstanceLifecycleListener> genericListeners = planItemInstanceLifeCycleListeners.get(null); executeListeners(genericListeners, planItemInstance, oldState, newState); } }
caseInstanceEntityId, planItemLifeCycleEvent.getPlanItem().getId(), planItemLifeCycleEvent.getPlanItem().getPlanItemDefinition(), planItemLifeCycleEvent.getTransition()); plannedOperations.remove();
PlanItemDefinition planItemDefinition = planItem.getPlanItemDefinition(); if (planItemDefinition != null) { planItemInstanceEntity.setPlanItemDefinitionId(planItemDefinition.getId());
@Override public void run() { super.run(); if (isRepeatingOnDelete()) { // Create new repeating instance PlanItemInstanceEntity newPlanItemInstanceEntity = copyAndInsertPlanItemInstance(commandContext, planItemInstanceEntity, true); if (planItemInstanceEntity.getPlanItem() != null && planItemInstanceEntity.getPlanItem().getPlanItemDefinition() instanceof EventListener) { CommandContextUtil.getAgenda(commandContext).planCreatePlanItemInstanceOperation(newPlanItemInstanceEntity); } else { String oldState = newPlanItemInstanceEntity.getState(); String newState = PlanItemInstanceState.WAITING_FOR_REPETITION; newPlanItemInstanceEntity.setState(newState); PlanItemLifeCycleListenerUtil.callLifecycleListeners(commandContext, newPlanItemInstanceEntity, oldState, newState); // Plan item creation "for Repetition" CommandContextUtil.getAgenda(commandContext).planCreatePlanItemInstanceForRepetitionOperation(newPlanItemInstanceEntity); // Plan item doesn't have entry criteria (checked in the if condition) and immediately goes to ACTIVE CommandContextUtil.getAgenda(commandContext).planActivatePlanItemInstanceOperation(newPlanItemInstanceEntity, null); } } removeSentryRelatedData(); }
protected PlanItemInstanceEntity deleteParentPlanItemInstances(String parentId, List<PlanItemMoveEntry> moveToPlanItemMoveEntries, Set<String> planItemInstanceIdsNotToDelete, CommandContext commandContext) { PlanItemInstanceEntityManager planItemInstanceEntityManager = CommandContextUtil.getPlanItemInstanceEntityManager(commandContext); PlanItemInstanceEntity parentPlanItemInstance = null; if (parentId != null) { parentPlanItemInstance = planItemInstanceEntityManager.findById(parentId); } if (parentPlanItemInstance != null && parentPlanItemInstance.isStage()) { Stage parentStage = (Stage) parentPlanItemInstance.getPlanItem().getPlanItemDefinition(); if (!isStageAncestorOfAnyNewPlanItemDefinitions(parentStage.getId(), moveToPlanItemMoveEntries)) { PlanItemInstanceEntity toDeleteParentExecution = resolveParentPlanItemInstanceToDelete(parentPlanItemInstance, moveToPlanItemMoveEntries); PlanItemInstanceEntity finalDeleteExecution = null; if (toDeleteParentExecution != null) { finalDeleteExecution = toDeleteParentExecution; } else { finalDeleteExecution = parentPlanItemInstance; } parentPlanItemInstance = finalDeleteExecution.getStagePlanItemInstanceEntity(); CmmnEngineConfiguration cmmnEngineConfiguration = CommandContextUtil.getCmmnEngineConfiguration(commandContext); Date currentTime = cmmnEngineConfiguration.getClock().getCurrentTime(); finalDeleteExecution.setEndedTime(currentTime); finalDeleteExecution.setTerminatedTime(currentTime); finalDeleteExecution.setState(PlanItemInstanceState.TERMINATED); } } return parentPlanItemInstance; }