[incubator-kie-issues-1136] Add script onEntry, on Exit for java (apa…

…che#3490)

* [incubator-kie-issues-1136] Add script onEntry, on Exit for java

jbpm/jbpm-bpmn2/src/main/java/org/jbpm/bpmn2/xml/GlobalHandler.java

@@ -18,13 +18,18 @@
  */
 package org.jbpm.bpmn2.xml;
 
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 
 import org.jbpm.compiler.xml.Handler;
 import org.jbpm.compiler.xml.Parser;
 import org.jbpm.compiler.xml.core.BaseAbstractHandler;
+import org.jbpm.process.core.context.variable.Variable;
+import org.jbpm.process.core.context.variable.VariableScope;
+import org.jbpm.process.core.datatype.DataTypeResolver;
 import org.jbpm.workflow.core.impl.WorkflowProcessImpl;
 import org.kie.api.definition.process.Process;
 import org.xml.sax.Attributes;
@@ -53,6 +58,7 @@ public Object start(final String uri,
 
         final String identifier = attrs.getValue("identifier");
         final String type = attrs.getValue("type");
+        process.addImports(Collections.singleton(type));
         emptyAttributeCheck(localName, "identifier", identifier, parser);
         emptyAttributeCheck(localName, "type", type, parser);
 
@@ -63,6 +69,21 @@ public Object start(final String uri,
         }
         map.put(identifier, type);
 
+        VariableScope variableScope = (VariableScope) process.getDefaultContext(VariableScope.VARIABLE_SCOPE);
+        List<Variable> variables = variableScope.getVariables();
+        Variable variable = new Variable();
+        variable.setId(identifier);
+        variable.setType(DataTypeResolver.fromType(type, parser.getClassLoader()));
+        // if name is given use it as variable name instead of id
+        if (identifier != null && identifier.length() > 0) {
+            variable.setName(identifier);
+            variable.setMetaData(identifier, variable.getName());
+        } else {
+            variable.setName(identifier);
+        }
+        variable.setMetaData(identifier, variable.getName());
+        variables.add(variable);
+
         return null;
     }
 

jbpm/jbpm-flow-builder/src/main/java/org/jbpm/compiler/canonical/AbstractNodeVisitor.java

@@ -20,8 +20,11 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
+import org.jbpm.process.builder.action.ActionCompilerRegistry;
 import org.jbpm.process.core.ContextContainer;
 import org.jbpm.process.core.context.variable.Mappable;
 import org.jbpm.process.core.context.variable.Variable;
@@ -33,6 +36,8 @@
 import org.jbpm.workflow.core.impl.ConnectionImpl;
 import org.jbpm.workflow.core.impl.DataAssociation;
 import org.jbpm.workflow.core.impl.DataDefinition;
+import org.jbpm.workflow.core.impl.DroolsConsequenceAction;
+import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
 import org.jbpm.workflow.core.node.Assignment;
 import org.jbpm.workflow.core.node.HumanTaskNode;
 import org.jbpm.workflow.core.node.StartNode;
@@ -69,6 +74,7 @@
 import static org.jbpm.ruleflow.core.Metadata.HIDDEN;
 import static org.jbpm.ruleflow.core.factory.NodeFactory.METHOD_DONE;
 import static org.jbpm.ruleflow.core.factory.NodeFactory.METHOD_NAME;
+import static org.kie.kogito.internal.utils.ConversionUtils.sanitizeString;
 
 public abstract class AbstractNodeVisitor<T extends Node> extends AbstractVisitor {
 
@@ -79,6 +85,43 @@ public void visitNode(T node, BlockStmt body, VariableScope variableScope, Proce
         if (isAdHocNode(node) && !(node instanceof HumanTaskNode)) {
             metadata.addSignal(node.getName(), null);
         }
+        if (isExtendedNode(node)) {
+            ExtendedNodeImpl extendedNodeImpl = (ExtendedNodeImpl) node;
+            addScript(extendedNodeImpl, body, ON_ACTION_SCRIPT_METHOD, ExtendedNodeImpl.EVENT_NODE_ENTER);
+            addScript(extendedNodeImpl, body, ON_ACTION_SCRIPT_METHOD, ExtendedNodeImpl.EVENT_NODE_EXIT);
+        }
+    }
+
+    private void addScript(ExtendedNodeImpl extendedNodeImpl, BlockStmt body, String factoryMethod, String actionType) {
+        if (!extendedNodeImpl.hasActions(actionType)) {
+            return;
+        }
+        List<DroolsConsequenceAction> scripts = extendedNodeImpl.getActions(actionType).stream()
+                .filter(Predicate.not(Objects::isNull))
+                .filter(DroolsConsequenceAction.class::isInstance)
+                .map(DroolsConsequenceAction.class::cast)
+                .filter(e -> e.getConsequence() != null && !e.getConsequence().isBlank())
+                .toList();
+
+        for (DroolsConsequenceAction script : scripts) {
+            body.addStatement(getFactoryMethod(getNodeId((T) extendedNodeImpl), factoryMethod,
+                    new StringLiteralExpr(actionType),
+                    new StringLiteralExpr(script.getDialect()),
+                    new StringLiteralExpr(sanitizeString(script.getConsequence())),
+                    buildDroolsConsequenceAction(extendedNodeImpl, script.getDialect(), script.getConsequence())));
+            ;
+        }
+    }
+
+    private Expression buildDroolsConsequenceAction(ExtendedNodeImpl extendedNodeImpl, String dialect, String script) {
+        if (script == null) {
+            return new NullLiteralExpr();
+        }
+        return ActionCompilerRegistry.instance().find(dialect).buildAction(extendedNodeImpl, script);
+    }
+
+    private boolean isExtendedNode(T node) {
+        return node instanceof ExtendedNodeImpl;
     }
 
     private boolean isAdHocNode(Node node) {

jbpm/jbpm-flow-builder/src/main/java/org/jbpm/compiler/canonical/AbstractVisitor.java

@@ -54,8 +54,9 @@
 
 public abstract class AbstractVisitor {
 
+    protected static final String ON_ACTION_SCRIPT_METHOD = "onActionScript";
     protected static final String FACTORY_FIELD_NAME = "factory";
-    protected static final String KCONTEXT_VAR = "kcontext";
+    public static final String KCONTEXT_VAR = "kcontext";
 
     protected MethodCallExpr getWorkflowElementConstructor(WorkflowElementIdentifier identifier) {
         Type type = new ClassOrInterfaceType().setName(WorkflowElementIdentifierFactory.class.getName());

jbpm/jbpm-flow-builder/src/main/java/org/jbpm/process/builder/action/ActionCompiler.java

@@ -0,0 +1,36 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.jbpm.process.builder.action;
+
+import java.util.Arrays;
+
+import org.jbpm.workflow.core.impl.NodeImpl;
+
+import com.github.javaparser.ast.expr.Expression;
+
+public interface ActionCompiler {
+
+    String[] dialects();
+
+    default boolean accept(String dialect) {
+        return Arrays.asList(dialect).contains(dialect);
+    }
+
+    Expression buildAction(NodeImpl nodeImpl, String scrtip);
+}

jbpm/jbpm-flow-builder/src/main/java/org/jbpm/process/builder/action/ActionCompilerRegistry.java

@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.jbpm.process.builder.action;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.ServiceLoader;
+
+import org.jbpm.util.JbpmClassLoaderUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ActionCompilerRegistry {
+
+    private static final Logger logger = LoggerFactory.getLogger(ActionCompilerRegistry.class);
+
+    private static ActionCompilerRegistry INSTANCE;
+
+    private List<ActionCompiler> registry;
+
+    public static ActionCompilerRegistry instance() {
+        if (INSTANCE == null) {
+            INSTANCE = new ActionCompilerRegistry();
+        }
+        return INSTANCE;
+    }
+
+    protected ActionCompilerRegistry() {
+        this.registry = new ArrayList<>();
+        ServiceLoader.load(ActionCompiler.class, JbpmClassLoaderUtil.findClassLoader()).forEach(registry::add);
+    }
+
+    public void register(ActionCompiler actionCompiler) {
+        this.registry.add(actionCompiler);
+        logger.debug("Manual registration of scripting language {} with instance {}", List.of(actionCompiler.dialects()), actionCompiler);
+    }
+
+    public ActionCompiler find(String language) {
+        for (ActionCompiler transformer : registry) {
+            if (transformer.accept(language)) {
+                return transformer;
+            }
+        }
+        throw new IllegalArgumentException("action compiler not support for dialect " + language);
+    }
+}

jbpm/jbpm-flow-builder/src/main/java/org/jbpm/process/builder/action/JavaActionCompiler.java

@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.jbpm.process.builder.action;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.jbpm.compiler.canonical.AbstractNodeVisitor;
+import org.jbpm.process.core.context.variable.Variable;
+import org.jbpm.process.core.context.variable.VariableScope;
+import org.jbpm.workflow.core.impl.NodeImpl;
+
+import com.github.javaparser.StaticJavaParser;
+import com.github.javaparser.ast.NodeList;
+import com.github.javaparser.ast.body.Parameter;
+import com.github.javaparser.ast.expr.AssignExpr;
+import com.github.javaparser.ast.expr.AssignExpr.Operator;
+import com.github.javaparser.ast.expr.CastExpr;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.LambdaExpr;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.expr.NameExpr;
+import com.github.javaparser.ast.expr.StringLiteralExpr;
+import com.github.javaparser.ast.expr.VariableDeclarationExpr;
+import com.github.javaparser.ast.stmt.BlockStmt;
+import com.github.javaparser.ast.type.ClassOrInterfaceType;
+import com.github.javaparser.ast.type.Type;
+
+public class JavaActionCompiler implements ActionCompiler {
+
+    @Override
+    public String[] dialects() {
+        return new String[] { "java" };
+    }
+
+    @Override
+    public boolean accept(String dialect) {
+        return dialect.toLowerCase().contains("java");
+    }
+
+    @Override
+    public Expression buildAction(NodeImpl nodeImpl, String script) {
+        BlockStmt newDroolsConsequenceActionExpression = new BlockStmt();
+        newDroolsConsequenceActionExpression = StaticJavaParser.parseBlock("{" + script + "}");
+        Set<NameExpr> identifiers = new HashSet<>(newDroolsConsequenceActionExpression.findAll(NameExpr.class));
+        for (NameExpr identifier : identifiers) {
+            VariableScope scope = (VariableScope) nodeImpl.resolveContext(VariableScope.VARIABLE_SCOPE, identifier.getNameAsString());
+            if (scope == null) {
+                continue;
+            }
+            Variable var = scope.findVariable(identifier.getNameAsString());
+            if (var == null) {
+                continue;
+            }
+            Type type = StaticJavaParser.parseType(var.getType().getStringType());
+            VariableDeclarationExpr target = new VariableDeclarationExpr(type, var.getName());
+            Expression source = new MethodCallExpr(new NameExpr(AbstractNodeVisitor.KCONTEXT_VAR), "getVariable", NodeList.nodeList(new StringLiteralExpr(var.getName())));
+            source = new CastExpr(type, source);
+            AssignExpr assign = new AssignExpr(target, source, Operator.ASSIGN);
+            newDroolsConsequenceActionExpression.addStatement(0, assign);
+        }
+        ClassOrInterfaceType type = StaticJavaParser.parseClassOrInterfaceType(org.kie.kogito.internal.process.runtime.KogitoProcessContext.class.getName());
+        return new LambdaExpr(NodeList.nodeList(new Parameter(type, AbstractNodeVisitor.KCONTEXT_VAR)), newDroolsConsequenceActionExpression, true);
+    }
+
+}

jbpm/jbpm-flow-builder/src/main/java/org/jbpm/process/builder/action/MVELActionCompiler.java

@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.jbpm.process.builder.action;
+
+import org.jbpm.compiler.canonical.AbstractNodeVisitor;
+import org.jbpm.workflow.core.impl.NodeImpl;
+
+import com.github.javaparser.StaticJavaParser;
+import com.github.javaparser.ast.NodeList;
+import com.github.javaparser.ast.body.Parameter;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.LambdaExpr;
+import com.github.javaparser.ast.stmt.BlockStmt;
+import com.github.javaparser.ast.type.ClassOrInterfaceType;
+
+import static org.kie.kogito.internal.utils.ConversionUtils.sanitizeString;
+
+public class MVELActionCompiler implements ActionCompiler {
+
+    @Override
+    public String[] dialects() {
+        return new String[] { "mvel" };
+    }
+
+    @Override
+    public Expression buildAction(NodeImpl nodeImpl, String script) {
+        BlockStmt actionExpression = StaticJavaParser.parseBlock(
+                "{ org.mvel2.MVEL.eval(\"" + sanitizeString(script) +
+                        "\", new org.jbpm.workflow.instance.impl.NodeInstanceResolverFactory((org.jbpm.workflow.instance.NodeInstance) kcontext.getNodeInstance())); }");
+        ClassOrInterfaceType type = StaticJavaParser.parseClassOrInterfaceType(org.kie.kogito.internal.process.runtime.KogitoProcessContext.class.getName());
+        return new LambdaExpr(NodeList.nodeList(new Parameter(type, AbstractNodeVisitor.KCONTEXT_VAR)), actionExpression, true);
+    }
+
+}

jbpm/jbpm-flow-builder/src/main/resources/META-INF/services/org.jbpm.process.builder.action.ActionCompiler

@@ -0,0 +1,2 @@
+org.jbpm.process.builder.action.JavaActionCompiler
+org.jbpm.process.builder.action.MVELActionCompiler

jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/AbstractCompositeNodeFactory.java

@@ -109,4 +109,5 @@ public P done() {
         }
         return super.done();
     }
+
 }