Restore XML variable mappings for call activities (#3711)

* revert change main activity [extension remove from call activity #2837]

* callActivityBehaviour

* pre commit changes by Elias

* Assertion changes and #2837 revert

* replacing test

* removed unused import and code refractor
Co-authored-by: NElias Ricken de Medeiros <26007058+erdemedeiros@users.noreply.github.com>

activiti-core/activiti-engine/src/main/java/org/activiti/engine/impl/bpmn/behavior/CallActivityBehavior.java

@@ -128,9 +128,10 @@ public class CallActivityBehavior extends AbstractBpmnActivityBehavior implement
     Map<String, Object> variablesFromExtensionFile = calculateInboundVariables(execution, processDefinition);
 
     variables.putAll(variablesFromExtensionFile);
+    variables = copyProcessVariables(execution, expressionManager, callActivity, variables);
 
     if (!variables.isEmpty()) {
-      initializeVariables(subProcessInstance, variables);
+        initializeVariables(subProcessInstance, variables);
     }
 
     // Create the first execution that will visit all the process definition elements
@@ -141,15 +142,16 @@ public class CallActivityBehavior extends AbstractBpmnActivityBehavior implement
 
     Context.getProcessEngineConfiguration().getEventDispatcher()
       .dispatchEvent(ActivitiEventBuilder.createProcessStartedEvent(subProcessInitialExecution, variables, false));
-  }
+}
 
-  public void completing(DelegateExecution execution, DelegateExecution subProcessInstance) throws Exception {
+public void completing(DelegateExecution execution, DelegateExecution subProcessInstance) throws Exception {
 
-      Map<String, Object> outboundVariables = calculateOutBoundVariables(execution, subProcessInstance.getVariables());
-      if (outboundVariables != null) {
-          execution.setVariables(outboundVariables);
-      }
-  }
+    Map<String, Object> outboundVariables = calculateOutBoundVariables(copyOutParameters(execution, subProcessInstance),
+            subProcessInstance.getVariables());
+    if (outboundVariables != null) {
+        execution.setVariables(outboundVariables);
+    }
+}
 
   public void completed(DelegateExecution execution) throws Exception {
     // only control flow. no sub process instance data available
@@ -198,6 +200,41 @@ public class CallActivityBehavior extends AbstractBpmnActivityBehavior implement
   protected Map<String, Object> calculateOutBoundVariables(DelegateExecution execution,
                                                            Map<String, Object> subProcessVariables) {
     return new HashMap<String, Object>();
-  }
+}
+
+protected Map<String, Object> copyProcessVariables(DelegateExecution execution, ExpressionManager expressionManager,
+        CallActivity callActivity, Map<String, Object> variables) {
+    for (IOParameter ioParameter : callActivity.getInParameters()) {
+        Object value = null;
+        if (StringUtils.isNotEmpty(ioParameter.getSourceExpression())) {
+            Expression expression = expressionManager.createExpression(ioParameter.getSourceExpression().trim());
+            value = expression.getValue(execution);
+
+        } else {
+            value = execution.getVariable(ioParameter.getSource());
+        }
+        variables.put(ioParameter.getTarget(), value);
+    }
+    return variables;
+}
+
+protected DelegateExecution copyOutParameters(DelegateExecution execution, DelegateExecution subProcessInstance) {
+
+    ExpressionManager expressionManager = Context.getProcessEngineConfiguration().getExpressionManager();
+    ExecutionEntity executionEntity = (ExecutionEntity) execution;
+    CallActivity callActivity = (CallActivity) executionEntity.getCurrentFlowElement();
+    for (IOParameter ioParameter : callActivity.getOutParameters()) {
+        Object value = null;
+        if (StringUtils.isNotEmpty(ioParameter.getSourceExpression())) {
+            Expression expression = expressionManager.createExpression(ioParameter.getSourceExpression().trim());
+            value = expression.getValue(subProcessInstance);
+
+        } else {
+            value = subProcessInstance.getVariable(ioParameter.getSource());
+        }
+        execution.setVariable(ioParameter.getTarget(), value);
+    }
+    return execution;
+}
 
 }

activiti-core/activiti-engine/src/test/java/org/activiti/engine/test/api/event/VariableEventsTest.java

@@ -19,8 +19,11 @@ package org.activiti.engine.test.api.event;
 import static java.util.Collections.singletonMap;
 import static org.activiti.engine.impl.util.CollectionUtil.map;
 import static org.assertj.core.api.Assertions.assertThat;
-
+import static org.assertj.core.api.Assertions.tuple;
+import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
+
 import org.activiti.engine.delegate.event.ActivitiEvent;
 import org.activiti.engine.delegate.event.ActivitiEventType;
 import org.activiti.engine.delegate.event.ActivitiVariableEvent;
@@ -216,20 +219,21 @@ public class VariableEventsTest extends PluggableActivitiTestCase {
 
     @Deployment
     public void testProcessInstanceVariableEventsOnCallActivity() throws Exception {
-      ProcessInstance processInstance = runtimeService
-          .startProcessInstanceByKey("callVariableProcess",
-              singletonMap("parentVar1", "parentVar1Value"));
-      assertThat(processInstance).isNotNull();
-
-      assertThat(listener.getEventsReceived()).hasSize(2);
+        runtimeService.startProcessInstanceByKey("callVariableProcess",
+                singletonMap("parentVar1", "parentVar1Value"));
+
+        final List<ActivitiVariableEvent> variableEvents = listener.getEventsReceived().stream()
+                .filter(event -> event instanceof ActivitiVariableEvent).map(ActivitiVariableEvent.class::cast)
+                .collect(Collectors.toList());
+        assertThat(variableEvents).extracting(ActivitiVariableEvent::getType, ActivitiVariableEvent::getVariableName)
+                .containsExactly(tuple(ActivitiEventType.VARIABLE_CREATED, "parentVar1"),
+                        tuple(ActivitiEventType.VARIABLE_CREATED, "subVar1"),
+                        tuple(ActivitiEventType.VARIABLE_CREATED, "parentVar2"),
+                        tuple(ActivitiEventType.VARIABLE_DELETED, "subVar1"),
+                        tuple(ActivitiEventType.VARIABLE_DELETED, "parentVar2"),
+                        tuple(ActivitiEventType.VARIABLE_DELETED, "parentVar1"));
 
-      ActivitiVariableEvent event = (ActivitiVariableEvent) listener.getEventsReceived().get(0);
-      assertThat(event.getType()).isEqualTo(ActivitiEventType.VARIABLE_CREATED);
-
-      event = (ActivitiVariableEvent) listener.getEventsReceived().get(1);
-      assertThat(event.getType()).isEqualTo(ActivitiEventType.VARIABLE_DELETED);
     }
-
     /**
      * Test create, update and delete of task-local variables.
      */

activiti-core/activiti-engine/src/test/java/org/activiti/engine/test/bpmn/event/error/mapError/BoundaryErrorMapTest.java

@@ -99,5 +99,18 @@ public class BoundaryErrorMapTest extends PluggableActivitiTestCase {
 
     runtimeService.startProcessInstanceByKey("subprocssWithSingleExceptionMap", vars);
     assertThat(FlagDelegate.isVisited()).isTrue();
-  }
+}
+
+@Deployment(resources = {
+        "org/activiti/engine/test/bpmn/event/error/mapError/BoundaryErrorMapTest.testCallProcessSingleDirectMap.bpmn20.xml",
+        "org/activiti/engine/test/bpmn/event/error/mapError/BoundaryErrorMapTest.testCallProcessCalee.bpmn20.xml" })
+public void testCallProcessSingleDirectMap() {
+    FlagDelegate.reset();
+    Map<String, Object> vars = new HashMap<String, Object>();
+    vars.put("exceptionClass", BoundaryErrorParentException.class.getName());
+
+    runtimeService.startProcessInstanceByKey("callProcssWithSingleExceptionMap", vars);
+    assertThat(FlagDelegate.isVisited()).isTrue();
+}
+
 }

activiti-core/activiti-engine/src/test/java/org/activiti/engine/test/bpmn/multiinstance/MultiInstanceTest.java

@@ -826,6 +826,40 @@ public class MultiInstanceTest extends PluggableActivitiTestCase {
     assertProcessEnded(procId);
   }
 
+  @Deployment(resources = "org/activiti/engine/test/bpmn/multiinstance/MultiInstanceTest.testSequentialCallActivityWithList.bpmn20.xml")
+  public void testSequentialCallActivityWithList() {
+      ArrayList<String> list = new ArrayList<String>();
+      list.add("one");
+      list.add("two");
+
+      HashMap<String, Object> variables = new HashMap<String, Object>();
+      variables.put("list", list);
+
+      String procId = runtimeService.startProcessInstanceByKey("parentProcess", variables).getId();
+
+      Task task1 = taskService.createTaskQuery().processVariableValueEquals("element", "one").singleResult();
+      Task task2 = taskService.createTaskQuery().processVariableValueEquals("element", "two").singleResult();
+
+      assertThat(task1).isNotNull();
+      assertThat(task2).isNotNull();
+
+      HashMap<String, Object> subVariables = new HashMap<String, Object>();
+      subVariables.put("x", "y");
+
+      taskService.complete(task1.getId(), subVariables);
+      taskService.complete(task2.getId(), subVariables);
+
+      Task task3 = taskService.createTaskQuery().processDefinitionKey("midProcess").singleResult();
+      assertThat(task3).isNotNull();
+      taskService.complete(task3.getId(), null);
+
+      Task task4 = taskService.createTaskQuery().processDefinitionKey("parentProcess").singleResult();
+      assertThat(task4).isNotNull();
+      taskService.complete(task4.getId(), null);
+
+      assertProcessEnded(procId);
+  }
+
   @Deployment(resources = { "org/activiti/engine/test/bpmn/multiinstance/MultiInstanceTest.testSequentialCallActivityWithTimer.bpmn20.xml",
       "org/activiti/engine/test/bpmn/multiinstance/MultiInstanceTest.externalSubProcess.bpmn20.xml" })
   public void testSequentialCallActivityWithTimer() {

activiti-core/activiti-engine/src/test/resources/org/activiti/engine/test/api/tenant/TenancyTest.testCallActivityWithTenant-process02.bpmn20.xml

@@ -3,7 +3,7 @@
   <process id="process2" name="Process 2" isExecutable="true">
     <startEvent id="startevent2" name="Start"></startEvent>
     <scriptTask id="scripttask1" name="Script Task" scriptFormat="groovy" activiti:autoStoreVariables="false">
-      <script>out:println "Send For";</script>
+      <script>out:println "Send For  " + sendFor;</script>
     </scriptTask>
     <sequenceFlow id="flow1" sourceRef="startevent2" targetRef="scripttask1"></sequenceFlow>
     <endEvent id="endevent1" name="End"></endEvent>