public Function getEventFilterResolver()

in jbpm/jbpm-flow/src/main/java/org/jbpm/workflow/instance/impl/WorkflowProcessInstanceImpl.java [777:871]
91 lines of code
22 McCabe index (conditional complexity)

    public Function<String, Object> getEventFilterResolver(org.kie.api.runtime.process.NodeInstanceContainer container, org.kie.api.definition.process.Node node,
            List<org.kie.api.runtime.process.NodeInstance> currentView) {
        if (node instanceof DynamicNode) {
            // special handling for dynamic node to allow to resolve variables from individual node instances of the dynamic node
            // instead of just relying on process instance's variables
            return (varExpresion) -> {
                List<org.kie.api.runtime.process.NodeInstance> nodeInstances = getNodeInstances(node.getId(), currentView);
                if (nodeInstances != null && !nodeInstances.isEmpty()) {
                    StringBuilder st = new StringBuilder();
                    for (org.kie.api.runtime.process.NodeInstance ni : nodeInstances) {
                        Object result = resolveExpressionVariable(varExpresion, new NodeInstanceResolverFactory((NodeInstance) ni));
                        st.append(result).append("###");
                    }
                    return st.toString();
                } else {
                    NodeInstanceImpl instance = (NodeInstanceImpl) getNodeInstance(node.getId().toExternalFormat(), true);
                    if (instance != null) {
                        return instance.getVariable(varExpresion);
                    }
                    return null;
                }
            };
        } else if (node instanceof BoundaryEventNode) {
            return (varExpresion) -> {
                Function<String, Object> getScopedVariable;
                if (container instanceof CompositeContextNodeInstance) {
                    getScopedVariable = (name) -> getVariable(name, ((CompositeContextNodeInstance) container).getContextInstances(VariableScope.VARIABLE_SCOPE));
                } else if (container instanceof WorkflowProcessInstanceImpl) {
                    getScopedVariable = (name) -> ((WorkflowProcessInstanceImpl) container).getVariable(name);
                } else {
                    getScopedVariable = null;
                }
                Object value = getScopedVariable.apply(varExpresion);
                if (value != null) {
                    return value;
                }
                VariableResolverFactory resolverFactory = new ImmutableDefaultFactory() {
                    @Override
                    public boolean isResolveable(String varName) {
                        return getScopedVariable.apply(varName) != null;
                    }

                    @Override
                    public org.mvel2.integration.VariableResolver getVariableResolver(String varName) {
                        return new org.mvel2.integration.impl.SimpleValueResolver(getScopedVariable.apply(varName));
                    }
                };
                return resolveExpressionVariable(varExpresion, resolverFactory).orElse(null);
            };
        } else if (node instanceof ForEachNode) {
            return (varExpression) -> {
                try {
                    // for each can have multiple outcomes 1 per item of the list so it should be computed like that
                    ForEachNodeInstance forEachNodeInstance = (ForEachNodeInstance) getNodeInstanceByNodeId(node.getId(), true);
                    if (forEachNodeInstance == null) {
                        return new Object[0];
                    }
                    List<CompositeContextNodeInstance> data = forEachNodeInstance.getNodeInstances().stream().filter(e -> e instanceof CompositeContextNodeInstance)
                            .map(e -> (CompositeContextNodeInstance) e).collect(Collectors.toList());
                    List<Object> outcome = new ArrayList<>();
                    for (CompositeContextNodeInstance nodeInstance : data) {
                        Object resolvedValue = resolveExpressionVariable(varExpression, new NodeInstanceResolverFactory(nodeInstance)).orElse(null);
                        if (resolvedValue != null) {
                            outcome.add(resolvedValue);
                        }
                    }
                    return outcome.toArray();
                } catch (Throwable t) {
                    return new Object[0];
                }
            };
        } else if (node instanceof EventSubProcessNode || node instanceof StateNode) {
            return (varName) -> {
                return resolveExpressionVariable(varName, new ProcessInstanceResolverFactory(this)).orElse(null);
            };
        } else if (node instanceof CompositeContextNode) {
            return (varExpression) -> {
                List<org.kie.api.runtime.process.NodeInstance> nodeInstances = getNodeInstances(node.getId(), currentView);
                List<Object> outcome = new ArrayList<>();
                if (nodeInstances != null && !nodeInstances.isEmpty()) {
                    for (org.kie.api.runtime.process.NodeInstance nodeInstance : nodeInstances) {
                        Object resolvedValue = resolveExpressionVariable(varExpression, new NodeInstanceResolverFactory((NodeInstance) nodeInstance)).orElse(null);
                        if (resolvedValue != null) {
                            outcome.add(resolvedValue);
                        }
                    }
                }
                return outcome.toArray();
            };
        } else {
            return (varName) -> {
                return resolveExpressionVariable(varName, new ProcessInstanceResolverFactory(this)).orElse(null);
            };
        }
    }