Examples with StepDefinition org.activiti.workflow.simple.definition.StepDefinition used on opensource projects

Example 1 with StepDefinition

use of org.activiti.workflow.simple.definition.StepDefinition in project Activiti by Activiti.

the class ChoiceStepsDefinitionConverter method createProcessArtifact.

protected ExclusiveGateway createProcessArtifact(ChoiceStepsDefinition choiceStepsDefinition, WorkflowDefinitionConversion conversion) {
    // First choice gateway
    ExclusiveGateway forkGateway = createExclusiveGateway(conversion);
    // Sequence flow from last activity to first gateway
    addSequenceFlow(conversion, conversion.getLastActivityId(), forkGateway.getId());
    conversion.setLastActivityId(forkGateway.getId());
    // Convert all other steps, disabling activity id updates which makes all 
    // generated steps have a sequence flow to the first gateway
    WorkflowDefinitionConversionFactory conversionFactory = conversion.getConversionFactory();
    List<FlowElement> endElements = new ArrayList<FlowElement>();
    List<SequenceFlow> bypassingFlows = new ArrayList<SequenceFlow>();
    for (ListConditionStepDefinition<ChoiceStepsDefinition> stepListDefinition : choiceStepsDefinition.getStepList()) {
        StringBuilder conditionBuilder = new StringBuilder();
        for (ConditionDefinition conditionDefintion : stepListDefinition.getConditions()) {
            if (conditionBuilder.length() > 0) {
                conditionBuilder.append(" && ");
            } else {
                conditionBuilder.append("${");
            }
            conditionBuilder.append(conditionDefintion.getLeftOperand());
            conditionBuilder.append(" ");
            conditionBuilder.append(conditionDefintion.getOperator());
            conditionBuilder.append(" ");
            conditionBuilder.append(conditionDefintion.getRightOperand());
        }
        for (int i = 0; i < stepListDefinition.getSteps().size(); i++) {
            if (i == 0) {
                conversion.setSequenceflowGenerationEnabled(false);
            } else {
                conversion.setSequenceflowGenerationEnabled(true);
            }
            StepDefinition step = stepListDefinition.getSteps().get(i);
            FlowElement flowElement = (FlowElement) conversionFactory.getStepConverterFor(step).convertStepDefinition(step, conversion);
            if (i == 0) {
                if (conditionBuilder.length() > 0) {
                    conditionBuilder.append("}");
                    SequenceFlow mainFlow = addSequenceFlow(conversion, forkGateway.getId(), flowElement.getId(), conditionBuilder.toString());
                    if (stepListDefinition.getName() != null) {
                        mainFlow.setName(stepListDefinition.getName());
                    }
                } else {
                    addSequenceFlow(conversion, forkGateway.getId(), flowElement.getId());
                }
            }
            if ((i + 1) == stepListDefinition.getSteps().size()) {
                endElements.add(flowElement);
            }
        }
        if (stepListDefinition.getSteps().isEmpty()) {
            // Special case for a "stepless" stepListDefinition, which should just create a sequence-flow from the fork to the join
            SequenceFlow created = null;
            if (conditionBuilder.length() > 0) {
                conditionBuilder.append("}");
                created = addSequenceFlow(conversion, forkGateway.getId(), null, conditionBuilder.toString());
            } else {
                created = addSequenceFlow(conversion, forkGateway.getId(), null);
            }
            if (stepListDefinition.getName() != null) {
                created.setName(stepListDefinition.getName());
            }
            bypassingFlows.add(created);
        }
    }
    conversion.setSequenceflowGenerationEnabled(false);
    // Second choice gateway
    ExclusiveGateway joinGateway = createExclusiveGateway(conversion);
    conversion.setLastActivityId(joinGateway.getId());
    conversion.setSequenceflowGenerationEnabled(true);
    // Create sequenceflow from all generated steps to the second gateway
    for (FlowElement endElement : endElements) {
        if (!(endElement instanceof EndEvent)) {
            addSequenceFlow(conversion, endElement.getId(), joinGateway.getId());
        }
    }
    for (SequenceFlow bypassingFlow : bypassingFlows) {
        bypassingFlow.setTargetRef(joinGateway.getId());
    }
    return forkGateway;
}

Example 2 with StepDefinition

use of org.activiti.workflow.simple.definition.StepDefinition in project Activiti by Activiti.

the class JsonConverterTest method testHumanStepConversion.

@Test
public void testHumanStepConversion() {
    WorkflowDefinition workflowDefinition = new WorkflowDefinition().name("testWorkflow").addHumanStep("step1", "fred").addHumanStepForGroup("step2", Collections.singletonList("group")).addHumanStepForWorkflowInitiator("step3");
    // Add form to last step
    HumanStepDefinition stepWithForm = new HumanStepDefinition();
    stepWithForm.setName("step4");
    stepWithForm.setDescription("Step description");
    workflowDefinition.getSteps().add(stepWithForm);
    FormDefinition formDefinition = new FormDefinition();
    stepWithForm.setForm(formDefinition);
    formDefinition.setFormKey("123");
    TextPropertyDefinition textProp = new TextPropertyDefinition();
    textProp.setMandatory(true);
    textProp.setName("textProp");
    textProp.setWritable(false);
    formDefinition.addFormProperty(textProp);
    textProp.getParameters().put("custom-parameter", "This is a test");
    NumberPropertyDefinition numberProp = new NumberPropertyDefinition();
    numberProp.setMandatory(true);
    numberProp.setName("numberProp");
    numberProp.setWritable(false);
    formDefinition.addFormProperty(numberProp);
    ReferencePropertyDefinition reference = new ReferencePropertyDefinition();
    reference.setMandatory(true);
    reference.setName("referenceProp");
    reference.setWritable(false);
    reference.setType("referencedType");
    formDefinition.addFormProperty(reference);
    ListPropertyDefinition itemType = new ListPropertyDefinition();
    itemType.setMandatory(true);
    itemType.setName("referenceProp");
    itemType.setWritable(false);
    itemType.addEntry(new ListPropertyEntry("1", "Item 1"));
    itemType.addEntry(new ListPropertyEntry("2", "Item 2"));
    formDefinition.addFormProperty(itemType);
    // Write result to byte-array
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    Writer writer = new OutputStreamWriter(baos);
    converter.writeWorkflowDefinition(workflowDefinition, writer);
    // Parse definition based on written JSON
    WorkflowDefinition parsedDefinition = converter.readWorkflowDefinition(baos.toByteArray());
    assertEquals(workflowDefinition.getSteps().size(), parsedDefinition.getSteps().size());
    int index = 0;
    for (StepDefinition stepDefinition : parsedDefinition.getSteps()) {
        assertTrue(stepDefinition instanceof HumanStepDefinition);
        HumanStepDefinition humanStep = (HumanStepDefinition) stepDefinition;
        HumanStepDefinition originalStep = (HumanStepDefinition) workflowDefinition.getSteps().get(index);
        // Check general human-step fields
        assertEquals(originalStep.getAssignee(), humanStep.getAssignee());
        assertEquals(originalStep.getAssignmentType(), humanStep.getAssignmentType());
        assertEquals(originalStep.getCandidateGroups(), humanStep.getCandidateGroups());
        assertEquals(originalStep.getCandidateUsers(), humanStep.getCandidateUsers());
        assertEquals(originalStep.getName(), humanStep.getName());
        assertEquals(originalStep.getDescription(), humanStep.getDescription());
        if (originalStep.getForm() != null) {
            // Encountered step with form attached to it, should be last step
            assertEquals(3, index);
            assertEquals("123", humanStep.getForm().getFormKey());
            assertEquals(originalStep.getForm().getFormPropertyDefinitions().size(), humanStep.getForm().getFormPropertyDefinitions().size());
            // Check form-fields, generic fields
            for (int i = 0; i < originalStep.getForm().getFormPropertyDefinitions().size(); i++) {
                FormPropertyDefinition origDef = originalStep.getForm().getFormPropertyDefinitions().get(i);
                FormPropertyDefinition parsedDef = humanStep.getForm().getFormPropertyDefinitions().get(i);
                assertEquals(origDef.getName(), parsedDef.getName());
                assertEquals(origDef.isMandatory(), parsedDef.isMandatory());
                assertEquals(origDef.isWritable(), parsedDef.isWritable());
                assertEquals(origDef.getClass(), parsedDef.getClass());
                if (parsedDef instanceof TextPropertyDefinition) {
                    assertTrue(parsedDef.getParameters() != null);
                    assertEquals(1L, parsedDef.getParameters().size());
                    assertEquals("This is a test", parsedDef.getParameters().get("custom-parameter"));
                }
                if (parsedDef instanceof ListPropertyDefinition) {
                    ListPropertyDefinition parsed = (ListPropertyDefinition) parsedDef;
                    assertEquals(2L, parsed.getEntries().size());
                }
            }
        }
        index++;
    }
}

Example 3 with StepDefinition

use of org.activiti.workflow.simple.definition.StepDefinition in project Activiti by Activiti.

the class SimpleTableEditor method loadTaskRows.

protected void loadTaskRows(StepDefinitionContainer<?> container, TaskTable taskTable) {
    for (StepDefinition stepDefinition : container.getSteps()) {
        if (stepDefinition instanceof HumanStepDefinition) {
            HumanStepDefinition humanStepDefinition = (HumanStepDefinition) stepDefinition;
            taskTable.addTaskRow(humanStepDefinition);
        } else if (stepDefinition instanceof StepDefinitionContainer<?>) {
            loadTaskRows((StepDefinitionContainer<?>) stepDefinition, taskTable);
        }
    }
}

Example 4 with StepDefinition

use of org.activiti.workflow.simple.definition.StepDefinition in project Activiti by Activiti.

the class AlfrescoReviewStepConverter method createProcessArtifact.

@Override
protected FlowElement createProcessArtifact(AlfrescoReviewStepDefinition stepDefinition, WorkflowDefinitionConversion conversion) {
    FlowElement lastElement;
    M2Model model = AlfrescoConversionUtil.getContentModel(conversion);
    String namespacePrefix = model.getNamespaces().get(0).getPrefix();
    String id = stepDefinition.getId();
    if (id == null) {
        id = AlfrescoConversionUtil.getValidIdString(stepDefinition.getName());
    }
    // Break down the review into separate steps and convert those instead
    HumanStepDefinition reviewTask = new HumanStepDefinition();
    reviewTask.setName(stepDefinition.getName());
    reviewTask.setDescription("Review task");
    // Clone the review-form and add custom transitions property
    FormDefinition finalForm = null;
    if (stepDefinition.getForm() != null) {
        finalForm = stepDefinition.getForm().clone();
    } else {
        finalForm = new FormDefinition();
    }
    finalForm.addFormProperty(createTransitionsProperty());
    reviewTask.setForm(finalForm);
    // Assignment
    if (stepDefinition.getAssignmentType() == HumanStepAssignmentType.USER) {
        reviewTask.setAssignee(new PropertyReference(stepDefinition.getAssignmentPropertyName()).getPlaceholder());
    }
    // Add a script-task that initializes the correct variables for the review
    ScriptServiceTaskBuilder builder = new ScriptServiceTaskBuilder();
    builder.setExecutionVariable(getCountVariableName(id, namespacePrefix), "0");
    String requiredCount = null;
    if (stepDefinition.getRequiredApprovalCount() != null) {
        if (PropertyReference.isPropertyReference(stepDefinition.getRequiredApprovalCount())) {
            PropertyReference reference = PropertyReference.createReference(stepDefinition.getRequiredApprovalCount());
            requiredCount = reference.getVariableReference(namespacePrefix);
            AlfrescoConversionUtil.getPropertyReferences(conversion).add(reference);
        } else {
            // No reference, use explicit value
            requiredCount = stepDefinition.getRequiredApprovalCount();
        }
    } else {
        requiredCount = "1";
    }
    builder.setExecutionVariable(getRequiredCountVariableName(id, namespacePrefix), requiredCount);
    ServiceTask serviceTask = builder.build();
    serviceTask.setName("Review initialization");
    serviceTask.setId(conversion.getUniqueNumberedId(ConversionConstants.SERVICE_TASK_ID_PREFIX));
    addFlowElement(conversion, serviceTask, true);
    // Create the actual element
    UserTask userTask = (UserTask) conversion.getConversionFactory().getStepConverterFor(reviewTask).convertStepDefinition(reviewTask, conversion);
    lastElement = userTask;
    M2Type userTaskType = model.getType(userTask.getFormKey());
    // Update parent, since we use an "outcome" for this task
    userTaskType.setParentName(AlfrescoConversionConstants.OUTCOME_BASE_FORM_TYPE);
    // Add script to the complete-task listener to update approval count (if needed)
    ScriptTaskListenerBuilder listenerBuilder = AlfrescoConversionUtil.getScriptTaskListenerBuilder(conversion, userTask.getId(), AlfrescoConversionConstants.TASK_LISTENER_EVENT_COMPLETE);
    String approverCount = getCountVariableName(id, namespacePrefix);
    listenerBuilder.addLine("if(task.getVariableLocal('" + getTransitionProperty(userTaskType, namespacePrefix) + "') == '" + AlfrescoConversionConstants.TRANSITION_APPROVE + "') {");
    listenerBuilder.addLine("execution.setVariable('" + approverCount + "', " + approverCount + " + 1);");
    listenerBuilder.addLine("}");
    if (stepDefinition.getAssignmentType() == HumanStepAssignmentType.USERS) {
        String assignmentVariableName = id + "Assignee";
        // Add the assignee-property to the content-model
        M2ClassAssociation reviewAssignee = new M2ClassAssociation();
        M2AssociationTarget target = new M2AssociationTarget();
        target.setClassName(AlfrescoConversionConstants.CONTENT_TYPE_PEOPLE);
        target.setMandatory(true);
        target.setMany(false);
        M2AssociationSource source = new M2AssociationSource();
        source.setMany(false);
        source.setMandatory(true);
        reviewAssignee.setName(AlfrescoConversionUtil.getQualifiedName(namespacePrefix, assignmentVariableName));
        reviewAssignee.setTarget(target);
        reviewAssignee.setSource(source);
        userTaskType.getAssociations().add(reviewAssignee);
        userTask.setAssignee(new PropertyReference(assignmentVariableName).getUsernameReferenceExpression(namespacePrefix));
        // Finally, add the multi-instance characteristics to the userTask
        MultiInstanceLoopCharacteristics mi = new MultiInstanceLoopCharacteristics();
        mi.setCompletionCondition(getCompletionCondition(id, namespacePrefix));
        mi.setElementVariable(new PropertyReference(assignmentVariableName).getVariableReference(namespacePrefix));
        PropertyReference reference = null;
        if (PropertyReference.isPropertyReference(stepDefinition.getAssignmentPropertyName())) {
            reference = PropertyReference.createReference(stepDefinition.getAssignmentPropertyName());
        } else {
            reference = new PropertyReference(stepDefinition.getAssignmentPropertyName());
        }
        mi.setInputDataItem(reference.getVariableReference(namespacePrefix));
        AlfrescoConversionUtil.getPropertyReferences(conversion).add(reference);
        mi.setSequential(false);
        userTask.setLoopCharacteristics(mi);
    }
    if (stepDefinition.getRejectionSteps() != null) {
        // Create choice-step
        ChoiceStepsDefinition choice = new ChoiceStepsDefinition();
        choice.setId(id + "choice");
        // Add rejection steps to the choice
        ListConditionStepDefinition<ChoiceStepsDefinition> rejectStepList = new ListConditionStepDefinition<ChoiceStepsDefinition>();
        rejectStepList.setName("Rejected");
        for (StepDefinition child : stepDefinition.getRejectionSteps()) {
            rejectStepList.addStep(child);
        }
        // Add end-process step to reject path, if needed
        if (stepDefinition.isEndProcessOnReject()) {
            rejectStepList.addStep(new AlfrescoEndProcessStepDefinition());
        }
        // Make choice condition based on review outcome
        ConditionDefinition condition = new ConditionDefinition();
        condition.setLeftOperand(getCountVariableName(id, namespacePrefix));
        condition.setOperator("<");
        condition.setRightOperand(getRequiredCountVariableName(id, namespacePrefix));
        rejectStepList.setConditions(Arrays.asList(condition));
        choice.addStepList(rejectStepList);
        // Add default (empty) choice for approval AFTER the review-one
        ListConditionStepDefinition<ChoiceStepsDefinition> defaultStepList = new ListConditionStepDefinition<ChoiceStepsDefinition>();
        defaultStepList.setName("Approved");
        choice.addStepList(defaultStepList);
        // Convert the choice-step
        lastElement = (FlowElement) conversion.getConversionFactory().getStepConverterFor(choice).convertStepDefinition(choice, conversion);
    }
    return lastElement;
}

Example 5 with StepDefinition

use of org.activiti.workflow.simple.definition.StepDefinition in project Activiti by Activiti.

the class ParallelStepsDefinitionConverter method createProcessArtifact.

protected ParallelGateway createProcessArtifact(ParallelStepsDefinition parallelStepsDefinition, WorkflowDefinitionConversion conversion) {
    // First parallel gateway
    ParallelGateway forkGateway = createParallelGateway(conversion);
    // Sequence flow from last activity to first gateway
    addSequenceFlow(conversion, conversion.getLastActivityId(), forkGateway.getId());
    conversion.setLastActivityId(forkGateway.getId());
    // Convert all other steps, disabling activity id updates which makes all 
    // generated steps have a sequence flow to the first gateway
    WorkflowDefinitionConversionFactory conversionFactory = conversion.getConversionFactory();
    List<FlowElement> endElements = new ArrayList<FlowElement>();
    for (ListStepDefinition<ParallelStepsDefinition> stepListDefinition : parallelStepsDefinition.getStepList()) {
        for (int i = 0; i < stepListDefinition.getSteps().size(); i++) {
            if (i == 0) {
                conversion.setSequenceflowGenerationEnabled(false);
            } else {
                conversion.setSequenceflowGenerationEnabled(true);
            }
            StepDefinition step = stepListDefinition.getSteps().get(i);
            FlowElement flowElement = (FlowElement) conversionFactory.getStepConverterFor(step).convertStepDefinition(step, conversion);
            if (i == 0) {
                addSequenceFlow(conversion, forkGateway.getId(), flowElement.getId());
            }
            if ((i + 1) == stepListDefinition.getSteps().size()) {
                endElements.add(flowElement);
            }
        }
    }
    conversion.setSequenceflowGenerationEnabled(false);
    // Second parallel gateway
    ParallelGateway joinGateway = createParallelGateway(conversion);
    conversion.setLastActivityId(joinGateway.getId());
    conversion.setSequenceflowGenerationEnabled(true);
    // Create sequence flow from all generated steps to the second gateway
    for (FlowElement endElement : endElements) {
        addSequenceFlow(conversion, endElement.getId(), joinGateway.getId());
    }
    return forkGateway;
}