Examples with Stage org.camunda.bpm.model.cmmn.instance.Stage used on opensource projects

Example 1 with Stage

use of org.camunda.bpm.model.cmmn.instance.Stage in project camunda-bpm-platform by camunda.

the class CmmnTransformerTest method testActivityTreeWithOneStageAndNestedHumanTasks.

/**
 *   +-----------------+                                       +-----------------+
 *   | Case1            \                                      | aCaseDefinition |
 *   +-------------------+-----------------+                   +-----------------+
 *   |                                     |                            |
 *   |     +------------------------+      |                   +-----------------+
 *   |    / X                        \     |                   |  aCasePlanModel |
 *   |   +    +-------+  +-------+    +    |                   +-----------------+
 *   |   |    |   A   |  |   B   |    |    |  ==>                       |
 *   |   +    +-------+  +-------+    +    |                   +-----------------+
 *   |    \                          /     |                   |        X        |
 *   |     +------------------------+      |                   +-----------------+
 *   |                                     |                           / \
 *   +-------------------------------------+                          /   \
 *                                                 +-----------------+     +-----------------+
 *                                                 |        A        |     |        B        |
 *                                                 +-----------------+     +-----------------+
 */
@Test
public void testActivityTreeWithOneStageAndNestedHumanTasks() {
    // given
    Stage stage = createElement(casePlanModel, "X", Stage.class);
    HumanTask humanTaskA = createElement(casePlanModel, "A", HumanTask.class);
    HumanTask humanTaskB = createElement(casePlanModel, "B", HumanTask.class);
    PlanItem planItemX = createElement(casePlanModel, "PI_X", PlanItem.class);
    PlanItem planItemA = createElement(stage, "PI_A", PlanItem.class);
    PlanItem planItemB = createElement(stage, "PI_B", PlanItem.class);
    planItemX.setDefinition(stage);
    planItemA.setDefinition(humanTaskA);
    planItemB.setDefinition(humanTaskB);
    // when
    List<CaseDefinitionEntity> caseDefinitions = transform();
    // then
    assertEquals(1, caseDefinitions.size());
    CaseDefinitionEntity caseDefinition = caseDefinitions.get(0);
    List<CmmnActivity> activities = caseDefinition.getActivities();
    CmmnActivity casePlanModelActivity = activities.get(0);
    List<CmmnActivity> children = casePlanModelActivity.getActivities();
    assertEquals(1, children.size());
    CmmnActivity planItemStage = children.get(0);
    assertEquals(planItemX.getId(), planItemStage.getId());
    children = planItemStage.getActivities();
    assertEquals(2, children.size());
    CmmnActivity childPlanItem = children.get(0);
    assertEquals(planItemA.getId(), childPlanItem.getId());
    assertTrue(childPlanItem.getActivities().isEmpty());
    childPlanItem = children.get(1);
    assertEquals(planItemB.getId(), childPlanItem.getId());
    assertTrue(childPlanItem.getActivities().isEmpty());
}

Example 2 with Stage

use of org.camunda.bpm.model.cmmn.instance.Stage in project camunda-bpm-platform by camunda.

the class StageItemHandler method initializeAutoComplete.

protected void initializeAutoComplete(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context) {
    PlanItemDefinition definition = getDefinition(element);
    if (definition instanceof Stage) {
        Stage stage = (Stage) definition;
        activity.setProperty(PROPERTY_AUTO_COMPLETE, stage.isAutoComplete());
    }
}

Example 3 with Stage

use of org.camunda.bpm.model.cmmn.instance.Stage in project camunda-bpm-platform by camunda.

the class CmmnTransformerTest method testNestedStages.

/**
 *   +-----------------+                                                    +-----------------+
 *   | Case1            \                                                   | aCaseDefinition |
 *   +-------------------+-------------------+                              +-----------------+
 *   |                                       |                                       |
 *   |  +-------+                            |                              +-----------------+
 *   |  |  A1   |                            |              +---------------|  aCasePlanModel |---------------+
 *   |  +-------+                            |              |               +-----------------+               |
 *   |                                       |              |                        |                        |
 *   |    +------------------------+         |      +-----------------+     +-----------------+      +-----------------+
 *   |   / X1                       \        |      |       A1        |     |        X1       |      |        Y        |-----------+
 *   |  +    +-------+  +-------+    +       |      +-----------------+     +-----------------+      +-----------------+           |
 *   |  |    |  A2   |  |   B   |    |       |                                      / \                                           / \
 *   |  +    +-------+  +-------+    +       |                                     /   \                                         /   \
 *   |   \                          /        |                    +---------------+     +---------------+     +-----------------+     +-----------------+
 *   |    +------------------------+         |                    |      A2       |     |      B        |     |        C        |     |       X2        |
 *   |                                       |                    +---------------+     +---------------+     +-----------------+     +-----------------+
 *   |    +-----------------------------+    |  ==>                                                                                          / \
 *   |   / Y                             \   |                                                                              +---------------+   +---------------+
 *   |  +    +-------+                    +  |                                                                              |      A1       |   |       B       |
 *   |  |    |   C   |                    |  |                                                                              +---------------+   +---------------+
 *   |  |    +-------+                    |  |
 *   |  |                                 |  |
 *   |  |   +------------------------+    |  |
 *   |  |  / X2                       \   |  |
 *   |  | +    +-------+  +-------+    +  |  |
 *   |  | |    |  A1   |  |   B   |    |  |  |
 *   |  | +    +-------+  +-------+    +  |  |
 *   |  |  \                          /   |  |
 *   |  +   +------------------------+    +  |
 *   |   \                               /   |
 *   |    +-----------------------------+    |
 *   |                                       |
 *   +---------------------------------------+
 */
@Test
public void testNestedStages() {
    // given
    Stage stageX = createElement(casePlanModel, "X", Stage.class);
    Stage stageY = createElement(casePlanModel, "Y", Stage.class);
    HumanTask humanTaskA = createElement(casePlanModel, "A", HumanTask.class);
    HumanTask humanTaskB = createElement(casePlanModel, "B", HumanTask.class);
    HumanTask humanTaskC = createElement(casePlanModel, "C", HumanTask.class);
    PlanItem planItemA1 = createElement(casePlanModel, "PI_A1", PlanItem.class);
    planItemA1.setDefinition(humanTaskA);
    PlanItem planItemX1 = createElement(casePlanModel, "PI_X1", PlanItem.class);
    planItemX1.setDefinition(stageX);
    PlanItem planItemA2 = createElement(stageX, "PI_A2", PlanItem.class);
    planItemA2.setDefinition(humanTaskA);
    PlanItem planItemB = createElement(stageX, "PI_B", PlanItem.class);
    planItemB.setDefinition(humanTaskB);
    PlanItem planItemY = createElement(casePlanModel, "PI_Y", PlanItem.class);
    planItemY.setDefinition(stageY);
    PlanItem planItemC = createElement(stageY, "PI_C", PlanItem.class);
    planItemC.setDefinition(humanTaskC);
    PlanItem planItemX2 = createElement(stageY, "PI_X2", PlanItem.class);
    planItemX2.setDefinition(stageX);
    // when
    List<CaseDefinitionEntity> caseDefinitions = transform();
    // then
    assertEquals(1, caseDefinitions.size());
    CaseDefinitionEntity caseDefinition = caseDefinitions.get(0);
    List<CmmnActivity> activities = caseDefinition.getActivities();
    CmmnActivity casePlanModelActivity = activities.get(0);
    List<CmmnActivity> children = casePlanModelActivity.getActivities();
    assertEquals(3, children.size());
    CmmnActivity childPlanItem = children.get(0);
    assertEquals(planItemA1.getId(), childPlanItem.getId());
    assertTrue(childPlanItem.getActivities().isEmpty());
    childPlanItem = children.get(1);
    assertEquals(planItemX1.getId(), childPlanItem.getId());
    List<CmmnActivity> childrenOfX1 = childPlanItem.getActivities();
    assertFalse(childrenOfX1.isEmpty());
    assertEquals(2, childrenOfX1.size());
    childPlanItem = childrenOfX1.get(0);
    assertEquals(planItemA2.getId(), childPlanItem.getId());
    assertTrue(childPlanItem.getActivities().isEmpty());
    childPlanItem = childrenOfX1.get(1);
    assertEquals(planItemB.getId(), childPlanItem.getId());
    assertTrue(childPlanItem.getActivities().isEmpty());
    childPlanItem = children.get(2);
    assertEquals(planItemY.getId(), childPlanItem.getId());
    List<CmmnActivity> childrenOfY = childPlanItem.getActivities();
    assertFalse(childrenOfY.isEmpty());
    assertEquals(2, childrenOfY.size());
    childPlanItem = childrenOfY.get(0);
    assertEquals(planItemC.getId(), childPlanItem.getId());
    assertTrue(childPlanItem.getActivities().isEmpty());
    childPlanItem = childrenOfY.get(1);
    assertEquals(planItemX2.getId(), childPlanItem.getId());
    List<CmmnActivity> childrenOfX2 = childPlanItem.getActivities();
    assertFalse(childrenOfX2.isEmpty());
    assertEquals(2, childrenOfX2.size());
    childPlanItem = childrenOfX2.get(0);
    assertEquals(planItemA2.getId(), childPlanItem.getId());
    assertTrue(childPlanItem.getActivities().isEmpty());
    childPlanItem = childrenOfX2.get(1);
    assertEquals(planItemB.getId(), childPlanItem.getId());
    assertTrue(childPlanItem.getActivities().isEmpty());
}

Example 4 with Stage

use of org.camunda.bpm.model.cmmn.instance.Stage in project camunda-bpm-platform by camunda.

the class CmmnTransform method transformPlanItem.

protected void transformPlanItem(PlanItem planItem, CmmnActivity parent) {
    PlanItemDefinition definition = planItem.getDefinition();
    ItemHandler planItemTransformer = null;
    if (definition instanceof HumanTask) {
        planItemTransformer = getPlanItemHandler(HumanTask.class);
    } else if (definition instanceof ProcessTask) {
        planItemTransformer = getPlanItemHandler(ProcessTask.class);
    } else if (definition instanceof CaseTask) {
        planItemTransformer = getPlanItemHandler(CaseTask.class);
    } else if (definition instanceof DecisionTask) {
        planItemTransformer = getPlanItemHandler(DecisionTask.class);
    } else if (definition instanceof Task) {
        planItemTransformer = getPlanItemHandler(Task.class);
    } else if (definition instanceof Stage) {
        planItemTransformer = getPlanItemHandler(Stage.class);
    } else if (definition instanceof Milestone) {
        planItemTransformer = getPlanItemHandler(Milestone.class);
    } else if (definition instanceof EventListener) {
        planItemTransformer = getPlanItemHandler(EventListener.class);
    }
    if (planItemTransformer != null) {
        CmmnActivity newActivity = planItemTransformer.handleElement(planItem, context);
        if (definition instanceof Stage) {
            Stage stage = (Stage) definition;
            transformStage(stage, newActivity);
            context.setParent(parent);
        } else if (definition instanceof HumanTask) {
            HumanTask humanTask = (HumanTask) definition;
            // According to the specification: A HumanTask can only contain
            // one planningTable, the XSD allows multiple planningTables!
            Collection<PlanningTable> planningTables = humanTask.getPlanningTables();
            for (PlanningTable planningTable : planningTables) {
                transformPlanningTable(planningTable, parent);
            }
        }
        for (CmmnTransformListener transformListener : transformListeners) {
            if (definition instanceof HumanTask) {
                transformListener.transformHumanTask(planItem, (HumanTask) definition, newActivity);
            } else if (definition instanceof ProcessTask) {
                transformListener.transformProcessTask(planItem, (ProcessTask) definition, newActivity);
            } else if (definition instanceof CaseTask) {
                transformListener.transformCaseTask(planItem, (CaseTask) definition, newActivity);
            } else if (definition instanceof DecisionTask) {
                transformListener.transformDecisionTask(planItem, (DecisionTask) definition, newActivity);
            } else if (definition instanceof Task) {
                transformListener.transformTask(planItem, (Task) definition, newActivity);
            } else if (definition instanceof Stage) {
                transformListener.transformStage(planItem, (Stage) definition, newActivity);
            } else if (definition instanceof Milestone) {
                transformListener.transformMilestone(planItem, (Milestone) definition, newActivity);
            } else if (definition instanceof EventListener) {
                transformListener.transformEventListener(planItem, (EventListener) definition, newActivity);
            }
        }
    }
}

Example 5 with Stage

use of org.camunda.bpm.model.cmmn.instance.Stage in project camunda-cmmn-model by camunda.

the class StageImpl method registerType.

public static void registerType(ModelBuilder modelBuilder) {
    ModelElementTypeBuilder typeBuilder = modelBuilder.defineType(Stage.class, CMMN_ELEMENT_STAGE).namespaceUri(CMMN11_NS).extendsType(PlanFragment.class).instanceProvider(new ModelTypeInstanceProvider<Stage>() {

        public Stage newInstance(ModelTypeInstanceContext instanceContext) {
            return new StageImpl(instanceContext);
        }
    });
    autoCompleteAttribute = typeBuilder.booleanAttribute(CMMN_ATTRIBUTE_AUTO_COMPLETE).defaultValue(false).build();
    exitCriteriaRefCollection = typeBuilder.stringAttribute(CMMN_ATTRIBUTE_EXIT_CRITERIA_REFS).namespace(CMMN10_NS).idAttributeReferenceCollection(Sentry.class, CmmnAttributeElementReferenceCollection.class).build();
    SequenceBuilder sequenceBuilder = typeBuilder.sequence();
    planningTableChild = sequenceBuilder.element(PlanningTable.class).build();
    planItemDefinitionCollection = sequenceBuilder.elementCollection(PlanItemDefinition.class).build();
    exitCriterionCollection = sequenceBuilder.elementCollection(ExitCriterion.class).build();
    typeBuilder.build();
}