功能：

1. 添加特殊的补批方式
2. 添加工作流的公共参数
3. 修正脚本运行命令替换
4. 添加java任务返回值携带回写参数

byit-myth-admin/src/main/java/com/byit/api/ApiFlowOperatingController.java

 package com.byit.api;
 
 import com.byit.dto.specials.SpecialJobParam;
+import com.byit.service.ApiFlowOperatingService;
 import io.swagger.annotations.Api;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -18,10 +19,19 @@ import org.springframework.web.bind.annotation.RestController;
 @RestController
 @RequestMapping("api/operating/node/")
 public class ApiFlowOperatingController {
+
+    private final ApiFlowOperatingService apiFlowOperatingService;
+
+    public ApiFlowOperatingController(ApiFlowOperatingService apiFlowOperatingService) {
+        this.apiFlowOperatingService = apiFlowOperatingService;
+    }
+
     /**
      * 特殊的补批接口  可以依照魔衣工作流下的某一个节点，自动补批其下所由的节点
      * @param specialJobParam 采纳数信息
      */
     @PostMapping("specialRunBatch")
-    public void specialRunBatch(@RequestBody SpecialJobParam specialJobParam){}
+    public void specialRunBatch(@RequestBody SpecialJobParam specialJobParam){
+        apiFlowOperatingService.specialRunBatch(specialJobParam);
+    }
 }

byit-myth-admin/src/main/java/com/byit/service/ApiFlowOperatingService.java

+package com.byit.service;
+
+import com.byit.dto.specials.SpecialJobParam;
+
+/**
+ * 工作流操作实现解耦
+ *
+ * @author huangfu
+ * @date 2020年9月23日11:20:12
+ */
+public interface ApiFlowOperatingService {
+    /**
+     * 另外一种实现的补批接口
+     * 基于某一节点自动识别下面所有的节点
+     *
+     * @param specialJobParam 补批参数
+     */
+    void specialRunBatch(SpecialJobParam specialJobParam);
+}

byit-myth-admin/src/main/resources/config/application-local.yml

 spring:
   datasource:
     driver-class-name: com.mysql.jdbc.Driver
-    url: jdbc:mysql://10.0.10.118:3306/myth-job?Unicode=true&characterEncoding=UTF-8&useSSL=true
+    url: jdbc:mysql://10.0.120.30:3307/myth-job?Unicode=true&characterEncoding=UTF-8&useSSL=true
     username: root
-    password: 123456
+    password: root
 
 
 

byit-myth-core/myth-admin-core/src/main/java/com/byit/dto/NodeRelyDto.java

+package com.byit.dto;
+
+import com.byit.model.Node;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+
+/**
+ * 节点依赖数据载体
+ *
+ * @author huangfu
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode
+public class NodeRelyDto {
+    private String relyId;
+    private Node node;
+}

byit-myth-core/myth-admin-core/src/main/java/com/byit/mapper/NodeDependencyMapper.java

 package com.byit.mapper;
 
-import com.byit.model.Node;
 import com.byit.model.NodeDependencyKey;
 import org.apache.ibatis.annotations.Param;
+import org.springframework.stereotype.Repository;
 
 import java.util.List;
 
+@Repository
 public interface NodeDependencyMapper {
     int deleteById(NodeDependencyKey key);
 
@@ -15,6 +16,7 @@ public interface NodeDependencyMapper {
 
     /**
      * 根据节点id删除依赖关系
+     *
      * @param nodeId
      * @return
      */
@@ -22,6 +24,7 @@ public interface NodeDependencyMapper {
 
     /**
      * 根据节点id查询本节点依赖的节点
+     *
      * @param nodeId
      * @return
      */
@@ -31,10 +34,18 @@ public interface NodeDependencyMapper {
 
     /**
      * 查询依赖于当前nodeid的节点id
+     *
      * @param nodeId
      * @return
      */
     List<Integer> findSubNodeList(Integer nodeId);
 
     List<String> findNodeInfoByNodeId(Integer nodeId);
+
+    /**
+     * 查询所有节点的依赖节点
+     * @param nodeIds 所有的节点id
+     * @return 所有节点的依赖关系
+     */
+    List<NodeDependencyKey> findAllNodeDependencyKey(@Param("nodeIds") List<Integer> nodeIds);
 }
\ No newline at end of file

byit-myth-core/myth-admin-core/src/main/java/com/byit/model/Flow.java

@@ -46,7 +46,7 @@ public class Flow implements Serializable {
     /**
      * 当前工作流的介绍
      */
-    @ApiModelProperty("当前工作流的介绍")
+    @ApiModelProperty("当前工作流的公共参数")
     private String flowDesc;
 
     /**

byit-myth-core/myth-admin-core/src/main/java/com/byit/model/FlowVersion.java

@@ -46,7 +46,7 @@ public class FlowVersion implements Serializable {
     /**
      * 工作流的介绍
      */
-    @ApiModelProperty("工作流的介绍")
+    @ApiModelProperty("工作流的公共参数")
     private String flowDesc;
 
     /**

byit-myth-core/myth-admin-core/src/main/java/com/byit/service/FlowService.java

@@ -18,6 +18,14 @@ import java.util.List;
  * @create: 2019-12-23 17:33
  */
 public interface FlowService {
+    /**
+     * 查询工作流名称  基于工作流名称查询
+     *
+     * @param flowName 工作流名称
+     * @param workspaceId 工作空间名称ID
+     * @return 返回对应的
+     */
+    Flow findFlowByName(String flowName,  Integer workspaceId);
 
     /**
      * 查询当天将要运行的工作流

byit-myth-core/myth-admin-core/src/main/java/com/byit/service/NodeDependencyService.java

 package com.byit.service;
 
+import com.byit.model.NodeDependencyKey;
+
 import java.util.List;
 
 /**
@@ -14,4 +16,11 @@ public interface NodeDependencyService {
      */
     List<Integer> findDependIdByNodeId(Integer nodeId);
 
+    /**
+     * 查询所有节点的依赖节点
+     * @param nodeIds 所有的节点id
+     * @return 所有节点的依赖关系
+     */
+    List<NodeDependencyKey> findAllNodeDependencyKey(List<Integer> nodeIds);
+
 }
\ No newline at end of file

byit-myth-core/myth-admin-core/src/main/java/com/byit/service/impl/NodeDependencyServiceImpl.java

 package com.byit.service.impl;
 
 import com.byit.mapper.NodeDependencyMapper;
+import com.byit.model.NodeDependencyKey;
 import com.byit.service.NodeDependencyService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -25,4 +26,9 @@ public class NodeDependencyServiceImpl implements NodeDependencyService {
     public List<Integer> findDependIdByNodeId(Integer nodeId) {
         return nodeDependencyMapper.findDependIdByNodeId(nodeId);
     }
+
+    @Override
+    public List<NodeDependencyKey> findAllNodeDependencyKey(List<Integer> nodeIds) {
+        return nodeDependencyMapper.findAllNodeDependencyKey(nodeIds);
+    }
 }

byit-myth-core/myth-admin-core/src/main/java/com/byit/thread/helper/ScheduleThreadRunHelper.java

 package com.byit.thread.helper;
 
 import cn.hutool.core.collection.CollectionUtil;
+import com.alibaba.fastjson.JSON;
+import com.byit.dto.executor.RunParamWrapped;
+import com.byit.dto.executor.ScriptParamAndPlaceholderDto;
 import com.byit.dto.plugin.JavaTask;
 import com.byit.enums.NodeTypeEnum;
 import com.byit.enums.PlaceholderEnum;
@@ -20,12 +23,14 @@ import com.byit.thread.BaseThreadRunHelper;
 import com.byit.util.SpringUtil;
 import io.netty.util.TimerTask;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Component;
 
 import javax.sql.DataSource;
 import java.util.Date;
 import java.util.List;
+import java.util.Map;
 
 /**
  * 排期表操作
@@ -57,16 +62,44 @@ public class ScheduleThreadRunHelper extends BaseThreadRunHelper {
             log.debug("------排期表查询到有需要存在的节点--------");
             //循环遍历添加任务
             jobTaskSchedules.forEach(mythJobTaskSchedule ->{
-                //除去JAVA任务
-                if(!NodeTypeEnum.JAVA.getCode().equals(mythJobTaskSchedule.getJobType())){
+                //获取运行时参数
+                String runParam = mythJobTaskSchedule.getRunParam();
+                //获取命令
+                String command = mythJobTaskSchedule.getRunCommand();
+                //转换参数对象为参数包装体
+                RunParamWrapped runParamWrapped = JSON.parseObject(runParam, RunParamWrapped.class);
+                //当参数包装体不为空时 证明存在参数 或私有或公有
+                if(runParamWrapped != null) {
+                    //获取到私有参数
+                    String privateParam = runParamWrapped.getPrivateParam();
+                    //获取到公有参数
+                    Map<String,String> publicParam = runParamWrapped.getPublicParamMap();
+                    //将私有参数转换为对应的参数DTO
+                    ScriptParamAndPlaceholderDto scriptParamAndPlaceholderDto = JSON.parseObject(privateParam,ScriptParamAndPlaceholderDto.class);
+                    //脚本参数不为空的时候
+                    if(scriptParamAndPlaceholderDto != null) {
+                        Map<String, String> param = scriptParamAndPlaceholderDto.getParam();
+                        if(CollectionUtil.isNotEmpty(param)){
+                            command = PlaceholderUtils.commandReplace(command,param );
+                        }
+                    }
+                    //公共参数不为空的时候
+                    if(CollectionUtil.isNotEmpty(publicParam)) {
+                        command = PlaceholderUtils.commandReplace(command,publicParam );
+                    }
+                    //替换运行参数中的时间参数
                     if (ScheduleTypeEnum.NORMAL.getCode().equals(mythJobTaskSchedule.getScheduleType())) {
-                        mythJobTaskSchedule.setRunParam(PlaceholderUtils.formatParam(mythJobTaskSchedule.getRunParam()));
+                        mythJobTaskSchedule.setRunParam(PlaceholderUtils.formatParam(privateParam));
                     }
-                    String command = mythJobTaskSchedule.getRunCommand();
+                }
+
+                //除去JAVA任务
+                if(!NodeTypeEnum.JAVA.getCode().equals(mythJobTaskSchedule.getJobType())){
                     assert command != null;
                     command = command.replace("${"+ PlaceholderEnum.DATE_PLACEHOLDER.getName()+"}", DateUtil.dateLessDayStr(new Date(),"yyyyMMdd",1));
                     mythJobTaskSchedule.setRunCommand(command);
                 }
+
                 Long triggerTime = mythJobTaskSchedule.getTriggerTime();
                 TimerTask timerTask = null;
                 if (NodeTypeEnum.JAVA.getType().equals(mythJobTaskSchedule.getJobType())) {

byit-myth-core/myth-admin-core/src/main/java/com/byit/util/FlowNodeRelyParseUtil.java

+package com.byit.util;
+
+import cn.hutool.core.collection.CollectionUtil;
+import com.byit.dto.NodeRelyDto;
+import com.byit.model.Node;
+import com.byit.model.NodeDependencyKey;
+import org.apache.commons.lang3.StringUtils;
+
+import java.io.IOException;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 工作流节点依赖解析工具类
+ *
+ * @author huangfu
+ */
+public class FlowNodeRelyParseUtil {
+
+    /**
+     * 解析当前版本的节点依赖
+     *
+     * @param nodeAllList          所有的节点信息
+     * @param startNodeName        开始的节点名称
+     * @param allNodeDependencyKey 所有的主键信息
+     * @return 返回解析之后的节点
+     */
+    public static Set<NodeRelyDto> parseThisVersionNodeRely(List<Node> nodeAllList, String startNodeName, List<NodeDependencyKey> allNodeDependencyKey, boolean hasStart) {
+        List<NodeRelyDto> tempNodeRelyDtoList = new ArrayList<>(8);
+        //构建节点id与节点的字典关系
+        Map<Integer, List<Node>> nodeMap = nodeAllList.stream().collect(Collectors.groupingBy(Node::getNodeId));
+        //筛选开始节点
+        Node meetTheCriteriaNode = nodeAllList.stream().filter(node -> startNodeName.equals(node.getNodeName())).findFirst().orElse(null);
+        if (meetTheCriteriaNode != null) {
+            //构建一个队列
+            Queue<Integer> queue = new LinkedList<>();
+            //初始化开始节点  将开始节点加入到当前的结果集里面  注意开始节点不包含任何依赖
+            if (hasStart) {
+                NodeRelyDto nodeRelyDto = new NodeRelyDto();
+                nodeRelyDto.setNode(meetTheCriteriaNode);
+                tempNodeRelyDtoList.add(nodeRelyDto);
+                //构建一个队列初始化
+                queue.offer(meetTheCriteriaNode.getNodeId());
+            }else{
+                List<NodeDependencyKey> nodeDependencyKeys = nodeIdMatch(allNodeDependencyKey, meetTheCriteriaNode.getNodeId());
+                nodeDependencyKeys.forEach(e ->{
+                    NodeRelyDto nodeRelyDto = new NodeRelyDto();
+
+                    Node node = nodeMap.get(e.getNodeId()).get(0);
+                    nodeRelyDto.setNode(node);
+                    tempNodeRelyDtoList.add(nodeRelyDto);
+                    //构建一个队列初始化
+                    queue.offer(node.getNodeId());
+                });
+            }
+
+            while (queue.size() > 0) {
+                Integer relyNodeId = queue.poll();
+                //寻找依赖节点是当前节点的节点id
+                //基于当前节点的id  查询所有依赖该节点的节点
+                List<NodeDependencyKey> nodeDependencyKeys = nodeIdMatch(allNodeDependencyKey, relyNodeId);
+                List<NodeRelyDto> nodeRelyDtos = buildRelyNode(nodeDependencyKeys, nodeMap, relyNodeId);
+                //遍历查询到的所由的依赖节点的信息
+                if (CollectionUtil.isNotEmpty(nodeRelyDtos)) {
+                    nodeRelyDtos.forEach(nodeRely -> {
+                        //向队列设置一个节点id
+                        queue.offer(nodeRely.getNode().getNodeId());
+                        //添加到最终结果集
+                        tempNodeRelyDtoList.add(nodeRely);
+                    });
+                }
+            }
+            return buildResult(tempNodeRelyDtoList);
+        }
+
+        return null;
+    }
+
+    /**
+     * 节点匹配
+     *
+     * @param allNodeDependencyKey 所有的节点主键
+     * @param thisNodeId           当前节点的id
+     * @return 匹配成功的
+     */
+    public static List<NodeDependencyKey> nodeIdMatch(List<NodeDependencyKey> allNodeDependencyKey, Integer thisNodeId) {
+        List<NodeDependencyKey> nodeDependencyKeys = new ArrayList<>(8);
+        allNodeDependencyKey.forEach(key -> {
+            if (key.getDependencyId().equals(thisNodeId)) {
+                nodeDependencyKeys.add(key);
+            }
+        });
+        return nodeDependencyKeys;
+    }
+
+    /**
+     * 构建最终的结果
+     *
+     * @param tempNodeRelyDtoList 临时结果集
+     * @return 构建完成的数据
+     */
+    private static Set<NodeRelyDto> buildResult(List<NodeRelyDto> tempNodeRelyDtoList) {
+        Set<NodeRelyDto> tempNodeRelyDtoSet = new HashSet<>(tempNodeRelyDtoList);
+        //全部节点构建完毕后 对结果集进行分组  以相同的节点为key 依赖节点为value  构建某一节点的依赖节点
+        Set<NodeRelyDto> nodeRelyDtoSet = new HashSet<>(8);
+        Map<Node, List<NodeRelyDto>> resultMap = tempNodeRelyDtoSet.stream().collect(Collectors.groupingBy(NodeRelyDto::getNode));
+        resultMap.forEach((node, nodeDtoList) -> {
+            //抽芯构建一个新的
+            NodeRelyDto nodeRelyDto = new NodeRelyDto();
+            nodeRelyDto.setNode(node);
+            List<String> relIdList = nodeDtoList.stream().map(NodeRelyDto::getRelyId).collect(Collectors.toList());
+            String relIds = StringUtils.join(relIdList, ",");
+            nodeRelyDto.setRelyId(relIds);
+            nodeRelyDtoSet.add(nodeRelyDto);
+        });
+        return nodeRelyDtoSet;
+    }
+
+    /**
+     * 构建依赖节点
+     * <p>
+     * 将依赖节点构建为节点 包装起来
+     *
+     * @param nodeDependencyKeys 当前节点依赖的节点id
+     * @param nodeMap            节点字典
+     * @param thisNodeId         当前的节点id
+     * @return 构建完成的节点信息
+     */
+    private static List<NodeRelyDto> buildRelyNode(List<NodeDependencyKey> nodeDependencyKeys, Map<Integer, List<Node>> nodeMap, Integer thisNodeId) {
+        return nodeDependencyKeys.stream().map(nodeDependencyKey -> {
+            List<Node> nodes = nodeMap.get(nodeDependencyKey.getNodeId());
+            Node node = nodes.get(0);
+            NodeRelyDto nodeRelyDto = new NodeRelyDto();
+            nodeRelyDto.setNode(node);
+            //设置当前的依赖节点
+            nodeRelyDto.setRelyId(String.valueOf(thisNodeId));
+            return nodeRelyDto;
+        }).collect(Collectors.toList());
+    }
+}
\ No newline at end of file

byit-myth-core/myth-admin-core/src/main/resources/mapper/NodeDependencyMapper.xml

@@ -25,6 +25,18 @@
     where  dependency_id = #{nodeId,jdbcType=INTEGER}
   </select>
 
+  <select id="findAllNodeDependencyKey" resultMap="BaseResultMap">
+    select node_id, dependency_id from node_dependency 
+    <where>
+      node_id in (
+      
+        <foreach collection="nodeIds" item="nodeId" separator=",">
+          #{nodeId}
+        </foreach>
+      )
+    </where>
+  </select>
+
     <select id="findNodeInfoByNodeId" resultType="string">
         select node.node_name
         from node_dependency depend

byit-myth-core/myth-dto-core/src/main/java/com/byit/dto/executor/RunParamWrapped.java

+package com.byit.dto.executor;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+
+import java.io.Serializable;
+import java.util.Map;
+
+/**
+ * 运行参数包装逻辑
+ *
+ * @author huangfu
+ * @date 2020年9月24日15:32:39
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode
+public class RunParamWrapped implements Serializable {
+    private static final long serialVersionUID = -2926047980768857364L;
+    /**
+     * 公共参数字典
+     */
+    private Map<String,String> publicParamMap;
+
+    /**
+     * 私有参数
+     */
+    private String privateParam;
+}

byit-myth-core/myth-dto-core/src/main/java/com/byit/dto/plugin/PluginFlowConfig.java

@@ -5,6 +5,8 @@ import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import java.util.Map;
+
 /**
  * @description: 插件端工作流的配置
  * @author: gml
@@ -17,6 +19,11 @@ import lombok.NoArgsConstructor;
 public class PluginFlowConfig {
 
     /**
+     * 公共参数
+     */
+    private Map<String,String> publicParam;
+
+    /**
      * 当前工作流版本的告警的时机(0 不告警， 1 完成时告警， 2 失败时告警， 3 成功时告警)
      */
     private String alarmlAction;

byit-myth-core/myth-dto-core/src/main/java/com/byit/dto/specials/SpecialJobParam.java

@@ -4,6 +4,7 @@ import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -29,7 +30,7 @@ public class SpecialJobParam {
     /**
      * 是否补批本节点   1：是   2：否
      */
-    private String supplementStatus;
+    private String supplementStatus = "1";
 
     /**
      * 开始节点的名称
@@ -39,6 +40,16 @@ public class SpecialJobParam {
     /**
      * 任务名称  -> 任务参数载体
      */
-    Map<String,String> paramCarrier;
+    private Map<String,String> paramCarrier;
+
+    /**
+     * 公共参数
+     */
+    private Map<String,String> publicParam;
+
+    /**
+     * 时间参数
+     */
+    private List<String> repairTimeList;
 
 }