Examples with CallActivityBehavior org.activiti.engine.impl.bpmn.behavior.CallActivityBehavior used on opensource projects

Example 1 with CallActivityBehavior

use of org.activiti.engine.impl.bpmn.behavior.CallActivityBehavior in project alfresco-repository by Alfresco.

the class AlfrescoCallActivityBpmnParseHandler method executeParse.

protected void executeParse(BpmnParse bpmnParse, CallActivity callActivity) {
    if (multiTenancyEnabled && tenantService.isEnabled()) {
        ActivityImpl activity = findActivity(bpmnParse, callActivity.getId());
        ActivityBehavior activityBehavior = activity.getActivityBehavior();
        if (activityBehavior instanceof CallActivityBehavior) {
            CallActivityBehavior callActivityBehavior = (CallActivityBehavior) activityBehavior;
            // Make name of process-definition to be called aware of the current tenant
            callActivityBehavior.setProcessDefinitonKey(tenantService.getName(callActivityBehavior.getProcessDefinitonKey()));
        }
    }
}

Example 2 with CallActivityBehavior

use of org.activiti.engine.impl.bpmn.behavior.CallActivityBehavior in project Activiti by Activiti.

the class BaseProcessDefinitionDiagramLayoutResource method getActivity.

private void getActivity(String processInstanceId, ActivityImpl activity, ArrayNode activityArray, ArrayNode sequenceFlowArray, ProcessInstance processInstance, List<String> highLightedFlows, Map<String, ObjectNode> subProcessInstanceMap) {
    ObjectNode activityJSON = new ObjectMapper().createObjectNode();
    // Gather info on the multi instance marker
    String multiInstance = (String) activity.getProperty("multiInstance");
    if (multiInstance != null) {
        if (!"sequential".equals(multiInstance)) {
            multiInstance = "parallel";
        }
    }
    ActivityBehavior activityBehavior = activity.getActivityBehavior();
    // Gather info on the collapsed marker
    Boolean collapsed = (activityBehavior instanceof CallActivityBehavior);
    Boolean expanded = (Boolean) activity.getProperty(BpmnParse.PROPERTYNAME_ISEXPANDED);
    if (expanded != null) {
        collapsed = !expanded;
    }
    Boolean isInterrupting = null;
    if (activityBehavior instanceof BoundaryEventActivityBehavior) {
        isInterrupting = ((BoundaryEventActivityBehavior) activityBehavior).isInterrupting();
    }
    // Outgoing transitions of activity
    for (PvmTransition sequenceFlow : activity.getOutgoingTransitions()) {
        String flowName = (String) sequenceFlow.getProperty("name");
        boolean isHighLighted = (highLightedFlows.contains(sequenceFlow.getId()));
        boolean isConditional = sequenceFlow.getProperty(BpmnParse.PROPERTYNAME_CONDITION) != null && !((String) activity.getProperty("type")).toLowerCase().contains("gateway");
        boolean isDefault = sequenceFlow.getId().equals(activity.getProperty("default")) && ((String) activity.getProperty("type")).toLowerCase().contains("gateway");
        List<Integer> waypoints = ((TransitionImpl) sequenceFlow).getWaypoints();
        ArrayNode xPointArray = new ObjectMapper().createArrayNode();
        ArrayNode yPointArray = new ObjectMapper().createArrayNode();
        for (int i = 0; i < waypoints.size(); i += 2) {
            // waypoints.size()
            // minimally 4: x1, y1,
            // x2, y2
            xPointArray.add(waypoints.get(i));
            yPointArray.add(waypoints.get(i + 1));
        }
        ObjectNode flowJSON = new ObjectMapper().createObjectNode();
        flowJSON.put("id", sequenceFlow.getId());
        flowJSON.put("name", flowName);
        flowJSON.put("flow", "(" + sequenceFlow.getSource().getId() + ")--" + sequenceFlow.getId() + "-->(" + sequenceFlow.getDestination().getId() + ")");
        if (isConditional)
            flowJSON.put("isConditional", isConditional);
        if (isDefault)
            flowJSON.put("isDefault", isDefault);
        if (isHighLighted)
            flowJSON.put("isHighLighted", isHighLighted);
        flowJSON.put("xPointArray", xPointArray);
        flowJSON.put("yPointArray", yPointArray);
        sequenceFlowArray.add(flowJSON);
    }
    // Nested activities (boundary events)
    ArrayNode nestedActivityArray = new ObjectMapper().createArrayNode();
    for (ActivityImpl nestedActivity : activity.getActivities()) {
        nestedActivityArray.add(nestedActivity.getId());
    }
    Map<String, Object> properties = activity.getProperties();
    ObjectNode propertiesJSON = new ObjectMapper().createObjectNode();
    for (String key : properties.keySet()) {
        Object prop = properties.get(key);
        if (prop instanceof String)
            propertiesJSON.put(key, (String) properties.get(key));
        else if (prop instanceof Integer)
            propertiesJSON.put(key, (Integer) properties.get(key));
        else if (prop instanceof Boolean)
            propertiesJSON.put(key, (Boolean) properties.get(key));
        else if ("initial".equals(key)) {
            ActivityImpl act = (ActivityImpl) properties.get(key);
            propertiesJSON.put(key, act.getId());
        } else if ("timerDeclarations".equals(key)) {
            ArrayList<TimerDeclarationImpl> timerDeclarations = (ArrayList<TimerDeclarationImpl>) properties.get(key);
            ArrayNode timerDeclarationArray = new ObjectMapper().createArrayNode();
            if (timerDeclarations != null)
                for (TimerDeclarationImpl timerDeclaration : timerDeclarations) {
                    ObjectNode timerDeclarationJSON = new ObjectMapper().createObjectNode();
                    timerDeclarationJSON.put("isExclusive", timerDeclaration.isExclusive());
                    if (timerDeclaration.getRepeat() != null)
                        timerDeclarationJSON.put("repeat", timerDeclaration.getRepeat());
                    timerDeclarationJSON.put("retries", String.valueOf(timerDeclaration.getRetries()));
                    timerDeclarationJSON.put("type", timerDeclaration.getJobHandlerType());
                    timerDeclarationJSON.put("configuration", timerDeclaration.getJobHandlerConfiguration());
                    //timerDeclarationJSON.put("expression", timerDeclaration.getDescription());
                    timerDeclarationArray.add(timerDeclarationJSON);
                }
            if (timerDeclarationArray.size() > 0)
                propertiesJSON.put(key, timerDeclarationArray);
        // TODO: implement getting description
        } else if ("eventDefinitions".equals(key)) {
            ArrayList<EventSubscriptionDeclaration> eventDefinitions = (ArrayList<EventSubscriptionDeclaration>) properties.get(key);
            ArrayNode eventDefinitionsArray = new ObjectMapper().createArrayNode();
            if (eventDefinitions != null) {
                for (EventSubscriptionDeclaration eventDefinition : eventDefinitions) {
                    ObjectNode eventDefinitionJSON = new ObjectMapper().createObjectNode();
                    if (eventDefinition.getActivityId() != null)
                        eventDefinitionJSON.put("activityId", eventDefinition.getActivityId());
                    eventDefinitionJSON.put("eventName", eventDefinition.getEventName());
                    eventDefinitionJSON.put("eventType", eventDefinition.getEventType());
                    eventDefinitionJSON.put("isAsync", eventDefinition.isAsync());
                    eventDefinitionJSON.put("isStartEvent", eventDefinition.isStartEvent());
                    eventDefinitionsArray.add(eventDefinitionJSON);
                }
            }
            if (eventDefinitionsArray.size() > 0)
                propertiesJSON.put(key, eventDefinitionsArray);
        // TODO: implement it
        } else if ("errorEventDefinitions".equals(key)) {
            ArrayList<ErrorEventDefinition> errorEventDefinitions = (ArrayList<ErrorEventDefinition>) properties.get(key);
            ArrayNode errorEventDefinitionsArray = new ObjectMapper().createArrayNode();
            if (errorEventDefinitions != null) {
                for (ErrorEventDefinition errorEventDefinition : errorEventDefinitions) {
                    ObjectNode errorEventDefinitionJSON = new ObjectMapper().createObjectNode();
                    if (errorEventDefinition.getErrorCode() != null)
                        errorEventDefinitionJSON.put("errorCode", errorEventDefinition.getErrorCode());
                    else
                        errorEventDefinitionJSON.putNull("errorCode");
                    errorEventDefinitionJSON.put("handlerActivityId", errorEventDefinition.getHandlerActivityId());
                    errorEventDefinitionsArray.add(errorEventDefinitionJSON);
                }
            }
            if (errorEventDefinitionsArray.size() > 0)
                propertiesJSON.put(key, errorEventDefinitionsArray);
        }
    }
    if ("callActivity".equals(properties.get("type"))) {
        CallActivityBehavior callActivityBehavior = null;
        if (activityBehavior instanceof CallActivityBehavior) {
            callActivityBehavior = (CallActivityBehavior) activityBehavior;
        }
        if (callActivityBehavior != null) {
            propertiesJSON.put("processDefinitonKey", callActivityBehavior.getProcessDefinitonKey());
            // get processDefinitonId from execution or get last processDefinitonId
            // by key
            ArrayNode processInstanceArray = new ObjectMapper().createArrayNode();
            if (processInstance != null) {
                List<Execution> executionList = runtimeService.createExecutionQuery().processInstanceId(processInstanceId).activityId(activity.getId()).list();
                if (!executionList.isEmpty()) {
                    for (Execution execution : executionList) {
                        ObjectNode processInstanceJSON = subProcessInstanceMap.get(execution.getId());
                        processInstanceArray.add(processInstanceJSON);
                    }
                }
            }
            // last definition
            if (processInstanceArray.size() == 0 && StringUtils.isNotEmpty(callActivityBehavior.getProcessDefinitonKey())) {
                // Get last definition by key
                ProcessDefinition lastProcessDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionKey(callActivityBehavior.getProcessDefinitonKey()).latestVersion().singleResult();
                // TODO: unuseful fields there are processDefinitionName, processDefinitionKey
                if (lastProcessDefinition != null) {
                    ObjectNode processInstanceJSON = new ObjectMapper().createObjectNode();
                    processInstanceJSON.put("processDefinitionId", lastProcessDefinition.getId());
                    processInstanceJSON.put("processDefinitionKey", lastProcessDefinition.getKey());
                    processInstanceJSON.put("processDefinitionName", lastProcessDefinition.getName());
                    processInstanceArray.add(processInstanceJSON);
                }
            }
            if (processInstanceArray.size() > 0) {
                propertiesJSON.put("processDefinitons", processInstanceArray);
            }
        }
    }
    activityJSON.put("activityId", activity.getId());
    activityJSON.put("properties", propertiesJSON);
    if (multiInstance != null)
        activityJSON.put("multiInstance", multiInstance);
    if (collapsed)
        activityJSON.put("collapsed", collapsed);
    if (nestedActivityArray.size() > 0)
        activityJSON.put("nestedActivities", nestedActivityArray);
    if (isInterrupting != null)
        activityJSON.put("isInterrupting", isInterrupting);
    activityJSON.put("x", activity.getX());
    activityJSON.put("y", activity.getY());
    activityJSON.put("width", activity.getWidth());
    activityJSON.put("height", activity.getHeight());
    activityArray.add(activityJSON);
    // Nested activities (boundary events)
    for (ActivityImpl nestedActivity : activity.getActivities()) {
        getActivity(processInstanceId, nestedActivity, activityArray, sequenceFlowArray, processInstance, highLightedFlows, subProcessInstanceMap);
    }
}

Example 3 with CallActivityBehavior

use of org.activiti.engine.impl.bpmn.behavior.CallActivityBehavior in project Activiti by Activiti.

the class DefaultActivityBehaviorFactory method createCallActivityBehavior.

// Call activity
public CallActivityBehavior createCallActivityBehavior(CallActivity callActivity) {
    String expressionRegex = "\\$+\\{+.+\\}";
    CallActivityBehavior callActivityBehaviour = null;
    if (StringUtils.isNotEmpty(callActivity.getCalledElement()) && callActivity.getCalledElement().matches(expressionRegex)) {
        callActivityBehaviour = createCallActivityBehavior(expressionManager.createExpression(callActivity.getCalledElement()), callActivity.getMapExceptions());
    } else {
        callActivityBehaviour = createCallActivityBehavior(callActivity.getCalledElement(), callActivity.getMapExceptions());
    }
    return callActivityBehaviour;
}