Skip to content

B
byit-myth-job
Commit 8edbcee1 by guominglei
Options

插件端工作流保存进行环路校验

parent 7ff3247d
Showing with 404 additions and 205 deletions
byit-myth-admin/src/main/java/com/byit/api/ApiFlowController.java
package com.byit.api;
import com.byit.job.dto.plugin.PluginFlow;
import com.byit.job.dto.plugin.PluginFlowDepend;
import com.byit.job.dto.plugin.PluginPackage;
import com.byit.service.ApiFlowService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
......@@ -27,8 +26,8 @@ public class ApiFlowController {
@PostMapping("publish")
@ApiOperation("发布工作流，并开始调度")
public String publishFlow(@RequestBody PluginFlow flow){
apiFlowService.publishFlow(flow);
public String publishFlow(@RequestBody PluginPackage pluginPackage){
apiFlowService.publishFlow(pluginPackage);
return "SUCCESS";
}
......@@ -39,27 +38,6 @@ public class ApiFlowController {
return "SUCCESS";
}
@PostMapping("addDepend")
@ApiOperation("添加工作流依赖，只是添加一个依赖")
public String addDepend(String flowName, String dependFlowName, String workspaceName){
apiFlowService.addDepend(flowName, dependFlowName, workspaceName);
return "SUCCESS";
}
@PostMapping("resetDepend")
@ApiOperation("重置工作流依赖，将工作流的所有依赖重置为依赖工作流名称集合中的工作流")
public String resetDepend(@RequestBody PluginFlowDepend flowDepend){
apiFlowService.resetDepend(flowDepend);
return "SUCCESS";
}
@PostMapping("deleteDepend")
@ApiOperation("删除工作流依赖，只是删除一个依赖关系")
public String deleteDepend(String flowName, String dependFlowName, String workspaceName){
apiFlowService.deleteDepend(flowName, dependFlowName, workspaceName);
return "SUCCESS";
}
@PostMapping("start")
@ApiOperation("开始工作流的调度，将工作流启用调度")
public String start(String flowName, String workspaceName){
......
byit-myth-admin/src/main/java/com/byit/service/ApiFlowService.java
package com.byit.service;
import com.byit.job.dto.plugin.PluginFlow;
import com.byit.job.dto.plugin.PluginFlowDepend;
import com.byit.job.dto.plugin.PluginPackage;
/**
* @description: 工作流的api请求业务处理接口
......@@ -12,12 +12,6 @@ public interface ApiFlowService {
void deleteFlow(String flowName);
void addDepend(String flowName, String dependFlowName, String workspaceName);
void resetDepend(PluginFlowDepend flowDepend);
void deleteDepend(String flowName, String dependFlowName, String workspaceName);
void start(String flowName, String workspaceName);
void repealSchedule(String flowName, String workspaceName);
......@@ -28,5 +22,13 @@ public interface ApiFlowService {
void reStartSchedule(String runId);
void publishFlow(PluginFlow flow);
void publishFlow(PluginPackage pluginPackage);
/**
* 判断工作流石佛存在
* @param workspaceId
* @param flow
* @return
*/
void validateFlow(Integer workspaceId, PluginFlow flow);
}
byit-myth-admin/src/main/java/com/byit/service/impl/ApiFlowServiceImpl.java
package com.byit.service.impl;
import com.byit.enums.DagCheckEnum;
import com.byit.enums.FlowPropertyEnum;
import com.byit.job.dto.plugin.PluginBaseNode;
import com.byit.job.dto.plugin.PluginFlow;
import com.byit.job.dto.plugin.PluginFlowDepend;
import com.byit.job.dto.plugin.PluginPackage;
import com.byit.job.enums.plugin.PluginNodeTypeEnum;
import com.byit.job.utils.CronExpression;
import com.byit.mapper.FlowMapper;
import com.byit.mapper.WorkspaceMapper;
import com.byit.model.Flow;
import com.byit.model.Workspace;
import com.byit.service.ApiFlowService;
import com.byit.util.ApiFlowDagCheck;
import com.byit.utils.ValidationUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
/**
* @description: 工作流的Api请求业务处理实现类
* @author: gml
* @create: 2019-12-30 14:37
*/
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class ApiFlowServiceImpl implements ApiFlowService {
......@@ -26,27 +40,114 @@ public class ApiFlowServiceImpl implements ApiFlowService {
private WorkspaceMapper workspaceMapper;
@Override
public void publishFlow(PluginFlow flow) {
@Transactional(rollbackFor = Exception.class)
public void publishFlow(PluginPackage pluginPackage) {
//校验参数
validate(pluginPackage);
}
@Override
public void deleteFlow(String flowName) {
/**
* 校验插件端请求参数是否合法
* @param pluginPackage
*/
private void validate(PluginPackage pluginPackage) {
ValidationUtil.dataNotBank(pluginPackage.getWorkspaceName(), "工作空间名称不允许为空！");
ValidationUtil.dataNotNull(pluginPackage.getFlow(), "工作流信息不允许为空！");
Workspace workspace = workspaceMapper.getByName(pluginPackage.getWorkspaceName());
ValidationUtil.dataNotNull(workspace, "工作空间不存在，请先添加工作空间");
PluginFlow flow = pluginPackage.getFlow();
//校验工作流参数配置
validateFlow(workspace.getWorkspaceId(), flow);
//校验工作流名称是否重复
HashSet<String> flowNameSet = new HashSet<>();
//用来工作流的内嵌关系
HashMap<String, Integer> lineMap = new HashMap<>();
//父工作流
HashSet<String> fromFlowSet = new HashSet<>();
//内嵌工作流
HashSet<String> toFlowSet = new HashSet<>();
checkFlow(workspace, flow, flowNameSet, fromFlowSet, toFlowSet, lineMap);
//校验内嵌的工作流是否存在环路
ApiFlowDagCheck flowDagCheck = new ApiFlowDagCheck();
flowDagCheck.initDag(flowNameSet, fromFlowSet, toFlowSet, lineMap);
//校验是否存在环路
DagCheckEnum loopCheck = flowDagCheck.checkDag();
ValidationUtil.isTrueValidation(DagCheckEnum.PASS.getCode().equals(loopCheck.getCode()), loopCheck.getMsg());
}
@Override
public void addDepend(String flowName, String dependFlowName, String workspaceName) {
/**
* 校验工作流
* @param workspace
* @param flow
* @param flowNameSet
* @param fromFlowSet
* @param flowNameSet
* @param lineMap
*/
private void checkFlow(Workspace workspace, PluginFlow flow, HashSet<String> flowNameSet, HashSet<String> fromFlowSet, HashSet<String> toFlowSet, HashMap<String, Integer> lineMap) {
//校验是否存在重名工作流
ValidationUtil.isTrueValidation(!flowNameSet.add(flow.getName()), "同一个工作空间内工作流名称不允许重复！");
fromFlowSet.add(flow.getName());
List<PluginBaseNode> nodeList = flow.getNodeList();
//用来校验同一工作流下是否有重复的节点
HashSet<String> nodeSet = new HashSet<>();
nodeList.forEach(node -> {
ValidationUtil.dataNotBank(node.getName(), "节点名称不允许为空！");
ValidationUtil.isTrueValidation(!nodeSet.add(node.getName()), "同一个工作流下任务节点不允许重复！");
//判断节点类型
if (PluginNodeTypeEnum.FLOW.getCode().equals(node.getType())){
//校验node的类别
ValidationUtil.isTrueValidation(!(node instanceof PluginFlow), "工作流的type设置错误，只有当节点为内嵌工作流是type才允许设置为flow");
//校验父工作流和内嵌工作流的执行类型是否一致
ValidationUtil.isTrueValidation(!(flow.getConfig().getExecType().equals(((PluginFlow) node).getConfig().getExecType())), "内嵌工作流的调度配置必须和父工作流配置保持一致！");
validateFlow(workspace.getWorkspaceId(), (PluginFlow) node);
toFlowSet.add(node.getName());
lineMap.put(flow.getName() + "_" + node.getName(), 1);
checkFlow(workspace, (PluginFlow) node, flowNameSet, fromFlowSet, toFlowSet, lineMap);
}
});
//校验同一个工作流下的任务节点是否存在环路
ApiFlowDagCheck nodeDagCheck = new ApiFlowDagCheck();
nodeDagCheck.initDag(nodeList);
//校验开始节点名称
DagCheckEnum checkStart = nodeDagCheck.checkStart();
ValidationUtil.isTrueValidation(DagCheckEnum.PASS.getCode().equals(checkStart.getCode()), checkStart.getCode() == 0 ? checkStart.getMsg() : checkStart.getMsg() + "start");
//校验结束节点名称
DagCheckEnum endCheck = nodeDagCheck.checkEnd();
ValidationUtil.isTrueValidation(DagCheckEnum.PASS.getCode().equals(endCheck.getCode()), endCheck.getCode() == 0 ? endCheck.getMsg() : endCheck.getMsg() + "end");
//校验是否有游离节点
DagCheckEnum freeCheck = nodeDagCheck.checkFreeNode();
ValidationUtil.isTrueValidation(DagCheckEnum.PASS.getCode().equals(freeCheck.getCode()), freeCheck.getMsg());
//校验是否存在环路
DagCheckEnum loopCheck = nodeDagCheck.checkDag();
ValidationUtil.isTrueValidation(DagCheckEnum.PASS.getCode().equals(loopCheck.getCode()), loopCheck.getMsg());
}
@Override
public void resetDepend(PluginFlowDepend flowDepend) {
public void validateFlow(Integer workspaceId, PluginFlow pluginFlow) {
ValidationUtil.dataNotBank(pluginFlow.getName(), "工作流名称不允许为空！");
ValidationUtil.dataNotNull(pluginFlow.getConfig(), "工作流配置不允许为空！");
ValidationUtil.dataNotBank(pluginFlow.getConfig().getExecType(), "工作流的调度类型不允许为空！");
if (FlowPropertyEnum.SCHEDULE_MODE.getCode().equals(pluginFlow.getConfig().getExecType())){
ValidationUtil.dataNotBank(pluginFlow.getConfig().getFlowCron(), "工作流cron表达式不允许为空！");
ValidationUtil.isTrueValidation(CronExpression.isValidExpression(pluginFlow.getConfig().getFlowCron()), "工作流cron表达式不符合规范！");
}
Flow flow = flowMapper.getByWorkSpaceAndName(workspaceId, pluginFlow.getName());
//判断是否是重发
//是重发
if (pluginFlow.isRePublish()){
ValidationUtil.dataNotNull(flow, "工作流【"+ flow.getFlowName() + "】不存在！");
}else {//不是重发
ValidationUtil.isTrueValidation(null != flow, "工作流【"+ flow.getFlowName() + "】已存在！");
}
}
@Override
public void deleteDepend(String flowName, String dependFlowName, String workspaceName) {
public void deleteFlow(String flowName) {
}
......
byit-myth-core/myth-admin-core/src/main/java/com/byit/enums/DagCheckEnum.java 0 → 100644
package com.byit.enums;
import lombok.Getter;
@Getter
public enum DagCheckEnum {
LOOP(0, "存在环路"),
FREE(1, "存在游离节点"),
PASS(2, "校验通过"),
STARTNAME_WRONG(3, "开始节点必须是"),
ENDNAME_WRONG(4, "结束节点必须是"),
;
private Integer code;
private String msg;
private DagCheckEnum(Integer code, String msg){
this.code = code;
this.msg = msg;
}
public Integer getCode(){
return this.code;
}
public String getMsg(){
return this.msg;
}
public static String getNameByCode(Integer code) {
for (DagCheckEnum type : DagCheckEnum.values()) {
if (type.getCode().equals(code)) {
return type.getMsg();
}
}
return null;
}
}
byit-myth-core/myth-admin-core/src/main/java/com/byit/enums/FlowPropertyEnum.java
......@@ -11,6 +11,8 @@ public enum FlowPropertyEnum {
ISNOT_INNER("1", "不是内嵌工作流"),
IS_START("0", "启动"),
NO_START("1", "未启动"),
MANUAL_MODE("2", "手动执行"),
SCHEDULE_MODE("1", "周期执行")
;
private String code;
......
byit-myth-core/myth-admin-core/src/main/java/com/byit/mapper/FlowMapper.java
package com.byit.mapper;
import com.byit.model.Flow;
import org.apache.ibatis.annotations.Param;
public interface FlowMapper {
int deleteById(Integer flowId);
......@@ -11,4 +12,11 @@ public interface FlowMapper {
int updateByIdSelective(Flow record);
/**
* 根据工作空间和工作流名称查找是否存在工作流
* @param workspaceId
* @param flowName
* @return
*/
Flow getByWorkSpaceAndName(@Param("workspaceId") Integer workspaceId, @Param("flowName") String flowName);
}
\ No newline at end of file
byit-myth-core/myth-admin-core/src/main/java/com/byit/mapper/WorkspaceMapper.java
......@@ -5,13 +5,16 @@ import com.byit.model.Workspace;
public interface WorkspaceMapper {
int deleteById(Integer workspaceId);
int insert(Workspace record);
int insertSelective(Workspace record);
Workspace getById(Integer workspaceId);
int updateByIdSelective(Workspace record);
int updateById(Workspace record);
/**
* 根据名称查找工作空间
* @param workspaceName
* @return
*/
Workspace getByName(String workspaceName);
}
\ No newline at end of file
byit-myth-core/myth-admin-core/src/main/java/com/byit/util/ApiFlowDagCheck.java
package com.byit.util;
import com.byit.job.dto.plugin.PluginFlow;
import com.byit.utils.ValidationUtil;
import com.byit.enums.DagCheckEnum;
import com.byit.job.dto.plugin.PluginBaseNode;
import java.util.*;
......@@ -11,33 +11,175 @@ import java.util.*;
* @create: 2019-12-30 16:34
*/
public class ApiFlowDagCheck {
//节点个数
private int flowNum;
private int nodeNum;
//连线个数
private int lineNum;
//节点入度
private Map<Integer, Integer> importNum = new HashMap<>();
private Map<String, Integer> importNum = new HashMap<>();
//入口集合
private Set<String> fromSet = new HashSet<>();
//出口集合
private Set<String> toSet = new HashSet<>();
//节点集合
private Set<String> flowSet = new HashSet<>();
private Set<String> nodeSet = new HashSet<>();
//用队列保存拓扑序列
private Queue<Integer> queue = new LinkedList<>();
private Queue<String> queue = new LinkedList<>();
//存储连线信息
private Map<String, Integer> graph = new HashMap<>();
//依赖的节点
private Set<String> dependSet = new HashSet<>();
private Set<String> dependencySet = new HashSet<>();
public void initDag(List<PluginBaseNode> nodeList){
//设置节点个数
this.nodeNum = nodeList.size();
public void init(List<PluginFlow> flowList){
for (PluginFlow pluginFlow : flowList){
if (!flowSet.add(pluginFlow.getFlowName())){
ValidationUtil.dataNotNull(null, "工作流名称不允许重复！");
//初始化连线信息
nodeList.forEach(node -> {
//判断节点是否有依赖
if (null != node.getDependNodeNameList() && node.getDependNodeNameList().size() > 0){
node.getDependNodeNameList().forEach(dependNodeName -> {
fromSet.add(dependNodeName);
dependencySet.add(dependNodeName);
//插入一条连线信息
graph.put(dependNodeName + "_" + node.getName(), 1);
lineNum += 1;
});
toSet.add(node.getName());
}else {
queue.offer(node.getName());
}
nodeSet.add(node.getName());
});
//初始化入度
initImportNum();
}
/**
* 初始化入度
*/
private void initImportNum(){
//初始化入度
for (String from : nodeSet){
for (String to : nodeSet){
Integer line = graph.get(from + "_" + to);
if (line != null && line == 1){
Integer count = importNum.get(to) == null ? 1 : importNum.get(to) + 1;
importNum.put(to, count);
}
}
}
}
public void initDag(HashSet<String> flowNameSet, HashSet<String> fromFlowSet, HashSet<String> toFlowSet, HashMap<String, Integer> lineMap) {
nodeSet.addAll(flowNameSet);
fromSet.addAll(fromFlowSet);
toSet.addAll(toFlowSet);
//初始化连线信息
graph = lineMap;
//初始化入度
initImportNum();
}
/**
* 校验是否保存游离节点
* @return
*/
public DagCheckEnum checkFreeNode(){
if(lineNum < nodeNum - 1){
return DagCheckEnum.FREE;
}
for (String jobName : nodeSet){
if (fromSet.contains(jobName)){
continue;
}
if(toSet.contains(jobName)){
continue;
}
return DagCheckEnum.FREE;
}
return DagCheckEnum.PASS;
}
/**
* 校验是否存在环路
* @return
*/
public DagCheckEnum checkDag(){
//入度为0的结点的个数，也就是入队个数
int number = 0;
//暂时存放拓扑序列
Queue<String> temp = new LinkedList<String>();
//删除这些被删除结点的出边（即对应结点入度减一）
while(!queue.isEmpty()){
String fromNode = queue.peek();
temp.offer(queue.poll());
number++;
for(String toNode : nodeSet){
String line = fromNode + "_" + toNode;
if(graph.get(line) != null && graph.get(line) == 1){
Integer num = importNum.get(toNode) - 1;
importNum.put(toNode, num);
//出现了新的入度为0的结点，删除
if(num == 0){
queue.offer(toNode);
}
}
}
}
if(number != nodeNum){
System.out.println("最后存在入度为1的结点，这个有向图是有回路的。");
return DagCheckEnum.LOOP;
}else{
System.out.println("这个有向图不存在回路，拓扑序列为：" + temp.toString());
return DagCheckEnum.PASS;
}
}
/**
* 校验是否单一起点
* @return
*/
public DagCheckEnum checkStart(){
int startNum = queue.size();
if(startNum == 0){
return DagCheckEnum.LOOP;
}else if(startNum == 1){
if("start".equals(queue.element())){
return DagCheckEnum.PASS;
}else{
return DagCheckEnum.STARTNAME_WRONG;
}
}
return DagCheckEnum.STARTNAME_WRONG;
}
/**
* 校验是否统一结尾
* @return
*/
public DagCheckEnum checkEnd(){
List<String> tempList = new ArrayList<>();
for (String nodeName : nodeSet){
if (dependencySet.contains(String.valueOf(nodeName))){
continue;
}
tempList.add(nodeName);
}
int num = tempList.size();
if(num == 0){
return DagCheckEnum.LOOP;
}else if(num == 1){
String nodeName = tempList.get(0);
if ("end".equals(nodeName)){
return DagCheckEnum.PASS;
}else {
return DagCheckEnum.ENDNAME_WRONG;
}
}
return DagCheckEnum.ENDNAME_WRONG;
}
}
byit-myth-core/myth-admin-core/src/main/java/com/byit/util/DagCheck.java
//package com.byit.util;
//
//import com.byit.enums.DagCheckEnum;
//import lombok.Data;
//import org.apache.commons.lang3.StringUtils;
//
......
byit-myth-core/myth-admin-core/src/main/resources/mapper/FlowMapper.xml
......@@ -40,30 +40,21 @@
from flow
where flow_id = #{flowId,jdbcType=INTEGER}
</select>
<select id="getByWorkSpaceAndName" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from flow
where workspace_id = #{workspaceId}
and flow_name = #{flowName}
</select>
<delete id="deleteById" parameterType="java.lang.Integer">
<!-- generated @mbg.generated date: 2019-12-31 -->
delete from flow
where flow_id = #{flowId,jdbcType=INTEGER}
</delete>
<insert id="insert" parameterType="com.byit.model.Flow">
<!-- generated @mbg.generated date: 2019-12-31 -->
insert into flow (flow_id, alarm_email, exec_type,
flow_cron, flow_desc, flow_name,
flow_node_count, flow_timeout, is_inner,
alarml_action, priority, trigger_next_time,
workspace_id, author, add_time,
start_up, principal, version_name,
repeat_count, remaining_count, schedule_follow,
is_update)
values (#{flowId,jdbcType=INTEGER}, #{alarmEmail,jdbcType=VARCHAR}, #{execType,jdbcType=CHAR},
#{flowCron,jdbcType=VARCHAR}, #{flowDesc,jdbcType=VARCHAR}, #{flowName,jdbcType=VARCHAR},
#{flowNodeCount,jdbcType=INTEGER}, #{flowTimeout,jdbcType=BIGINT}, #{isInner,jdbcType=CHAR},
#{alarmlAction,jdbcType=CHAR}, #{priority,jdbcType=CHAR}, #{triggerNextTime,jdbcType=BIGINT},
#{workspaceId,jdbcType=INTEGER}, #{author,jdbcType=VARCHAR}, #{addTime,jdbcType=TIMESTAMP},
#{startUp,jdbcType=CHAR}, #{principal,jdbcType=VARCHAR}, #{versionName,jdbcType=VARCHAR},
#{repeatCount,jdbcType=INTEGER}, #{remainingCount,jdbcType=INTEGER}, #{scheduleFollow,jdbcType=CHAR},
#{isUpdate,jdbcType=CHAR})
</insert>
<insert id="insertSelective" parameterType="com.byit.model.Flow">
<!-- generated @mbg.generated date: 2019-12-31 -->
insert into flow
......@@ -274,30 +265,5 @@
</set>
where flow_id = #{flowId,jdbcType=INTEGER}
</update>
<update id="updateById" parameterType="com.byit.model.Flow">
<!-- generated @mbg.generated date: 2019-12-31 -->
update flow
set alarm_email = #{alarmEmail,jdbcType=VARCHAR},
exec_type = #{execType,jdbcType=CHAR},
flow_cron = #{flowCron,jdbcType=VARCHAR},
flow_desc = #{flowDesc,jdbcType=VARCHAR},
flow_name = #{flowName,jdbcType=VARCHAR},
flow_node_count = #{flowNodeCount,jdbcType=INTEGER},
flow_timeout = #{flowTimeout,jdbcType=BIGINT},
is_inner = #{isInner,jdbcType=CHAR},
alarml_action = #{alarmlAction,jdbcType=CHAR},
priority = #{priority,jdbcType=CHAR},
trigger_next_time = #{triggerNextTime,jdbcType=BIGINT},
workspace_id = #{workspaceId,jdbcType=INTEGER},
author = #{author,jdbcType=VARCHAR},
add_time = #{addTime,jdbcType=TIMESTAMP},
start_up = #{startUp,jdbcType=CHAR},
principal = #{principal,jdbcType=VARCHAR},
version_name = #{versionName,jdbcType=VARCHAR},
repeat_count = #{repeatCount,jdbcType=INTEGER},
remaining_count = #{remainingCount,jdbcType=INTEGER},
schedule_follow = #{scheduleFollow,jdbcType=CHAR},
is_update = #{isUpdate,jdbcType=CHAR}
where flow_id = #{flowId,jdbcType=INTEGER}
</update>
</mapper>
\ No newline at end of file
byit-myth-core/myth-admin-core/src/main/resources/mapper/WorkspaceMapper.xml
......@@ -13,6 +13,7 @@
<!-- generated @mbg.generated date: 2019-12-31 -->
workspace_id, workspace_name, author, add_time, remove_mark
</sql>
<select id="getById" parameterType="java.lang.Integer" resultMap="BaseResultMap">
<!-- generated @mbg.generated date: 2019-12-31 -->
select
......@@ -20,18 +21,20 @@
from workspace
where workspace_id = #{workspaceId,jdbcType=INTEGER}
</select>
<select id="getByName" parameterType="string" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from workspace
where workspace_name = #{workspaceName,jdbcType=STRING}
</select>
<delete id="deleteById" parameterType="java.lang.Integer">
<!-- generated @mbg.generated date: 2019-12-31 -->
delete from workspace
where workspace_id = #{workspaceId,jdbcType=INTEGER}
</delete>
<insert id="insert" parameterType="com.byit.model.Workspace">
<!-- generated @mbg.generated date: 2019-12-31 -->
insert into workspace (workspace_id, workspace_name, author,
add_time, remove_mark)
values (#{workspaceId,jdbcType=INTEGER}, #{workspaceName,jdbcType=VARCHAR}, #{author,jdbcType=VARCHAR},
#{addTime,jdbcType=TIMESTAMP}, #{removeMark,jdbcType=CHAR})
</insert>
<insert id="insertSelective" parameterType="com.byit.model.Workspace">
<!-- generated @mbg.generated date: 2019-12-31 -->
insert into workspace
......@@ -89,13 +92,4 @@
</set>
where workspace_id = #{workspaceId,jdbcType=INTEGER}
</update>
<update id="updateById" parameterType="com.byit.model.Workspace">
<!-- generated @mbg.generated date: 2019-12-31 -->
update workspace
set workspace_name = #{workspaceName,jdbcType=VARCHAR},
author = #{author,jdbcType=VARCHAR},
add_time = #{addTime,jdbcType=TIMESTAMP},
remove_mark = #{removeMark,jdbcType=CHAR}
where workspace_id = #{workspaceId,jdbcType=INTEGER}
</update>
</mapper>
\ No newline at end of file
byit-myth-core/myth-core-common/src/main/java/com/byit/job/dto/plugin/PluginBaseNode.java
......@@ -3,6 +3,7 @@ package com.byit.job.dto.plugin;
import lombok.Data;
import java.io.Serializable;
import java.util.List;
/**
* @description: 基础Node
......@@ -15,12 +16,12 @@ public class PluginBaseNode implements Serializable {
/**
* 名称
*/
private String nodeName;
private String name;
/**
* 任务描述
* 描述
*/
private String nodeDesc;
private String desc;
/**
* 类型 节点：node， 内嵌工作流：innerFlow
......@@ -32,6 +33,11 @@ public class PluginBaseNode implements Serializable {
*/
private String author;
/**
* 依赖的任务节点名称集合，只能是节点的名称，如果不是内嵌工作流不允许设置依赖
*/
private List<String> dependNodeNameList;
private static final long serialVersionUID = 1L;
}
byit-myth-core/myth-core-common/src/main/java/com/byit/job/dto/plugin/PluginFlow.java
......@@ -2,7 +2,6 @@ package com.byit.job.dto.plugin;
import lombok.Data;
import java.io.Serializable;
import java.util.List;
/**
......@@ -11,22 +10,7 @@ import java.util.List;
* @create: 2019-12-30 10:44
*/
@Data
public class PluginFlow implements Serializable {
/**
* 当前工作流的介绍
*/
private String flowDesc;
/**
* 当前版本工作流名字
*/
private String flowName;
/**
* 创建人
*/
private String author;
public class PluginFlow extends PluginBaseNode {
/**
* 责任人
......@@ -36,7 +20,7 @@ public class PluginFlow implements Serializable {
/**
* 是否是重新发布 true 是，false 否
*/
private Boolean rePublish;
private boolean rePublish;
/**
* 下属任务节点集合
......@@ -44,11 +28,6 @@ public class PluginFlow implements Serializable {
private List<PluginBaseNode> nodeList;
/**
* 依赖的工作流名称集合
*/
private List<String> dependFlowNameList;
/**
* 工作流的配置项
*/
private PluginFlowConfig config;
......
byit-myth-core/myth-core-common/src/main/java/com/byit/job/dto/plugin/PluginInnerFlow.java deleted 100644 → 0
package com.byit.job.dto.plugin;
import lombok.Data;
import java.util.List;
/**
* @description: 内嵌工作流
* @author: gml
* @create: 2019-12-30 10:46
*/
@Data
public class PluginInnerFlow extends PluginBaseNode {
/**
* 责任人
*/
private String principal;
/**
* 工作流的配置项
*/
private PluginFlowConfig config;
/**
* 是否是重新发布 true 是，false 否
*/
private Boolean rePublish;
/**
* 依赖的任务节点名称集合，只能是节点的名称
*/
private List<String> dependNodeNameList;
/**
* 下属任务节点集合
*/
private List<PluginNode> nodeList;
}
byit-myth-core/myth-core-common/src/main/java/com/byit/job/dto/plugin/PluginNode.java
......@@ -2,8 +2,6 @@ package com.byit.job.dto.plugin;
import lombok.Data;
import java.util.List;
/**
* @description: 插件端的任务节点
* @author: gml
......@@ -51,9 +49,5 @@ public class PluginNode extends PluginBaseNode {
*/
private PluginNodeConfig config;
/**
* 依赖节点的名称集合
*/
private List<String> dependNodeNameList;
}
byit-myth-core/myth-core-common/src/main/java/com/byit/job/dto/plugin/PluginFlowDepend.java → byit-myth-core/myth-core-common/src/main/java/com/byit/job/dto/plugin/PluginPackage.java
......@@ -2,29 +2,22 @@ package com.byit.job.dto.plugin;
import lombok.Data;
import java.util.List;
/**
* @description: 工作流的依赖关系
* @description: 插件段的发布包
* @author: gml
* @create: 2019-12-31 11:04
* @create: 2020-01-02 14:38
*/
@Data
public class PluginFlowDepend {
/**
* 工作流名称
*/
private String flowName;
public class PluginPackage {
/**
* 工作空间的名称
* 工作空间名称
*/
private String workspaceName;
/**
* 工作流依赖的工作流名称
* 工作流
*/
private List<String> dependFlowNameList;
private PluginFlow flow;
}
byit-myth-core/myth-core-common/src/main/java/com/byit/job/enums/plugin/PluginNodeTypeEnum.java 0 → 100644
package com.byit.job.enums.plugin;
/**
* @description: 节点的类型枚举
* @author: gml
* @create: 2020-01-02 14:12
*/
public enum PluginNodeTypeEnum {
NODE("node", "节点"),
FLOW("flow", "工作流")
;
private String code;
private String msg;
private PluginNodeTypeEnum(String code, String msg){
this.code = code;
this.msg = msg;
}
public String getCode(){
return this.code;
}
public String getMsg(){
return this.msg;
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment