[1.3.5-prepare][cherry-pick]#4555 update branch name error (#4662)

It solves the problem that the name of the branch will not change after the name of the branch is changed in the workflow page and instance page.

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/ProcessDefinitionService.java

@@ -403,6 +403,10 @@ public class ProcessDefinitionService extends BaseDAGService {
             }
         }
 
+        // get the processdefinitionjson before saving,and then save the name and taskid
+        String oldJson = processDefine.getProcessDefinitionJson();
+        processDefinitionJson = processService.changeJson(processData,oldJson);
+
         Date now = new Date();
 
         processDefine.setId(id);

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/ProcessInstanceService.java

@@ -359,16 +359,15 @@ public class ProcessInstanceService extends BaseDAGService {
                     processInstance.getName(), processInstance.getState().toString(), "update");
             return result;
         }
-        Date schedule = null;
+        Date  schedule ;
+        schedule = processInstance.getScheduleTime();
         if (scheduleTime != null) {
             schedule = DateUtils.getScheduleDate(scheduleTime);
-        } else {
-            schedule = processInstance.getScheduleTime();
         }
         processInstance.setScheduleTime(schedule);
         processInstance.setLocations(locations);
         processInstance.setConnects(connects);
-        String globalParams = null;
+        String globalParams;
         String originDefParams = null;
         int timeout = processInstance.getTimeout();
         ProcessDefinition processDefinition = processService.findProcessDefineById(processInstance.getProcessDefinitionId());
@@ -392,13 +391,18 @@ public class ProcessInstanceService extends BaseDAGService {
             if(tenant != null){
                 processInstance.setTenantCode(tenant.getTenantCode());
             }
+            // get the processinstancejson before saving,and then save the name and taskid
+            String oldJson = processInstance.getProcessInstanceJson();
+            if (StringUtils.isNotEmpty(oldJson)) {
+                processInstanceJson = processService.changeJson(processData,oldJson);
+            }
             processInstance.setProcessInstanceJson(processInstanceJson);
             processInstance.setGlobalParams(globalParams);
         }
 
         int update = processService.updateProcessInstance(processInstance);
         int updateDefine = 1;
-        if (Boolean.TRUE.equals(syncDefine) && StringUtils.isNotEmpty(processInstanceJson)) {
+        if (Boolean.TRUE.equals(syncDefine)) {
             processDefinition.setProcessDefinitionJson(processInstanceJson);
             processDefinition.setGlobalParams(originDefParams);
             processDefinition.setLocations(locations);

dolphinscheduler-common/src/main/java/org/apache/dolphinscheduler/common/task/conditions/ConditionsParameters.java

@@ -36,6 +36,13 @@ public class ConditionsParameters extends AbstractParameters {
     private List<String> failedNode;
 
 
+    public String getConditionResult() {
+        return "{"
+                + "\"successNode\": [\"" + successNode.get(0)
+                + "\"],\"failedNode\": [\"" + failedNode.get(0)
+                + "\"]}";
+    }
+
     @Override
     public boolean checkParameters() {
         return true;

dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java

@@ -25,6 +25,7 @@ import org.apache.dolphinscheduler.common.enums.*;
 import org.apache.dolphinscheduler.common.model.DateInterval;
 import org.apache.dolphinscheduler.common.model.TaskNode;
 import org.apache.dolphinscheduler.common.process.Property;
+import org.apache.dolphinscheduler.common.task.conditions.ConditionsParameters;
 import org.apache.dolphinscheduler.common.task.subprocess.SubProcessParameters;
 import org.apache.dolphinscheduler.common.utils.*;
 import org.apache.dolphinscheduler.dao.entity.*;
@@ -1906,4 +1907,60 @@ public class ProcessService {
                 taskInstance.getId());
     }
 
+    /**
+     * solve the branch rename bug
+     *
+     * @param processData
+     * @param oldJson
+     * @return String
+     */
+    public String changeJson(ProcessData processData, String oldJson) {
+        ProcessData oldProcessData = JSONUtils.parseObject(oldJson, ProcessData.class);
+        HashMap<String, String> oldNameTaskId = new HashMap<>();
+        List<TaskNode> oldTasks = oldProcessData.getTasks();
+        for (int i = 0; i < oldTasks.size(); i++) {
+            TaskNode taskNode = oldTasks.get(i);
+            String oldName = taskNode.getName();
+            String oldId = taskNode.getId();
+            oldNameTaskId.put(oldName, oldId);
+        }
+
+        // take the processdefinitionjson saved this time, and then save the taskid and name
+        HashMap<String, String> newNameTaskId = new HashMap<>();
+        List<TaskNode> newTasks = processData.getTasks();
+        for (int i = 0; i < newTasks.size(); i++) {
+            TaskNode taskNode = newTasks.get(i);
+            String newId = taskNode.getId();
+            String newName = taskNode.getName();
+            newNameTaskId.put(newId, newName);
+        }
+
+        // replace the previous conditionresult with a new one
+        List<TaskNode> tasks = processData.getTasks();
+        for (int i = 0; i < tasks.size(); i++) {
+            TaskNode taskNode = newTasks.get(i);
+            String type = taskNode.getType();
+            if (TaskType.CONDITIONS.getDescp().equalsIgnoreCase(type)) {
+                ConditionsParameters conditionsParameters = JSONUtils.parseObject(taskNode.getConditionResult(), ConditionsParameters.class);
+                String oldSuccessNodeName = conditionsParameters.getSuccessNode().get(0);
+                String oldFailedNodeName = conditionsParameters.getFailedNode().get(0);
+                String newSuccessNodeName = newNameTaskId.get(oldNameTaskId.get(oldSuccessNodeName));
+                String newFailedNodeName = newNameTaskId.get(oldNameTaskId.get(oldFailedNodeName));
+                if (newSuccessNodeName != null) {
+                    ArrayList<String> successNode = new ArrayList<>();
+                    successNode.add(newSuccessNodeName);
+                    conditionsParameters.setSuccessNode(successNode);
+                }
+                if (newFailedNodeName != null) {
+                    ArrayList<String> failedNode = new ArrayList<>();
+                    failedNode.add(newFailedNodeName);
+                    conditionsParameters.setFailedNode(failedNode);
+                }
+                String conditionResultStr = conditionsParameters.getConditionResult();
+                taskNode.setConditionResult(conditionResultStr);
+                tasks.set(i, taskNode);
+            }
+        }
+        return JSONUtils.toJsonString(processData);
+    }
 }

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/process/ProcessServiceTest.java

@@ -19,12 +19,17 @@ package org.apache.dolphinscheduler.service.process;
 import org.apache.dolphinscheduler.common.Constants;
 import org.apache.dolphinscheduler.common.enums.CommandType;
 import org.apache.dolphinscheduler.common.enums.WarningType;
+import org.apache.dolphinscheduler.common.model.TaskNode;
+import org.apache.dolphinscheduler.common.task.conditions.ConditionsParameters;
 import org.apache.dolphinscheduler.common.utils.JSONUtils;
 import org.apache.dolphinscheduler.dao.entity.Command;
+import org.apache.dolphinscheduler.dao.entity.ProcessData;
 import org.apache.dolphinscheduler.dao.entity.ProcessInstance;
 import org.apache.dolphinscheduler.dao.entity.ProcessInstanceMap;
 import org.apache.dolphinscheduler.dao.entity.TaskInstance;
 
+import java.util.ArrayList;
+
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -102,6 +107,110 @@ public class ProcessServiceTest {
         );
         Assert.assertEquals(CommandType.START_FAILURE_TASK_PROCESS, command.getCommandType());
 
+    }
+
+
+    @Test
+    public void testChangeJson() {
+
+        ProcessData oldProcessData = new ProcessData();
+        ConditionsParameters conditionsParameters = new ConditionsParameters();
+        ArrayList<TaskNode> tasks = new ArrayList<>();
+        TaskNode taskNode = new TaskNode();
+        TaskNode taskNode11 = new TaskNode();
+        TaskNode taskNode111 = new TaskNode();
+        ArrayList<String> successNode = new ArrayList<>();
+        ArrayList<String> faildNode = new ArrayList<>();
+
+        taskNode.setName("bbb");
+        taskNode.setType("SHELL");
+        taskNode.setId("222");
+
+        taskNode11.setName("vvv");
+        taskNode11.setType("CONDITIONS");
+        taskNode11.setId("444");
+        successNode.add("bbb");
+        faildNode.add("ccc");
+
+        taskNode111.setName("ccc");
+        taskNode111.setType("SHELL");
+        taskNode111.setId("333");
+
+        conditionsParameters.setSuccessNode(successNode);
+        conditionsParameters.setFailedNode(faildNode);
+        taskNode11.setConditionResult(conditionsParameters.getConditionResult());
+        tasks.add(taskNode);
+        tasks.add(taskNode11);
+        tasks.add(taskNode111);
+        oldProcessData.setTasks(tasks);
+
+        ProcessData newProcessData = new ProcessData();
+        ConditionsParameters conditionsParameters2 = new ConditionsParameters();
+        TaskNode taskNode2 = new TaskNode();
+        TaskNode taskNode22 = new TaskNode();
+        TaskNode taskNode222 = new TaskNode();
+        ArrayList<TaskNode> tasks2 = new ArrayList<>();
+        ArrayList<String> successNode2 = new ArrayList<>();
+        ArrayList<String> faildNode2 = new ArrayList<>();
+
+        taskNode2.setName("bbbchange");
+        taskNode2.setType("SHELL");
+        taskNode2.setId("222");
+
+        taskNode22.setName("vv");
+        taskNode22.setType("CONDITIONS");
+        taskNode22.setId("444");
+        successNode2.add("bbb");
+        faildNode2.add("ccc");
+
+        taskNode222.setName("ccc");
+        taskNode222.setType("SHELL");
+        taskNode222.setId("333");
+
+        conditionsParameters2.setSuccessNode(successNode2);
+        conditionsParameters2.setFailedNode(faildNode2);
+        taskNode22.setConditionResult(conditionsParameters2.getConditionResult());
+        tasks2.add(taskNode2);
+        tasks2.add(taskNode22);
+        tasks2.add(taskNode222);
+
+        newProcessData.setTasks(tasks2);
+
+        ProcessData exceptProcessData = new ProcessData();
+        ConditionsParameters conditionsParameters3 = new ConditionsParameters();
+        TaskNode taskNode3 = new TaskNode();
+        TaskNode taskNode33 = new TaskNode();
+        TaskNode taskNode333 = new TaskNode();
+        ArrayList<TaskNode> tasks3 = new ArrayList<>();
+        ArrayList<String> successNode3 = new ArrayList<>();
+        ArrayList<String> faildNode3 = new ArrayList<>();
+
+        taskNode3.setName("bbbchange");
+        taskNode3.setType("SHELL");
+        taskNode3.setId("222");
+
+        taskNode33.setName("vv");
+        taskNode33.setType("CONDITIONS");
+        taskNode33.setId("444");
+        successNode3.add("bbbchange");
+        faildNode3.add("ccc");
+
+        taskNode333.setName("ccc");
+        taskNode333.setType("SHELL");
+        taskNode333.setId("333");
+
+        conditionsParameters3.setSuccessNode(successNode3);
+        conditionsParameters3.setFailedNode(faildNode3);
+        taskNode33.setConditionResult(conditionsParameters3.getConditionResult());
+        tasks3.add(taskNode3);
+        tasks3.add(taskNode33);
+        tasks3.add(taskNode333);
+        exceptProcessData.setTasks(tasks3);
+
+        String expect = JSONUtils.toJsonString(exceptProcessData);
+        String oldJson = JSONUtils.toJsonString(oldProcessData);
+
+        Assert.assertEquals(expect, new ProcessService().changeJson(newProcessData,oldJson));
 
     }
 }