Merge remote-tracking branch 'origin/developer' into developer

byit-mybatis-plugin/pom.xml

@@ -38,6 +38,7 @@
 			<plugin>
 				<groupId>org.springframework.boot</groupId>
 				<artifactId>spring-boot-maven-plugin</artifactId>
+				<version>1.5.19.RELEASE</version>
 			</plugin>
 		</plugins>
 	</build>

byit-myth-admin/pom.xml

@@ -39,12 +39,6 @@
             <groupId>io.springfox</groupId>
             <artifactId>springfox-swagger-ui</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.byit</groupId>
-            <artifactId>byit-validation-starter</artifactId>
-            <version>1.0-SNAPSHOT</version>
-        </dependency>
-
     </dependencies>
 
     <build>

byit-myth-admin/src/main/java/com/byit/controller/FlowController.java

@@ -49,9 +49,9 @@ public class FlowController {
 
     @PostMapping("get")
     @ApiOperation("查询工作流")
-    public NodeVo getFlow(@RequestBody Integer flowId){
-        NodeVo flow = flowService.getFlowId(flowId);
-        return null;
+    public FlowVo getFlow(@RequestBody Integer flowId){
+        FlowVo flow = flowService.getFlowId(flowId);
+        return flow;
     }
 
     @PostMapping("start")

byit-myth-core/myth-admin-core/src/main/java/com/byit/enums/FlowProperTyEnum.java

+package com.byit.enums;
+
+/**
+ * @description: 工作流属性的枚举类
+ * @author: gml
+ * @create: 2019-12-26 15:17
+ */
+public enum FlowProperTyEnum {
+
+    HAVE_DEPEND("0", "有下游依赖"),
+    NO_HAVE_DEPEND("1", "没有下游依赖"),
+    IS_INNER("0", "是内嵌工作流"),
+    ISNOT_INNER("1", "不是内嵌工作流"),
+    IS_TOP("0", "是顶级工作流"),
+    ISNOT_TOP("1", "不是顶级工作流")
+    ;
+
+    private String code;
+    private String name;
+
+    private FlowProperTyEnum(String code, String name){
+        this.code = code;
+        this.name = name;
+    }
+
+    public String getCode(){
+        return this.code;
+    }
+
+    public String getName(){
+        return this.name;
+    }
+
+}

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

 package com.byit.mapper;
 
 import com.byit.model.NodeDependencyKey;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
 
 public interface NodeDependencyMapper {
     int deleteById(NodeDependencyKey key);
 
-    int insert(NodeDependencyKey record);
+    int insert(@Param("nodeId") Integer nodeId, @Param("dependNodeId") Integer dependNodeId);
 
     int insertSelective(NodeDependencyKey record);
+
+    /**
+     * 根据节点id删除依赖关系
+     * @param nodeId
+     * @return
+     */
+    int deleteByNodeId(Integer nodeId);
+
+    /**
+     * 根据节点id查询本节点依赖的节点
+     * @param nodeId
+     * @return
+     */
+    List<Integer> findByNodeId(Integer nodeId);
 }
\ No newline at end of file

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

@@ -2,6 +2,8 @@ package com.byit.mapper;
 
 import com.byit.model.Node;
 
+import java.util.List;
+
 public interface NodeMapper {
     int deleteById(Integer nodeId);
 
@@ -25,4 +27,23 @@ public interface NodeMapper {
      */
     int updateOnforkDown(Integer flowId);
 
+    /**
+     * 查找在工作流调度上的节点
+     * @param flowId
+     * @return
+     */
+    List<Node> findOnforkByFlowId(Integer flowId);
+
+    /**
+     * 查找工作流下的虚拟节点
+     * @param flowId
+     * @return
+     */
+    List<Node> findVirtualByFlowId(Integer flowId);
+
+    /**
+     * 删除工作流下的虚拟节点
+     * @param flowId
+     */
+    void deleteVirtualNode(Integer flowId);
 }
\ No newline at end of file

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

@@ -2,14 +2,14 @@ package com.byit.model;
 
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
-import java.io.Serializable;
-import java.util.Date;
-
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import java.io.Serializable;
+import java.util.Date;
+
 /**
  * 工作流
  * @author gen
@@ -69,21 +69,21 @@ public class Flow implements Serializable {
     private Long flowTimeout;
 
     /**
-     * 是否有下游节点  0 否，1 是
+     * 是否有下游节点  1 否，0 是
      */
-    @ApiModelProperty("是否有下游节点  0 否，1 是")
+    @ApiModelProperty("是否有下游节点  1 否，0 是")
     private String isHaveDepend;
 
     /**
-     * 是否是内嵌工作流 0 否， 1 是
+     * 是否是内嵌工作流 1 否， 0 是
      */
-    @ApiModelProperty("是否是内嵌工作流 0 否， 1 是")
+    @ApiModelProperty("是否是内嵌工作流 1 否， 0 是")
     private String isInner;
 
     /**
-     * 是否是顶级工作流 0 否， 1 是
+     * 是否是顶级工作流 1 否， 0 是
      */
-    @ApiModelProperty("是否是顶级工作流 0 否， 1 是")
+    @ApiModelProperty("是否是顶级工作流 1 否， 0 是")
     private String isTop;
 
     /**
@@ -125,7 +125,7 @@ public class Flow implements Serializable {
     /**
      * 是否启动   0不启动  1启动
      */
-    @ApiModelProperty("是否启动   0不启动  1启动")
+    @ApiModelProperty("是否启动   1不启动  0启动")
     private String startUp;
 
     /**

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

@@ -2,14 +2,14 @@ package com.byit.model;
 
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
-import java.io.Serializable;
-import java.util.Date;
-
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import java.io.Serializable;
+import java.util.Date;
+
 /**
  * 工作流版本
  * @author gen
@@ -135,21 +135,21 @@ public class FlowVersion implements Serializable {
     private String versionName;
 
     /**
-     * 是否有下游节点  0 否，1 是
+     * 是否有下游节点  1 否，0 是
      */
-    @ApiModelProperty("是否有下游节点  0 否，1 是")
+    @ApiModelProperty("是否有下游节点  1 否，0 是")
     private String isHaveDepend;
 
     /**
-     * 是否是内嵌工作流 0 否， 1 是
+     * 是否是内嵌工作流 1 否， 0 是
      */
-    @ApiModelProperty("是否是内嵌工作流 0 否， 1 是")
+    @ApiModelProperty("是否是内嵌工作流 1 否， 0 是")
     private String isInner;
 
     /**
-     * 是否是顶级工作流 0 否， 1 是
+     * 是否是顶级工作流 1 否， 0 是
      */
-    @ApiModelProperty("是否是顶级工作流 0 否， 1 是")
+    @ApiModelProperty("是否是顶级工作流 1 否， 0 是")
     private String isTop;
 
     /**

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

@@ -63,21 +63,21 @@ public class FlowVo implements Serializable {
     private Long flowTimeout;
 
     /**
-     * 是否有下游节点  0 否，1 是
+     * 是否有下游节点  1 否，0 是
      */
-    @ApiModelProperty("是否有下游节点  0 否，1 是")
+    @ApiModelProperty("是否有下游节点  1 否，0 是")
     private String isHaveDepend;
 
     /**
-     * 是否是内嵌工作流 0 否， 1 是
+     * 是否是内嵌工作流 1 否， 0 是
      */
-    @ApiModelProperty("是否是内嵌工作流 0 否， 1 是")
+    @ApiModelProperty("是否是内嵌工作流 1 否， 0 是")
     private String isInner;
 
     /**
-     * 是否是顶级工作流 0 否， 1 是
+     * 是否是顶级工作流 1 否， 0 是
      */
-    @ApiModelProperty("是否是顶级工作流 0 否， 1 是")
+    @ApiModelProperty("是否是顶级工作流 1 否， 0 是")
     private String isTop;
 
 
@@ -112,9 +112,9 @@ public class FlowVo implements Serializable {
     private Date addTime;
 
     /**
-     * 是否启动   0不启动  1启动
+     * 是否启动   1不启动  0启动
      */
-    @ApiModelProperty("是否启动   0不启动  1启动")
+    @ApiModelProperty("是否启动   1不启动  0启动")
     private String startUp;
 
     /**
@@ -142,10 +142,16 @@ public class FlowVo implements Serializable {
     private Integer remainingCount;
 
     /**
+     * 节点是否跟随任务流，1跟随  2不跟随
+     */
+    @ApiModelProperty("节点是否跟随任务流，1跟随  2不跟随")
+    private String scheduleFollow;
+
+    /**
      * 工作流依赖的工作流id
      */
     @ApiModelProperty("工作流依赖的工作流id")
-    private String flowDepend;
+    private List<Integer> flowDepend;
 
     /**
      * 在工作流调度中的节点

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

@@ -5,6 +5,7 @@ import lombok.Data;
 
 import java.io.Serializable;
 import java.util.Date;
+import java.util.List;
 
 /**
  * @description: 工作流VO类
@@ -205,6 +206,12 @@ public class NodeVo implements Serializable {
     @ApiModelProperty("源码")
     private String runSource;
 
+    /**
+     * 依赖节点
+     */
+    @ApiModelProperty("依赖节点")
+    private List<Integer> dependNodeId;
+
 
     /**
      */

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

@@ -2,7 +2,6 @@ package com.byit.service;
 
 import com.byit.model.Flow;
 import com.byit.model.vo.FlowVo;
-import com.byit.model.vo.NodeVo;
 
 /**
  * @description: 工作流业务逻辑接口
@@ -41,7 +40,7 @@ public interface FlowService {
      * @param flowId
      * @return
      */
-    NodeVo getFlowId(Integer flowId);
+    FlowVo getFlowId(Integer flowId);
 
     /**
      * 启动工作流

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

@@ -3,6 +3,7 @@ package com.byit.service.impl;
 import com.byit.job.utils.CronExpression;
 import com.byit.mapper.FlowDependentMapper;
 import com.byit.mapper.FlowMapper;
+import com.byit.mapper.NodeDependencyMapper;
 import com.byit.mapper.NodeMapper;
 import com.byit.model.Flow;
 import com.byit.model.FlowDependentKey;
@@ -11,6 +12,7 @@ import com.byit.model.vo.FlowVo;
 import com.byit.model.vo.NodeVo;
 import com.byit.service.FlowService;
 import com.byit.util.FlowInitUtil;
+import com.byit.utils.ValidationUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;
@@ -18,7 +20,7 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
-import java.util.Arrays;
+import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 
@@ -38,34 +40,33 @@ public class FlowServiceImpl implements FlowService {
     private NodeMapper nodeMapper;
     @Resource
     private FlowDependentMapper flowDependentMapper;
+    @Resource
+    private NodeDependencyMapper nodeDependencyMapper;
 
     @Override
     public Flow saveJobFlow(FlowVo flowVo) {
-        //TODO 未做参数校验
-        Flow flow = new Flow();
-        BeanUtils.copyProperties(flowVo, flow);
-
-        //只要修改就设置为未启动
-        flow.setStartUp("0");
+        ValidationUtil.dataNotNull(flowVo.getFlowId(), "工作流Id不允许为空！");
 
         //设置在工作流上的节点相关信息
         List<NodeVo> nodeVoList = flowVo.getNodeVoList();
         if (null != nodeVoList && nodeVoList.size() > 0){
             //设置在工作流上的节点数目
-            int nodeCount = nodeVoList.size();
-            log.info("将【{}】个节点在工作流【{}】调度流程中", nodeCount, flow.getFlowName());
-            flow.setFlowNodeCount(nodeCount);
-            //将工作流下的所有节点设为不在工作流调度上
-            log.info("将工作流【{}】所有的节点移下调度", flow.getFlowName());
-            nodeMapper.updateOnforkDown(flow.getFlowId());
-            //将对应的节点更改为在调度上
-            log.info("给工作流【{}】添加节点调度调度", flow.getFlowName());
-            nodeVoList.forEach(nodeVo -> nodeMapper.updateOnforkUp(nodeVo.getNodeId()));
+            log.info("将【{}】个节点在工作流【{}】调度流程中", nodeVoList.size(), flowVo.getFlowName());
+            //重新组织节点的依赖和调度关系
+            reNodeDepend(flowVo, nodeVoList);
         }
 
         //重组工作流依赖
         reFlowDepend(flowVo);
 
+        Flow flow = new Flow();
+        BeanUtils.copyProperties(flowVo, flow);
+
+        //只要修改就设置为未启动
+        flow.setStartUp("0");
+        //设置在工作流上的节点数目
+        flow.setFlowNodeCount(nodeVoList.size());
+
         //更新工作流的相关信息
         flowMapper.updateByIdSelective(flow);
 
@@ -73,6 +74,66 @@ public class FlowServiceImpl implements FlowService {
     }
 
     /**
+     * 重新组织节点的依赖和调度关系
+     * @param flowVo
+     * @param nodeVoList
+     */
+    private void reNodeDepend(FlowVo flowVo, List<NodeVo> nodeVoList) {
+
+        //将工作流下的所有节点设为不在工作流调度上
+        log.info("将工作流【{}】所有的节点移下调度,并删除相关的依赖关系", flowVo.getFlowName());
+        //查询当前工作流下所有在调度上的节点
+        List<Node> nodeList = nodeMapper.findOnforkByFlowId(flowVo.getFlowId());
+        //删除在调度上的节点的相关依赖
+        nodeList.forEach(node -> nodeDependencyMapper.deleteByNodeId(node.getNodeId()));
+        nodeMapper.updateOnforkDown(flowVo.getFlowId());
+
+        //查找并删除工作流下的虚节点
+        List<Node> virtualNodeList = nodeMapper.findVirtualByFlowId(flowVo.getFlowId());
+        if (null != virtualNodeList && virtualNodeList.size() > 0){
+            for (Node node : virtualNodeList) {
+                Flow virtualFlow = new Flow();
+                virtualFlow.setFlowId(node.getMapFlowId());
+                virtualFlow.setIsInner("0");
+                //将内嵌的工作流设置为不是内嵌
+                flowMapper.updateByIdSelective(virtualFlow);
+            }
+        }
+        //删除工作流下虚拟的节点
+        nodeMapper.deleteVirtualNode(flowVo.getFlowId());
+
+        //将对应的节点更改为在调度上
+        log.info("给工作流【{}】添加节点调度调度", flowVo.getFlowName());
+        for (NodeVo nodeVo : nodeVoList) {
+            if (StringUtils.isNotEmpty(nodeVo.getIsVirtual()) && "1".equals(nodeVo.getIsVirtual())){
+                //如果是虚拟节点就根据节点的id查找工作流的id
+                Flow virtualFlow = flowMapper.getById(nodeVo.getNodeId());
+                Node virtualNode = new Node();
+                virtualNode.setMapFlowId(nodeVo.getNodeId());
+                virtualNode.setIsVirtual("0");
+                virtualNode.setAuthor(virtualFlow.getAuthor());
+                virtualNode.setAddTime(new Date());
+                virtualNode.setOnFork("0");
+                virtualNode.setVersionName(virtualFlow.getVersionName());
+                Integer virtualNodeId = nodeMapper.insertSelective(virtualNode);
+                //将虚拟节点真实节点改为nodeid
+                nodeVo.setNodeId(virtualNode.getNodeId());
+                //将映射的工作流改为是内嵌工作流
+                virtualFlow.setIsInner("1");
+                flowMapper.updateByIdSelective(virtualFlow);
+            }else {
+                nodeMapper.updateOnforkUp(nodeVo.getNodeId());
+            }
+            //重新组建节点的依赖关系
+            if (null != nodeVo.getDependNodeId() && nodeVo.getDependNodeId().size() > 0){
+                List<Integer> dependNodeList = nodeVo.getDependNodeId();
+                dependNodeList.forEach(dependNodeId-> nodeDependencyMapper.insert(nodeVo.getNodeId(), dependNodeId));
+            }
+        }
+
+    }
+
+    /**
      * 重新组织工作流的依赖关系
      * @param flowVo
      */
@@ -92,15 +153,16 @@ public class FlowServiceImpl implements FlowService {
 
         log.info("开始建立【{}】工作流的依赖关系，并将上游工作流设置为拥有下游工作流", flowVo.getFlowName());
         //判断是否有工作流依赖
-        if (StringUtils.isNotEmpty(flowVo.getFlowDepend())){
-            String flowDepends = flowVo.getFlowDepend();
-            List<String> flowDependList = Arrays.asList(flowDepends);
-            for (String flowDependId : flowDependList){
-                Flow flow = flowMapper.getById(Integer.valueOf(flowDependId));
+        if (null != flowVo.getFlowDepend() && flowVo.getFlowDepend().size() > 0){
+            List<Integer> flowDependList = flowVo.getFlowDepend();
+            for (Integer flowDependId : flowDependList){
+                Flow flow = flowMapper.getById(flowDependId);
                 flow.setIsHaveDepend("1");
                 flowMapper.updateByIdSelective(flow);
-                flowDependentMapper.insert(flowVo.getFlowId(), Integer.valueOf(Integer.valueOf(flowDependId)));
+                flowDependentMapper.insert(flowVo.getFlowId(), flowDependId);
             }
+        }else {
+            flowVo.setIsTop("1");
         }
 
     }
@@ -108,7 +170,8 @@ public class FlowServiceImpl implements FlowService {
     @Override
     @Transactional
     public Flow createFlow(FlowVo flowVo) {
-        //TODO 未做参数校验
+        ValidationUtil.dataNotBank(flowVo.getFlowName(), "工作流名称不允许为空！");
+        ValidationUtil.dataNotBank(flowVo.getScheduleFollow(), "请填写节点是否跟随工作流调度！");
         Flow flow = new Flow();
         BeanUtils.copyProperties(flowVo, flow);
 
@@ -146,8 +209,25 @@ public class FlowServiceImpl implements FlowService {
     }
 
     @Override
-    public NodeVo getFlowId(Integer flowId) {
-        return null;
+    public FlowVo getFlowId(Integer flowId) {
+        ValidationUtil.dataNotNull(flowId, "工作流Id不允许为空！");
+        Flow flow = flowMapper.getById(flowId);
+        ValidationUtil.dataNotNull(flow, "查无此工作流！");
+        FlowVo flowVo = new FlowVo();
+        BeanUtils.copyProperties(flow, flowVo);
+        //将工作流下在调度上的节点添加进来
+        List<Node> nodeList = nodeMapper.findOnforkByFlowId(flowId);
+        if (null != nodeList && nodeList.size() > 0){
+            List<NodeVo> nodeVoList = new ArrayList<>();
+            nodeList.forEach(node -> {
+                NodeVo nodeVo = new NodeVo();
+                BeanUtils.copyProperties(node, nodeVo);
+                List<Integer> dependNodeIdList = nodeDependencyMapper.findByNodeId(node.getNodeId());
+                nodeVoList.add(nodeVo);
+            });
+            flowVo.setNodeVoList(nodeVoList);
+        }
+        return flowVo;
     }
 
     @Override

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

@@ -6,16 +6,27 @@
     <id column="node_id" jdbcType="INTEGER" property="nodeId" />
     <id column="dependency_id" jdbcType="INTEGER" property="dependencyId" />
   </resultMap>
+
+  <select id="findByNodeId" parameterType="integer" resultType="integer">
+    select dependency_id from node_dependency where node_id = #{nodeId,jdbcType=INTEGER}
+  </select>
+
   <delete id="deleteById" parameterType="com.byit.model.NodeDependencyKey">
     <!-- generated @mbg.generated date: 2019-12-25 -->
     delete from node_dependency
     where node_id = #{nodeId,jdbcType=INTEGER}
       and dependency_id = #{dependencyId,jdbcType=INTEGER}
   </delete>
-  <insert id="insert" parameterType="com.byit.model.NodeDependencyKey">
+
+  <delete id="deleteByNodeId" parameterType="integer">
+    delete from node_dependency
+    where node_id = #{nodeId,jdbcType=INTEGER}
+  </delete>
+
+  <insert id="insert" parameterType="integer">
     <!-- generated @mbg.generated date: 2019-12-25 -->
     insert into node_dependency (node_id, dependency_id)
-    values (#{nodeId,jdbcType=INTEGER}, #{dependencyId,jdbcType=INTEGER})
+    values (#{nodeId,jdbcType=INTEGER}, #{dependNodeId,jdbcType=INTEGER})
   </insert>
   <insert id="insertSelective" parameterType="com.byit.model.NodeDependencyKey">
     <!-- generated @mbg.generated date: 2019-12-25 -->

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

@@ -60,12 +60,39 @@
     from node
     where node_id = #{nodeId,jdbcType=INTEGER}
   </select>
+
+  <select id="findOnforkByFlowId" parameterType="integer" resultMap="BaseResultMap">
+    select
+    <include refid="Base_Column_List" />
+    ,
+    <include refid="Blob_Column_List" />
+    from node
+    where flow_id = #{flowId,jdbcType=INTEGER}
+         and on_fork = '0';
+  </select>
+
+  <select id="findVirtualByFlowId" parameterType="integer" resultMap="BaseResultMap">
+    select
+    <include refid="Base_Column_List" />
+    ,
+    <include refid="Blob_Column_List" />
+    from node
+    where flow_id = #{flowId,jdbcType=INTEGER}
+    and is_virtual = '0';
+  </select>
+
   <delete id="deleteById" parameterType="java.lang.Integer">
     <!-- generated @mbg.generated date: 2019-12-25 -->
     delete from node
     where node_id = #{nodeId,jdbcType=INTEGER}
   </delete>
 
+  <delete id="deleteVirtualNode">
+    delete from node
+    where flow_id = #{flowId,jdbcType=INTEGER}
+    and is_virtual = '0';
+  </delete>
+
   <insert id="insertSelective" parameterType="com.byit.model.Node">
     <!-- generated @mbg.generated date: 2019-12-25 -->
     insert into node

byit-myth-executor/myth-exector-plugin/pom.xml

@@ -53,12 +53,13 @@
     </dependencies>
 
 
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.springframework.boot</groupId>
-                <artifactId>spring-boot-maven-plugin</artifactId>
-            </plugin>
-        </plugins>
-    </build>
+<!--    <build>-->
+<!--        <plugins>-->
+<!--            <plugin>-->
+<!--                <groupId>org.springframework.boot</groupId>-->
+<!--                <artifactId>spring-boot-maven-plugin</artifactId>-->
+<!--                <version>${spring-boot.version}</version>-->
+<!--            </plugin>-->
+<!--        </plugins>-->
+<!--    </build>-->
 </project>
\ No newline at end of file